@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/disk-pressure-tools.test.ts

@@ -0,0 +1,277 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { SkillProjectionCache } from "../daemon/conversation-skill-tools.js";
+import type { SkillProjectionContext } from "../daemon/conversation-tool-setup.js";
+import type { Message, ToolDefinition } from "../providers/types.js";
+import type { DiskUsageInfo } from "../util/disk-usage.js";
+
+let diskSample: DiskUsageInfo | null = null;
+
+const mockConfig = {
+  timeouts: {
+    shellDefaultTimeoutSec: 120,
+    shellMaxTimeoutSec: 600,
+    permissionTimeoutSec: 300,
+  },
+  sandbox: {
+    enabled: false,
+    backend: "native" as const,
+    docker: {
+      image: "vellum-sandbox:latest",
+      cpus: 1,
+      memoryMb: 512,
+      pidsLimit: 256,
+      network: "none" as const,
+    },
+  },
+  permissions: { mode: "workspace" as const },
+};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => mockConfig,
+  getConfigReadOnly: () => mockConfig,
+  loadConfig: () => mockConfig,
+  applyNestedDefaults: () => mockConfig,
+  deepMergeOverwrite: (_base: unknown, override: unknown) => override,
+  invalidateConfigCache: () => undefined,
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => undefined,
+  getNestedValue: () => undefined,
+  setNestedValue: () => undefined,
+  mergeDefaultWorkspaceConfig: (config: unknown) => config,
+  API_KEY_PROVIDERS: [] as const,
+  _appendQuarantineBulletin: () => undefined,
+}));
+
+mock.module("../daemon/conversation-skill-tools.js", () => ({
+  projectSkillTools: mock((_history: Message[], _opts: unknown) => ({
+    allowedToolNames: new Set<string>(),
+    toolDefinitions: [],
+  })),
+  resetSkillToolProjection: () => undefined,
+}));
+
+mock.module("../runtime/agent-wake.js", () => ({
+  wakeAgentForOpportunity: async () => undefined,
+}));
+
+mock.module("../runtime/assistant-event.js", () => ({
+  buildAssistantEvent: (message: unknown, conversationId?: string) => ({
+    id: "event-test",
+    type: "message",
+    timestamp: new Date().toISOString(),
+    conversationId,
+    message,
+  }),
+}));
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  AssistantEventHub: class {},
+  broadcastMessage: () => {},
+  capabilityForMessageType: () => undefined,
+  assistantEventHub: {
+    publish: async () => undefined,
+    listClientsByCapability: () => [],
+  },
+}));
+
+mock.module("../util/disk-usage.js", () => ({
+  getDiskUsageInfo: () => diskSample,
+}));
+
+const { _setOverridesForTesting } =
+  await import("../config/assistant-feature-flags.js");
+const {
+  DISK_PRESSURE_THRESHOLD_PERCENT,
+  __resetDiskPressureGuardForTests,
+  evaluateDiskPressureNow,
+} = await import("../daemon/disk-pressure-guard.js");
+const { createResolveToolsCallback } =
+  await import("../daemon/conversation-tool-setup.js");
+const { ToolApprovalHandler } =
+  await import("../tools/tool-approval-handler.js");
+const {
+  _clearRegistryForTesting,
+  listBackgroundTools,
+  registerBackgroundTool,
+} = await import("../tools/background-tool-registry.js");
+const { shellTool } = await import("../tools/terminal/shell.js");
+const { hostShellTool } = await import("../tools/host-terminal/host-shell.js");
+
+function makeToolDef(name: string): ToolDefinition {
+  return { name, description: `${name} tool`, input_schema: {} };
+}
+
+function makeProjectionCtx(
+  overrides: Partial<SkillProjectionContext> = {},
+): SkillProjectionContext {
+  return {
+    skillProjectionState: new Map(),
+    skillProjectionCache: {} as SkillProjectionCache,
+    coreToolNames: new Set(),
+    toolsDisabledDepth: 0,
+    ...overrides,
+  };
+}
+
+function setDiskUsage(usedMb: number, totalMb = 100): void {
+  diskSample = {
+    path: "/workspace",
+    totalMb,
+    usedMb,
+    freeMb: Math.max(0, totalMb - usedMb),
+  };
+}
+
+beforeEach(() => {
+  _clearRegistryForTesting();
+  __resetDiskPressureGuardForTests();
+  _setOverridesForTesting({ "safe-storage-limits": true });
+  setDiskUsage(10);
+});
+
+afterEach(() => {
+  _clearRegistryForTesting();
+  __resetDiskPressureGuardForTests();
+  _setOverridesForTesting({});
+  diskSample = null;
+});
+
+describe("disk pressure cleanup tool restrictions", () => {
+  test("cleanup mode hides non-allowlisted tools and restores normal tools after the turn", () => {
+    const toolDefs = [
+      makeToolDef("bash"),
+      makeToolDef("host_bash"),
+      makeToolDef("file_read"),
+      makeToolDef("file_write"),
+      makeToolDef("skill_execute"),
+      makeToolDef("web_fetch"),
+    ];
+    const ctx = makeProjectionCtx({ diskPressureCleanupModeActive: true });
+    const resolve = createResolveToolsCallback(toolDefs, ctx)!;
+
+    const cleanupTools = resolve([]);
+    const cleanupNames = cleanupTools.map((tool) => tool.name).sort();
+
+    expect(cleanupNames).toEqual(["bash", "file_read", "host_bash"]);
+    expect(ctx.allowedToolNames?.has("bash")).toBe(true);
+    expect(ctx.allowedToolNames?.has("file_write")).toBe(false);
+    expect(ctx.allowedToolNames?.has("skill_execute")).toBe(false);
+
+    ctx.diskPressureCleanupModeActive = false;
+    const normalTools = resolve([]);
+    const normalNames = normalTools.map((tool) => tool.name);
+
+    expect(normalNames).toContain("file_write");
+    expect(normalNames).toContain("skill_execute");
+    expect(normalNames).toContain("web_fetch");
+    expect(ctx.allowedToolNames?.has("file_write")).toBe(true);
+  });
+
+  test("executor fallback rejects non-cleanup tools even if stale allowlist includes them", async () => {
+    const handler = new ToolApprovalHandler();
+    const result = await handler.checkPreExecutionGates(
+      "file_write",
+      { path: "large.log", content: "data" },
+      {
+        workingDir: "/workspace",
+        conversationId: "conv-cleanup",
+        trustClass: "guardian",
+        allowedToolNames: new Set(["file_write"]),
+        diskPressureCleanupModeActive: true,
+      },
+      "sandbox",
+      "low",
+      Date.now(),
+      () => undefined,
+    );
+
+    expect(result.allowed).toBe(false);
+    if (result.allowed) {
+      throw new Error("Expected disk pressure cleanup gate to reject tool");
+    }
+    expect(result.result.content).toContain(
+      "not available during disk pressure cleanup mode",
+    );
+  });
+
+  test("locking cancels registered terminal background tools with disk pressure reason", () => {
+    const bashCancel = mock((_reason?: string) => undefined);
+    const hostCancel = mock((_reason?: string) => undefined);
+    const otherCancel = mock((_reason?: string) => undefined);
+
+    registerBackgroundTool({
+      id: "bg-bash",
+      toolName: "bash",
+      conversationId: "conv-1",
+      command: "sleep 100",
+      startedAt: 1,
+      cancel: bashCancel,
+    });
+    registerBackgroundTool({
+      id: "bg-host",
+      toolName: "host_bash",
+      conversationId: "conv-1",
+      command: "sleep 100",
+      startedAt: 2,
+      cancel: hostCancel,
+    });
+    registerBackgroundTool({
+      id: "bg-other",
+      toolName: "web_fetch",
+      conversationId: "conv-1",
+      command: "fetch",
+      startedAt: 3,
+      cancel: otherCancel,
+    });
+
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT);
+    const status = evaluateDiskPressureNow();
+
+    expect(status.locked).toBe(true);
+    expect(bashCancel).toHaveBeenCalledWith("disk_pressure");
+    expect(hostCancel).toHaveBeenCalledWith("disk_pressure");
+    expect(otherCancel).not.toHaveBeenCalled();
+    expect(listBackgroundTools().map((tool) => tool.id)).toEqual(["bg-other"]);
+  });
+
+  test("background shell modes are blocked during cleanup mode", async () => {
+    const shellResult = await shellTool.execute(
+      {
+        command: "sleep 100",
+        activity: "check disk usage",
+        background: true,
+      },
+      {
+        workingDir: "/workspace",
+        conversationId: "conv-cleanup",
+        trustClass: "guardian",
+        diskPressureCleanupModeActive: true,
+      },
+    );
+
+    expect(shellResult.isError).toBe(true);
+    expect(shellResult.content).toContain(
+      "background shell commands are not available",
+    );
+
+    const hostResult = await hostShellTool.execute(
+      {
+        command: "sleep 100",
+        activity: "check disk usage",
+        background: true,
+      },
+      {
+        workingDir: "/workspace",
+        conversationId: "conv-cleanup",
+        trustClass: "guardian",
+        diskPressureCleanupModeActive: true,
+      },
+    );
+
+    expect(hostResult.isError).toBe(true);
+    expect(hostResult.content).toContain(
+      "background host shell commands are not available",
+    );
+  });
+});

