@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/runtime-events-sse-reconnect.test.ts

@@ -0,0 +1,353 @@
+/**
+ * HTTP-layer tests for the B7.2 reconnect handler on GET /v1/events.
+ *
+ * Covers:
+ *   - replay of buffered events when `lastSeenSeq` is in-window
+ *   - cursor older than the ring -> connection goes live without any
+ *     extra wire signal (client is expected to detect the seq jump
+ *     and refetch via the messages API)
+ *   - omitted `lastSeenSeq` falls through to legacy live-only behavior
+ *   - dedup against live events that race in mid-replay
+ *   - malformed `lastSeenSeq` query param rejected with 400
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { getOrCreateConversation } from "../memory/conversation-key-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import {
+  _resetConversationStreamsForTesting,
+  stampAndBuffer,
+} from "../runtime/conversation-stream-state.js";
+
+initializeDb();
+
+const decoder = new TextDecoder();
+
+async function readFrame(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+): Promise<string> {
+  const { value, done } = await reader.read();
+  expect(done).toBe(false);
+  return decoder.decode(value);
+}
+
+describe("SSE reconnect replay (B7.2)", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM conversation_keys");
+    db.run("DELETE FROM conversations");
+    _resetConversationStreamsForTesting();
+  });
+
+  afterEach(() => {
+    _resetConversationStreamsForTesting();
+  });
+
+  test("replays buffered events with seq > lastSeenSeq before the first heartbeat", async () => {
+    const { conversationId } = getOrCreateConversation("reconnect-replay");
+
+    // Stamp three events into the ring as if they had already been
+    // broadcast prior to the client's reconnect. Seqs start at 1, so
+    // these get seqs 1, 2, 3.
+    const events = [
+      buildAssistantEvent({ type: "pong" }, conversationId),
+      buildAssistantEvent({ type: "pong" }, conversationId),
+      buildAssistantEvent({ type: "pong" }, conversationId),
+    ];
+    for (const event of events) stampAndBuffer(event);
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: {
+        conversationKey: "reconnect-replay",
+        lastSeenSeq: "1",
+      },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // Frames 1-2 are the two events with seq > 1 (i.e. seqs 2 and 3),
+    // emitted before the initial heartbeat.
+    const frame1 = await readFrame(reader);
+    expect(frame1).toContain("event: assistant_event");
+    expect(frame1).toContain('"seq":2');
+    expect(frame1).toContain('"clientSeq":1');
+
+    const frame2 = await readFrame(reader);
+    expect(frame2).toContain('"seq":3');
+    expect(frame2).toContain('"clientSeq":2');
+
+    // Then the heartbeat.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("connects live without replay when lastSeenSeq is older than the ring's oldest entry", async () => {
+    // When the client's cursor is older than the ring can serve, the
+    // route deliberately does NOT signal anything special over the
+    // wire -- the connection just goes live. The client is expected to
+    // detect the gap from the seq jump on its first live event and
+    // refetch via the existing messages API.
+    const { conversationId } = getOrCreateConversation(
+      "reconnect-out-of-window",
+    );
+
+    // Push 202 events through stampAndBuffer so the ring's natural
+    // count-based eviction (cap 200) drops seqs 1 and 2. A cursor of
+    // 0 then falls outside what getReplayWindow can serve.
+    for (let i = 0; i < 202; i++) {
+      stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+    }
+    const { _peekStreamForTesting } =
+      await import("../runtime/conversation-stream-state.js");
+    const peek = _peekStreamForTesting(conversationId);
+    expect(peek?.oldestSeq).toBe(3);
+    expect(peek?.newestSeq).toBe(202);
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: {
+        conversationKey: "reconnect-out-of-window",
+        lastSeenSeq: "0",
+      },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // No replay events ahead of the heartbeat -- the cursor was
+    // unserviceable so the route emits nothing extra.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("omitting lastSeenSeq skips replay entirely (legacy live-only behavior)", async () => {
+    const { conversationId } = getOrCreateConversation("reconnect-noparam");
+
+    // Pre-fill the ring -- without the cursor, these MUST NOT be replayed.
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: { conversationKey: "reconnect-noparam" },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // First frame is the heartbeat -- no replay events ahead of it.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("dedupes a buffered event when it also races through the live callback", async () => {
+    const { conversationId } = getOrCreateConversation("reconnect-dedup");
+
+    // Stamp two events. Seqs start at 1, so eventA=1 and eventB=2.
+    const eventA = buildAssistantEvent({ type: "pong" }, conversationId);
+    const eventB = buildAssistantEvent({ type: "pong" }, conversationId);
+    stampAndBuffer(eventA); // seq 1
+    stampAndBuffer(eventB); // seq 2
+
+    const ac = new AbortController();
+    const { AssistantEventHub } =
+      await import("../runtime/assistant-event-hub.js");
+    const testHub = new AssistantEventHub();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: {
+          conversationKey: "reconnect-dedup",
+          lastSeenSeq: "1",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+
+    const reader = stream.getReader();
+
+    // First frame is the replay of seq=2 (the only one with seq > 1).
+    const replayed = await readFrame(reader);
+    expect(replayed).toContain('"seq":2');
+
+    // Then the heartbeat.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    // Now publish eventB live (its seq is 2, already replayed). The
+    // callback's high-water dedup should drop it. Then publish a fresh
+    // event with seq=3 (via stampAndBuffer + manual publish), which
+    // SHOULD be delivered.
+    await testHub.publish(eventB);
+
+    const eventC = buildAssistantEvent({ type: "pong" }, conversationId);
+    stampAndBuffer(eventC); // seq 3
+    await testHub.publish(eventC);
+
+    const liveFrame = await readFrame(reader);
+    expect(liveFrame).toContain('"seq":3');
+
+    ac.abort();
+  });
+
+  test("clientSeq is gap-free when targeted events create seq gaps", async () => {
+    // Stamp three events: two untargeted (seq 1, 3) + one with a
+    // capability target (seq 2, host_bash). A process subscriber
+    // does NOT match capability targeting (matchesSubscriber requires
+    // type=client + matching capability), so the replay filters out
+    // seq 2. The subscriber receives seq 1 and 3 — a gap in raw seq
+    // — but clientSeq is 1, 2 — gap-free.
+    const { conversationId } = getOrCreateConversation("clientseq-gap");
+
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId), {
+      targeting: { targetCapability: "host_bash" },
+    });
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: {
+        conversationKey: "clientseq-gap",
+        lastSeenSeq: "0",
+      },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // seq 2 (host_bash-targeted) is filtered out by replay.
+    // Only seq 1 and 3 are delivered, with gap-free clientSeq.
+    const f1 = await readFrame(reader);
+    expect(f1).toContain('"seq":1');
+    expect(f1).toContain('"clientSeq":1');
+
+    const f2 = await readFrame(reader);
+    expect(f2).toContain('"seq":3');
+    expect(f2).toContain('"clientSeq":2');
+
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("live callback includes clientSeq on conversation-scoped events", async () => {
+    const { conversationId } = getOrCreateConversation("clientseq-live");
+
+    const ac = new AbortController();
+    const { AssistantEventHub } =
+      await import("../runtime/assistant-event-hub.js");
+    const testHub = new AssistantEventHub();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "clientseq-live" },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+
+    const reader = stream.getReader();
+
+    // Drain the initial heartbeat.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    // Publish two live events with seq via stampAndBuffer.
+    const e1 = buildAssistantEvent({ type: "pong" }, conversationId);
+    const e2 = buildAssistantEvent({ type: "pong" }, conversationId);
+    stampAndBuffer(e1);
+    stampAndBuffer(e2);
+    await testHub.publish(e1);
+    await testHub.publish(e2);
+
+    const f1 = await readFrame(reader);
+    expect(f1).toContain('"seq":1');
+    expect(f1).toContain('"clientSeq":1');
+
+    const f2 = await readFrame(reader);
+    expect(f2).toContain('"seq":2');
+    expect(f2).toContain('"clientSeq":2');
+
+    ac.abort();
+  });
+
+  test("rejects empty lastSeenSeq", async () => {
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: {
+          conversationKey: "reconnect-empty",
+          lastSeenSeq: "",
+        },
+      }),
+    ).toThrow(/lastSeenSeq must not be empty/);
+  });
+
+  test("rejects non-integer lastSeenSeq", async () => {
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: {
+          conversationKey: "reconnect-float",
+          lastSeenSeq: "1.5",
+        },
+      }),
+    ).toThrow(/non-negative integer/);
+  });
+
+  test("rejects negative lastSeenSeq", async () => {
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: {
+          conversationKey: "reconnect-neg",
+          lastSeenSeq: "-1",
+        },
+      }),
+    ).toThrow(/non-negative integer/);
+  });
+});

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

@@ -11,10 +11,10 @@ const getOrCreateCalls: Array<{
   conversationId: string;
   options?: Record<string, unknown>;
 }> = [];
-const processCalls: Array<unknown[]> = [];
+const processCalls: Array<Record<string, unknown>> = [];
 let fakeConversation: {
   taskRunId?: string;
-  processMessage: (...args: unknown[]) => Promise<string>;
+  processMessage: (options: Record<string, unknown>) => Promise<string>;
 };
 
 function resetConversationMock() {
@@ -22,8 +22,8 @@ function resetConversationMock() {
   processCalls.length = 0;
   fakeConversation = {
     taskRunId: "stale-task-run",
-    async processMessage(...args: unknown[]) {
-      processCalls.push(args);
+    async processMessage(options: Record<string, unknown>) {
+      processCalls.push(options);
       return "message-id";
     },
   };
@@ -109,8 +109,8 @@ describe("schedule run-now trust propagation", () => {
       trustClass: "guardian",
     });
     expect(processCalls).toHaveLength(1);
-    expect(processCalls[0][0]).toBe("scan my inbox");
-    expect(processCalls[0][6]).toEqual({ isInteractive: false });
+    expect(processCalls[0].content).toBe("scan my inbox");
+    expect(processCalls[0].isInteractive).toBe(false);
     expect(fakeConversation.taskRunId).toBeUndefined();
   });
 
@@ -128,9 +128,9 @@ describe("schedule run-now trust propagation", () => {
     const observedTaskRunIds: Array<string | undefined> = [];
     fakeConversation = {
       taskRunId: undefined,
-      async processMessage(...args: unknown[]) {
+      async processMessage(options: Record<string, unknown>) {
         observedTaskRunIds.push(fakeConversation.taskRunId);
-        processCalls.push(args);
+        processCalls.push(options);
         return "message-id";
       },
     };
@@ -147,8 +147,8 @@ describe("schedule run-now trust propagation", () => {
       trustClass: "guardian",
     });
     expect(processCalls).toHaveLength(1);
-    expect(processCalls[0][0]).toBe("triage inbox in background");
-    expect(processCalls[0][6]).toEqual({ isInteractive: false });
+    expect(processCalls[0].content).toBe("triage inbox in background");
+    expect(processCalls[0].isInteractive).toBe(false);
     expect(typeof observedTaskRunIds[0]).toBe("string");
     expect(fakeConversation.taskRunId).toBeUndefined();
   });
@@ -538,3 +538,73 @@ describe("wake mode in schedule routes", () => {
     expect(wakeSchedule!.wakeConversationId).toBe("conv-abc");
   });
 });
+
+describe("PATCH /schedules/:id — timeout override", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  function listOne(): { id: string; timeoutMs: number | null } {
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({}) as {
+      schedules: Array<{ id: string; timeoutMs: number | null }>;
+    };
+    return result.schedules[0];
+  }
+
+  test("sets and clears the script timeout, exposing it in the list", () => {
+    // GIVEN a script schedule with no timeout override
+    const schedule = createSchedule({
+      name: "Script job",
+      cronExpression: "0 9 * * *",
+      message: "",
+      script: "echo hi",
+      mode: "script",
+      syntax: "cron",
+    });
+    expect(listOne().timeoutMs).toBeNull();
+
+    const patch = findRoute("schedules/:id", "PATCH");
+
+    // WHEN the guardian sets a custom timeout
+    patch.handler({
+      pathParams: { id: schedule.id },
+      body: { timeoutMs: 5000 },
+    });
+
+    // THEN the list reflects the override
+    expect(listOne().timeoutMs).toBe(5000);
+
+    // AND WHEN the guardian clears it
+    patch.handler({
+      pathParams: { id: schedule.id },
+      body: { timeoutMs: null },
+    });
+
+    // THEN it reverts to null
+    expect(listOne().timeoutMs).toBeNull();
+  });
+
+  test("rejects an out-of-range timeout", () => {
+    // GIVEN a script schedule
+    const schedule = createSchedule({
+      name: "Guarded job",
+      cronExpression: "0 9 * * *",
+      message: "",
+      script: "echo hi",
+      mode: "script",
+      syntax: "cron",
+    });
+
+    const patch = findRoute("schedules/:id", "PATCH");
+
+    // WHEN/THEN patching with a below-minimum timeout throws a RouteError
+    expect(() =>
+      patch.handler({
+        pathParams: { id: schedule.id },
+        body: { timeoutMs: 10 },
+      }),
+    ).toThrow("timeout_ms must be between");
+    expect(listOne().timeoutMs).toBeNull();
+  });
+});

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

@@ -9,6 +9,17 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
+// Stub the background-wake publisher so these store-level unit tests stay
+// hermetic. `notifySchedulesChanged()` fires a debounced background-wake
+// refresh on every mutation; left real, that 250ms timer performs a
+// synchronous DB read plus a platform-client lookup which compete with the
+// serialized async event delivery and can push a `sync_changed` past the
+// wait deadline on loaded runners. Background-wake behavior is covered by the
+// background-wake tests.
+mock.module("../background-wake/publisher.js", () => ({
+  refreshBackgroundWakeIntent: () => {},
+}));
+
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -38,7 +49,11 @@ function getRawDb(): import("bun:sqlite").Database {
 }
 
 async function waitFor(predicate: () => boolean): Promise<void> {
-  const deadline = Date.now() + 500;
+  // Event delivery is async (serialized through the hub's broadcast chain),
+  // so poll until it lands. The deadline is generous to absorb scheduling
+  // jitter on loaded CI runners — the happy path returns the moment the
+  // predicate holds, so a larger budget costs nothing when events flow.
+  const deadline = Date.now() + 2000;
   while (Date.now() < deadline) {
     if (predicate()) return;
     await new Promise((resolve) => setTimeout(resolve, 5));
@@ -1019,6 +1034,73 @@ describe("routing and mode fields", () => {
   });
 });
 
+// ── Script timeout override ─────────────────────────────────────────
+
+describe("script timeout override", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("defaults timeoutMs to null when not provided", () => {
+    // GIVEN a schedule created without a timeout override
+    const job = createSchedule({
+      name: "No timeout",
+      cronExpression: "0 9 * * *",
+      message: "no timeout",
+      syntax: "cron",
+    });
+
+    // THEN the stored timeout is null (the runner falls back to the default)
+    expect(job.timeoutMs).toBeNull();
+    expect(getSchedule(job.id)!.timeoutMs).toBeNull();
+  });
+
+  test("persists a timeoutMs override through create/read", () => {
+    // GIVEN a script schedule created with a custom timeout
+    const job = createSchedule({
+      name: "Slow script",
+      cronExpression: "0 9 * * *",
+      message: "",
+      script: "sleep 5",
+      mode: "script",
+      syntax: "cron",
+      timeoutMs: 120_000,
+    });
+
+    // THEN the override round-trips through the store
+    expect(job.timeoutMs).toBe(120_000);
+    expect(getSchedule(job.id)!.timeoutMs).toBe(120_000);
+  });
+
+  test("updateSchedule sets and clears the timeout override", () => {
+    // GIVEN a schedule with a custom timeout
+    const job = createSchedule({
+      name: "Adjust timeout",
+      cronExpression: "0 9 * * *",
+      message: "",
+      script: "echo hi",
+      mode: "script",
+      syntax: "cron",
+      timeoutMs: 90_000,
+    });
+
+    // WHEN the timeout is changed
+    const updated = updateSchedule(job.id, { timeoutMs: 5_000 });
+
+    // THEN the new value is stored
+    expect(updated!.timeoutMs).toBe(5_000);
+
+    // AND WHEN the timeout is cleared back to the default
+    const cleared = updateSchedule(job.id, { timeoutMs: null });
+
+    // THEN it reverts to null
+    expect(cleared!.timeoutMs).toBeNull();
+    expect(getSchedule(job.id)!.timeoutMs).toBeNull();
+  });
+});
+
 // ── listSchedules filters ───────────────────────────────────────────
 
 describe("listSchedules filters", () => {