@vellumai/assistant 0.6.5 → 0.6.6

package/src/approvals/__tests__/guardian-feed-event.test.ts

@@ -0,0 +1,304 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks — must be in place before dynamic imports resolve transitive
+// dependencies (emit-feed-event -> feed-writer -> assistant-event-hub).
+// ---------------------------------------------------------------------------
+
+const publishSpy = mock<(event: unknown) => Promise<void>>(async () => {});
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: publishSpy,
+    subscribe: () => () => {},
+  },
+}));
+
+// Capture emitFeedEvent calls without hitting the real persistence layer.
+const emitFeedEventCalls: Array<{
+  source: string;
+  title: string;
+  summary: string;
+  dedupKey?: string;
+  urgency?: string;
+}> = [];
+
+mock.module("../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: async (params: {
+    source: string;
+    title: string;
+    summary: string;
+    dedupKey?: string;
+    urgency?: string;
+  }) => {
+    emitFeedEventCalls.push(params);
+    return { id: params.dedupKey ?? "mock-id", ...params };
+  },
+}));
+
+// Stub heavy transitive dependencies that the resolvers import so the
+// test can load the module without standing up a full daemon environment.
+
+mock.module("../../calls/call-domain.js", () => ({
+  answerCall: async () => ({ ok: true }),
+}));
+
+mock.module("../../config/env.js", () => ({
+  getGatewayInternalBaseUrl: () => "http://localhost:0",
+}));
+
+mock.module("../../contacts/contact-store.js", () => ({
+  findContactChannel: () => null,
+}));
+
+mock.module("../../contacts/contacts-write.js", () => ({
+  upsertContactChannel: () => {},
+}));
+
+mock.module("../../memory/canonical-guardian-store.js", () => ({
+  getCanonicalGuardianRequest: () => null,
+}));
+
+mock.module("../../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async () => {},
+}));
+
+mock.module("../../notifications/signal.js", () => ({
+  isNotificationSourceChannel: () => false,
+}));
+
+mock.module("../../permissions/trust-store.js", () => ({
+  addRule: () => {},
+}));
+
+mock.module("../../permissions/v2-consent-policy.js", () => ({
+  isPermissionControlsV2Enabled: () => false,
+}));
+
+mock.module("../../runtime/assistant-scope.js", () => ({
+  DAEMON_INTERNAL_ASSISTANT_ID: "self",
+}));
+
+mock.module("../../runtime/auth/token-service.js", () => ({
+  mintDaemonDeliveryToken: () => "mock-token",
+}));
+
+mock.module("../../runtime/channel-approval-types.js", () => ({}));
+
+mock.module("../../runtime/channel-verification-service.js", () => ({
+  createOutboundSession: () => ({
+    sessionId: "mock-session",
+    secret: "123456",
+  }),
+}));
+
+mock.module("../../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async () => {},
+}));
+
+// Stub pending-interactions so tool_approval resolver can find/resolve.
+let mockInteraction: Record<string, unknown> | null = null;
+let mockResolved: Record<string, unknown> | null = null;
+
+mock.module("../../runtime/pending-interactions.js", () => ({
+  get: () => mockInteraction,
+  resolve: () => mockResolved,
+}));
+
+mock.module("../../tools/registry.js", () => ({
+  getTool: () => null,
+}));
+
+mock.module("../../tools/tool-approval-handler.js", () => ({
+  TC_GRANT_WAIT_MAX_MS: 30_000,
+}));
+
+// ---------------------------------------------------------------------------
+// Import the resolvers after all mocks are in place.
+// ---------------------------------------------------------------------------
+
+const { getResolver } = await import("../guardian-request-resolvers.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeRequest(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "req-001",
+    kind: "tool_approval",
+    status: "pending",
+    conversationId: "conv-abc",
+    toolName: "web_fetch",
+    sourceChannel: "vellum",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  } as never;
+}
+
+function makeCtx(
+  request: ReturnType<typeof makeRequest>,
+  decision: { action: string; userText?: string },
+) {
+  return {
+    request,
+    decision,
+    actor: {
+      actorPrincipalId: "principal-1",
+      actorExternalUserId: undefined,
+      channel: "vellum",
+      guardianPrincipalId: "principal-1",
+    },
+  } as never;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("guardian approval feed events", () => {
+  beforeEach(() => {
+    emitFeedEventCalls.length = 0;
+    mockInteraction = {
+      confirmationDetails: { toolName: "web_fetch" },
+    };
+    mockResolved = {
+      conversation: {
+        handleConfirmationResponse: () => {},
+      },
+    };
+  });
+
+  afterEach(() => {
+    mockInteraction = null;
+    mockResolved = null;
+  });
+
+  // -----------------------------------------------------------------------
+  // tool_approval (pendingInteractionResolver)
+  // -----------------------------------------------------------------------
+
+  describe("tool_approval", () => {
+    test("approval emits with title 'Tool Request Approved'", async () => {
+      const resolver = getResolver("tool_approval")!;
+      expect(resolver).toBeDefined();
+
+      const request = makeRequest();
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      // Allow microtask for the void promise to settle.
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Tool Request Approved",
+      );
+      expect(call).toBeDefined();
+      expect(call!.source).toBe("assistant");
+      expect(call!.summary).toContain("Approved");
+      expect(call!.summary).toContain("web_fetch");
+      expect(call!.urgency).toBeUndefined();
+    });
+
+    test("rejection emits with title 'Tool Request Denied' and urgency 'medium'", async () => {
+      const resolver = getResolver("tool_approval")!;
+
+      const request = makeRequest();
+      const ctx = makeCtx(request, { action: "reject" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Tool Request Denied",
+      );
+      expect(call).toBeDefined();
+      expect(call!.urgency).toBe("medium");
+      expect(call!.summary).toContain("Denied");
+    });
+
+    test("dedupKey includes request ID", async () => {
+      const resolver = getResolver("tool_approval")!;
+
+      const request = makeRequest({ id: "req-unique-42" });
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls[0];
+      expect(call).toBeDefined();
+      expect(call!.dedupKey).toBe("guardian-approval:req-unique-42");
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // access_request (accessRequestResolver)
+  // -----------------------------------------------------------------------
+
+  describe("access_request", () => {
+    test("approval emits with title 'Access Request Approved'", async () => {
+      const resolver = getResolver("access_request")!;
+      expect(resolver).toBeDefined();
+
+      const request = makeRequest({
+        kind: "access_request",
+        requesterExternalUserId: "user-123",
+        requesterChatId: "chat-456",
+      });
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Access Request Approved",
+      );
+      expect(call).toBeDefined();
+      expect(call!.source).toBe("assistant");
+      expect(call!.summary).toContain("Granted");
+      expect(call!.urgency).toBeUndefined();
+    });
+
+    test("denial emits with title 'Access Request Denied' and urgency 'medium'", async () => {
+      const resolver = getResolver("access_request")!;
+
+      const request = makeRequest({
+        kind: "access_request",
+        requesterExternalUserId: "user-123",
+        requesterChatId: "chat-456",
+      });
+      const ctx = makeCtx(request, { action: "reject" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Access Request Denied",
+      );
+      expect(call).toBeDefined();
+      expect(call!.urgency).toBe("medium");
+      expect(call!.summary).toContain("Denied");
+    });
+
+    test("dedupKey includes request ID", async () => {
+      const resolver = getResolver("access_request")!;
+
+      const request = makeRequest({
+        id: "req-access-99",
+        kind: "access_request",
+        requesterExternalUserId: "user-123",
+        requesterChatId: "chat-456",
+      });
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls[0];
+      expect(call).toBeDefined();
+      expect(call!.dedupKey).toBe("guardian-access:req-access-99");
+    });
+  });
+});

package/src/approvals/guardian-request-resolvers.ts

@@ -15,6 +15,7 @@ import { answerCall } from "../calls/call-domain.js";
 import { getGatewayInternalBaseUrl } from "../config/env.js";
 import { findContactChannel } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
+import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
   type CanonicalGuardianRequest,
   getCanonicalGuardianRequest,
@@ -266,6 +267,20 @@ const pendingInteractionResolver: GuardianRequestResolver = {
       ctx.emissionContext,
     );
 
+    const approved = decision.action !== "reject";
+    void emitFeedEvent({
+      source: "assistant",
+      title: approved ? "Tool Request Approved" : "Tool Request Denied",
+      summary: `${approved ? "Approved" : "Denied"} access to ${request.toolName ?? "unknown tool"}.`,
+      dedupKey: `guardian-approval:${request.id}`,
+      urgency: approved ? undefined : "medium",
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit guardian approval feed event",
+      );
+    });
+
     log.info(
       {
         event: "resolver_tool_approval_applied",
@@ -518,6 +533,19 @@ const accessRequestResolver: GuardianRequestResolver = {
         }
       }
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Access Request Denied",
+        summary: `Denied access request.`,
+        dedupKey: `guardian-access:${request.id}`,
+        urgency: "medium",
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit access request feed event",
+        );
+      });
+
       return {
         ok: true,
         applied: true,
@@ -558,6 +586,19 @@ const accessRequestResolver: GuardianRequestResolver = {
         "Access request resolver: voice approval — direct trusted-contact activation (no verification session)",
       );
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Access Request Approved",
+        summary: `Granted access request.`,
+        dedupKey: `guardian-access:${request.id}`,
+        urgency: undefined,
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit access request feed event",
+        );
+      });
+
       return { ok: true, applied: true };
     }
 
