@vellumai/assistant 0.6.1 → 0.6.3

package/src/__tests__/permission-checker-host-gate.test.ts

@@ -14,11 +14,6 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-import {
-  initPermissionModeStore,
-  resetForTesting as resetPermissionModeStore,
-  setHostAccess,
-} from "../permissions/permission-mode-store.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { RiskLevel } from "../permissions/types.js";
 import { PermissionChecker } from "../tools/permission-checker.js";
@@ -47,6 +42,13 @@ mock.module("../hooks/manager.js", () => ({
   }),
 }));
 
+const hostAccessByConversation = new Map<string, boolean>();
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationHostAccess: (conversationId: string) =>
+    hostAccessByConversation.get(conversationId) ?? false,
+}));
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -96,13 +98,12 @@ const executionTarget: ExecutionTarget = "host";
 
 beforeEach(() => {
   _setOverridesForTesting({});
-  resetPermissionModeStore();
-  initPermissionModeStore();
+  hostAccessByConversation.clear();
 });
 
 afterEach(() => {
   _setOverridesForTesting({});
-  resetPermissionModeStore();
+  hostAccessByConversation.clear();
 });
 
 // ---------------------------------------------------------------------------
@@ -125,7 +126,7 @@ describe("permission-checker host-access gate (v2)", () => {
 
     describe("host tools with hostAccess=false", () => {
       beforeEach(() => {
-        setHostAccess(false);
+        hostAccessByConversation.set("test-conv", false);
       });
 
       for (const toolName of HOST_TOOL_NAMES) {
@@ -151,6 +152,12 @@ describe("permission-checker host-access gate (v2)", () => {
 
           // The prompter should have been called (interactive dialog)
           expect(promptSpy).toHaveBeenCalled();
+          const call = promptSpy.mock.calls[0] as unknown as unknown[];
+          expect(call[3]).toEqual([]);
+          expect(call[4]).toEqual([]);
+          expect(call[8]).toBe(false);
+          expect(call[10]).toBeUndefined();
+          expect(call[12]).toBe(true);
           // Since the mock prompter returns "allow", the result should be allowed
           expect(result.allowed).toBe(true);
           expect(result.decision).toBe("allow");
@@ -185,7 +192,7 @@ describe("permission-checker host-access gate (v2)", () => {
 
     describe("host tools with hostAccess=true", () => {
       beforeEach(() => {
-        setHostAccess(true);
+        hostAccessByConversation.set("test-conv", true);
       });
 
       for (const toolName of HOST_TOOL_NAMES) {
@@ -217,7 +224,7 @@ describe("permission-checker host-access gate (v2)", () => {
         "web_search",
       ]) {
         test(`${toolName} is auto-allowed regardless of hostAccess`, async () => {
-          setHostAccess(false);
+          hostAccessByConversation.set("test-conv", false);
           const checker = new PermissionChecker(makePrompter());
           const result = await checker.checkPermission(
             toolName,
@@ -239,7 +246,7 @@ describe("permission-checker host-access gate (v2)", () => {
 
     describe("requireFreshApproval bypasses v2 auto-allow", () => {
       beforeEach(() => {
-        setHostAccess(true);
+        hostAccessByConversation.set("test-conv", true);
       });
 
       test("host tool with requireFreshApproval falls through to prompter", async () => {
@@ -263,6 +270,12 @@ describe("permission-checker host-access gate (v2)", () => {
         );
 
         expect(promptSpy).toHaveBeenCalled();
+        const call = promptSpy.mock.calls[0] as unknown as unknown[];
+        expect(call[3]).toEqual([]);
+        expect(call[4]).toEqual([]);
+        expect(call[8]).toBe(false);
+        expect(call[10]).toBeUndefined();
+        expect(call[12]).toBe(false);
         expect(result.allowed).toBe(true);
         expect(result.decision).toBe("allow");
       });
@@ -288,6 +301,12 @@ describe("permission-checker host-access gate (v2)", () => {
         );
 
         expect(promptSpy).toHaveBeenCalled();
+        const call = promptSpy.mock.calls[0] as unknown as unknown[];
+        expect(call[3]).toEqual([]);
+        expect(call[4]).toEqual([]);
+        expect(call[8]).toBe(false);
+        expect(call[10]).toBeUndefined();
+        expect(call[12]).toBe(false);
         expect(result.allowed).toBe(true);
         expect(result.decision).toBe("allow");
       });
@@ -295,7 +314,7 @@ describe("permission-checker host-access gate (v2)", () => {
 
     describe("non-interactive guardian session with hostAccess=false", () => {
       beforeEach(() => {
-        setHostAccess(false);
+        hostAccessByConversation.set("test-conv", false);
       });
 
       test("host tool is NOT auto-approved (denies instead of guardian_auto_approve)", async () => {
@@ -329,7 +348,7 @@ describe("permission-checker host-access gate (v2)", () => {
 
     describe("forcePromptSideEffects bypasses v2 auto-allow for side-effect tools", () => {
       beforeEach(() => {
-        setHostAccess(true);
+        hostAccessByConversation.set("test-conv", true);
       });
 
       test("host side-effect tool with forcePromptSideEffects falls through to prompter", async () => {
@@ -401,6 +420,47 @@ describe("permission-checker host-access gate (v2)", () => {
         expect(result.decision).toBe("allow");
       });
     });
+
+    test("host access is evaluated per conversation", async () => {
+      hostAccessByConversation.set("allow-conv", true);
+      hostAccessByConversation.set("deny-conv", false);
+
+      const promptSpy = mock(() =>
+        Promise.resolve({ decision: "deny" as const }),
+      );
+      const checker = new PermissionChecker({
+        prompt: promptSpy,
+      } as unknown as PermissionPrompter);
+
+      const allowed = await checker.checkPermission(
+        "host_bash",
+        {},
+        makeTool("host_bash"),
+        makeContext({ conversationId: "allow-conv" }),
+        executionTarget,
+        noopEmit,
+        noopSanitize,
+        Date.now(),
+        noopDiff,
+      );
+      const denied = await checker.checkPermission(
+        "host_bash",
+        {},
+        makeTool("host_bash"),
+        makeContext({ conversationId: "deny-conv" }),
+        executionTarget,
+        noopEmit,
+        noopSanitize,
+        Date.now(),
+        noopDiff,
+      );
+
+      expect(allowed.allowed).toBe(true);
+      expect(allowed.decision).toBe("allow");
+      expect(denied.allowed).toBe(false);
+      expect(denied.decision).toBe("deny");
+      expect(promptSpy).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe("when permission-controls-v2 flag is OFF", () => {

package/src/__tests__/permission-mode.test.ts

@@ -6,51 +6,28 @@ import {
   PermissionModeSchema,
 } from "../permissions/permission-mode.js";
 
-// ---------------------------------------------------------------------------
-// Tests: PermissionModeSchema
-// ---------------------------------------------------------------------------
-
 describe("PermissionModeSchema", () => {
-  test("parses empty object with correct defaults", () => {
-    const result = PermissionModeSchema.parse({});
-    expect(result.askBeforeActing).toBe(true);
-    expect(result.hostAccess).toBe(false);
+  test("parses empty object with the host-access default", () => {
+    expect(PermissionModeSchema.parse({})).toEqual({ hostAccess: false });
   });
 
   test("DEFAULT_PERMISSION_MODE matches schema defaults", () => {
-    const parsed = PermissionModeSchema.parse({});
-    expect(parsed).toEqual(DEFAULT_PERMISSION_MODE);
+    expect(PermissionModeSchema.parse({})).toEqual(DEFAULT_PERMISSION_MODE);
   });
 
-  test("accepts explicit true/true", () => {
-    const result = PermissionModeSchema.parse({
-      askBeforeActing: true,
+  test("accepts explicit host access values", () => {
+    expect(PermissionModeSchema.parse({ hostAccess: true })).toEqual({
       hostAccess: true,
     });
-    expect(result.askBeforeActing).toBe(true);
-    expect(result.hostAccess).toBe(true);
-  });
-
-  test("accepts explicit false/false", () => {
-    const result = PermissionModeSchema.parse({
-      askBeforeActing: false,
+    expect(PermissionModeSchema.parse({ hostAccess: false })).toEqual({
       hostAccess: false,
     });
-    expect(result.askBeforeActing).toBe(false);
-    expect(result.hostAccess).toBe(false);
   });
 
   test("round-trips through JSON serialization", () => {
-    const original = { askBeforeActing: false, hostAccess: true };
+    const original = { hostAccess: true };
     const json = JSON.stringify(original);
-    const parsed = PermissionModeSchema.parse(JSON.parse(json));
-    expect(parsed).toEqual(original);
-  });
-
-  test("rejects non-boolean askBeforeActing", () => {
-    expect(() =>
-      PermissionModeSchema.parse({ askBeforeActing: "yes" }),
-    ).toThrow();
+    expect(PermissionModeSchema.parse(JSON.parse(json))).toEqual(original);
   });
 
   test("rejects non-boolean hostAccess", () => {
@@ -58,44 +35,39 @@ describe("PermissionModeSchema", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Tests: PermissionsConfigSchema (permissionMode fields)
-// ---------------------------------------------------------------------------
-
-describe("PermissionsConfigSchema permissionMode fields", () => {
-  test("defaults askBeforeActing to true and hostAccess to false", () => {
-    const result = PermissionsConfigSchema.parse({});
-    expect(result.askBeforeActing).toBe(true);
-    expect(result.hostAccess).toBe(false);
+describe("PermissionsConfigSchema", () => {
+  test("defaults to workspace mode with host access disabled", () => {
+    expect(PermissionsConfigSchema.parse({})).toEqual({
+      mode: "workspace",
+      hostAccess: false,
+    });
   });
 
-  test("preserves existing mode field alongside new fields", () => {
-    const result = PermissionsConfigSchema.parse({ mode: "strict" });
-    expect(result.mode).toBe("strict");
-    expect(result.askBeforeActing).toBe(true);
-    expect(result.hostAccess).toBe(false);
+  test("preserves the mode field alongside hostAccess", () => {
+    expect(PermissionsConfigSchema.parse({ mode: "strict" })).toEqual({
+      mode: "strict",
+      hostAccess: false,
+    });
   });
 
-  test("accepts overridden values for new fields", () => {
-    const result = PermissionsConfigSchema.parse({
+  test("accepts overridden hostAccess values", () => {
+    expect(
+      PermissionsConfigSchema.parse({
+        mode: "workspace",
+        hostAccess: true,
+      }),
+    ).toEqual({
       mode: "workspace",
-      askBeforeActing: false,
       hostAccess: true,
     });
-    expect(result.mode).toBe("workspace");
-    expect(result.askBeforeActing).toBe(false);
-    expect(result.hostAccess).toBe(true);
   });
 
-  test("round-trips new fields through JSON serialization", () => {
+  test("round-trips hostAccess through JSON serialization", () => {
     const input = {
       mode: "workspace" as const,
-      askBeforeActing: false,
       hostAccess: true,
     };
     const json = JSON.stringify(input);
-    const parsed = PermissionsConfigSchema.parse(JSON.parse(json));
-    expect(parsed.askBeforeActing).toBe(false);
-    expect(parsed.hostAccess).toBe(true);
+    expect(PermissionsConfigSchema.parse(JSON.parse(json))).toEqual(input);
   });
 });

package/src/__tests__/pkb-autoinject.test.ts

@@ -0,0 +1,96 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { readAutoinjectList } from "../daemon/conversation-runtime-assembly.js";
+
+// ---------------------------------------------------------------------------
+// Setup / Teardown
+// ---------------------------------------------------------------------------
+
+let pkbDir: string;
+const dirs: string[] = [];
+
+beforeEach(() => {
+  pkbDir = join(
+    tmpdir(),
+    `vellum-pkb-autoinject-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(pkbDir, { recursive: true });
+  dirs.push(pkbDir);
+});
+
+afterEach(() => {
+  for (const dir of dirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("readAutoinjectList", () => {
+  test("returns null when _autoinject.md does not exist", () => {
+    expect(readAutoinjectList(pkbDir)).toBeNull();
+  });
+
+  test("returns empty array when _autoinject.md is empty", () => {
+    writeFileSync(join(pkbDir, "_autoinject.md"), "", "utf-8");
+    expect(readAutoinjectList(pkbDir)).toEqual([]);
+  });
+
+  test("returns empty array when _autoinject.md contains only comments", () => {
+    writeFileSync(
+      join(pkbDir, "_autoinject.md"),
+      "_ This is a comment\n_ Another comment\n",
+      "utf-8",
+    );
+    expect(readAutoinjectList(pkbDir)).toEqual([]);
+  });
+
+  test("parses standard default content", () => {
+    writeFileSync(
+      join(pkbDir, "_autoinject.md"),
+      "_ comment\n\nINDEX.md\nessentials.md\nthreads.md\nbuffer.md\n",
+      "utf-8",
+    );
+    expect(readAutoinjectList(pkbDir)).toEqual([
+      "INDEX.md",
+      "essentials.md",
+      "threads.md",
+      "buffer.md",
+    ]);
+  });
+
+  test("parses custom entries", () => {
+    writeFileSync(
+      join(pkbDir, "_autoinject.md"),
+      "INDEX.md\ncustom-topic.md\n",
+      "utf-8",
+    );
+    expect(readAutoinjectList(pkbDir)).toEqual([
+      "INDEX.md",
+      "custom-topic.md",
+    ]);
+  });
+
+  test("strips blank lines and whitespace", () => {
+    writeFileSync(
+      join(pkbDir, "_autoinject.md"),
+      "INDEX.md\n\n  essentials.md  \n\n",
+      "utf-8",
+    );
+    expect(readAutoinjectList(pkbDir)).toEqual(["INDEX.md", "essentials.md"]);
+  });
+
+  test("strips comment lines mixed with filenames", () => {
+    writeFileSync(
+      join(pkbDir, "_autoinject.md"),
+      "_ Always loaded files\nINDEX.md\n_ Core facts\nessentials.md\n",
+      "utf-8",
+    );
+    expect(readAutoinjectList(pkbDir)).toEqual(["INDEX.md", "essentials.md"]);
+  });
+});

package/src/__tests__/platform-callback-registration.test.ts

@@ -69,6 +69,25 @@ describe("platform callback registration", () => {
     expect(context.authHeader).toBe("Api-Key ast-managed-key");
   });
 
+  test("self-hosted assistant with stored credentials is enabled without IS_PLATFORM", async () => {
+    mockIsPlatform = false;
+    mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
+      "https://platform.example.com";
+    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
+      "22222222-3333-4444-8555-666666666666";
+    mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
+      "ast-self-hosted-key";
+
+    const context = await resolvePlatformCallbackRegistrationContext();
+
+    expect(context.enabled).toBe(true);
+    expect(context.isPlatform).toBe(false);
+    expect(context.platformBaseUrl).toBe("https://platform.example.com");
+    expect(context.assistantId).toBe("22222222-3333-4444-8555-666666666666");
+    expect(context.hasAssistantApiKey).toBe(true);
+    expect(context.authHeader).toBe("Api-Key ast-self-hosted-key");
+  });
+
   test("registerCallbackRoute falls back to assistant API key auth", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";