@vellumai/assistant 0.6.5 → 0.6.6

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

@@ -9,7 +9,10 @@ mock.module("../util/logger.js", () => ({
 
 import { getDb, initializeDb } from "../memory/db.js";
 import { scheduleRouteDefinitions } from "../runtime/routes/schedule-routes.js";
-import { createSchedule } from "../schedule/schedule-store.js";
+import {
+  createSchedule,
+  createScheduleRun,
+} from "../schedule/schedule-store.js";
 import { scheduleTask } from "../tasks/task-scheduler.js";
 import { createTask } from "../tasks/task-store.js";
 
@@ -160,3 +163,130 @@ describe("schedule run-now trust propagation", () => {
     expect(fakeConversation.taskRunId).toBeUndefined();
   });
 });
+
+// ── schedules/:id/runs limit handling ─────────────────────────────────────
+
+function getRunsHandler() {
+  const route = scheduleRouteDefinitions({
+    sendMessageDeps: {} as never,
+  }).find(
+    (candidate) =>
+      candidate.endpoint === "schedules/:id/runs" &&
+      candidate.method === "GET",
+  );
+  if (!route) throw new Error("Runs schedule route not found");
+  return route.handler;
+}
+
+async function callRunsHandler(
+  jobId: string,
+  limitParam?: string,
+): Promise<{ status: number; body: unknown }> {
+  const handler = getRunsHandler();
+  const suffix = limitParam !== undefined ? `?limit=${limitParam}` : "";
+  const urlStr = `http://localhost/v1/schedules/${jobId}/runs${suffix}`;
+  const response = await handler({
+    req: new Request(urlStr),
+    url: new URL(urlStr),
+    server: {} as never,
+    authContext: {} as never,
+    params: { id: jobId },
+  });
+  return { status: response.status, body: await response.json() };
+}
+
+describe("schedule runs list — limit handling", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns 200 with default limit when no param is provided", async () => {
+    const job = createSchedule({
+      name: "runs default",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 3; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const { status, body } = await callRunsHandler(job.id);
+    expect(status).toBe(200);
+    expect(Array.isArray((body as { runs: unknown[] }).runs)).toBe(true);
+    expect((body as { runs: unknown[] }).runs).toHaveLength(3);
+  });
+
+  test("non-numeric limit falls back to default (does not 500)", async () => {
+    const job = createSchedule({
+      name: "runs nan",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    createScheduleRun(job.id, "conv");
+    const { status } = await callRunsHandler(job.id, "abc");
+    expect(status).toBe(200);
+  });
+
+  test("negative limit is clamped to 1 (does not bypass cap)", async () => {
+    const job = createSchedule({
+      name: "runs negative",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 5; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const { status, body } = await callRunsHandler(job.id, "-5");
+    expect(status).toBe(200);
+    // clamped to 1, not interpreted as "no limit"
+    expect((body as { runs: unknown[] }).runs).toHaveLength(1);
+  });
+
+  test("zero limit is clamped to 1", async () => {
+    const job = createSchedule({
+      name: "runs zero",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 3; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const { status, body } = await callRunsHandler(job.id, "0");
+    expect(status).toBe(200);
+    expect((body as { runs: unknown[] }).runs).toHaveLength(1);
+  });
+
+  test("limit above 100 is capped at 100", async () => {
+    const job = createSchedule({
+      name: "runs huge",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    // 5 runs, requesting 9999 → bounded at 100, actual returns = 5
+    for (let i = 0; i < 5; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const { status, body } = await callRunsHandler(job.id, "9999");
+    expect(status).toBe(200);
+    expect((body as { runs: unknown[] }).runs).toHaveLength(5);
+  });
+
+  test("fractional limit is floored", async () => {
+    const job = createSchedule({
+      name: "runs frac",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 5; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const { status, body } = await callRunsHandler(job.id, "2.7");
+    expect(status).toBe(200);
+    expect((body as { runs: unknown[] }).runs).toHaveLength(2);
+  });
+});

package/src/__tests__/scheduler-recurrence.test.ts

@@ -126,11 +126,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message });
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -170,11 +166,7 @@ describe("scheduler RRULE execution", () => {
       onMessage?.();
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     // The run_task path involves a dynamic import which can take >50ms in CI,
     // exceeding the patched setTimeout delay. Await the actual callback instead
     // of relying on a fixed timeout.
@@ -239,11 +231,7 @@ describe("scheduler RRULE execution", () => {
     };
 
     // First tick: the expired schedule should fire its final due run
-    const scheduler1 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler1 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler1.stop();
 
@@ -263,11 +251,7 @@ describe("scheduler RRULE execution", () => {
 
     // Second tick: the disabled schedule must NOT fire again
     processedMessages.length = 0;
-    const scheduler2 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler2 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler2.stop();
 
@@ -297,11 +281,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message });
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -361,11 +341,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push(message);
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -414,11 +390,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push(message);
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -497,11 +469,7 @@ describe("scheduler RRULE execution", () => {
         processedMessages.push(message);
       };
 
-      const scheduler = startScheduler(
-        processMessage,
-        () => {},
-        () => {},
-      );
+      const scheduler = startScheduler(processMessage, () => {});
       await new Promise((resolve) => setTimeout(resolve, 500));
       scheduler.stop();
 
@@ -540,11 +508,7 @@ describe("scheduler RRULE execution", () => {
     const forcedDueAt = getSchedule(schedule.id)!.nextRunAt;
 
     const processMessage = async () => {};
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -575,11 +539,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message });
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -627,11 +587,7 @@ describe("scheduler RRULE execution", () => {
       notifyCalls.push(payload);
     };
 
-    const scheduler = startScheduler(
-      async () => {},
-      notifyScheduleOneShot,
-      () => {},
-    );
+    const scheduler = startScheduler(async () => {}, notifyScheduleOneShot);
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -664,11 +620,7 @@ describe("scheduler RRULE execution", () => {
       throw new Error("Simulated failure");
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -710,11 +662,7 @@ describe("scheduler RRULE execution", () => {
       notifyCalls.push(payload);
     };
 
-    const scheduler = startScheduler(
-      async () => {},
-      notifyScheduleOneShot,
-      () => {},
-    );
+    const scheduler = startScheduler(async () => {}, notifyScheduleOneShot);
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -767,11 +715,7 @@ describe("scheduler RRULE execution", () => {
       notifyCalls.push(payload);
     };
 
-    const scheduler = startScheduler(
-      async () => {},
-      notifyScheduleOneShot,
-      () => {},
-    );
+    const scheduler = startScheduler(async () => {}, notifyScheduleOneShot);
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 

package/src/__tests__/scheduler-reuse-conversation.test.ts

@@ -103,11 +103,7 @@ describe("scheduler conversation reuse", () => {
       processedMessages.push({ conversationId, message });
     };
 
-    const scheduler1 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler1 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler1.stop();
 
@@ -126,11 +122,7 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
     processedMessages.length = 0;
 
-    const scheduler2 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler2 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler2.stop();
 
@@ -168,11 +160,7 @@ describe("scheduler conversation reuse", () => {
       processedMessages.push({ conversationId, message });
     };
 
-    const scheduler1 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler1 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler1.stop();
 
@@ -183,11 +171,7 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
     processedMessages.length = 0;
 
-    const scheduler2 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler2 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler2.stop();
 
@@ -220,11 +204,7 @@ describe("scheduler conversation reuse", () => {
       processedMessages.push({ conversationId, message });
     };
 
-    const scheduler1 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler1 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler1.stop();
 
@@ -238,11 +218,7 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
     processedMessages.length = 0;
 
-    const scheduler2 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler2 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler2.stop();
 
@@ -273,11 +249,7 @@ describe("scheduler conversation reuse", () => {
       processedMessages.push({ conversationId, message });
     };
 
-    const scheduler = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -318,11 +290,7 @@ describe("scheduler conversation reuse", () => {
       if (shouldFail) throw new Error("Simulated failure");
     };
 
-    const scheduler1 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler1 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler1.stop();
 
@@ -334,11 +302,7 @@ describe("scheduler conversation reuse", () => {
     processedMessages.length = 0;
     shouldFail = true;
 
-    const scheduler2 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler2 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler2.stop();
 
@@ -352,11 +316,7 @@ describe("scheduler conversation reuse", () => {
     processedMessages.length = 0;
     shouldFail = false;
 
-    const scheduler3 = startScheduler(
-      processMessage,
-      () => {},
-      () => {},
-    );
+    const scheduler3 = startScheduler(processMessage, () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler3.stop();
 

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

@@ -2,7 +2,6 @@ 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***" },
 ]);
@@ -18,12 +17,6 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
-mock.module("../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: triggerMock,
-  }),
-}));
-
 mock.module("../security/secret-scanner.js", () => ({
   compileCustomPatterns: () => [],
   redactSecrets: (content: string) => content,
@@ -35,7 +28,6 @@ import { SecretDetectionHandler } from "../tools/secret-detection-handler.js";
 describe("SecretDetectionHandler under v2", () => {
   beforeEach(() => {
     _setOverridesForTesting({});
-    triggerMock.mockClear();
     scanTextMock.mockClear();
   });
 
@@ -63,7 +55,6 @@ describe("SecretDetectionHandler under v2", () => {
       "allow",
       Date.now(),
       emitLifecycleEvent,
-      (_toolName, input) => input,
     );
 
     expect(result.earlyReturn).toBe(true);
@@ -79,6 +70,5 @@ describe("SecretDetectionHandler under v2", () => {
         decision: "deny",
       }),
     );
-    expect(triggerMock).toHaveBeenCalled();
   });
 });

package/src/__tests__/shell-identity.test.ts

@@ -2,8 +2,6 @@ import { beforeAll, describe, expect, test } from "bun:test";
 
 import {
   analyzeShellCommand,
-  buildShellAllowlistOptions,
-  buildShellCommandCandidates,
   deriveShellActionKeys,
 } from "../permissions/shell-identity.js";
 import { parse } from "../tools/terminal/parser.js";
@@ -236,135 +234,3 @@ describe("deriveShellActionKeys", () => {
   });
 });
 
-describe("buildShellCommandCandidates", () => {
-  test("raw candidate is always present", async () => {
-    const candidates = await buildShellCommandCandidates("ls -la");
-    expect(candidates[0]).toBe("ls -la");
-  });
-
-  test("simple action adds canonical and action candidates", async () => {
-    const candidates = await buildShellCommandCandidates(
-      "cd repo && gh pr view 5525 --json title",
-    );
-    expect(candidates[0]).toBe("cd repo && gh pr view 5525 --json title");
-    // Should include the canonical primary command
-    expect(candidates).toContain("gh pr view 5525 --json title");
-    // Should include action keys
-    expect(candidates).toContain("action:gh pr view");
-    expect(candidates).toContain("action:gh pr");
-    expect(candidates).toContain("action:gh");
-  });
-
-  test("complex command returns raw-only", async () => {
-    const candidates = await buildShellCommandCandidates(
-      'git add . && git commit -m "fix"',
-    );
-    expect(candidates).toEqual(['git add . && git commit -m "fix"']);
-  });
-
-  test("pipeline returns raw and action key candidates", async () => {
-    const candidates = await buildShellCommandCandidates("git log | grep fix");
-    expect(candidates[0]).toBe("git log | grep fix");
-    expect(candidates).toContain("action:git log");
-    expect(candidates).toContain("action:git");
-  });
-
-  test("pipeline with setup prefix includes action candidates", async () => {
-    const candidates = await buildShellCommandCandidates(
-      "cd /tmp && pdftotext file.pdf | wc -c",
-    );
-    expect(candidates[0]).toBe("cd /tmp && pdftotext file.pdf | wc -c");
-    expect(candidates).toContain("action:pdftotext");
-  });
-
-  test("candidate order is stable", async () => {
-    const c1 = await buildShellCommandCandidates("npm install express");
-    const c2 = await buildShellCommandCandidates("npm install express");
-    expect(c1).toEqual(c2);
-  });
-
-  test("empty command returns raw", async () => {
-    const candidates = await buildShellCommandCandidates("");
-    expect(candidates).toEqual([""]);
-  });
-
-  test("semicolon chain returns raw-only", async () => {
-    const candidates = await buildShellCommandCandidates(
-      "cd repo; gh pr view 123",
-    );
-    expect(candidates).toHaveLength(1);
-  });
-
-  test("deduplication preserves order", async () => {
-    // Single command — raw and canonical are the same
-    const candidates = await buildShellCommandCandidates("git status");
-    // raw is 'git status', canonical would also be 'git status' (same segment)
-    // so it should be deduped to just once
-    const gitStatusCount = candidates.filter((c) => c === "git status").length;
-    expect(gitStatusCount).toBe(1);
-  });
-});
-
-describe("buildShellAllowlistOptions — complex command restrictions", () => {
-  test("chain with && offers exact only", async () => {
-    const options = await buildShellAllowlistOptions(
-      "gh pr view 123 && rm -rf /",
-    );
-    expect(options).toHaveLength(1);
-    expect(options[0].pattern).toBe("gh pr view 123 && rm -rf /");
-    expect(options[0].description).toContain("compound");
-  });
-
-  test("pipeline offers exact and action-key options", async () => {
-    const options = await buildShellAllowlistOptions(
-      "cat file.txt | grep error | wc -l",
-    );
-    expect(options.length).toBeGreaterThanOrEqual(2);
-    expect(options[0].pattern).toBe("cat file.txt | grep error | wc -l");
-    expect(options[0].description).toContain("compound");
-    expect(options.some((o) => o.pattern.startsWith("action:"))).toBe(true);
-  });
-
-  test("pipeline offers action-key options from first segment", async () => {
-    const options = await buildShellAllowlistOptions(
-      "pdftotext file.pdf | head -100",
-    );
-    expect(options.length).toBeGreaterThanOrEqual(2);
-    expect(options[0].pattern).toBe("pdftotext file.pdf | head -100");
-    expect(
-      options.some(
-        (o) =>
-          o.pattern === "action:pdftotext" &&
-          o.description.includes('Any "pdftotext" command'),
-      ),
-    ).toBe(true);
-  });
-
-  test("semicolon chain offers exact only", async () => {
-    const options = await buildShellAllowlistOptions("cd repo; gh pr view 123");
-    expect(options).toHaveLength(1);
-    expect(options[0].description).toContain("compound");
-  });
-
-  test("newline-separated commands offer exact only", async () => {
-    const options = await buildShellAllowlistOptions("cd repo\ngh pr view 123");
-    expect(options).toHaveLength(1);
-    expect(options[0].description).toContain("compound");
-  });
-
-  test("setup-prefix + single-action still gets action-key options", async () => {
-    const options = await buildShellAllowlistOptions(
-      "cd /repo && npm install express",
-    );
-    expect(options.length).toBeGreaterThan(1);
-    expect(options.some((o) => o.pattern.startsWith("action:"))).toBe(true);
-  });
-
-  test("simple single command gets action-key options", async () => {
-    const options = await buildShellAllowlistOptions("npm install express");
-    expect(options.length).toBeGreaterThan(1);
-    expect(options[0].pattern).toBe("npm install express");
-    expect(options.some((o) => o.pattern === "action:npm install")).toBe(true);
-    expect(options.some((o) => o.pattern === "action:npm")).toBe(true);
-  });
-});