kandev/apps/backend/internal/plugins/service_test.go

package plugins

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	goruntime "runtime"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/kandev/kandev/internal/common/logger"
	"github.com/kandev/kandev/internal/plugins/pkgtar/pkgtartest"
	"github.com/kandev/kandev/internal/plugins/store"
	"github.com/kandev/kandev/internal/secrets"
	"github.com/kandev/kandev/pkg/pluginsdk"
)

func testLogger(t *testing.T) *logger.Logger {
	t.Helper()
	log, err := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "console"})
	if err != nil {
		t.Fatalf("new logger: %v", err)
	}
	return log
}

// fakeRuntime is a controllable PluginRuntime for tests: Start/Stop just
// flip an in-memory "running" flag (recording every call) instead of
// spawning a real subprocess, so Service's install/activate/status-machine
// logic can be tested without internal/plugins/runtime's real go-plugin
// machinery.
type fakeRuntime struct {
	mu sync.Mutex

	running       map[string]bool
	startErr      map[string]error
	restartCounts map[string]int

	startCalls   []string
	stopCalls    []string
	lastStartCtx context.Context

	// blockStarted/blockProceed, when set via blockNextStart, make the very
	// next Start call signal blockStarted and then wait on blockProceed
	// before continuing — used by concurrency tests to pause a caller
	// mid-Start and prove a competing caller is blocked out.
	blockStarted chan struct{}
	blockProceed chan struct{}
}

type fakeUserStateCleanup struct {
	deleteErr error
	delete    func(context.Context, string) error
	calls     int
}

func (f *fakeUserStateCleanup) DeleteAllForPlugin(ctx context.Context, pluginID string) error {
	f.calls++
	if f.deleteErr != nil {
		return f.deleteErr
	}
	return f.delete(ctx, pluginID)
}

func newFakeRuntime() *fakeRuntime {
	return &fakeRuntime{
		running:       map[string]bool{},
		startErr:      map[string]error{},
		restartCounts: map[string]int{},
	}
}

// blockNextStart arms a one-shot block on the next Start call: Start closes
// the returned started channel once it is entered, then waits until the
// returned release func is called before returning.
func (r *fakeRuntime) blockNextStart() (started <-chan struct{}, release func()) {
	s := make(chan struct{})
	p := make(chan struct{})
	r.mu.Lock()
	r.blockStarted = s
	r.blockProceed = p
	r.mu.Unlock()
	return s, func() { close(p) }
}

func (r *fakeRuntime) Start(ctx context.Context, rec *store.Record, hostFactory func(string) pluginsdk.Host) error {
	r.mu.Lock()
	r.startCalls = append(r.startCalls, rec.ID)
	r.lastStartCtx = ctx
	started, proceed := r.blockStarted, r.blockProceed
	r.blockStarted, r.blockProceed = nil, nil
	r.mu.Unlock()

	if started != nil {
		close(started)
		<-proceed
	}

	r.mu.Lock()
	defer r.mu.Unlock()
	if err := r.startErr[rec.ID]; err != nil {
		return err
	}
	_ = hostFactory(rec.ID) // exercise the factory, mirroring the real manager
	r.running[rec.ID] = true
	return nil
}

func (r *fakeRuntime) Stop(id string) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.stopCalls = append(r.stopCalls, id)
	r.running[id] = false
}

func (r *fakeRuntime) Get(id string) (*pluginsdk.RemotePlugin, bool) {
	r.mu.Lock()
	defer r.mu.Unlock()
	if !r.running[id] {
		return nil, false
	}
	return nil, true
}

func (r *fakeRuntime) Ping(id string) error {
	r.mu.Lock()
	defer r.mu.Unlock()
	if !r.running[id] {
		return fmt.Errorf("not running")
	}
	return nil
}

func (r *fakeRuntime) Running(id string) bool {
	r.mu.Lock()
	defer r.mu.Unlock()
	return r.running[id]
}

func (r *fakeRuntime) RestartCount(id string) int {
	r.mu.Lock()
	defer r.mu.Unlock()
	return r.restartCounts[id]
}

func (r *fakeRuntime) StopAll() {
	r.mu.Lock()
	defer r.mu.Unlock()
	for id := range r.running {
		r.running[id] = false
	}
}

func (r *fakeRuntime) setStartErr(id string, err error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.startErr[id] = err
}

func (r *fakeRuntime) clearStartErr(id string) {
	r.mu.Lock()
	defer r.mu.Unlock()
	delete(r.startErr, id)
}

func (r *fakeRuntime) startCallCount(id string) int {
	r.mu.Lock()
	defer r.mu.Unlock()
	n := 0
	for _, got := range r.startCalls {
		if got == id {
			n++
		}
	}
	return n
}

func (r *fakeRuntime) startCtx() context.Context {
	r.mu.Lock()
	defer r.mu.Unlock()
	return r.lastStartCtx
}

func (r *fakeRuntime) stopped(id string) bool {
	r.mu.Lock()
	defer r.mu.Unlock()
	for _, got := range r.stopCalls {
		if got == id {
			return true
		}
	}
	return false
}

// fakeSecretRevealer is a minimal in-memory SecretVault for tests.
type fakeSecretRevealer struct {
	mu     sync.Mutex
	values map[string]string
}

func newFakeSecretRevealer() *fakeSecretRevealer {
	return &fakeSecretRevealer{values: map[string]string{}}
}

func (v *fakeSecretRevealer) set(ref, value string) {
	v.mu.Lock()
	defer v.mu.Unlock()
	v.values[ref] = value
}

func (v *fakeSecretRevealer) Reveal(_ context.Context, ref string) (string, error) {
	v.mu.Lock()
	defer v.mu.Unlock()
	value, ok := v.values[ref]
	if !ok {
		return "", fmt.Errorf("%w: %s", secrets.ErrNotFound, ref)
	}
	return value, nil
}

func (v *fakeSecretRevealer) Set(_ context.Context, id, _, value string) error {
	v.mu.Lock()
	defer v.mu.Unlock()
	v.values[id] = value
	return nil
}

func (v *fakeSecretRevealer) Delete(_ context.Context, id string) error {
	v.mu.Lock()
	defer v.mu.Unlock()
	if _, ok := v.values[id]; !ok {
		return fmt.Errorf("%w: %s", secrets.ErrNotFound, id)
	}
	delete(v.values, id)
	return nil
}

