@vellumai/assistant 0.6.1 → 0.6.3

package/src/__tests__/conversation-host-access-routes.test.ts

@@ -0,0 +1,229 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+let authDisabled = true;
+let boundGuardianPrincipalId: string | null = null;
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => authDisabled,
+  hasUngatedHttpAuthDisabled: () => false,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+  getGatewayPort: () => 7830,
+  getRuntimeHttpPort: () => 7821,
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeGatewayOriginSecret: () => undefined,
+  getIngressPublicBaseUrl: () => undefined,
+  setIngressPublicBaseUrl: () => {},
+}));
+
+mock.module("../contacts/contact-store.js", () => ({
+  findGuardianForChannel: () =>
+    boundGuardianPrincipalId
+      ? {
+          channel: { externalUserId: undefined },
+          contact: { principalId: boundGuardianPrincipalId },
+        }
+      : null,
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import {
+  createConversation,
+  updateConversationHostAccess,
+} from "../memory/conversation-crud.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { conversationManagementRouteDefinitions } from "../runtime/routes/conversation-management-routes.js";
+
+initializeDb();
+
+const routes = conversationManagementRouteDefinitions({
+  switchConversation: async (conversationId) => {
+    const conversation = {
+      conversationId,
+      title: "Switched conversation",
+      conversationType: "standard",
+      hostAccess: false,
+    };
+    return conversation;
+  },
+  renameConversation: () => true,
+  clearAllConversations: () => 0,
+  cancelGeneration: () => true,
+  destroyConversation: () => {},
+  undoLastMessage: async () => null,
+  regenerateResponse: async () => null,
+});
+
+function findRoute(method: string, endpoint: string) {
+  const route = routes.find(
+    (routeDef) => routeDef.method === method && routeDef.endpoint === endpoint,
+  );
+  if (!route) {
+    throw new Error(`Route not found: ${method} ${endpoint}`);
+  }
+  return route;
+}
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+describe("conversation host-access transport", () => {
+  let server: RuntimeHttpServer | null = null;
+
+  beforeEach(async () => {
+    await server?.stop();
+    server = null;
+    authDisabled = true;
+    boundGuardianPrincipalId = null;
+    clearTables();
+  });
+
+  afterAll(async () => {
+    await server?.stop();
+    resetDb();
+    mock.restore();
+  });
+
+  test("GET and PATCH /v1/conversations/:id/host-access use the conversation store", async () => {
+    const conversation = createConversation("Host access test");
+
+    const getRoute = findRoute("GET", "conversations/:id/host-access");
+    const getResponse = await getRoute.handler({
+      req: new Request("http://localhost/v1/conversations/test/host-access"),
+      url: new URL("http://localhost/v1/conversations/test/host-access"),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: conversation.id },
+    });
+
+    expect(getResponse.status).toBe(200);
+    expect(await getResponse.json()).toEqual({
+      conversationId: conversation.id,
+      hostAccess: false,
+    });
+
+    const received: Array<{
+      assistantId: string;
+      type: string;
+      conversationId?: string;
+      hostAccess?: boolean;
+    }> = [];
+    const subscription = assistantEventHub.subscribe(
+      { assistantId: DAEMON_INTERNAL_ASSISTANT_ID },
+      (event) => {
+        received.push({
+          assistantId: event.assistantId,
+          type: event.message.type,
+          conversationId: event.conversationId,
+          hostAccess:
+            event.message.type === "conversation_host_access_updated"
+              ? event.message.hostAccess
+              : undefined,
+        });
+      },
+    );
+
+    const patchRoute = findRoute("PATCH", "conversations/:id/host-access");
+    const patchResponse = await patchRoute.handler({
+      req: new Request("http://localhost/v1/conversations/test/host-access", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ hostAccess: true }),
+      }),
+      url: new URL("http://localhost/v1/conversations/test/host-access"),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: conversation.id },
+    });
+
+    await Promise.resolve();
+
+    expect(patchResponse.status).toBe(200);
+    expect(await patchResponse.json()).toEqual({
+      conversationId: conversation.id,
+      hostAccess: true,
+    });
+    expect(received).toHaveLength(1);
+    expect(received[0]).toEqual({
+      assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
+      type: "conversation_host_access_updated",
+      conversationId: conversation.id,
+      hostAccess: true,
+    });
+    subscription.dispose();
+  });
+
+  test("conversation summaries include hostAccess", async () => {
+    const conversation = createConversation("Summary host access");
+    updateConversationHostAccess(conversation.id, true);
+
+    server = new RuntimeHttpServer({
+      port: 0,
+      bearerToken: "test-bearer-token",
+    });
+    await server.start();
+
+    const response = await fetch(
+      `http://127.0.0.1:${server.actualPort}/v1/conversations/${conversation.id}`,
+    );
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      conversation: {
+        id: string;
+        hostAccess: boolean;
+      };
+    };
+
+    expect(body.conversation.id).toBe(conversation.id);
+    expect(body.conversation.hostAccess).toBe(true);
+  });
+
+  test("PATCH /v1/conversations/:id/host-access rejects non-guardian actors when auth is enforced", async () => {
+    authDisabled = false;
+    boundGuardianPrincipalId = "guardian-principal";
+    const conversation = createConversation("Guarded host access");
+
+    const patchRoute = findRoute("PATCH", "conversations/:id/host-access");
+    const patchResponse = await patchRoute.handler({
+      req: new Request("http://localhost/v1/conversations/test/host-access", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ hostAccess: true }),
+      }),
+      url: new URL("http://localhost/v1/conversations/test/host-access"),
+      server: null as never,
+      authContext: {
+        actorPrincipalId: "trusted-contact-principal",
+      } as never,
+      params: { id: conversation.id },
+    });
+
+    expect(patchResponse.status).toBe(403);
+  });
+});

