@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/schedule-routes.test.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { getDb, initializeDb } from "../memory/db.js";
+import { scheduleRouteDefinitions } from "../runtime/routes/schedule-routes.js";
+import { createSchedule } from "../schedule/schedule-store.js";
+import { scheduleTask } from "../tasks/task-scheduler.js";
+import { createTask } from "../tasks/task-store.js";
+
+initializeDb();
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM cron_runs");
+  db.run("DELETE FROM cron_jobs");
+  db.run("DELETE FROM task_runs");
+  db.run("DELETE FROM tasks");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function getRunNowHandler(sendMessageDeps: {
+  getOrCreateConversation: (
+    conversationId: string,
+    options?: Record<string, unknown>,
+  ) => Promise<unknown>;
+}) {
+  const route = scheduleRouteDefinitions({
+    sendMessageDeps: sendMessageDeps as never,
+  }).find(
+    (candidate) =>
+      candidate.endpoint === "schedules/:id/run" && candidate.method === "POST",
+  );
+  if (!route) {
+    throw new Error("Run-now schedule route not found");
+  }
+  return route.handler;
+}
+
+describe("schedule run-now trust propagation", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("manual run-now executes plain schedules with guardian trust", async () => {
+    const schedule = createSchedule({
+      name: "Direct schedule",
+      cronExpression: "* * * * *",
+      message: "scan my inbox",
+      syntax: "cron",
+    });
+
+    const getOrCreateCalls: Array<{
+      conversationId: string;
+      options?: Record<string, unknown>;
+    }> = [];
+    const processCalls: Array<unknown[]> = [];
+    const fakeConversation: {
+      taskRunId?: string;
+      processMessage: (...args: unknown[]) => Promise<string>;
+    } = {
+      taskRunId: "stale-task-run",
+      async processMessage(...args: unknown[]) {
+        processCalls.push(args);
+        return "message-id";
+      },
+    };
+
+    const handler = getRunNowHandler({
+      getOrCreateConversation: async (conversationId, options) => {
+        getOrCreateCalls.push({ conversationId, options });
+        return fakeConversation;
+      },
+    });
+
+    const response = await handler({
+      req: new Request(`http://localhost/v1/schedules/${schedule.id}/run`, {
+        method: "POST",
+      }),
+      url: new URL(`http://localhost/v1/schedules/${schedule.id}/run`),
+      server: {} as never,
+      authContext: {} as never,
+      params: { id: schedule.id },
+    });
+
+    expect(response.status).toBe(200);
+    expect(getOrCreateCalls).toHaveLength(1);
+    expect(getOrCreateCalls[0].options?.trustContext).toEqual({
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    });
+    expect(processCalls).toHaveLength(1);
+    expect(processCalls[0][0]).toBe("scan my inbox");
+    expect(processCalls[0][6]).toEqual({ isInteractive: false });
+    expect(fakeConversation.taskRunId).toBeUndefined();
+  });
+
+  test("manual run-now executes scheduled tasks with guardian trust and taskRunId", async () => {
+    const task = createTask({
+      title: "Email triage",
+      template: "triage inbox in background",
+    });
+    const schedule = scheduleTask({
+      taskId: task.id,
+      name: "Scheduled task",
+      cronExpression: "* * * * *",
+    });
+
+    const getOrCreateCalls: Array<{
+      conversationId: string;
+      options?: Record<string, unknown>;
+    }> = [];
+    const observedTaskRunIds: Array<string | undefined> = [];
+    const processCalls: Array<unknown[]> = [];
+    const fakeConversation: {
+      taskRunId?: string;
+      processMessage: (...args: unknown[]) => Promise<string>;
+    } = {
+      taskRunId: undefined,
+      async processMessage(...args: unknown[]) {
+        observedTaskRunIds.push(fakeConversation.taskRunId);
+        processCalls.push(args);
+        return "message-id";
+      },
+    };
+
+    const handler = getRunNowHandler({
+      getOrCreateConversation: async (conversationId, options) => {
+        getOrCreateCalls.push({ conversationId, options });
+        return fakeConversation;
+      },
+    });
+
+    const response = await handler({
+      req: new Request(`http://localhost/v1/schedules/${schedule.id}/run`, {
+        method: "POST",
+      }),
+      url: new URL(`http://localhost/v1/schedules/${schedule.id}/run`),
+      server: {} as never,
+      authContext: {} as never,
+      params: { id: schedule.id },
+    });
+
+    expect(response.status).toBe(200);
+    expect(getOrCreateCalls).toHaveLength(1);
+    expect(getOrCreateCalls[0].options?.trustContext).toEqual({
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    });
+    expect(processCalls).toHaveLength(1);
+    expect(processCalls[0][0]).toBe("triage inbox in background");
+    expect(processCalls[0][6]).toEqual({ isInteractive: false });
+    expect(typeof observedTaskRunIds[0]).toBe("string");
+    expect(fakeConversation.taskRunId).toBeUndefined();
+  });
+});