func (v *fakeSecretRevealer) ListIDs(_ context.Context) ([]string, error) {
	v.mu.Lock()
	defer v.mu.Unlock()
	ids := make([]string, 0, len(v.values))
	for id := range v.values {
		ids = append(ids, id)
	}
	return ids, nil
}

func (v *fakeSecretRevealer) get(id string) (string, bool) {
	v.mu.Lock()
	defer v.mu.Unlock()
	value, ok := v.values[id]
	return value, ok
}

// testPackage builds a valid, runtime-managed plugin tar.gz for the CURRENT
// host platform (so pkgtar.Install's platform check passes), with a
// capabilities.events subscription and (optionally) a UI bundle.
func testPackage(t *testing.T, id, version string, withUIBundle bool) *bytes.Buffer {
	t.Helper()
	platformKey := goruntime.GOOS + "-" + goruntime.GOARCH
	manifestYAML := fmt.Sprintf(`
id: %s
api_version: 1
version: %s
display_name: Test Plugin
capabilities:
  events: ["task.*"]
  state: true
  secrets: true
runtime:
  type: binary
  executables:
    %s: server/plugin
`, id, version, platformKey)
	if withUIBundle {
		manifestYAML += "ui:\n  bundle: \"/ui/bundle.js\"\n  styles: [\"/ui/style.css\"]\n"
	}

	var buf bytes.Buffer
	files := map[string][]byte{
		"manifest.yaml": []byte(manifestYAML),
		"server/plugin": []byte("#!/bin/sh\necho fake\n"),
	}
	if withUIBundle {
		files["ui/bundle.js"] = []byte("export default {};")
		files["ui/style.css"] = []byte("body{}")
	}
	if err := pkgtartest.WritePackage(&buf, files); err != nil {
		t.Fatalf("WritePackage: %v", err)
	}
	return &buf
}

func testAgentToolPackage(t *testing.T, id, toolName string) *bytes.Buffer {
	t.Helper()
	platformKey := goruntime.GOOS + "-" + goruntime.GOARCH
	manifestYAML := fmt.Sprintf(`
id: %s
api_version: 1
version: 1.0.0
display_name: Test Plugin
runtime:
  type: binary
  executables:
    %s: server/plugin
agent_tools:
  - name: %s
    description: Test tool
    surfaces: [kanban-task]
    input_schema:
      type: object
`, id, platformKey, toolName)
	var buf bytes.Buffer
	if err := pkgtartest.WritePackage(&buf, map[string][]byte{
		"manifest.yaml": []byte(manifestYAML),
		"server/plugin": []byte("#!/bin/sh\necho fake\n"),
	}); err != nil {
		t.Fatalf("WritePackage: %v", err)
	}
	return &buf
}

type installBarrierStore struct {
	store.Store
	firstSave    chan struct{}
	secondSave   chan struct{}
	releaseFirst chan struct{}
	saves        int
	mu           sync.Mutex
}

func (s *installBarrierStore) Save(record *store.Record) error {
	s.mu.Lock()
	s.saves++
	call := s.saves
	s.mu.Unlock()
	switch call {
	case 1:
		close(s.firstSave)
		<-s.releaseFirst
	case 2:
		close(s.secondSave)
	}
	return s.Store.Save(record)
}

func TestServiceInstallSerializesAgentToolCollisionValidation(t *testing.T) {
	dir := t.TempDir()
	barrier := &installBarrierStore{
		Store: store.NewFSStore(dir), firstSave: make(chan struct{}),
		secondSave: make(chan struct{}), releaseFirst: make(chan struct{}),
	}
	svc := NewService(barrier, NewRegistry(), nil, testLogger(t))
	svc.SetPluginsDir(dir)
	svc.SetRuntime(newFakeRuntime())
	firstPackage := testAgentToolPackage(t, "plugin-a", "echo")
	secondPackage := testAgentToolPackage(t, "plugin_a", "echo")

	errs := make(chan error, 2)
	go func() {
		_, err := svc.Install(context.Background(), firstPackage)
		errs <- err
	}()
	<-barrier.firstSave
	go func() {
		_, err := svc.Install(context.Background(), secondPackage)
		errs <- err
	}()

	secondCrossedBoundary := false
	select {
	case <-barrier.secondSave:
		secondCrossedBoundary = true
	case <-time.After(100 * time.Millisecond):
	}
	close(barrier.releaseFirst)
	firstErr, secondErr := <-errs, <-errs

	if secondCrossedBoundary {
		t.Error("second install persisted before the first catalog mutation completed")
	}
	if (firstErr == nil) == (secondErr == nil) {
		t.Fatalf("install errors = %v, %v; want exactly one collision", firstErr, secondErr)
	}
}

// newTestService wires a Service against a real FSStore rooted at a temp
// plugins dir, a fresh Registry, and a fakeRuntime — mirroring what Provide
// does, minus the real runtime.Manager.
func newTestService(t *testing.T) (*Service, *store.FSStore, *fakeRuntime) {
	t.Helper()
	svc, _, fsStore, rt := newTestServiceWithDir(t)
	return svc, fsStore, rt
}

func newTestServiceWithDir(t *testing.T) (*Service, string, *store.FSStore, *fakeRuntime) {
	t.Helper()
	dir := t.TempDir()
	fsStore := store.NewFSStore(dir)
	reg := NewRegistry()
	svc := NewService(fsStore, reg, nil, testLogger(t))
	svc.SetPluginsDir(dir)
	rt := newFakeRuntime()
	svc.SetRuntime(rt)
	return svc, dir, fsStore, rt
}

func installTestPlugin(t *testing.T, svc *Service, id string) *store.Record {
	t.Helper()
	rec, err := svc.Install(context.Background(), testPackage(t, id, "1.0.0", false))
	if err != nil {
		t.Fatalf("Install(%q): %v", id, err)
	}
	return rec
}

func TestServiceRejectsActiveRepositoryProviderOwnerCollision(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-first", "bitbucket")); err != nil {
		t.Fatalf("install first provider owner: %v", err)
	}

	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-second", "bitbucket")); err == nil {
		t.Fatal("Install() expected active repository provider ownership collision, got nil")
	}
}

func TestServiceRejectsNoncanonicalRepositoryProviderOwner(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-first", "Bitbucket")); err == nil {
		t.Fatal("Install() expected non-canonical repository provider rejection, got nil")
	}
}