@@ -793,6 +834,19 @@ const accessRequestResolver: GuardianRequestResolver = {
       ? `Access approved for ${requesterLabel}. Give them this verification code: \`${session.secret}\`. The code expires in 10 minutes.`
       : `Access approved for ${requesterLabel}. Give them this verification code: \`${session.secret}\`. The code expires in 10 minutes. I could not notify them automatically, so please tell them to send the code manually.`;
 
+    void emitFeedEvent({
+      source: "assistant",
+      title: "Access Request Approved",
+      summary: `Granted access request.`,
+      dedupKey: `guardian-access:${request.id}`,
+      urgency: undefined,
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit access request feed event",
+      );
+    });
+
     return {
       ok: true,
       applied: true,
@@ -867,6 +921,19 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
         }
       }
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Tool Grant Denied",
+        summary: `Denied grant request for ${request.toolName ?? "unknown tool"}.`,
+        dedupKey: `guardian-grant:${request.id}`,
+        urgency: "medium",
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit tool grant denial feed event",
+        );
+      });
+
       return { ok: true, applied: true };
     }
 
@@ -965,6 +1032,19 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
       }
     }
 
+    void emitFeedEvent({
+      source: "assistant",
+      title: "Tool Grant Approved",
+      summary: `Approved grant request for ${request.toolName ?? "unknown tool"}.`,
+      dedupKey: `guardian-grant:${request.id}`,
+      urgency: undefined,
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit tool grant approval feed event",
+      );
+    });
+
     return { ok: true, applied: true, grantMinted: false };
   },
 };