package/src/__tests__/search-skills-unified.test.ts

@@ -43,6 +43,20 @@ const mockSkillsshSearch = mock(
     }>
   > => [],
 );
+const mockFetchSkillAudits = mock(
+  async (
+    _source: string,
+    _skillSlugs: string[],
+  ): Promise<
+    Record<
+      string,
+      Record<
+        string,
+        { risk: string; alerts?: number; score?: number; analyzedAt: string }
+      >
+    >
+  > => ({}),
+);
 
 // ---------------------------------------------------------------------------
 // Mock modules — before importing module under test
@@ -79,6 +93,7 @@ mock.module("../skills/clawhub.js", () => ({
 
 mock.module("../skills/skillssh-registry.js", () => ({
   searchSkillsRegistry: mockSkillsshSearch,
+  fetchSkillAudits: mockFetchSkillAudits,
 }));
 
 // Stub install-meta (needed by the new origin derivation logic)
@@ -166,11 +181,13 @@ describe("searchSkills (unified)", () => {
     mockCatalogSkills.mockReset();
     mockClawhubSearch.mockReset();
     mockSkillsshSearch.mockReset();
+    mockFetchSkillAudits.mockReset();
 
     // Defaults: empty results
     mockCatalogSkills.mockReturnValue([]);
     mockClawhubSearch.mockResolvedValue({ skills: [] });
     mockSkillsshSearch.mockResolvedValue([]);
+    mockFetchSkillAudits.mockResolvedValue({});
   });
 
   test("returns results from all three registries", async () => {
@@ -221,6 +238,11 @@ describe("searchSkills (unified)", () => {
     expect(result.skills[1]!.id).toBe("deploy");
     expect(result.skills[1]!.origin).toBe("clawhub");
     expect(result.skills[1]!.kind).toBe("catalog");
+    // Verify version is mapped through from clawhub search results
+    const clawhubSkill = result.skills[1]!;
+    if (clawhubSkill.origin === "clawhub") {
+      expect(clawhubSkill.version).toBe("1.0.0");
+    }
     expect(result.skills[2]!.id).toBe("vercel-labs/skills/react-best");
     expect(result.skills[2]!.origin).toBe("skillssh");
     expect(result.skills[2]!.kind).toBe("catalog");
@@ -419,4 +441,100 @@ describe("searchSkills (unified)", () => {
       expect(skill.installs).toBe(99);
     }
   });
+
+  test("attaches audit data to skills.sh results on success", async () => {
+    mockCatalogSkills.mockReturnValue([]);
+    mockClawhubSearch.mockResolvedValue({ skills: [] });
+    mockSkillsshSearch.mockResolvedValue([
+      {
+        id: "acme/tools/lint",
+        skillId: "lint",
+        name: "Lint",
+        installs: 10,
+        source: "acme/tools",
+      },
+      {
+        id: "acme/tools/format",
+        skillId: "format",
+        name: "Format",
+        installs: 20,
+        source: "acme/tools",
+      },
+    ]);
+    mockFetchSkillAudits.mockResolvedValue({
+      lint: {
+        ath: { risk: "safe", score: 100, analyzedAt: "2025-01-01T00:00:00Z" },
+      },
+      format: {
+        socket: {
+          risk: "low",
+          alerts: 2,
+          analyzedAt: "2025-01-02T00:00:00Z",
+        },
+      },
+    });
+
+    const result = await searchSkills("lint", dummyCtx);
+    expect(result.success).toBe(true);
+    if (!result.success) throw new Error("Expected success");
+
+    expect(result.skills).toHaveLength(2);
+
+    const lintSkill = result.skills.find((s) => s.id === "acme/tools/lint")!;
+    expect(lintSkill.origin).toBe("skillssh");
+    if (lintSkill.origin === "skillssh") {
+      expect(lintSkill.audit).toBeDefined();
+      expect(lintSkill.audit!.ath).toEqual({
+        risk: "safe",
+        score: 100,
+        analyzedAt: "2025-01-01T00:00:00Z",
+      });
+    }
+
+    const formatSkill = result.skills.find(
+      (s) => s.id === "acme/tools/format",
+    )!;
+    expect(formatSkill.origin).toBe("skillssh");
+    if (formatSkill.origin === "skillssh") {
+      expect(formatSkill.audit).toBeDefined();
+      expect(formatSkill.audit!.socket).toEqual({
+        risk: "low",
+        alerts: 2,
+        analyzedAt: "2025-01-02T00:00:00Z",
+      });
+    }
+
+    // Verify fetchSkillAudits was called with grouped source/slugs
+    expect(mockFetchSkillAudits).toHaveBeenCalledTimes(1);
+    expect(mockFetchSkillAudits).toHaveBeenCalledWith("acme/tools", [
+      "lint",
+      "format",
+    ]);
+  });
+
+  test("search succeeds when fetchSkillAudits throws", async () => {
+    mockCatalogSkills.mockReturnValue([]);
+    mockClawhubSearch.mockResolvedValue({ skills: [] });
+    mockSkillsshSearch.mockResolvedValue([
+      {
+        id: "org/repo/my-skill",
+        skillId: "my-skill",
+        name: "My Skill",
+        installs: 5,
+        source: "org/repo",
+      },
+    ]);
+    mockFetchSkillAudits.mockRejectedValue(new Error("audit service down"));
+
+    const result = await searchSkills("my-skill", dummyCtx);
+    expect(result.success).toBe(true);
+    if (!result.success) throw new Error("Expected success");
+
+    expect(result.skills).toHaveLength(1);
+    const skill = result.skills[0]!;
+    expect(skill.origin).toBe("skillssh");
+    if (skill.origin === "skillssh") {
+      expect(skill.audit).toBeUndefined();
+    }
+  });
 });

package/src/__tests__/secret-detection-handler.test.ts

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
+const triggerMock = mock(async () => {});
+const scanTextMock = mock(() => [
+  { type: "api_key", redactedValue: "sk-***redacted***" },
+]);
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    secretDetection: {
+      enabled: true,
+      action: "prompt",
+      entropyThreshold: 4.5,
+      customPatterns: [],
+    },
+  }),
+}));
+
+mock.module("../hooks/manager.js", () => ({
+  getHookManager: () => ({
+    trigger: triggerMock,
+  }),
+}));
+
+mock.module("../security/secret-scanner.js", () => ({
+  compileCustomPatterns: () => [],
+  redactSecrets: (content: string) => content,
+  scanText: scanTextMock,
+}));
+
+import { SecretDetectionHandler } from "../tools/secret-detection-handler.js";
+
+describe("SecretDetectionHandler under v2", () => {
+  beforeEach(() => {
+    _setOverridesForTesting({});
+    triggerMock.mockClear();
+    scanTextMock.mockClear();
+  });
+
+  test("blocks secret output without opening a deterministic approval prompt", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+
+    const promptMock = mock(async () => ({ decision: "allow" as const }));
+    const handler = new SecretDetectionHandler({
+      prompt: promptMock,
+    } as never);
+    const emitLifecycleEvent = mock(() => {});
+
+    const result = await handler.handle(
+      { content: "secret output", isError: false },
+      "bash",
+      { command: "print-secret" },
+      {
+        conversationId: "conv-1",
+        workingDir: "/tmp",
+        requestId: "req-1",
+        isInteractive: true,
+      } as never,
+      "sandbox",
+      "medium",
+      "allow",
+      Date.now(),
+      emitLifecycleEvent,
+      (_toolName, input) => input,
+    );
+
+    expect(result.earlyReturn).toBe(true);
+    expect(result.result.isError).toBe(true);
+    expect(result.result.content).toContain(
+      "Secret-output approval cards are disabled under v2",
+    );
+    expect(promptMock).not.toHaveBeenCalled();
+    expect(emitLifecycleEvent).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        type: "permission_denied",
+        decision: "deny",
+      }),
+    );
+    expect(triggerMock).toHaveBeenCalled();
+  });
+});