func TestServiceRejectsActiveReferenceSourceOwnerCollisionAndReleasesOnDisable(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithReferenceSource(t, "kandev-plugin-first", "bitbucket.pull-requests")); err != nil {
		t.Fatalf("install first reference source owner: %v", err)
	}
	if _, err := svc.Install(t.Context(), testPackageWithReferenceSource(t, "kandev-plugin-second", "bitbucket.pull-requests")); err == nil {
		t.Fatal("Install() expected active reference source ownership collision, got nil")
	}

	if err := svc.Disable("kandev-plugin-first"); err != nil {
		t.Fatalf("Disable first reference source owner: %v", err)
	}
	if _, err := svc.Install(t.Context(), testPackageWithReferenceSource(t, "kandev-plugin-second", "bitbucket.pull-requests")); err != nil {
		t.Fatalf("install reference source after owner disable: %v", err)
	}
}

func TestServiceRejectsActiveReferenceProviderKindOwnerCollision(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithReferenceSourceDescriptor(t, "kandev-plugin-first", "bitbucket.pull-requests", "bitbucket", "pull_request")); err != nil {
		t.Fatalf("install first reference owner: %v", err)
	}

	if _, err := svc.Install(t.Context(), testPackageWithReferenceSourceDescriptor(t, "kandev-plugin-second", "bitbucket.prs", "bitbucket", "pull_request")); err == nil {
		t.Fatal("Install() expected active reference provider/kind ownership collision, got nil")
	}

	if err := svc.Disable("kandev-plugin-first"); err != nil {
		t.Fatalf("Disable first reference provider/kind owner: %v", err)
	}
	if _, err := svc.Install(t.Context(), testPackageWithReferenceSourceDescriptor(t, "kandev-plugin-second", "bitbucket.prs", "bitbucket", "pull_request")); err != nil {
		t.Fatalf("install reference provider/kind after owner disable: %v", err)
	}
}

func TestServiceRejectsHostOwnedReferenceIdentity(t *testing.T) {
	svc, _, _ := newTestService(t)
	svc.SetReservedReferenceIdentities([]ReferenceIdentity{{
		Source: "github_pull_requests", Provider: "github", Kind: "pull_request",
	}})

	if _, err := svc.Install(t.Context(), testPackageWithReferenceSourceDescriptor(
		t, "kandev-plugin-shadow", "github_pull_requests", "shadow", "pull_request",
	)); err == nil || !strings.Contains(err.Error(), "owned by the host") {
		t.Fatalf("Install() error = %v, want host-owned source collision", err)
	}
}

func TestServiceDemotesPersistedHostOwnedReferenceCollision(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithReferenceSourceDescriptor(
		t, "kandev-plugin-shadow", "github_pull_requests", "github", "pull_request",
	)); err != nil {
		t.Fatalf("install pre-reservation plugin: %v", err)
	}

	svc.SetReservedReferenceIdentities([]ReferenceIdentity{{
		Source: "github_pull_requests", Provider: "github", Kind: "pull_request",
	}})
	record, _ := svc.Get("kandev-plugin-shadow")
	if record.Status != StatusError {
		t.Fatalf("persisted collision status = %s, want %s", record.Status, StatusError)
	}
}

func testPackageWithRepositoryProvider(t *testing.T, id, provider string) *bytes.Buffer {
	return testPackageWithRepositoryProviderVersion(t, id, "1.0.0", provider)
}

func testPackageWithRepositoryProviderVersion(t *testing.T, id, version, provider string) *bytes.Buffer {
	t.Helper()
	platformKey := goruntime.GOOS + "-" + goruntime.GOARCH
	manifestYAML := fmt.Sprintf(`
id: %s
api_version: 1
version: %q
display_name: Test Plugin
repository_providers: [%s]
runtime:
  type: binary
  executables:
    %s: server/plugin
`, id, version, provider, platformKey)
	var buf bytes.Buffer
	if err := pkgtartest.WritePackage(&buf, map[string][]byte{
		"manifest.yaml": []byte(manifestYAML),
		"server/plugin": []byte("#!/bin/sh\necho fake\n"),
	}); err != nil {
		t.Fatalf("WritePackage: %v", err)
	}
	return &buf
}

func testPackageWithReferenceSource(t *testing.T, id, source string) *bytes.Buffer {
	return testPackageWithReferenceSourceDescriptor(t, id, source, "bitbucket", "pull_request")
}

func testPackageWithReferenceSourceDescriptor(t *testing.T, id, source, provider, kind string) *bytes.Buffer {
	t.Helper()
	platformKey := goruntime.GOOS + "-" + goruntime.GOARCH
	manifestYAML := fmt.Sprintf(`
id: %s
api_version: 1
version: "1.0.0"
display_name: Test Plugin
reference_sources:
  - source: %s
    provider: %s
    kind: %s
    display_name: Bitbucket
    kind_label: Pull request
runtime:
  type: binary
  executables:
    %s: server/plugin
`, id, source, provider, kind, platformKey)
	var buf bytes.Buffer
	if err := pkgtartest.WritePackage(&buf, map[string][]byte{
		"manifest.yaml": []byte(manifestYAML),
		"server/plugin": []byte("#!/bin/sh\necho fake\n"),
	}); err != nil {
		t.Fatalf("WritePackage: %v", err)
	}
	return &buf
}

func TestServiceListReturnsInstalledPlugins(t *testing.T) {
	svc, _, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	installTestPlugin(t, svc, "kandev-plugin-jira")

	list := svc.List()
	if len(list) != 2 {
		t.Fatalf("List() len = %d, want 2", len(list))
	}
}

func TestServiceGetMissingReturnsNotFound(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Get("missing"); !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("Get() error = %v, want store.ErrNotFound", err)
	}
}

func TestServiceUpdateConfigPersists(t *testing.T) {
	svc, fsStore, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")

	if err := svc.UpdateConfig(context.Background(), "kandev-plugin-slack", map[string]any{"default_channel": "#dev"}); err != nil {
		t.Fatalf("UpdateConfig() unexpected error: %v", err)
	}

	cfg, err := fsStore.GetConfig("kandev-plugin-slack")
	if err != nil {
		t.Fatalf("GetConfig() unexpected error: %v", err)
	}
	if cfg["default_channel"] != "#dev" {
		t.Fatalf("GetConfig() default_channel = %v, want %q", cfg["default_channel"], "#dev")
	}
}

