@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/migration-export-to-gcs.test.ts

@@ -37,6 +37,23 @@ const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
+// The gateway's debug export arrives over IPC as a base64 tar.gz. Stand in
+// for the socket so the debug profile can be exercised without a gateway.
+const FAKE_GATEWAY_ARCHIVE = Buffer.from("not really a tar.gz");
+const gatewayDebugExportMock = mock(async () => ({
+  ok: true as const,
+  archive_base64: FAKE_GATEWAY_ARCHIVE.toString("base64"),
+  size_bytes: FAKE_GATEWAY_ARCHIVE.length,
+}));
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCallPersistent: (method: string) => {
+    if (method !== "gateway_debug_export") {
+      throw new Error(`unexpected IPC method ${method}`);
+    }
+    return gatewayDebugExportMock();
+  },
+}));
+
 mock.module("../permissions/trust-store.js", () => ({
   getAllRules: () => [],
   isStarterBundleAccepted: () => false,
@@ -328,6 +345,131 @@ describe("handleMigrationExportToGcs — happy path", () => {
   }, 15_000);
 });
 
+describe("handleMigrationExportToGcs — debug profile", () => {
+  test("adds the gateway's archive under gateway/ and marks the manifest", async () => {
+    gatewayDebugExportMock.mockClear();
+    let capturedBody: Buffer | undefined;
+    const fixture = await startFixtureServer(async (req, res) => {
+      capturedBody = await collectBody(req);
+      res.writeHead(200);
+      res.end();
+    });
+
+    try {
+      const req = new Request("http://localhost/v1/migrations/export-to-gcs", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          upload_url: makeFakeSignedUploadUrl(fixture.port),
+          profile: "debug",
+        }),
+      });
+      const res = await callHandler(
+        handleMigrationExportToGcs,
+        req,
+        undefined,
+        202,
+      );
+      const body = (await res.json()) as AcceptedResponse;
+      const terminal = await waitForJobTerminal(body.job_id);
+      expect(terminal.status).toBe("complete");
+
+      expect(gatewayDebugExportMock).toHaveBeenCalledTimes(1);
+      const validation = validateVBundle(new Uint8Array(capturedBody!));
+      expect(validation.is_valid).toBe(true);
+      const manifest = validation.manifest!;
+      expect(manifest.export_options.include_gateway).toBe(true);
+      const gatewayEntry = manifest.contents.find(
+        (f) => f.path === "gateway/export.tar.gz",
+      );
+      expect(gatewayEntry?.size_bytes).toBe(FAKE_GATEWAY_ARCHIVE.length);
+      // Staff never receive credentials. The store mock reports itself
+      // unreachable, which would force `secrets_redacted: false` had the
+      // handler tried to collect them.
+      expect(manifest.secrets_redacted).toBe(true);
+      expect(
+        manifest.contents.some((f) => f.path.startsWith("credentials/")),
+      ).toBe(false);
+    } finally {
+      await fixture.close();
+    }
+  }, 15_000);
+
+  test("the default profile never asks the gateway", async () => {
+    gatewayDebugExportMock.mockClear();
+    let capturedBody: Buffer | undefined;
+    const fixture = await startFixtureServer(async (req, res) => {
+      capturedBody = await collectBody(req);
+      res.writeHead(200);
+      res.end();
+    });
+
+    try {
+      const req = new Request("http://localhost/v1/migrations/export-to-gcs", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          upload_url: makeFakeSignedUploadUrl(fixture.port),
+        }),
+      });
+      const res = await callHandler(
+        handleMigrationExportToGcs,
+        req,
+        undefined,
+        202,
+      );
+      const body = (await res.json()) as AcceptedResponse;
+      const terminal = await waitForJobTerminal(body.job_id);
+      expect(terminal.status).toBe("complete");
+
+      expect(gatewayDebugExportMock).not.toHaveBeenCalled();
+      const manifest = validateVBundle(new Uint8Array(capturedBody!)).manifest!;
+      expect(manifest.export_options.include_gateway).toBeUndefined();
+      expect(manifest.contents.some((f) => f.path.startsWith("gateway/"))).toBe(
+        false,
+      );
+    } finally {
+      await fixture.close();
+    }
+  }, 15_000);
+
+  test("a debug bundle is not sent at all if the gateway cannot export", async () => {
+    gatewayDebugExportMock.mockImplementationOnce(async () => {
+      throw new Error("gateway socket missing");
+    });
+    let putCount = 0;
+    const fixture = await startFixtureServer(async (_req, res) => {
+      putCount += 1;
+      res.writeHead(200);
+      res.end();
+    });
+
+    try {
+      const req = new Request("http://localhost/v1/migrations/export-to-gcs", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          upload_url: makeFakeSignedUploadUrl(fixture.port),
+          profile: "debug",
+        }),
+      });
+      const res = await callHandler(
+        handleMigrationExportToGcs,
+        req,
+        undefined,
+        202,
+      );
+      const body = (await res.json()) as { job_id: string };
+      const terminal = await waitForJobTerminal(body.job_id);
+      expect(terminal.status).toBe("failed");
+      expect(terminal.error?.code).toBe("gateway_debug_export_failed");
+      expect(putCount).toBe(0);
+    } finally {
+      await fixture.close();
+    }
+  }, 15_000);
+});
+
 describe("handleMigrationExportToGcs — concurrency", () => {
   test("second export while first is running returns 409 export_in_progress", async () => {
     // First fixture: deliberately slow so the first job stays pending long

package/src/__tests__/mode-session-history.test.ts

@@ -0,0 +1,245 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "./helpers/set-config.js";
+
+setConfig("memory", { enabled: false });
+
+import type { ModeSessionDescriptor } from "../api/mode-session.js";
+import type { ConversationMessage } from "../api/responses/conversation-message.js";
+import { setModeSessionRecoveryHealthy } from "../config/session-groups-gate.js";
+import type { Conversation } from "../daemon/conversation.js";
+import { ConversationModeSessionCoordinator } from "../daemon/conversation-mode-session.js";
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import {
+  addMessage,
+  createConversation,
+} from "../persistence/conversation-crud.js";
+import {
+  beginConversationModeSession,
+  finalizeConversationModeSession,
+} from "../persistence/conversation-mode-sessions.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+await initializeDb();
+
+interface MessagesResponse {
+  messages: ConversationMessage[];
+  modeSessions?: ModeSessionDescriptor[];
+}
+
+function registerCoordinator(
+  conversationId: string,
+  coordinator: ConversationModeSessionCoordinator,
+): void {
+  setConversation(conversationId, {
+    modeSessions: coordinator,
+    isProcessing: () => false,
+    snapshotQueuedMessages: () => [],
+  } as unknown as Conversation);
+}
+
+describe("mode-session history projection", () => {
+  afterEach(() => {
+    setModeSessionRecoveryHealthy(true);
+    clearConversations();
+  });
+
+  test("omits unrecovered active descriptors while preserving terminal history and stamps", async () => {
+    const conversation = createConversation();
+    for (const id of ["active-session", "terminal-session"]) {
+      beginConversationModeSession({
+        id,
+        conversationId: conversation.id,
+        mode: "browser",
+        sourceStartedAt: 100,
+      });
+      await addMessage(
+        conversation.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: id }]),
+        {
+          id: `${id}-message`,
+          metadata: { modeSession: { mode: "browser", id } },
+          skipIndexing: true,
+        },
+      );
+    }
+    finalizeConversationModeSession({
+      id: "terminal-session",
+      conversationId: conversation.id,
+      expectedRevision: 1,
+      status: "completed",
+      endedAt: 200,
+      endReason: "settled",
+    });
+    setModeSessionRecoveryHealthy(false);
+    const response = (await handleListMessages({
+      queryParams: { conversationId: conversation.id },
+    })) as unknown as MessagesResponse;
+    expect(response.modeSessions?.map(({ summary }) => summary.id)).toEqual([
+      "terminal-session",
+    ]);
+    expect(response.messages.map((message) => message.modeSession?.id)).toEqual(
+      ["active-session", "terminal-session"],
+    );
+  });
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversation_mode_sessions");
+    db.run("DELETE FROM conversations");
+  });
+
+  test.each([false, true])(
+    "omits orphaned active descriptors with live coordinator=%s",
+    async (hasCoordinator) => {
+      const conversation = createConversation();
+      beginConversationModeSession({
+        id: "orphan-session",
+        conversationId: conversation.id,
+        mode: "browser",
+        sourceStartedAt: 100,
+      });
+      await addMessage(
+        conversation.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: "Saved output" }]),
+        {
+          metadata: { modeSession: { id: "orphan-session", mode: "browser" } },
+          skipIndexing: true,
+        },
+      );
+      if (hasCoordinator) {
+        registerCoordinator(
+          conversation.id,
+          new ConversationModeSessionCoordinator(conversation.id),
+        );
+      }
+      const response = (await handleListMessages({
+        queryParams: {
+          conversationId: conversation.id,
+          modeSessionIds: "orphan-session",
+        },
+      })) as unknown as MessagesResponse;
+      expect(response.modeSessions).toBeUndefined();
+      expect(response.messages[0]?.modeSession).toEqual({
+        id: "orphan-session",
+        mode: "browser",
+      });
+    },
+  );
+
+  test("returns same-conversation summaries, membership, aliases, and activity", async () => {
+    const conversation = createConversation();
+    const coordinator = new ConversationModeSessionCoordinator(conversation.id);
+    registerCoordinator(conversation.id, coordinator);
+    const session = coordinator.activateSource({
+      sourceId: "browser-source",
+      generation: 1,
+      mode: "browser",
+      sourceStartedAt: 100,
+    })!;
+    const requestedSession = coordinator.activateSource({
+      sourceId: "computer-source",
+      generation: 1,
+      mode: "computer_use",
+      sourceStartedAt: 200,
+    })!;
+
+    await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "First" }]),
+      {
+        id: "assistant-123",
+        metadata: {
+          modeSession: { mode: "browser", id: session.id },
+          sentAt: 120,
+        },
+        skipIndexing: true,
+      },
+    );
+    await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Second" }]),
+      {
+        id: "assistant-456",
+        metadata: {
+          modeSession: { mode: "browser", id: session.id },
+          sentAt: 180,
+        },
+        skipIndexing: true,
+      },
+    );
+
+    const response = (await handleListMessages({
+      queryParams: {
+        conversationId: conversation.id,
+        modeSessionIds: requestedSession.id,
+      },
+    })) as unknown as MessagesResponse;
+
+    expect(response.messages).toHaveLength(1);
+    expect(response.messages[0]).toMatchObject({
+      id: "assistant-123",
+      mergedMessageIds: ["assistant-456"],
+      modeSession: { mode: "browser", id: session.id },
+      modeSessionActivity: { firstAt: 120, lastAt: 180 },
+    });
+    expect(
+      response.modeSessions?.map((descriptor) => descriptor.summary.id).sort(),
+    ).toEqual([session.id, requestedSession.id].sort());
+  });
+
+  test("drops copied membership without a child-owned lifecycle record", async () => {
+    const parent = createConversation();
+    const child = createConversation();
+    expect(
+      beginConversationModeSession({
+        id: "session-parent",
+        conversationId: parent.id,
+        mode: "browser",
+        sourceStartedAt: 100,
+      }).ok,
+    ).toBe(true);
+    await addMessage(
+      child.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Copied" }]),
+      {
+        metadata: {
+          modeSession: { mode: "browser", id: "session-parent" },
+        },
+        skipIndexing: true,
+      },
+    );
+
+    const response = (await handleListMessages({
+      queryParams: { conversationId: child.id },
+    })) as unknown as MessagesResponse;
+
+    expect(response.messages).toHaveLength(1);
+    expect(response.messages[0]).not.toHaveProperty("modeSession");
+    expect(response.messages[0]).not.toHaveProperty("modeSessionActivity");
+    expect(response.modeSessions).toBeUndefined();
+  });
+
+  test("bounds and validates explicitly requested IDs", async () => {
+    const conversation = createConversation();
+    const ids = Array.from({ length: 101 }, (_, index) => `session-${index}`);
+    await expect(
+      handleListMessages({
+        queryParams: {
+          conversationId: conversation.id,
+          modeSessionIds: ids.join(","),
+        },
+      }),
+    ).rejects.toThrow("modeSessionIds contains an invalid session ID");
+  });
+});