package/src/__tests__/conversation-inject-context.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "bun:test";
+
+import type { Message } from "../providers/types.js";
+
+/**
+ * Unit tests for Conversation.injectInheritedContext() and
+ * Conversation.getCurrentSystemPrompt().
+ *
+ * These methods are thin enough to test via a minimal stub that mirrors the
+ * Conversation fields they touch, avoiding the heavyweight constructor
+ * dependencies.
+ */
+
+/**
+ * Minimal stub that replicates the subset of Conversation used by
+ * injectInheritedContext() and getCurrentSystemPrompt().
+ */
+function createStub(systemPrompt: string) {
+  return {
+    messages: [] as Message[],
+    systemPrompt,
+
+    injectInheritedContext(messages: Message[]): void {
+      if (this.messages.length !== 0) {
+        throw new Error(
+          "injectInheritedContext must be called before any messages have been added",
+        );
+      }
+      this.messages = [...messages];
+    },
+
+    getCurrentSystemPrompt(): string {
+      return this.systemPrompt;
+    },
+  };
+}
+
+const sampleMessages: Message[] = [
+  { role: "user", content: [{ type: "text", text: "Hello from parent" }] },
+  {
+    role: "assistant",
+    content: [{ type: "text", text: "Hi there, I am the assistant" }],
+  },
+  {
+    role: "user",
+    content: [{ type: "text", text: "Follow-up question" }],
+  },
+];
+
+describe("Conversation.injectInheritedContext", () => {
+  test("injected messages appear in this.messages after injection", () => {
+    const stub = createStub("You are a helpful assistant.");
+    stub.injectInheritedContext(sampleMessages);
+
+    expect(stub.messages).toHaveLength(3);
+    expect(stub.messages[0]).toEqual(sampleMessages[0]);
+    expect(stub.messages[1]).toEqual(sampleMessages[1]);
+    expect(stub.messages[2]).toEqual(sampleMessages[2]);
+  });
+
+  test("injected messages are a shallow copy, not the same array reference", () => {
+    const stub = createStub("prompt");
+    stub.injectInheritedContext(sampleMessages);
+
+    expect(stub.messages).not.toBe(sampleMessages);
+    // Individual message objects are shared (shallow copy)
+    expect(stub.messages[0]).toBe(sampleMessages[0]);
+  });
+
+  test("assertion fires if called after messages have been added", () => {
+    const stub = createStub("prompt");
+    // Simulate a message already being present (as if persistUserMessage was called)
+    stub.messages.push({
+      role: "user",
+      content: [{ type: "text", text: "existing message" }],
+    });
+
+    expect(() => stub.injectInheritedContext(sampleMessages)).toThrow(
+      "injectInheritedContext must be called before any messages have been added",
+    );
+  });
+
+  test("injecting an empty array leaves messages empty", () => {
+    const stub = createStub("prompt");
+    stub.injectInheritedContext([]);
+
+    expect(stub.messages).toHaveLength(0);
+  });
+});
+
+describe("Conversation.getCurrentSystemPrompt", () => {
+  test("returns the construction-time system prompt", () => {
+    const prompt = "You are a research assistant with deep knowledge.";
+    const stub = createStub(prompt);
+
+    expect(stub.getCurrentSystemPrompt()).toBe(prompt);
+  });
+
+  test("returns empty string when constructed with empty prompt", () => {
+    const stub = createStub("");
+    expect(stub.getCurrentSystemPrompt()).toBe("");
+  });
+});

package/src/__tests__/conversation-queue.test.ts