func TestServiceUpdateConfigMissingReturnsNotFound(t *testing.T) {
	svc, _, _ := newTestService(t)
	err := svc.UpdateConfig(context.Background(), "missing", map[string]any{"a": "b"})
	if !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("UpdateConfig() error = %v, want store.ErrNotFound", err)
	}
}

func TestServiceUninstallStopsRuntimeRemovesPackageAndRecord(t *testing.T) {
	svc, fsStore, rt := newTestService(t)
	rec := installTestPlugin(t, svc, "kandev-plugin-slack")
	installDir := filepath.Dir(rec.InstallPath) // .../plugins/kandev-plugin-slack

	if err := svc.Uninstall(context.Background(), "kandev-plugin-slack"); err != nil {
		t.Fatalf("Uninstall() unexpected error: %v", err)
	}

	if !rt.stopped("kandev-plugin-slack") {
		t.Fatal("Uninstall() did not stop the runtime process")
	}
	if _, err := svc.Get("kandev-plugin-slack"); !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("Get() after Uninstall() error = %v, want store.ErrNotFound", err)
	}
	if _, err := fsStore.Get("kandev-plugin-slack"); !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("store.Get() after Uninstall() error = %v, want store.ErrNotFound", err)
	}
	if _, err := os.Stat(installDir); !os.IsNotExist(err) {
		t.Fatalf("expected the extracted package dir to be removed, stat err = %v", err)
	}
}

// TestServiceUninstallDeletesPluginState pins the fix for the plugin_state
// leak on Uninstall: removing a plugin previously deleted its file tree and
// registry record but never its plugin_state rows, so a reinstalled (or
// id-reused) plugin silently inherited stale state from a previous install.
func TestServiceUninstallDeletesPluginState(t *testing.T) {
	svc, _, _ := newTestService(t)
	svc.SetState(newTestStateStore(t))
	installTestPlugin(t, svc, "kandev-plugin-slack")

	ctx := context.Background()
	if err := svc.StateStore().Set(ctx, "kandev-plugin-slack", "instance", "", "install_id", json.RawMessage(`"abc"`)); err != nil {
		t.Fatalf("seed plugin_state: %v", err)
	}

	if err := svc.Uninstall(context.Background(), "kandev-plugin-slack"); err != nil {
		t.Fatalf("Uninstall() unexpected error: %v", err)
	}

	entries, err := svc.StateStore().List(ctx, "kandev-plugin-slack", "instance", "")
	if err != nil {
		t.Fatalf("List() after Uninstall(): %v", err)
	}
	if len(entries) != 0 {
		t.Fatalf("plugin_state entries after Uninstall() = %d, want 0 (state should be deleted)", len(entries))
	}
}

// TestServiceUninstallDeletesPluginUserStateForEveryUser pins AC20: the
// per-user counterpart of TestServiceUninstallDeletesPluginState — uninstall
// must purge plugin_user_state rows for every user who wrote one, not just
// whichever user happened to trigger the uninstall.
func TestServiceUninstallDeletesPluginUserStateForEveryUser(t *testing.T) {
	svc, _, _ := newTestService(t)
	svc.SetUserState(newTestUserStateStore(t))
	installTestPlugin(t, svc, "kandev-plugin-notes")

	ctx := context.Background()
	if _, err := svc.UserState().Set(ctx, "kandev-plugin-notes", "user_1", "task", "task_1", "note", json.RawMessage(`"a"`), nil); err != nil {
		t.Fatalf("seed user_1: %v", err)
	}
	if _, err := svc.UserState().Set(ctx, "kandev-plugin-notes", "user_2", "task", "task_1", "note", json.RawMessage(`"b"`), nil); err != nil {
		t.Fatalf("seed user_2: %v", err)
	}

	if err := svc.Uninstall(context.Background(), "kandev-plugin-notes"); err != nil {
		t.Fatalf("Uninstall() unexpected error: %v", err)
	}

	for _, userID := range []string{"user_1", "user_2"} {
		entries, err := svc.UserState().List(ctx, "kandev-plugin-notes", userID, "task", "task_1")
		if err != nil {
			t.Fatalf("List(%s) after Uninstall(): %v", userID, err)
		}
		if len(entries) != 0 {
			t.Fatalf("plugin_user_state entries for %s after Uninstall() = %d, want 0", userID, len(entries))
		}
	}
}

func TestServiceUninstallFailsClosedWhenUserStateCleanupFails(t *testing.T) {
	svc, fsStore, rt := newTestService(t)
	svc.SetUserState(newTestUserStateStore(t))
	rec := installTestPlugin(t, svc, "kandev-plugin-notes")
	ctx := context.Background()
	if _, err := svc.UserState().Set(ctx, rec.ID, "user_1", "task", "task_1", "note", json.RawMessage(`"a"`), nil); err != nil {
		t.Fatalf("seed user state: %v", err)
	}

	cleanupErr := errors.New("user state database unavailable")
	cleanup := &fakeUserStateCleanup{
		deleteErr: cleanupErr,
		delete:    svc.UserState().DeleteAllForPlugin,
	}
	svc.setUserStateCleanupStore(cleanup)
	deliverer := &fakeDeliverer{}
	svc.SetDeliverer(deliverer)

	err := svc.Uninstall(ctx, rec.ID)
	if err == nil || !strings.Contains(err.Error(), cleanupErr.Error()) {
		t.Fatalf("Uninstall() error = %v, want user-state cleanup failure", err)
	}
	if cleanup.calls != 1 {
		t.Fatalf("DeleteAllForPlugin calls after failed uninstall = %d, want 1", cleanup.calls)
	}
	if !rt.stopped(rec.ID) {
		t.Fatal("Uninstall() did not stop the runtime before cleanup failure")
	}
	if _, err := svc.Get(rec.ID); err != nil {
		t.Fatalf("Get() after failed uninstall: %v, want installed record", err)
	}
	if _, err := fsStore.Get(rec.ID); err != nil {
		t.Fatalf("store.Get() after failed uninstall: %v, want installed record", err)
	}
	if _, err := os.Stat(rec.InstallPath); err != nil {
		t.Fatalf("installed package after failed uninstall: %v", err)
	}
	if deliverer.refreshCount != 1 {
		t.Fatalf("deliverer refreshes after failed uninstall = %d, want stopped-state reconciliation only", deliverer.refreshCount)
	}

	cleanup.deleteErr = nil
	if err := svc.Uninstall(ctx, rec.ID); err != nil {
		t.Fatalf("retry Uninstall() error: %v", err)
	}
	if cleanup.calls != 2 {
		t.Fatalf("DeleteAllForPlugin calls after retry = %d, want 2", cleanup.calls)
	}
	if _, err := svc.Get(rec.ID); !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("Get() after successful retry = %v, want store.ErrNotFound", err)
	}
	entries, err := svc.UserState().List(ctx, rec.ID, "user_1", "task", "task_1")
	if err != nil {
		t.Fatalf("List() after successful retry: %v", err)
	}
	if len(entries) != 0 {
		t.Fatalf("user state rows after successful retry = %d, want 0", len(entries))
	}
}