package/src/__tests__/disk-usage.test.ts

@@ -0,0 +1,150 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const MIB = 1024 * 1024;
+const GIB = 1024 * MIB;
+
+let existingPaths = new Set<string>();
+const workspaceDir = "/workspace";
+let minikubeStorageSize: string | undefined;
+let statfsResult = {
+  bsize: 4096,
+  blocks: 0,
+  bavail: 0,
+};
+let spawnResult: {
+  status: number | null;
+  stdout: string;
+} = {
+  status: 0,
+  stdout: "",
+};
+let spawnCalls: Array<{ command: string; args: string[] }> = [];
+
+mock.module("node:fs", () => ({
+  existsSync: (path: string) => existingPaths.has(path),
+  statfsSync: () => statfsResult,
+}));
+
+mock.module("node:child_process", () => ({
+  spawnSync: (command: string, args: string[]) => {
+    spawnCalls.push({ command, args });
+    return spawnResult;
+  },
+}));
+
+mock.module("../config/env-registry.js", () => ({
+  getMinikubeStorageSize: () => minikubeStorageSize,
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspaceDir: () => workspaceDir,
+}));
+
+const { __resetDiskUsageCacheForTests, getDiskUsageInfo, parseK8sMemoryBytes } =
+  await import("../util/disk-usage.js");
+
+function statfsFor(totalBytes: number, freeBytes: number) {
+  return {
+    bsize: MIB,
+    blocks: totalBytes / MIB,
+    bavail: freeBytes / MIB,
+  };
+}
+
+describe("disk usage sampler", () => {
+  beforeEach(() => {
+    existingPaths = new Set([workspaceDir]);
+    minikubeStorageSize = undefined;
+    statfsResult = statfsFor(100 * MIB, 25 * MIB);
+    spawnResult = { status: 0, stdout: "" };
+    spawnCalls = [];
+    __resetDiskUsageCacheForTests();
+  });
+
+  test("reports regular statfs usage", () => {
+    const usage = getDiskUsageInfo();
+
+    expect(usage).toEqual({
+      path: "/workspace",
+      totalMb: 100,
+      usedMb: 75,
+      freeMb: 25,
+    });
+    expect(spawnCalls).toHaveLength(0);
+  });
+
+  test("falls back to root when the workspace path does not exist", () => {
+    existingPaths = new Set();
+
+    const usage = getDiskUsageInfo();
+
+    expect(usage?.path).toBe("/");
+  });
+
+  test("uses PVC capacity and du usage when host filesystem is larger", () => {
+    minikubeStorageSize = "1Gi";
+    statfsResult = statfsFor(10 * GIB, 8 * GIB);
+    spawnResult = {
+      status: 0,
+      stdout: `${100 * MIB}\t/workspace\n`,
+    };
+
+    const usage = getDiskUsageInfo();
+
+    expect(usage).toEqual({
+      path: "/workspace",
+      totalMb: 1024,
+      usedMb: 100,
+      freeMb: 924,
+    });
+    expect(spawnCalls).toEqual([
+      { command: "du", args: ["-sb", "/workspace"] },
+    ]);
+  });
+
+  test("includes /data in PVC du usage when it exists separately", () => {
+    existingPaths = new Set([workspaceDir, "/data"]);
+    minikubeStorageSize = "1Gi";
+    statfsResult = statfsFor(10 * GIB, 8 * GIB);
+    spawnResult = {
+      status: 0,
+      stdout: `${100 * MIB}\t/workspace\n${20 * MIB}\t/data\n`,
+    };
+
+    const usage = getDiskUsageInfo();
+
+    expect(usage?.usedMb).toBe(120);
+    expect(spawnCalls).toEqual([
+      { command: "du", args: ["-sb", "/workspace", "/data"] },
+    ]);
+  });
+
+  test("returns null for malformed Kubernetes memory strings", () => {
+    expect(parseK8sMemoryBytes("")).toBeNull();
+    expect(parseK8sMemoryBytes("abc")).toBeNull();
+    expect(parseK8sMemoryBytes("12Zi")).toBeNull();
+    expect(parseK8sMemoryBytes("-1Gi")).toBeNull();
+    expect(parseK8sMemoryBytes("0Gi")).toBeNull();
+  });
+
+  test("falls back to statfs when du fails in PVC mode", () => {
+    minikubeStorageSize = "1Gi";
+    statfsResult = statfsFor(10 * GIB, 8 * GIB);
+    spawnResult = {
+      status: 1,
+      stdout: "",
+    };
+
+    const usage = getDiskUsageInfo();
+
+    expect(usage).toEqual({
+      path: "/workspace",
+      totalMb: 10240,
+      usedMb: 2048,
+      freeMb: 8192,
+    });
+    expect(spawnCalls).toEqual([
+      { command: "du", args: ["-sb", "/workspace"] },
+    ]);
+  });
+});

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

