@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/pending-interactions-resolved-event.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Verifies that every resolution path through
+ * `runtime/pending-interactions.ts` publishes an `interaction_resolved`
+ * envelope on the event hub with the right state.
+ *
+ * Each test registers an interaction directly and calls `resolve()` or
+ * `removeByConversation()` so we exercise the tracker in isolation
+ * without spinning up a Conversation, prompter, or proxy.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+// Capture every broadcast emitted by the tracker. The real hub is replaced
+// with a thin recorder so we can assert payloads deterministically.
+const publishedMessages: ServerMessage[] = [];
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: ServerMessage) => {
+    publishedMessages.push(msg);
+  },
+  capabilityForMessageType: () => undefined,
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => ({ dispose: () => {}, active: true }),
+  },
+}));
+
+const pendingInteractions = await import("../runtime/pending-interactions.js");
+
+beforeEach(() => {
+  publishedMessages.length = 0;
+  pendingInteractions.clear();
+});
+
+afterEach(() => {
+  pendingInteractions.clear();
+});
+
+function lastResolvedEvent() {
+  const evt = publishedMessages.find((m) => m.type === "interaction_resolved");
+  expect(evt).toBeDefined();
+  return evt as Extract<ServerMessage, { type: "interaction_resolved" }>;
+}
+
+describe("pendingInteractions.resolve emits interaction_resolved", () => {
+  test("default state is 'cancelled'", () => {
+    pendingInteractions.register("req-1", {
+      conversationId: "conv-1",
+      kind: "confirmation",
+    });
+    const returned = pendingInteractions.resolve("req-1");
+    expect(returned).toBeDefined();
+    const evt = lastResolvedEvent();
+    expect(evt.requestId).toBe("req-1");
+    expect(evt.conversationId).toBe("conv-1");
+    expect(evt.state).toBe("cancelled");
+    expect(evt.kind).toBe("confirmation");
+  });
+
+  test("approved state propagates", () => {
+    pendingInteractions.register("req-approve", {
+      conversationId: "conv-a",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-approve", "approved");
+    expect(lastResolvedEvent().state).toBe("approved");
+  });
+
+  test("rejected state propagates", () => {
+    pendingInteractions.register("req-reject", {
+      conversationId: "conv-b",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-reject", "rejected");
+    expect(lastResolvedEvent().state).toBe("rejected");
+  });
+
+  test("answered state propagates (secret response)", () => {
+    pendingInteractions.register("req-secret", {
+      conversationId: "conv-c",
+      kind: "secret",
+    });
+    pendingInteractions.resolve("req-secret", "answered");
+    const evt = lastResolvedEvent();
+    expect(evt.state).toBe("answered");
+    expect(evt.kind).toBe("secret");
+  });
+
+  test("superseded state propagates", () => {
+    pendingInteractions.register("req-super", {
+      conversationId: "conv-d",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-super", "superseded");
+    expect(lastResolvedEvent().state).toBe("superseded");
+  });
+
+  test("no event is emitted when the requestId is unknown", () => {
+    pendingInteractions.resolve("never-registered", "approved");
+    expect(publishedMessages).toHaveLength(0);
+  });
+
+  test("a single resolve emits exactly one event", () => {
+    pendingInteractions.register("req-once", {
+      conversationId: "conv-e",
+      kind: "host_bash",
+    });
+    pendingInteractions.resolve("req-once", "answered");
+    // Second resolve is a no-op because the entry was already consumed.
+    pendingInteractions.resolve("req-once", "answered");
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    );
+    expect(events).toHaveLength(1);
+  });
+
+  test("clears the registered timer on resolve", () => {
+    let fired = false;
+    const timer = setTimeout(() => {
+      fired = true;
+    }, 10_000);
+    pendingInteractions.register("req-timer", {
+      conversationId: "conv-f",
+      kind: "confirmation",
+      timer,
+    });
+    pendingInteractions.resolve("req-timer", "approved");
+    clearTimeout(timer);
+    expect(fired).toBe(false);
+  });
+});
+
+describe("removeByConversation emits interaction_resolved per entry", () => {
+  test("emits superseded for every non-host interaction in the conversation", () => {
+    pendingInteractions.register("conf-1", {
+      conversationId: "conv-x",
+      kind: "confirmation",
+    });
+    pendingInteractions.register("secret-1", {
+      conversationId: "conv-x",
+      kind: "secret",
+    });
+    pendingInteractions.register("question-1", {
+      conversationId: "conv-x",
+      kind: "question",
+    });
+    pendingInteractions.register("host-bash-1", {
+      conversationId: "conv-x",
+      kind: "host_bash",
+    });
+    pendingInteractions.register("conf-other", {
+      conversationId: "conv-y",
+      kind: "confirmation",
+    });
+
+    pendingInteractions.removeByConversation("conv-x");
+
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    ) as Extract<ServerMessage, { type: "interaction_resolved" }>[];
+    expect(events).toHaveLength(3);
+    expect(events.every((e) => e.state === "superseded")).toBe(true);
+    const requestIds = new Set(events.map((e) => e.requestId));
+    expect(requestIds).toEqual(new Set(["conf-1", "secret-1", "question-1"]));
+
+    // host_bash entries survive auto-deny — no event for them.
+    expect(pendingInteractions.get("host-bash-1")).toBeDefined();
+    // Unrelated conversation is untouched.
+    expect(pendingInteractions.get("conf-other")).toBeDefined();
+  });
+
+  test("explicit state arg overrides the default 'superseded'", () => {
+    pendingInteractions.register("conf-2", {
+      conversationId: "conv-z",
+      kind: "confirmation",
+    });
+    pendingInteractions.removeByConversation("conv-z", "cancelled");
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    );
+    expect(events).toHaveLength(1);
+    expect(
+      (events[0] as Extract<ServerMessage, { type: "interaction_resolved" }>)
+        .state,
+    ).toBe("cancelled");
+  });
+});

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -100,7 +100,7 @@ mock.module("../permissions/checker.js", () => ({
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
   getRecentInvocations: () => [],
-  rotateToolInvocations: () => 0,
+  rotateToolInvocations: async () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({
@@ -111,7 +111,7 @@ mock.module("../tools/registry.js", () => ({
       description: "test tool",
       category: "shell",
       defaultRiskLevel: "medium",
-      getDefinition: () => ({}),
+      input_schema: {},
       execute: async () => fakeToolResult,
     };
   },

package/src/__tests__/platform.test.ts

@@ -8,8 +8,7 @@ import {
   getDataDir,
   getDbPath,
   getHistoryPath,
-  getInterfacesDir,
-  getLogPath,
+  getLogsDir,
   getPidPath,
   getSandboxRootDir,
   getSandboxWorkingDir,
@@ -65,9 +64,8 @@ describe("path characterization", () => {
 
     // Sub-paths under workspace/data
     expect(getDbPath()).toBe(join(data, "db", "assistant.db"));
-    expect(getLogPath()).toBe(join(data, "logs", "vellum.log"));
+    expect(getLogsDir()).toBe(join(data, "logs"));
     expect(getHistoryPath()).toBe(join(data, "history"));
-    expect(getInterfacesDir()).toBe(join(data, "interfaces"));
     expect(getSandboxRootDir()).toBe(join(data, "sandbox"));
     expect(getSandboxWorkingDir()).toBe(ws);
 
@@ -117,7 +115,6 @@ describe("path characterization", () => {
     expect(existsSync(join(data, "memory"))).toBe(true);
     expect(existsSync(join(data, "memory", "knowledge"))).toBe(true);
     expect(existsSync(join(data, "apps"))).toBe(true);
-    expect(existsSync(join(data, "interfaces"))).toBe(true);
 
     rmSync(wsDir, { recursive: true, force: true });
   });

package/src/__tests__/plugin-api-tool-definition.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Shape tests for the public `ToolDefinition` author-facing tool spec.
+ *
+ * These tests don't exercise runtime behavior — they assert via
+ * `satisfies` that representative tool literals line up with the public
+ * interface. If a later PR breaks a field name or signature in
+ * `assistant/src/plugin-api/types.ts`, this file fails to type-check and
+ * the regression is caught at `tsc --noEmit` / `bun test` time.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  RiskLevel,
+  type ToolContext,
+  type ToolDefinition,
+  type ToolExecutionResult,
+} from "../plugin-api/index.js";
+
+describe("ToolDefinition (public author-facing tool spec) ", () => {
+  test("a fully-populated literal satisfies the interface", () => {
+    const tool = {
+      description: "Greet the model in a fixed language.",
+      defaultRiskLevel: RiskLevel.Low,
+      input_schema: {
+        type: "object",
+        properties: {
+          language: { type: "string" },
+        },
+        required: ["language"],
+        additionalProperties: false,
+      },
+      async execute(
+        input: Record<string, unknown>,
+        _ctx: ToolContext,
+      ): Promise<ToolExecutionResult> {
+        return {
+          content: `hello, ${String(input.language)} speaker`,
+          isError: false,
+        };
+      },
+    } as const satisfies ToolDefinition;
+
+    // `as const` propagates literal types and verifies type compatibility,
+    // but the runtime expectations below also smoke-check the structure
+    // for anyone reading the test without TS folded in.
+    expect(typeof tool.execute).toBe("function");
+    expect(tool.defaultRiskLevel).toBe(RiskLevel.Low);
+  });
+
+  test("every field is optional — empty literal satisfies the interface", () => {
+    const tool: ToolDefinition = {};
+    expect(tool).toEqual({});
+  });
+
+  test("every author-facing risk level is permitted", () => {
+    const low: ToolDefinition = { defaultRiskLevel: RiskLevel.Low };
+    const medium: ToolDefinition = { defaultRiskLevel: RiskLevel.Medium };
+    const high: ToolDefinition = { defaultRiskLevel: RiskLevel.High };
+
+    expect(low.defaultRiskLevel).toBe(RiskLevel.Low);
+    expect(medium.defaultRiskLevel).toBe(RiskLevel.Medium);
+    expect(high.defaultRiskLevel).toBe(RiskLevel.High);
+  });
+
+  test("execute receives the public ToolContext", async () => {
+    // Type-only assertion: the execute signature uses the public
+    // ToolContext (narrow base). A daemon-internal field added to the
+    // rich ToolContext that doesn't exist on the narrow one must not be
+    // accessible here. We can't test this at runtime — the assertion
+    // lives in `tsc --noEmit` over this file.
+    const tool: ToolDefinition = {
+      async execute(_input, ctx) {
+        // `ctx` is the public `ToolContext`. Touch
+        // commonly-needed fields to make sure they're present.
+        const _conversationId = ctx.conversationId;
+        const _workingDir = ctx.workingDir;
+        const _signal = ctx.signal;
+        return { content: "ok", isError: false };
+      },
+    };
+    const result = await tool.execute?.(
+      {},
+      {
+        conversationId: "conv-abc",
+        workingDir: "/tmp",
+        signal: new AbortController().signal,
+      } as ToolContext,
+    );
+    expect(result?.isError).toBe(false);
+  });
+});

package/src/__tests__/plugin-bootstrap.test.ts

@@ -375,6 +375,7 @@ describe("plugin bootstrap", () => {
             name: "gated-off-tool",
             description: "should not be registered",
             defaultRiskLevel: RiskLevel.Low,
+            executionTarget: "sandbox",
             input_schema: { type: "object", properties: {}, required: [] },
             execute: async () => ({ content: "nope", isError: false }),
           },
@@ -421,8 +422,7 @@ describe("plugin bootstrap", () => {
   });
 
   test("requiresFlag absent: plugin activates unconditionally", async () => {
-    // Deliberately do not set any overrides — the resolver defaults
-    // undeclared keys to `true`, but more importantly a plugin with no
+    // Deliberately do not set any overrides — a plugin with no
     // `requiresFlag` key must not consult the resolver at all.
     let initFired = false;
     const plugin = buildPlugin("no-flag", {

package/src/__tests__/plugin-source-watcher.test.ts

@@ -0,0 +1,302 @@
+/**
+ * Tests for PluginSourceWatcher — filesystem watcher that detects plugin
+ * directory changes and triggers debounced reregistration.
+ *
+ * Key regression: the watcher must survive (and recover from) the Linux/Bun
+ * recursive-watch limitation where subdirectories created after watch starts
+ * are silently dropped. We test that close→reopen + rescan catches these.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+const TEST_PLUGINS_DIR = "/tmp/test-plugins";
+
+let capturedWatchCallback:
+  | ((eventType: string, filename: string | null) => void)
+  | null = null;
+let mockWatchShouldThrow = false;
+const mockWatcher = { close: mock(() => {}) };
+
+const mockWatch = mock(
+  (
+    _path: string,
+    _opts: Record<string, unknown>,
+    callback: (eventType: string, filename: string | null) => void,
+  ) => {
+    if (mockWatchShouldThrow) throw new Error("watch failed");
+    capturedWatchCallback = callback;
+    return mockWatcher;
+  },
+);
+
+const mockRereadirSync = mock((_path: string): string[] => []);
+
+let mockGetRegisteredPluginImpl: (name: string) => unknown | undefined = (
+  _name,
+) => undefined;
+const mockGetRegisteredPlugin = mock((name: string) =>
+  mockGetRegisteredPluginImpl(name),
+);
+
+let mockReregisterExternalPluginImpl = mock(async (_name: string) => {});
+const mockReregisterExternalPlugin = mock(async (name: string) =>
+  mockReregisterExternalPluginImpl(name),
+);
+
+mock.module("node:fs", () => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const actualFs = require("node:fs");
+  return {
+    ...actualFs,
+    watch: mockWatch,
+    readdirSync: mockRereadirSync,
+  };
+});
+
+mock.module("../plugins/registry.js", () => ({
+  getRegisteredPlugin: mockGetRegisteredPlugin,
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspacePluginsDir: mock(() => TEST_PLUGINS_DIR),
+}));
+
+mock.module("../daemon/external-plugins-bootstrap.js", () => ({
+  reregisterExternalPlugin: mockReregisterExternalPlugin,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: mock(() => ({
+    info: mock(() => {}),
+    warn: mock(() => {}),
+  })),
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { PluginSourceWatcher } from "../daemon/plugin-source-watcher.js";
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("PluginSourceWatcher", () => {
+  beforeEach(() => {
+    PluginSourceWatcher.resetForTests();
+    capturedWatchCallback = null;
+    mockWatchShouldThrow = false;
+    mockWatcher.close.mockClear();
+    mockWatch.mockClear();
+    mockRereadirSync.mockClear();
+    mockGetRegisteredPlugin.mockClear();
+    mockReregisterExternalPlugin.mockClear();
+    mockGetRegisteredPluginImpl = (_name: string) => undefined;
+    mockReregisterExternalPluginImpl = mock(async (_name: string) => {});
+  });
+
+  afterEach(() => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.stop();
+  });
+
+  test("start() creates a recursive watcher on the plugins directory", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    expect(capturedWatchCallback).not.toBeNull();
+  });
+
+  test("plugin directory creation triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin");
+
+    // Wait for debounce
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("nested file change within plugin triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("deeply nested file change triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/handlers/util/helper.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("dotfiles in plugins root are ignored", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", ".DS_Store");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("null filename is ignored", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", null);
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("rapid changes to same plugin are debounced into single rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+    capturedWatchCallback!("change", "my-plugin/src/handlers.ts");
+    capturedWatchCallback!("change", "my-plugin/package.json");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledTimes(1);
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("changes to different plugins trigger separate rebuilds (debounced)", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "plugin-a/src/index.ts");
+    capturedWatchCallback!("change", "plugin-b/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledTimes(2);
+    expect(mockReregisterExternalPlugin).toHaveBeenNthCalledWith(1, "plugin-a");
+    expect(mockReregisterExternalPlugin).toHaveBeenNthCalledWith(2, "plugin-b");
+  });
+
+  test("stop() closes watcher and cancels pending rebuilds", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+    watcher.stop();
+
+    expect(mockWatcher.close).toHaveBeenCalledTimes(1);
+    // No rebuild should fire after stop
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("ensureStarted() initializes watcher after start() if watch coverage was lost", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    expect(capturedWatchCallback).not.toBeNull();
+
+    // Simulate lost coverage while the daemon lifecycle is still started
+    // (e.g. a previous watch attempt failed after startup).
+    (watcher as unknown as { watcher: unknown }).watcher = null;
+    capturedWatchCallback = null;
+
+    watcher.ensureStarted();
+    expect(capturedWatchCallback).not.toBeNull();
+  });
+
+  test("ensureStarted() is a no-op when watcher is already running", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    const callCountAfterStart = mockWatch.mock.calls.length;
+
+    watcher.ensureStarted();
+    expect(mockWatch.mock.calls.length).toBe(callCountAfterStart);
+  });
+
+  test("watcher restart keeps the previous watcher active if replacement fails", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    const firstCallback = capturedWatchCallback;
+
+    mockWatchShouldThrow = true;
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+
+    expect(mockWatcher.close).not.toHaveBeenCalled();
+    expect((watcher as unknown as { watcher: unknown }).watcher).toBe(
+      mockWatcher,
+    );
+    expect(capturedWatchCallback).toBe(firstCallback);
+  });
+
+  test("singleton instance is shared across calls", () => {
+    const watcher1 = PluginSourceWatcher.getInstance();
+    const watcher2 = PluginSourceWatcher.getInstance();
+    expect(watcher1).toBe(watcher2);
+  });
+
+  test("resetForTests() clears the singleton", () => {
+    const watcher1 = PluginSourceWatcher.getInstance();
+    watcher1.start();
+
+    PluginSourceWatcher.resetForTests();
+    const watcher2 = PluginSourceWatcher.getInstance();
+
+    expect(watcher1).not.toBe(watcher2);
+  });
+
+  /**
+   * REGRESSION: When an event arrives during a close→reopen swap, rescan
+   * must catch any plugin not yet in the registry.
+   *
+   * Scenario:
+   * 1. Plugin "new-plugin" directory is created
+   * 2. Event fires, triggering a watcher restart (close + reopen)
+   * 3. Before the old watcher's callback is fully fired, another plugin
+   *    "late-plugin" is created
+   * 4. The new watcher doesn't yet know about "late-plugin"
+   * 5. After the reopen, rescan walks the directory and finds "late-plugin"
+   *    not in the registry, and schedules its rebuild
+   */
+  test("watcher restart + rescan catches plugins created during close→reopen", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    // Track which plugins are "registered" at each point
+    const registeredPlugins = new Set<string>();
+    mockGetRegisteredPluginImpl = (name: string) =>
+      registeredPlugins.has(name) ? { name } : undefined;
+
+    // Simulate multiple plugins on disk
+    mockRereadirSync.mockImplementation(() => [
+      "new-plugin",
+      "late-plugin",
+      ".DS_Store",
+    ]);
+
+    // Fire an event on new-plugin (this will trigger a watcher restart)
+    capturedWatchCallback!("change", "new-plugin/src/index.ts");
+
+    // Wait for the direct rebuild debounce, the watcher-restart debounce,
+    // and the rescan-triggered rebuild debounce.
+    await new Promise((r) => setTimeout(r, 1100));
+
+    // At this point, rescan should have run and discovered late-plugin,
+    // even though no direct fs.watch event was delivered for it.
+    const calls = mockReregisterExternalPlugin.mock.calls.map((c) => c[0]);
+    expect(calls).toContain("new-plugin");
+    expect(calls).toContain("late-plugin");
+    expect(calls).not.toContain(".DS_Store");
+  });
+});