func TestServiceUninstallMissingReturnsNotFound(t *testing.T) {
	svc, _, _ := newTestService(t)
	if err := svc.Uninstall(context.Background(), "missing"); !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("Uninstall() error = %v, want store.ErrNotFound", err)
	}
}

func TestServiceSetStatusInvalidTransitionRejected(t *testing.T) {
	svc, _, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack") // already active

	// active -> registered is not a legal single-hop edge.
	err := svc.SetStatus("kandev-plugin-slack", StatusRegistered)
	var invalidErr *ErrInvalidTransition
	if !errors.As(err, &invalidErr) {
		t.Fatalf("SetStatus() error = %v, want *ErrInvalidTransition", err)
	}
}

func TestServiceSetStatusIntoUninstalledRejected(t *testing.T) {
	svc, _, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")

	err := svc.SetStatus("kandev-plugin-slack", StatusUninstalled)
	var invalidErr *ErrInvalidTransition
	if !errors.As(err, &invalidErr) {
		t.Fatalf("SetStatus() error = %v, want *ErrInvalidTransition (use Uninstall instead)", err)
	}
}

func TestServiceEnableIsIdempotentWhenAlreadyActive(t *testing.T) {
	svc, _, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")

	if err := svc.Enable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Enable() on an already-active plugin: %v", err)
	}
	if got := rt.startCallCount("kandev-plugin-slack"); got != 1 {
		t.Fatalf("runtime Start called %d times, want 1 (Enable on an active plugin must be a no-op)", got)
	}
}

func TestServiceDisableFromActiveStopsRuntime(t *testing.T) {
	svc, _, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")

	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Disable() unexpected error: %v", err)
	}

	got, _ := svc.Get("kandev-plugin-slack")
	if got.Status != StatusDisabled {
		t.Fatalf("Get() Status = %q, want %q", got.Status, StatusDisabled)
	}
	if !rt.stopped("kandev-plugin-slack") {
		t.Fatal("Disable() did not stop the runtime process")
	}
}

func TestServiceRevokesDeclaredProviderLeasesWhenPluginBecomesInactive(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-bitbucket", "bitbucket")); err != nil {
		t.Fatalf("Install: %v", err)
	}

	var revoked []string
	svc.SetGitCredentialLeaseRevoker(func(providerID string) {
		revoked = append(revoked, providerID)
	})

	if err := svc.Disable("kandev-plugin-bitbucket"); err != nil {
		t.Fatalf("Disable: %v", err)
	}
	if got, want := revoked, []string{"bitbucket"}; !reflect.DeepEqual(got, want) {
		t.Fatalf("revoked provider leases = %#v, want %#v", got, want)
	}

	if err := svc.Uninstall(t.Context(), "kandev-plugin-bitbucket"); err != nil {
		t.Fatalf("Uninstall: %v", err)
	}
	if got, want := revoked, []string{"bitbucket", "bitbucket"}; !reflect.DeepEqual(got, want) {
		t.Fatalf("revoked provider leases after uninstall = %#v, want %#v", got, want)
	}
}

func TestServiceRevokesProviderLeasesBeforeReplacingActivePlugin(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProviderVersion(t, "kandev-plugin-bitbucket", "1.0.0", "bitbucket")); err != nil {
		t.Fatalf("install initial plugin: %v", err)
	}

	var revoked []string
	svc.SetGitCredentialLeaseRevoker(func(providerID string) {
		revoked = append(revoked, providerID)
	})

	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProviderVersion(t, "kandev-plugin-bitbucket", "1.1.0", "bitbucket")); err != nil {
		t.Fatalf("upgrade plugin: %v", err)
	}
	if got, want := revoked, []string{"bitbucket"}; !reflect.DeepEqual(got, want) {
		t.Fatalf("revoked provider leases during active upgrade = %#v, want %#v", got, want)
	}
}

func TestServiceDisableIsIdempotentWhenAlreadyDisabled(t *testing.T) {
	svc, _, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("first Disable(): %v", err)
	}

	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("second Disable() expected no error (idempotent), got %v", err)
	}
}

func TestServiceDisabledCanReEnableAndRespawns(t *testing.T) {
	svc, _, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Disable(): %v", err)
	}

	if err := svc.Enable("kandev-plugin-slack"); err != nil {
		t.Fatalf("re-Enable() unexpected error: %v", err)
	}
	got, _ := svc.Get("kandev-plugin-slack")
	if got.Status != StatusActive {
		t.Fatalf("Get() Status = %q, want %q", got.Status, StatusActive)
	}
	if want := 2; rt.startCallCount("kandev-plugin-slack") != want {
		t.Fatalf("runtime Start called %d times, want %d (install + re-enable)", rt.startCallCount("kandev-plugin-slack"), want)
	}
}