package/src/backup/__tests__/backup-worker.test.ts

@@ -20,23 +20,13 @@ import {
 import { unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { BackupConfig, BackupDestination } from "../../config/schema.js";
 import { BackupConfigSchema } from "../../config/schema.js";
 import type { StreamExportVBundleResult } from "../../runtime/migrations/vbundle-builder.js";
 import type { BackupDeps } from "../backup-worker.js";
-import {
-  createSnapshotNow,
-  runBackupTick,
-} from "../backup-worker.js";
+import { createSnapshotNow, runBackupTick } from "../backup-worker.js";
 
 // ---------------------------------------------------------------------------
 // Test fixtures
@@ -190,7 +180,6 @@ describe("runBackupTick — gating", () => {
       snapshotLockPath: join(ROOT, ".snapshot.lock"),
       // Explicit plaintext to avoid touching the key file
       trustPath: join(ROOT, "trust.json"),
-      hooksDir: join(ROOT, "hooks"),
     });
 
     expect(result).toBeNull();

package/src/backup/backup-worker.ts

@@ -42,14 +42,10 @@ import {
   getDbPath,
   getProtectedDir,
   getWorkspaceDir,
-  getWorkspaceHooksDir,
 } from "../util/platform.js";
 import { ensureBackupKey as realEnsureBackupKey } from "./backup-key.js";
 import type { SnapshotEntry } from "./list-snapshots.js";
-import {
-  pruneLocalSnapshots,
-  writeLocalSnapshot,
-} from "./local-writer.js";
+import { pruneLocalSnapshots, writeLocalSnapshot } from "./local-writer.js";
 import type { OffsiteWriteResult } from "./offsite-writer.js";
 import {
   pruneOffsiteSnapshotsInAll,
@@ -60,10 +56,7 @@ import {
   getLocalBackupsDir,
   resolveOffsiteDestinations,
 } from "./paths.js";
-import {
-  acquireSnapshotLock,
-  getSnapshotLockPath,
-} from "./snapshot-lock.js";
+import { acquireSnapshotLock, getSnapshotLockPath } from "./snapshot-lock.js";
 
 const log = getLogger("backup-worker");
 
@@ -118,8 +111,6 @@ export interface BackupDeps {
   localDir?: string;
   /** Override for the trust.json path (tests). */
   trustPath?: string;
-  /** Override for the hooks directory (tests). */
-  hooksDir?: string;
   /** Override for the backup key file path (tests). */
   backupKeyPath?: string;
   /**
@@ -187,9 +178,7 @@ async function performBackup(
   const ensureKey = deps.ensureBackupKey ?? realEnsureBackupKey;
   const workspaceDir = deps.workspaceDir ?? getWorkspaceDir();
   const localDir = deps.localDir ?? getLocalBackupsDir(config.localDirectory);
-  const trustPath =
-    deps.trustPath ?? join(getProtectedDir(), "trust.json");
-  const hooksDir = deps.hooksDir ?? getWorkspaceHooksDir();
+  const trustPath = deps.trustPath ?? join(getProtectedDir(), "trust.json");
   const backupKeyPath = deps.backupKeyPath ?? getBackupKeyPath();
 
   const startTimestamp = Date.now();
@@ -207,7 +196,6 @@ async function performBackup(
   const result = await streamExport({
     workspaceDir,
     trustPath,
-    hooksDir,
     source: "backup-worker",
     description: "Automated backup snapshot",
     checkpoint: () => {

package/src/bundler/app-compiler.ts

@@ -268,14 +268,97 @@ async function resolveAppImports(srcDir: string): Promise<void> {
   }
 }
 
+/**
+ * Per-appDir compile serialisation.
+ *
+ * compileApp() begins by `rm -rf dist/`, so two concurrent compiles on the
+ * same appDir can wipe each other's intermediate output. To prevent that
+ * while still picking up source edits that arrive mid-build, we track a
+ * two-slot queue per appDir:
+ *
+ * - `current`: the compile that is currently writing to dist/.
+ * - `pending`: at most one coalesced follow-up compile queued because a new
+ *   caller arrived while `current` was running. Additional callers arriving
+ *   during that window share `pending` — they do not spawn yet another run.
+ *   Once `current` settles, `pending` is promoted to `current` and begins
+ *   executing; new callers arriving after promotion queue a fresh `pending`.
+ *
+ * This keeps dist/ consistent under concurrency while guaranteeing that any
+ * source mutation observed after a compile starts will be reflected in a
+ * subsequent compile pass rather than silently dropped.
+ */
+interface CompileSlot {
+  current: Promise<CompileResult>;
+  pending?: Promise<CompileResult>;
+}
+
+const compileSlots = new Map<string, CompileSlot>();
+
 /**
  * Compile a TSX app from appDir/src/ into appDir/dist/.
  *
  * Expects appDir/src/main.tsx as the entry point and appDir/src/index.html
  * as the HTML shell. Produces appDir/dist/main.js and appDir/dist/index.html
  * (with script and optional stylesheet tags injected).
+ *
+ * Concurrent calls for the same appDir are serialised (see `compileSlots`
+ * above). Callers never see a partial or racing dist/ write; callers that
+ * represent work requested after a compile started always get a subsequent
+ * fresh compile.
  */
-export async function compileApp(appDir: string): Promise<CompileResult> {
+export function compileApp(appDir: string): Promise<CompileResult> {
+  const slot = compileSlots.get(appDir);
+
+  if (!slot) {
+    const current = runCompile(appDir);
+    const onSettled = () => slotCompileSettled(appDir, current);
+    current.then(onSettled, onSettled);
+    compileSlots.set(appDir, { current });
+    return current;
+  }
+
+  if (slot.pending) return slot.pending;
+
+  // A second distinct caller arrived while `current` is running. Queue a
+  // follow-up that starts once `current` settles (success or failure) so
+  // any source edits that happened mid-build still get compiled.
+  const rerun = async (): Promise<CompileResult> => {
+    try {
+      await slot.current;
+    } catch {
+      // Ignore: we want to rerun regardless of the prior compile's outcome.
+    }
+    return runCompile(appDir);
+  };
+  const pending = rerun();
+  const onSettled = () => slotCompileSettled(appDir, pending);
+  pending.then(onSettled, onSettled);
+  slot.pending = pending;
+  return pending;
+}
+
+function slotCompileSettled(
+  appDir: string,
+  finished: Promise<CompileResult>,
+): void {
+  const slot = compileSlots.get(appDir);
+  if (!slot) return;
+
+  if (slot.current !== finished) {
+    // finished is a rerun that hasn't been promoted yet, or a stale entry.
+    // Promotion happens below when `current` settles; there is nothing to do
+    // here because a subsequent slotCompileSettled(current) will run first.
+    return;
+  }
+
+  if (slot.pending) {
+    compileSlots.set(appDir, { current: slot.pending });
+  } else {
+    compileSlots.delete(appDir);
+  }
+}
+
+async function runCompile(appDir: string): Promise<CompileResult> {
   const start = performance.now();
   const srcDir = join(appDir, "src");
   const distDir = join(appDir, "dist");

package/src/calls/call-state.ts

@@ -1,8 +1,8 @@
 /**
  * Call session notifiers and controller registry.
  *
- * Follows the same notifier pattern as watch-state.ts: module-level Maps
- * with register/unregister/fire helpers keyed by conversationId.
+ * Uses module-level Maps with register/unregister/fire helpers keyed by
+ * conversationId.
  */
 
 import { getLogger } from "../util/logger.js";

package/src/channels/__tests__/types.test.ts

@@ -58,7 +58,7 @@ describe("isInterfaceId", () => {
 });
 
 describe("supportsHostProxy", () => {
-  // ── macOS: supports host_bash / host_file / host_cu, but NOT host_browser. ──
+  // ── macOS: supports all four host proxy capabilities. ──
   test("macos returns true (no capability)", () => {
     expect(supportsHostProxy("macos")).toBe(true);
   });
@@ -75,8 +75,8 @@ describe("supportsHostProxy", () => {
     expect(supportsHostProxy("macos", "host_cu")).toBe(true);
   });
 
-  test("macos returns false for host_browser", () => {
-    expect(supportsHostProxy("macos", "host_browser")).toBe(false);
+  test("macos returns true for host_browser", () => {
+    expect(supportsHostProxy("macos", "host_browser")).toBe(true);
   });
 
   // ── chrome-extension: only host_browser. ──

package/src/channels/types.ts

@@ -137,10 +137,12 @@ export function supportsHostProxy(
   id: InterfaceId,
   capability?: HostProxyCapability,
 ): boolean {
-  // host_browser is excluded for macos because the proxy path requires a
-  // Chrome extension that isn't guaranteed to be attached; browser tools
-  // fall back to the local Playwright Chromium instead.
-  if (id === "macos") return capability !== "host_browser";
+  // macOS supports all four host proxy capabilities including host_browser.
+  // The host_browser proxy is provisioned via the SSE sender path (or via the
+  // ChromeExtensionRegistry when an extension connection is present). When no
+  // extension is connected, browser tools fall through to cdp-inspect/local
+  // via the CDP factory's candidate chain.
+  if (id === "macos") return true;
   if (id === "chrome-extension" && capability === "host_browser") return true;
   return false;
 }