package/src/__tests__/mode-session-recovery.test.ts

@@ -0,0 +1,222 @@
+import { Database } from "bun:sqlite";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  isModeSessionRecoveryHealthy,
+  isSessionGroupsEnabled,
+  setModeSessionRecoveryHealthy,
+} from "../config/session-groups-gate.js";
+import {
+  getDbMigrationReadiness,
+  setDbMigrating,
+  setDbReady,
+} from "../daemon/daemon-readiness.js";
+import { recoverModeSessionsBeforeDbReady } from "../daemon/mode-session-startup-recovery.js";
+import {
+  beginConversationModeSession,
+  finalizeConversationModeSession,
+  getConversationModeSession,
+  recoverActiveConversationModeSessions,
+  updateConversationModeSessionActivity,
+} from "../persistence/conversation-mode-sessions.js";
+import { migrateCreateConversationModeSessions } from "../persistence/migrations/381-create-conversation-mode-sessions.js";
+import * as schema from "../persistence/schema.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+
+afterEach(() => {
+  setDbReady(true);
+  setModeSessionRecoveryHealthy(true);
+  setOverridesForTesting({});
+});
+
+function createStore() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/* sql */ `
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE conversations (id TEXT PRIMARY KEY);
+    INSERT INTO conversations (id) VALUES ('conv-123');
+  `);
+  const db = drizzle(sqlite, { schema });
+  migrateCreateConversationModeSessions(db);
+  return { db, options: { db } };
+}
+
+describe("mode session startup recovery", () => {
+  test("publishes readiness only after recovery succeeds", () => {
+    setDbMigrating();
+    let readinessDuringRecovery = getDbMigrationReadiness();
+
+    const result = recoverModeSessionsBeforeDbReady(() => {
+      readinessDuringRecovery = getDbMigrationReadiness();
+      return 2;
+    });
+
+    expect(readinessDuringRecovery).toMatchObject({
+      ready: false,
+      state: "running",
+    });
+    expect(result).toEqual({ ok: true, interruptedCount: 2 });
+    expect(getDbMigrationReadiness()).toEqual({
+      ready: true,
+      state: "ready",
+    });
+  });
+
+  test.each([false, true])(
+    "keeps ordinary work ready after recovery fails with flag %s",
+    (enabled) => {
+      setOverridesForTesting({ "session-groups": enabled });
+      setDbMigrating();
+      const recoveryError = new Error("recovery failed");
+      const result = recoverModeSessionsBeforeDbReady(() => {
+        throw recoveryError;
+      });
+      expect(result).toEqual({ ok: false, error: recoveryError });
+      expect(getDbMigrationReadiness()).toEqual({
+        ready: true,
+        state: "ready",
+      });
+      expect(isModeSessionRecoveryHealthy()).toBe(false);
+      expect(isSessionGroupsEnabled()).toBe(false);
+      setOverridesForTesting({ "session-groups": true });
+      expect(isSessionGroupsEnabled()).toBe(false);
+      setDbMigrating();
+      expect(recoverModeSessionsBeforeDbReady(() => 1)).toEqual({
+        ok: true,
+        interruptedCount: 1,
+      });
+      expect(isSessionGroupsEnabled()).toBe(true);
+    },
+  );
+
+  test("interrupts active records without fabricating an end time", () => {
+    const { options } = createStore();
+    beginConversationModeSession(
+      {
+        id: "session-active",
+        conversationId: "conv-123",
+        mode: "browser",
+        sourceStartedAt: 100,
+      },
+      options,
+    );
+    updateConversationModeSessionActivity(
+      {
+        id: "session-active",
+        conversationId: "conv-123",
+        expectedRevision: 1,
+        lastActivityAt: 140,
+        lastOwnedMessageId: "message-123",
+      },
+      options,
+    );
+
+    expect(recoverActiveConversationModeSessions(options)).toBe(1);
+    expect(
+      getConversationModeSession("conv-123", "session-active", options),
+    ).toMatchObject({
+      status: "interrupted",
+      lastActivityAt: 140,
+      lastOwnedMessageId: "message-123",
+      endedAt: null,
+      endReason: "assistant_restarted",
+      revision: 3,
+    });
+    expect(recoverActiveConversationModeSessions(options)).toBe(0);
+  });
+
+  test("preserves terminal truth and prevents an old callback from reopening it", () => {
+    const { options } = createStore();
+    beginConversationModeSession(
+      {
+        id: "session-completed",
+        conversationId: "conv-123",
+        mode: "computer_use",
+        sourceStartedAt: 100,
+      },
+      options,
+    );
+    finalizeConversationModeSession(
+      {
+        id: "session-completed",
+        conversationId: "conv-123",
+        expectedRevision: 1,
+        status: "completed",
+        endedAt: 150,
+        endReason: "settled",
+      },
+      options,
+    );
+
+    expect(recoverActiveConversationModeSessions(options)).toBe(0);
+    expect(
+      updateConversationModeSessionActivity(
+        {
+          id: "session-completed",
+          conversationId: "conv-123",
+          expectedRevision: 2,
+          lastActivityAt: 200,
+        },
+        options,
+      ),
+    ).toMatchObject({
+      ok: false,
+      reason: "terminal",
+      session: { status: "completed", endedAt: 150, revision: 2 },
+    });
+  });
+
+  test("recovered work can only continue under a fresh session id", () => {
+    const { options } = createStore();
+    beginConversationModeSession(
+      {
+        id: "session-before-restart",
+        conversationId: "conv-123",
+        mode: "browser",
+        sourceStartedAt: 100,
+      },
+      options,
+    );
+    recoverModeSessionsBeforeDbReady(() => {
+      throw new Error("recovery unavailable");
+    });
+    expect(
+      getConversationModeSession("conv-123", "session-before-restart", options)
+        ?.status,
+    ).toBe("active");
+    setDbMigrating();
+    expect(
+      recoverModeSessionsBeforeDbReady(() =>
+        recoverActiveConversationModeSessions(options),
+      ),
+    ).toEqual({ ok: true, interruptedCount: 1 });
+
+    expect(
+      beginConversationModeSession(
+        {
+          id: "session-before-restart",
+          conversationId: "conv-123",
+          mode: "browser",
+          sourceStartedAt: 200,
+        },
+        options,
+      ),
+    ).toMatchObject({ ok: false, reason: "already_exists" });
+    expect(
+      beginConversationModeSession(
+        {
+          id: "session-after-restart",
+          conversationId: "conv-123",
+          mode: "browser",
+          sourceStartedAt: 200,
+        },
+        options,
+      ),
+    ).toMatchObject({
+      ok: true,
+      session: { id: "session-after-restart", status: "active", revision: 1 },
+    });
+  });
+});