func TestServiceEnableFailurePersistsDiagnosticAndSuccessfulRetryClearsIt(t *testing.T) {
	svc, fsStore, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Disable(): %v", err)
	}

	rt.setStartErr("kandev-plugin-slack", errors.New("handshake failed: binary exited"))
	if err := svc.Enable("kandev-plugin-slack"); err == nil {
		t.Fatal("Enable() unexpectedly succeeded with a configured start failure")
	}

	failed, err := svc.Get("kandev-plugin-slack")
	if err != nil {
		t.Fatalf("Get() after failed Enable(): %v", err)
	}
	if failed.Status != StatusError {
		t.Fatalf("Status after failed Enable() = %q, want %q", failed.Status, StatusError)
	}
	if failed.LastError == "" || !strings.Contains(failed.LastError, "handshake failed") {
		t.Fatalf("LastError = %q, want the start failure", failed.LastError)
	}
	if failed.LastErrorAt == nil {
		t.Fatal("LastErrorAt is nil after failed Enable()")
	}
	onDisk, err := fsStore.Get("kandev-plugin-slack")
	if err != nil {
		t.Fatalf("store.Get() after failed Enable(): %v", err)
	}
	if onDisk.LastError != failed.LastError || onDisk.LastErrorAt == nil {
		t.Fatalf("persisted diagnostic = (%q, %v), want (%q, non-nil)", onDisk.LastError, onDisk.LastErrorAt, failed.LastError)
	}

	rt.clearStartErr("kandev-plugin-slack")
	if err := svc.Enable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Enable() retry unexpected error: %v", err)
	}
	recovered, err := svc.Get("kandev-plugin-slack")
	if err != nil {
		t.Fatalf("Get() after successful retry: %v", err)
	}
	if recovered.Status != StatusActive {
		t.Fatalf("Status after successful retry = %q, want %q", recovered.Status, StatusActive)
	}
	if recovered.LastError != "" || recovered.LastErrorAt != nil {
		t.Fatalf("diagnostic after successful retry = (%q, %v), want empty/nil", recovered.LastError, recovered.LastErrorAt)
	}
}

func TestServiceFailedRetryReplacesDiagnostic(t *testing.T) {
	svc, _, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Disable(): %v", err)
	}

	rt.setStartErr("kandev-plugin-slack", errors.New("first handshake failure"))
	if err := svc.Enable("kandev-plugin-slack"); err == nil {
		t.Fatal("first Enable() unexpectedly succeeded")
	}
	first, _ := svc.Get("kandev-plugin-slack")

	rt.setStartErr("kandev-plugin-slack", errors.New("second executable failure"))
	if err := svc.Enable("kandev-plugin-slack"); err == nil {
		t.Fatal("second Enable() unexpectedly succeeded")
	}
	second, _ := svc.Get("kandev-plugin-slack")
	if second.Status != StatusError {
		t.Fatalf("Status after failed retry = %q, want %q", second.Status, StatusError)
	}
	if second.LastError == first.LastError || !strings.Contains(second.LastError, "second executable failure") {
		t.Fatalf("LastError after failed retry = %q, want replacement diagnostic", second.LastError)
	}
}

// TestServiceEnable_ConcurrentCallsForSameID_OnlyOneActivationNoError proves
// Enable is guarded by a per-plugin lock: two near-simultaneous Enable calls
// for the same disabled plugin id must not both pass the StatusActive
// idempotency check and race into activate. Without the lock, the second
// call's SetStatus(Active) races the first, and the loser observes
// *ErrInvalidTransition ("active -> active") even though the plugin is
// correctly active by the time both calls return.
func TestServiceEnable_ConcurrentCallsForSameID_OnlyOneActivationNoError(t *testing.T) {
	svc, _, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Disable(): %v", err)
	}

	started, release := rt.blockNextStart()

	firstErr := make(chan error, 1)
	go func() {
		firstErr <- svc.Enable("kandev-plugin-slack")
	}()

	select {
	case <-started:
	case <-time.After(5 * time.Second):
		t.Fatal("first Enable() never reached the blocked runtime Start call")
	}

	secondErr := make(chan error, 1)
	go func() {
		secondErr <- svc.Enable("kandev-plugin-slack")
	}()

	// The second Enable() must still be blocked behind the per-plugin lock:
	// give it a bounded window to (incorrectly) complete, and fail if it does.
	select {
	case err := <-secondErr:
		t.Fatalf("second Enable() completed (err=%v) while the first was still starting — Enable is not per-plugin lock-guarded", err)
	case <-time.After(200 * time.Millisecond):
	}

	release()

	select {
	case err := <-firstErr:
		if err != nil {
			t.Fatalf("first Enable() unexpected error: %v", err)
		}
	case <-time.After(5 * time.Second):
		t.Fatal("first Enable() never returned after release")
	}
	select {
	case err := <-secondErr:
		if err != nil {
			t.Fatalf("second Enable() unexpected error (must be a no-op observing the now-active status): %v", err)
		}
	case <-time.After(5 * time.Second):
		t.Fatal("second Enable() never returned after the first released the lock")
	}

	// Install's initial activate() already called Start once; this Enable
	// (after the earlier Disable) must add exactly one more — never two —
	// proving the second concurrent Enable() did not also spawn.
	if got, want := rt.startCallCount("kandev-plugin-slack"), 2; got != want {
		t.Fatalf("runtime Start called %d times for kandev-plugin-slack, want exactly %d (no double activation)", got, want)
	}
	rec, err := svc.Get("kandev-plugin-slack")
	if err != nil {
		t.Fatalf("Get() unexpected error: %v", err)
	}
	if rec.Status != StatusActive {
		t.Fatalf("Status = %q, want %q", rec.Status, StatusActive)
	}
}

func TestServiceEnableConcurrentProviderOwnersActivatesOnlyOne(t *testing.T) {
	svc, _, rt := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-first", "bitbucket")); err != nil {
		t.Fatalf("install first: %v", err)
	}
	if err := svc.Disable("kandev-plugin-first"); err != nil {
		t.Fatalf("disable first: %v", err)
	}
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-second", "bitbucket")); err != nil {
		t.Fatalf("install second: %v", err)
	}
	if err := svc.Disable("kandev-plugin-second"); err != nil {
		t.Fatalf("disable second: %v", err)
	}

	started, release := rt.blockNextStart()
	firstResult := make(chan error, 1)
	secondResult := make(chan error, 1)
	go func() { firstResult <- svc.Enable("kandev-plugin-first") }()
	select {
	case <-started:
	case <-time.After(5 * time.Second):
		t.Fatal("first provider owner did not reach runtime start")
	}
	go func() { secondResult <- svc.Enable("kandev-plugin-second") }()
	select {
	case err := <-secondResult:
		t.Fatalf("competing owner completed before reservation released: %v", err)
	case <-time.After(100 * time.Millisecond):
	}
	release()

	if err := <-firstResult; err != nil {
		t.Fatalf("first owner activation: %v", err)
	}
	if err := <-secondResult; err == nil || !strings.Contains(err.Error(), "already owned") {
		t.Fatalf("second owner activation error = %v, want ownership collision", err)
	}
	first, _ := svc.Get("kandev-plugin-first")
	second, _ := svc.Get("kandev-plugin-second")
	if first.Status != StatusActive || second.Status == StatusActive {
		t.Fatalf("statuses = first:%s second:%s, want exactly first active", first.Status, second.Status)
	}
}