package/src/__tests__/secret-ingress-http.test.ts

@@ -175,6 +175,7 @@ function makeSendMessageDeps() {
     trustContext: undefined,
     hasPendingConfirmation: () => false,
     setHostBashProxy: () => {},
+    setHostBrowserProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},

package/src/__tests__/secret-scanner-executor.test.ts

@@ -56,10 +56,14 @@ mock.module("../permissions/checker.js", () => ({
   generateScopeOptions: () => [],
 }));
 
+// Mock every export so downstream test files that dynamically import modules
+// with a static `from "../memory/tool-usage-store.js"` still see all symbols.
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: (inv: unknown) => {
     recordedInvocations.push(inv);
   },
+  getRecentInvocations: () => [],
+  rotateToolInvocations: () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({

package/src/__tests__/secure-keys.test.ts

@@ -23,6 +23,7 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+import type { CesClient } from "../credential-execution/client.js";
 import * as encryptedStore from "../security/encrypted-store.js";
 import { _setStorePath } from "../security/encrypted-store.js";
 import {
@@ -31,6 +32,8 @@ import {
   getSecureKeyAsync,
   getSecureKeyResultAsync,
   listSecureKeysAsync,
+  setCesClient,
+  setCesReconnect,
   setSecureKeyAsync,
 } from "../security/secure-keys.js";
 
@@ -291,4 +294,108 @@ describe("secure-keys", () => {
       expect(result.unreachable).toBe(false);
     });
   });
+
+  // -----------------------------------------------------------------------
+  // CES reconnection reentrancy
+  // -----------------------------------------------------------------------
+  //
+  // The reconnect callback runs while the credential resolver is waiting on
+  // `_reconnectInFlight`. A nested `getSecureKeyAsync()` from inside the
+  // callback — e.g. `resolveManagedProxyContext()` reading the assistant API
+  // key for the handshake — would recursively `await` the same in-flight
+  // promise and deadlock for 45 seconds until `CREDENTIAL_OP_TIMEOUT_MS`
+  // fires. The guard in `attemptCesReconnection` short-circuits that
+  // reentrant case so nested reads resolve immediately (as "unreachable")
+  // and the outer reconnect makes progress.
+  describe("reconnect callback reentrancy", () => {
+    interface ControllableClient extends CesClient {
+      setReady: (ready: boolean) => void;
+    }
+
+    function makeControllableClient(initialReady = true): ControllableClient {
+      let ready = initialReady;
+      return {
+        handshake: async () => ({ accepted: true }),
+        call: async () => ({ found: false, value: undefined }) as never,
+        isReady: () => ready,
+        close: () => {
+          ready = false;
+        },
+        updateAssistantApiKey: async () => ({ updated: true }),
+        setReady: (r: boolean) => {
+          ready = r;
+        },
+      } as ControllableClient;
+    }
+
+    test("nested credential read inside reconnect callback does not deadlock", async () => {
+      // Seed the encrypted store with a value so nested reads have something
+      // to target if they were to accidentally succeed via fallback paths.
+      encryptedStore.setKey("test-key", "encrypted-value");
+
+      // Install a CES client that starts ready so the first read resolves
+      // the backend to CES RPC, then flip it to unready so the NEXT read
+      // triggers the reconnect path.
+      const client = makeControllableClient(true);
+      setCesClient(client);
+
+      // Prime the resolver so `_resolvedBackend` points at CES RPC.
+      await getSecureKeyAsync("test-key");
+      client.setReady(false);
+
+      let nestedReadResolved = false;
+      let reconnectCallbackRan = 0;
+
+      setCesReconnect(async () => {
+        reconnectCallbackRan++;
+        // Yield once so `_reconnectInFlight` (assigned after this IIFE's
+        // first await) is observable to any nested resolver. This matches
+        // production timing, where the callback awaits `pm.stop()` /
+        // `pm.start()` before reading credentials — those awaits complete
+        // the outer assignment, so the subsequent nested read sees a live
+        // `_reconnectInFlight` and is the recursion that caused the 45s
+        // deadlock.
+        await Promise.resolve();
+        await getSecureKeyAsync("test-key");
+        nestedReadResolved = true;
+        return makeControllableClient(true);
+      });
+
+      const start = Date.now();
+      await getSecureKeyAsync("test-key");
+      const elapsed = Date.now() - start;
+
+      expect(reconnectCallbackRan).toBe(1);
+      expect(nestedReadResolved).toBe(true);
+      // Pre-fix, this took 45s (CREDENTIAL_OP_TIMEOUT_MS). Post-fix it's
+      // bounded only by the mock callback's own work.
+      expect(elapsed).toBeLessThan(2000);
+    });
+
+    test("reconnect callback that throws still releases the reentrancy flag", async () => {
+      const client = makeControllableClient(true);
+      setCesClient(client);
+      await getSecureKeyAsync("any-key"); // prime the resolver
+      client.setReady(false);
+
+      setCesReconnect(async () => {
+        throw new Error("boom");
+      });
+
+      await getSecureKeyAsync("any-key");
+
+      // Swap in a reconnect that succeeds and wait past the 3s cooldown
+      // in `attemptCesReconnection`. A stuck reentrancy flag from the
+      // throwing callback would prevent this second attempt from running.
+      let secondCallbackRan = 0;
+      setCesReconnect(async () => {
+        secondCallbackRan++;
+        return makeControllableClient(true);
+      });
+      await new Promise((resolve) => setTimeout(resolve, 3_100));
+
+      await getSecureKeyAsync("any-key");
+      expect(secondCallbackRan).toBe(1);
+    });
+  });
 });