@@ -39,7 +39,6 @@ mock.module("../config/loader.js", () => ({
   }),
   loadConfig: () => ({}),
   loadRawConfig: () => ({}),
-  saveConfig: () => {},
   saveRawConfig: () => {},
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,

package/src/__tests__/events-client-registration.test.ts

@@ -395,6 +395,58 @@ describe("events client registration", () => {
     ac2.abort();
   });
 
+  // ── actorPrincipalId capture ──────────────────────────────────────────────
+
+  test("captures actorPrincipalId from x-vellum-actor-principal-id header", () => {
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "principal-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "user-A",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    const entry = hub.getClientById("principal-client-001");
+    expect(entry?.actorPrincipalId).toBe("user-A");
+    expect(hub.getActorPrincipalIdForClient("principal-client-001")).toBe(
+      "user-A",
+    );
+
+    ac.abort();
+  });
+
+  test("registers client with undefined actorPrincipalId when header is absent", () => {
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "principal-client-002",
+          "x-vellum-interface-id": "macos",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    const entry = hub.getClientById("principal-client-002");
+    expect(entry).toBeDefined();
+    expect(entry?.actorPrincipalId).toBeUndefined();
+    expect(
+      hub.getActorPrincipalIdForClient("principal-client-002"),
+    ).toBeUndefined();
+
+    ac.abort();
+  });
+
   // ── disposeClient (force disconnect) ──────────────────────────────────────
 
   test("disposeClient removes all subscribers for the clientId", () => {

package/src/__tests__/events-dev-bypass-actor.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Regression tests for the SSE registration dev-bypass actor principal
+ * translation.
+ *
+ * In `DISABLE_HTTP_AUTH=true` (platform-managed) deployments the synthetic
+ * dev-bypass `AuthContext` injects `actorPrincipalId="dev-bypass"` for every
+ * request. Tool-side trust resolution still resolves to the real local
+ * guardian's principalId via `resolveLocalTrustContext`. Without translation,
+ * `ClientEntry.actorPrincipalId === "dev-bypass"` and
+ * `ToolContext.sourceActorPrincipalId === "<real-guardian>"` mismatch, so the
+ * same-user check in HostBashProxy / HostFileProxy / HostCuProxy /
+ * conversation-surfaces rejects every targeted host proxy invocation and the
+ * auto-resolve path silently falls through to untargeted broadcast.
+ *
+ * The events-routes handler translates `"dev-bypass"` to the real guardian's
+ * principalId at registration time so both sides agree. This keeps targeted
+ * host proxy execution working on Docker / platform-managed deployments.
+ */
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+// ── Module mocks (must be set up before importing the route) ──────────────
+
+let fakeHttpAuthDisabled = false;
+let fakeGuardianPrincipalId: string | undefined = undefined;
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => fakeHttpAuthDisabled,
+  hasUngatedHttpAuthDisabled: () => false,
+}));
+
+mock.module("../runtime/local-actor-identity.js", () => ({
+  findLocalGuardianPrincipalId: () => fakeGuardianPrincipalId,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ── Real imports (after mocks) ────────────────────────────────────────────
+
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import { handleSubscribeAssistantEvents } from "../runtime/routes/events-routes.js";
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe("events SSE registration — dev-bypass actor translation", () => {
+  test("translates 'dev-bypass' to the real guardian principalId when auth is disabled", () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = "guardian-real-id";
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "devbypass-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    const entry = hub.getClientById("devbypass-client-001");
+    expect(entry?.actorPrincipalId).toBe("guardian-real-id");
+    expect(hub.getActorPrincipalIdForClient("devbypass-client-001")).toBe(
+      "guardian-real-id",
+    );
+
+    ac.abort();
+  });
+
+  test("registers without principalId when dev-bypass is set but no guardian is bound", () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = undefined;
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "devbypass-client-002",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    const entry = hub.getClientById("devbypass-client-002");
+    expect(entry).toBeDefined();
+    expect(entry?.actorPrincipalId).toBeUndefined();
+
+    ac.abort();
+  });
+
+  test("does NOT translate when auth is enabled (production mode)", () => {
+    // Defense in depth: make sure we never silently rewrite a real
+    // principalId that legitimately happens to be the literal "dev-bypass"
+    // string in a non-dev-bypass deployment. The translation is gated on
+    // isHttpAuthDisabled() === true.
+    fakeHttpAuthDisabled = false;
+    fakeGuardianPrincipalId = "guardian-real-id";
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "prod-client-003",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    const entry = hub.getClientById("prod-client-003");
+    expect(entry?.actorPrincipalId).toBe("dev-bypass");
+
+    ac.abort();
+  });
+
+  test("passes through non-dev-bypass principalId verbatim in dev-bypass mode", () => {
+    // Edge case: a service-token connection that happens to be made while
+    // the daemon runs in DISABLE_HTTP_AUTH=true mode should still register
+    // with its own principalId, not the guardian's.
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = "guardian-real-id";
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "service-client-004",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "service-account-A",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    const entry = hub.getClientById("service-client-004");
+    expect(entry?.actorPrincipalId).toBe("service-account-A");
+
+    ac.abort();
+  });
+});

package/src/__tests__/file-write-tool.test.ts

@@ -197,26 +197,20 @@ describe("file_write tool PKB re-index hook", () => {
     });
   });
 
-  test("always uses PKB_WORKSPACE_SCOPE regardless of context.memoryScopeId", async () => {
+  test("always uses PKB_WORKSPACE_SCOPE", async () => {
     const workingDir = makeTempDir();
     setWorkspaceDir(workingDir);
     mkdirSync(join(workingDir, "pkb"), { recursive: true });
 
-    const ctx: ToolContext = {
-      ...makeContext(workingDir),
-      memoryScopeId: "subagent:abc123",
-    };
-
     const result = await fileWriteTool.execute(
       { path: "pkb/private.md", content: "secret\n" },
-      ctx,
+      makeContext(workingDir),
     );
 
     expect(result.isError).toBe(false);
     expect(enqueueCalls).toHaveLength(1);
-    // PKB files are workspace-level — the per-conversation scopeId is NOT
-    // threaded through so different conversations can't overwrite each
-    // other's Qdrant points via target_id upsert deduplication.
+    // PKB files are workspace-level — points are keyed by PKB_WORKSPACE_SCOPE
+    // so all conversations share one PKB index.
     expect(enqueueCalls[0]?.memoryScopeId).toBe(PKB_WORKSPACE_SCOPE);
   });