func TestServiceDispatchLeaseBlocksDisableUntilRequestCompletes(t *testing.T) {
	svc, _, _ := newTestService(t)
	record := installTestPlugin(t, svc, "kandev-plugin-actions")
	_, release, err := svc.beginPluginDispatch(record.ID, dispatchGeneration(record))
	if err != nil {
		t.Fatalf("begin dispatch: %v", err)
	}

	disabled := make(chan error, 1)
	go func() { disabled <- svc.Disable(record.ID) }()
	select {
	case err := <-disabled:
		t.Fatalf("Disable completed while dispatch lease was active: %v", err)
	case <-time.After(100 * time.Millisecond):
	}
	release()
	select {
	case err := <-disabled:
		if err != nil {
			t.Fatalf("Disable after dispatch release: %v", err)
		}
	case <-time.After(5 * time.Second):
		t.Fatal("Disable remained blocked after dispatch release")
	}
}

func TestServiceRecoveryCannotReclaimOwnedProvider(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-recovering", "bitbucket")); err != nil {
		t.Fatalf("install recovering plugin: %v", err)
	}
	svc.handleStatusChange("kandev-plugin-recovering", false, errors.New("health check failed"))
	if _, err := svc.Install(t.Context(), testPackageWithRepositoryProvider(t, "kandev-plugin-owner", "bitbucket")); err != nil {
		t.Fatalf("install replacement owner: %v", err)
	}

	svc.handleStatusChange("kandev-plugin-recovering", true, nil)
	recovering, _ := svc.Get("kandev-plugin-recovering")
	if recovering.Status == StatusActive {
		t.Fatal("health recovery reclaimed a provider already owned by another active plugin")
	}
}

// TestServiceActivatePassesABoundedStartContext pins the fix for bounded
// startup: activate previously passed context.Background() straight through
// to runtime.Start, so a hung plugin binary could block Enable/Install
// indefinitely (up to go-plugin's own default). activate must instead pass a
// context with a deadline, so a caller can observe/rely on the bound even if
// a future runtime.Manager becomes context-aware for the handshake itself.
func TestServiceActivatePassesABoundedStartContext(t *testing.T) {
	svc, _, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")

	ctx := rt.startCtx()
	if ctx == nil {
		t.Fatal("runtime.Start() was never called")
	}
	if _, ok := ctx.Deadline(); !ok {
		t.Fatal("activate() passed a context with no deadline to runtime.Start(), want a bounded context.WithTimeout")
	}
}

func TestServiceHandleStatusChangeUnhealthyTransitionsToErrorAndRefreshesDeliverer(t *testing.T) {
	svc, _, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	deliverer := &fakeDeliverer{}
	svc.SetDeliverer(deliverer)

	svc.handleStatusChange("kandev-plugin-slack", false, errors.New("ping timeout"))

	got, _ := svc.Get("kandev-plugin-slack")
	if got.Status != StatusError {
		t.Fatalf("Status after unhealthy transition = %q, want %q", got.Status, StatusError)
	}
	if got.LastError == "" || !strings.Contains(got.LastError, "ping timeout") || got.LastErrorAt == nil {
		t.Fatalf("diagnostic after unhealthy transition = (%q, %v), want ping timeout/non-nil", got.LastError, got.LastErrorAt)
	}
	if deliverer.refreshCount != 1 {
		t.Fatalf("Refresh() call count = %d, want 1", deliverer.refreshCount)
	}
	if len(deliverer.flushedIDs) != 0 {
		t.Fatalf("Flush() should not be called on a degrade transition, got %v", deliverer.flushedIDs)
	}
}

func TestServiceHandleStatusChangeHealthyRecoversAndFlushesDeliverer(t *testing.T) {
	svc, _, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	svc.handleStatusChange("kandev-plugin-slack", false, errors.New("ping timeout")) // degrade first
	deliverer := &fakeDeliverer{}
	svc.SetDeliverer(deliverer)

	svc.handleStatusChange("kandev-plugin-slack", true, nil)

	got, _ := svc.Get("kandev-plugin-slack")
	if got.Status != StatusActive {
		t.Fatalf("Status after recovery = %q, want %q", got.Status, StatusActive)
	}
	if got.LastError != "" || got.LastErrorAt != nil {
		t.Fatalf("diagnostic after recovery = (%q, %v), want empty/nil", got.LastError, got.LastErrorAt)
	}
	if len(deliverer.flushedIDs) != 1 || deliverer.flushedIDs[0] != "kandev-plugin-slack" {
		t.Fatalf("Flush() calls = %v, want [kandev-plugin-slack]", deliverer.flushedIDs)
	}
}

func TestServiceHandleStatusChangePersistsRestartCountBestEffort(t *testing.T) {
	svc, fsStore, rt := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	rt.mu.Lock()
	rt.restartCounts["kandev-plugin-slack"] = 3
	rt.mu.Unlock()

	svc.handleStatusChange("kandev-plugin-slack", false, errors.New("ping timeout"))

	got, _ := svc.Get("kandev-plugin-slack")
	if got.RestartCount != 3 {
		t.Fatalf("Get().RestartCount = %d, want 3", got.RestartCount)
	}
	onDisk, err := fsStore.Get("kandev-plugin-slack")
	if err != nil {
		t.Fatalf("store.Get(): %v", err)
	}
	if onDisk.RestartCount != 3 {
		t.Fatalf("store.Get().RestartCount = %d, want 3", onDisk.RestartCount)
	}
}

// fakeDeliverer records Refresh/Flush calls so tests can assert the
// Service -> Deliverer attach-point contract without depending on the real
// delivery package.
type fakeDeliverer struct {
	refreshCount int
	flushedIDs   []string
}

func (f *fakeDeliverer) Refresh()              { f.refreshCount++ }
func (f *fakeDeliverer) Flush(pluginID string) { f.flushedIDs = append(f.flushedIDs, pluginID) }

func TestServiceInstallNotifiesDelivererRefresh(t *testing.T) {
	svc, _, _ := newTestService(t)
	deliverer := &fakeDeliverer{}
	svc.SetDeliverer(deliverer)

	installTestPlugin(t, svc, "kandev-plugin-slack")

	if deliverer.refreshCount != 1 {
		t.Fatalf("Refresh() call count = %d, want 1", deliverer.refreshCount)
	}
}