package/src/__tests__/send-endpoint-busy.test.ts

@@ -6,7 +6,7 @@
  * - Messages are queued (202, queued: true) when the conversation is busy, not 409.
  * - SSE subscribers receive events from messages sent via this endpoint.
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
@@ -115,6 +115,7 @@ function makeCompletingConversation(): Conversation {
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
     setHostBashProxy: () => {},
+    setHostBrowserProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},
@@ -173,6 +174,7 @@ function makeHangingConversation(): Conversation {
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
     setHostBashProxy: () => {},
+    setHostBrowserProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},
@@ -259,6 +261,7 @@ function makePendingApprovalConversation(
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
     setHostBashProxy: () => {},
+    setHostBrowserProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},
@@ -319,6 +322,10 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     eventHub = new AssistantEventHub();
   });
 
+  afterEach(async () => {
+    await server?.stop();
+  });
+
   async function startServer(
     conversationFactory: () => Conversation,
     options?: { approvalConversationGenerator?: ApprovalConversationGenerator },

package/src/__tests__/sequence-store.test.ts

@@ -130,7 +130,7 @@ describe("sequence-store", () => {
   describe("listSequences", () => {
     test("lists all sequences", () => {
       createSequence({ name: "A", channel: "gmail", steps: testSteps });
-      createSequence({ name: "B", channel: "agentmail", steps: testSteps });
+      createSequence({ name: "B", channel: "email", steps: testSteps });
       expect(listSequences()).toHaveLength(2);
     });
 

package/src/__tests__/server-history-render.test.ts

@@ -283,6 +283,55 @@ describe("renderHistoryContent", () => {
     expect(output2.textSegments).toEqual(["raw string"]);
     expect(output2.contentOrder).toEqual(["text:0"]);
   });
+
+  test("skips empty text blocks between consecutive tool_use blocks (consolidated message scenario)", () => {
+    // Simulates message consolidation where empty text blocks from intermediate
+    // API turns end up between tool_use blocks. Without the fix, these create
+    // phantom text segments that break tool-call grouping in the UI.
+    const output = renderHistoryContent([
+      { type: "text", text: "Let me check." },
+      { type: "tool_use", id: "tu_1", name: "bash", input: { command: "ls" } },
+      { type: "tool_result", tool_use_id: "tu_1", content: "file.txt" },
+      { type: "text", text: "" },
+      { type: "tool_use", id: "tu_2", name: "bash", input: { command: "pwd" } },
+      { type: "tool_result", tool_use_id: "tu_2", content: "/home" },
+      { type: "text", text: "Done." },
+    ]);
+
+    expect(output.textSegments).toEqual(["Let me check.", "Done."]);
+    expect(output.contentOrder).toEqual([
+      "text:0",
+      "tool:0",
+      "tool:1",
+      "text:1",
+    ]);
+  });
+
+  test("skips whitespace-only text blocks between consecutive tool_use blocks", () => {
+    const output = renderHistoryContent([
+      { type: "tool_use", id: "tu_1", name: "bash", input: { command: "ls" } },
+      { type: "tool_result", tool_use_id: "tu_1", content: "file.txt" },
+      { type: "text", text: "   \n  " },
+      { type: "tool_use", id: "tu_2", name: "bash", input: { command: "pwd" } },
+      { type: "tool_result", tool_use_id: "tu_2", content: "/home" },
+    ]);
+
+    expect(output.textSegments).toEqual([]);
+    expect(output.contentOrder).toEqual(["tool:0", "tool:1"]);
+  });
+
+  test("preserves non-empty text blocks between tool_use blocks", () => {
+    const output = renderHistoryContent([
+      { type: "tool_use", id: "tu_1", name: "bash", input: { command: "ls" } },
+      { type: "tool_result", tool_use_id: "tu_1", content: "file.txt" },
+      { type: "text", text: "Now let me try something else." },
+      { type: "tool_use", id: "tu_2", name: "bash", input: { command: "pwd" } },
+      { type: "tool_result", tool_use_id: "tu_2", content: "/home" },
+    ]);
+
+    expect(output.textSegments).toEqual(["Now let me try something else."]);
+    expect(output.contentOrder).toEqual(["tool:0", "text:0", "tool:1"]);
+  });
 });
 
 describe("getAttachmentsForMessage", () => {