@@ -1,5 +1,13 @@
 import { rmSync, writeFileSync } from "node:fs";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
 
 import type {
   AgentEvent,
@@ -95,6 +103,8 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
+const mockedConversationHostAccess = new Map<string, boolean>();
+
 mock.module("../prompts/system-prompt.js", () => ({
   buildSystemPrompt: () => "system prompt",
 }));
@@ -113,6 +123,7 @@ mock.module("../permissions/trust-store.js", () => ({
   addRule: () => {},
   findHighestPriorityRule: () => null,
   clearCache: () => {},
+  patternMatchesCandidate: () => false,
 }));
 
 mock.module("../security/secret-allowlist.js", () => ({
@@ -123,6 +134,14 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
+  getConversationHostAccess: (conversationId: string) =>
+    mockedConversationHostAccess.get(conversationId) ?? false,
+  updateConversationHostAccess: (
+    conversationId: string,
+    hostAccess: boolean,
+  ) => {
+    mockedConversationHostAccess.set(conversationId, hostAccess);
+  },
   deleteMessageById: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
@@ -1315,8 +1334,18 @@ describe("Terminal trace events on rejection/failure", () => {
 // ---------------------------------------------------------------------------
 
 describe("Conversation host attachment directives", () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     pendingRuns = [];
+    mockedConversationHostAccess.clear();
+    const { _setOverridesForTesting } =
+      await import("../config/assistant-feature-flags.js");
+    _setOverridesForTesting({ "permission-controls-v2": true });
+  });
+
+  afterEach(async () => {
+    const { _setOverridesForTesting } =
+      await import("../config/assistant-feature-flags.js");
+    _setOverridesForTesting({});
   });
 
   test("host attachment prompts and resolves when user allows", async () => {
@@ -1364,6 +1393,19 @@ describe("Conversation host attachment directives", () => {
         (e) => e.type === "confirmation_request",
       );
       expect(confirmation).toBeDefined();
+      expect(
+        (confirmation as { persistentDecisionsAllowed?: boolean })
+          .persistentDecisionsAllowed,
+      ).toBe(false);
+      expect(
+        (
+          confirmation as {
+            temporaryOptionsAvailable?: Array<
+              "allow_10m" | "allow_conversation"
+            >;
+          }
+        ).temporaryOptionsAvailable ?? [],
+      ).toEqual([]);
       conversation.handleConfirmationResponse(
         (confirmation as { requestId: string }).requestId,
         "allow",
@@ -1371,6 +1413,7 @@ describe("Conversation host attachment directives", () => {
 
       await p1;
 
+      expect(mockedConversationHostAccess.get("conv-1")).toBe(true);
       expect(conversation.lastAssistantAttachments).toHaveLength(1);
       expect(conversation.lastAssistantAttachments[0].sourceType).toBe(
         "host_file",

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -114,6 +114,7 @@ function createFakeConversation(conversationId: string): Conversation {
     } | null,
     messages: [] as Array<unknown>,
     hostBashProxy: undefined as unknown,
+    hostBrowserProxy: undefined as unknown,
     hostFileProxy: undefined as unknown,
     hostCuProxy: undefined as unknown,
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
@@ -178,12 +179,16 @@ function createFakeConversation(conversationId: string): Conversation {
     setHostBashProxy(this: { hostBashProxy: unknown }, proxy: unknown) {
       this.hostBashProxy = proxy;
     },
+    setHostBrowserProxy(this: { hostBrowserProxy: unknown }, proxy: unknown) {
+      this.hostBrowserProxy = proxy;
+    },
     setHostFileProxy(this: { hostFileProxy: unknown }, proxy: unknown) {
       this.hostFileProxy = proxy;
     },
     setHostCuProxy(this: { hostCuProxy: unknown }, proxy: unknown) {
       this.hostCuProxy = proxy;
     },
+    restoreBrowserProxyAvailability: () => {},
     addPreactivatedSkillId: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -170,8 +170,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: () => false,
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 
@@ -247,8 +249,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: () => false,
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 
@@ -320,8 +324,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       hasPendingConfirmation: (requestId: string) =>
         requestId === "tool-approval-live",
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 
@@ -397,8 +403,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "tool-req-code-1",
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 
@@ -470,8 +478,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "pending-reject-1",
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 
@@ -537,8 +547,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "pending-1",
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 
@@ -606,8 +618,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: () => false,
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 
@@ -676,8 +690,10 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: () => false,
       setHostBashProxy: () => {},
+      setHostBrowserProxy: () => {},
       setHostFileProxy: () => {},
       setHostCuProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
 

package/src/__tests__/conversation-routes-slash-commands.test.ts

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