func TestServiceUninstallNotifiesDelivererRefresh(t *testing.T) {
	svc, _, _ := newTestService(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")
	deliverer := &fakeDeliverer{}
	svc.SetDeliverer(deliverer)

	if err := svc.Uninstall(context.Background(), "kandev-plugin-slack"); err != nil {
		t.Fatalf("Uninstall(): %v", err)
	}

	if deliverer.refreshCount != 1 {
		t.Fatalf("Refresh() call count after Uninstall() = %d, want 1", deliverer.refreshCount)
	}
}

func TestServiceWithoutDelivererDoesNotPanic(t *testing.T) {
	svc, _, _ := newTestService(t)
	// No SetDeliverer call — Install/SetStatus/Uninstall must tolerate a
	// nil deliverer (delivery not wired yet, e.g. in unit tests or before
	// backendapp attaches it).
	installTestPlugin(t, svc, "kandev-plugin-slack")
	if err := svc.Disable("kandev-plugin-slack"); err != nil {
		t.Fatalf("Disable(): %v", err)
	}
	if err := svc.Uninstall(context.Background(), "kandev-plugin-slack"); err != nil {
		t.Fatalf("Uninstall(): %v", err)
	}
}

func TestServiceDelivererAccessorReturnsAttached(t *testing.T) {
	svc, _, _ := newTestService(t)
	if svc.Deliverer() != nil {
		t.Fatalf("Deliverer() = %v, want nil before SetDeliverer", svc.Deliverer())
	}
	deliverer := &fakeDeliverer{}
	svc.SetDeliverer(deliverer)
	if svc.Deliverer() != Deliverer(deliverer) {
		t.Fatalf("Deliverer() did not return the attached deliverer")
	}
}

func TestServiceRegistryAccessorReturnsSameRegistry(t *testing.T) {
	dir := t.TempDir()
	fsStore := store.NewFSStore(dir)
	reg := NewRegistry()
	svc := NewService(fsStore, reg, nil, testLogger(t))

	if svc.Registry() != reg {
		t.Fatalf("Registry() did not return the injected registry instance")
	}
}

func TestServiceRevealSecretWithoutVaultReturnsError(t *testing.T) {
	svc, _, _ := newTestService(t)
	if _, err := svc.RevealSecret(context.Background(), "some-ref"); err == nil {
		t.Fatal("RevealSecret() expected error when no vault configured, got nil")
	}
}

func TestServiceRevealSecretResolvesThroughVault(t *testing.T) {
	svc, _, _ := newTestService(t)
	vault := newFakeSecretRevealer()
	vault.set("my-secret-ref", "s3cr3t")
	svc.SetSecrets(vault)

	got, err := svc.RevealSecret(context.Background(), "my-secret-ref")
	if err != nil {
		t.Fatalf("RevealSecret() unexpected error: %v", err)
	}
	if got != "s3cr3t" {
		t.Fatalf("RevealSecret() = %q, want %q", got, "s3cr3t")
	}
}

func TestServiceActiveUIPluginsFiltersByStatusAndBundle(t *testing.T) {
	svc, _, _ := newTestService(t)

	if _, err := svc.Install(context.Background(), testPackage(t, "kandev-plugin-with-ui", "1.0.0", true)); err != nil {
		t.Fatalf("Install(with bundle): %v", err)
	}

	// Active but no bundle declared — must be excluded.
	installTestPlugin(t, svc, "kandev-plugin-no-ui")

	active := svc.ActiveUIPlugins()
	if len(active) != 1 {
		t.Fatalf("ActiveUIPlugins() len = %d, want 1: %+v", len(active), active)
	}
	if active[0].ID != "kandev-plugin-with-ui" {
		t.Fatalf("ActiveUIPlugins()[0].ID = %q, want %q", active[0].ID, "kandev-plugin-with-ui")
	}
}

func TestServiceStartActivePluginsSpawnsOnlyActiveManagedNotAlreadyRunning(t *testing.T) {
	svc, dir, fsStore, _ := newTestServiceWithDir(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")

	// Simulate a fresh boot: the registry is reloaded from disk (status
	// "active" persisted from the previous run), but the runtime manager
	// has no live process yet.
	reg2 := NewRegistry()
	if err := reg2.Load(fsStore); err != nil {
		t.Fatalf("Load(): %v", err)
	}
	svc2 := NewService(fsStore, reg2, nil, testLogger(t))
	svc2.SetPluginsDir(dir)
	rt2 := newFakeRuntime()
	svc2.SetRuntime(rt2)

	svc2.StartActivePlugins(context.Background())

	if !rt2.Running("kandev-plugin-slack") {
		t.Fatal("StartActivePlugins() did not spawn the active plugin")
	}
}

func TestServiceStartActivePluginsFailurePersistsDiagnosticAndRefreshesDeliverer(t *testing.T) {
	svc, dir, fsStore, _ := newTestServiceWithDir(t)
	installTestPlugin(t, svc, "kandev-plugin-slack")

	reg2 := NewRegistry()
	if err := reg2.Load(fsStore); err != nil {
		t.Fatalf("Load(): %v", err)
	}
	svc2 := NewService(fsStore, reg2, nil, testLogger(t))
	svc2.SetPluginsDir(dir)
	rt2 := newFakeRuntime()
	rt2.setStartErr("kandev-plugin-slack", errors.New("boot handshake failed"))
	svc2.SetRuntime(rt2)
	deliverer := &fakeDeliverer{}
	svc2.SetDeliverer(deliverer)

	svc2.StartActivePlugins(context.Background())

	got, err := svc2.Get("kandev-plugin-slack")
	if err != nil {
		t.Fatalf("Get() after boot failure: %v", err)
	}
	if got.Status != StatusError {
		t.Fatalf("Status after boot failure = %q, want %q", got.Status, StatusError)
	}
	if !strings.Contains(got.LastError, "boot handshake failed") || got.LastErrorAt == nil {
		t.Fatalf("diagnostic after boot failure = (%q, %v), want boot failure and timestamp", got.LastError, got.LastErrorAt)
	}
	// bootScan refreshes once at the end of its normal reconciliation, then
	// the failed active spawn refreshes again so delivery sees StatusError.
	if deliverer.refreshCount != 2 {
		t.Fatalf("Refresh() calls after boot failure = %d, want 2", deliverer.refreshCount)
	}
}