@vellumai/assistant 0.11.4-dev.202608201011.f81ab8d → 0.11.4-dev.202608201321.78202a0

package/openapi.yaml

@@ -4651,6 +4651,47 @@ paths:
                 required:
                   - recorded
                 additionalProperties: false
+  /v1/clients/web-presence:
+    post:
+      operationId: clients_webpresence_post
+      summary: Report web tab visibility and focused conversation
+      description:
+        Record the visibility and focused conversation reported by the web client identified by the
+        X-Vellum-Client-Id header.
+      tags:
+        - clients
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                visible:
+                  type: boolean
+                  description: Whether the reporting tab is currently visible.
+                focusedConversationId:
+                  anyOf:
+                    - type: string
+                    - type: "null"
+                  description: The conversation currently focused (chat composer on screen) in the tab, or null.
+              required:
+                - visible
+                - focusedConversationId
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  recorded:
+                    type: boolean
+                    description: Whether a connected client matched the reporting clientId.
+                required:
+                  - recorded
+                additionalProperties: false
   /v1/config:
     get:
       operationId: config_get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.4-dev.202608201011.f81ab8d",
+  "version": "0.11.4-dev.202608201321.78202a0",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/client-os-metadata-persistence.test.ts

@@ -201,6 +201,22 @@ describe("client OS per-row evidence marker", () => {
     expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(true);
   });
 
+  // Mirrors the Mac-originated case above: a plain browser tab reports
+  // `client.os: "web"`, while the Electron desktop renderer resolves its own
+  // host OS first and persists `macos`/`windows` instead.
+  test("marks an OS this row's own transport reported (web)", async () => {
+    const ctx = createWebTurnContext("web");
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-transport-os-web",
+      requestClientOs: "web",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "web" });
+    expect(lastUserMetadata().clientOsFromRequest).toBe(true);
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+  });
+
   test("marks an OS this row's own request headers reported", async () => {
     const ctx = createWebTurnContext(undefined);
     await persistQueuedMessageBody(ctx, {

package/src/__tests__/credential-broker-server-use.test.ts

@@ -44,8 +44,24 @@ import { setSecureKeyAsync } from "../security/secure-keys.js";
 import { CredentialBroker } from "../tools/credentials/broker.js";
 import {
   _setMetadataPath,
+  type CredentialMetadata,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
+import { serverUseDenialReason } from "../tools/credentials/tool-policy.js";
+
+/** The shared policy's verdict for a state the broker must also deny. */
+function sharedDenialReason(
+  metadata: CredentialMetadata,
+  toolName: string,
+  service: string,
+  field: string,
+): string {
+  const reason = serverUseDenialReason(metadata, toolName, service, field);
+  if (!reason) {
+    throw new Error("expected a denial reason from the shared policy");
+  }
+  return reason;
+}
 
 // ---------------------------------------------------------------------------
 // Tests — serverUse (publish_page / unpublish_page regression)
@@ -518,9 +534,10 @@ describe("CredentialBroker.serverUseById", () => {
     if (result.success) {
       throw new Error("expected denial");
     }
-    expect(result.reason).toContain("not allowed");
-    expect(result.reason).toContain("unauthorized_tool");
-    expect(result.reason).toContain("media_proxy");
+    // The broker passes the shared server-use policy's verdict through verbatim.
+    expect(result.reason).toBe(
+      sharedDenialReason(meta, "unauthorized_tool", "fal", "api_key"),
+    );
   });
 
   test("returns not found for unknown credential ID", async () => {
@@ -553,8 +570,10 @@ describe("CredentialBroker.serverUseById", () => {
     if (result.success) {
       throw new Error("expected denial");
     }
-    expect(result.reason).toContain("domain restrictions");
-    expect(result.reason).toContain("cannot be used server-side");
+    // The broker passes the shared server-use policy's verdict through verbatim.
+    expect(result.reason).toBe(
+      sharedDenialReason(meta, "media_proxy", "github", "oauth_token"),
+    );
   });
 
   test("returns empty injection templates when credential has none", async () => {

package/src/__tests__/plugin-config-data-migration.test.ts

@@ -32,7 +32,10 @@ import {
   populateCacheAtBoot,
   resetPluginCacheForTests,
 } from "../plugins/mtime-cache.js";
-import { PRESERVED_ENTRIES } from "../plugins/plugin-tree-walk.js";
+import {
+  PRESERVED_ENTRIES,
+  USER_STATE_ENTRIES,
+} from "../plugins/plugin-tree-walk.js";
 
 const ROOT = join(
   tmpdir(),
@@ -87,6 +90,10 @@ describe("PRESERVED_ENTRIES", () => {
     expect(PRESERVED_ENTRIES).toContain("data");
     expect(PRESERVED_ENTRIES).toContain(".disabled");
   });
+
+  test("user-state entries are the preserved set minus the provenance sidecar", () => {
+    expect([...USER_STATE_ENTRIES]).toEqual(["config.json", "data", ".disabled"]);
+  });
 });
 
 describe("fingerprint exclusion of preserved entries", () => {

package/src/__tests__/tool-policy.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
-import { isToolAllowed } from "../tools/credentials/tool-policy.js";
+import type { CredentialMetadata } from "../tools/credentials/metadata-store.js";
+import {
+  BROWSER_FILL_CAPABILITY,
+  isToolAllowed,
+  serverUseDenialReason,
+} from "../tools/credentials/tool-policy.js";
 
 describe("isToolAllowed", () => {
   // ── Allow cases ─────────────────────────────────────────────────────
@@ -72,3 +77,94 @@ describe("isToolAllowed", () => {
     ).toBe(false);
   });
 });
+
+describe("serverUseDenialReason", () => {
+  function metadata(
+    overrides: Partial<CredentialMetadata> = {},
+  ): CredentialMetadata {
+    return {
+      credentialId: "cred-1",
+      service: "acp",
+      field: "claude_oauth_token",
+      allowedTools: ["acp_spawn"],
+      allowedDomains: [],
+      createdAt: 0,
+      updatedAt: 0,
+      ...overrides,
+    };
+  }
+
+  test("denies when metadata is missing", () => {
+    expect(
+      serverUseDenialReason(
+        undefined,
+        "acp_spawn",
+        "acp",
+        "claude_oauth_token",
+      ),
+    ).toBe("No credential found for acp/claude_oauth_token");
+  });
+
+  test("denies fail-closed when allowedTools is empty", () => {
+    const reason = serverUseDenialReason(
+      metadata({ allowedTools: [] }),
+      "acp_spawn",
+      "acp",
+      "claude_oauth_token",
+    );
+    expect(reason).toContain(
+      'Tool "acp_spawn" is not allowed to use credential acp/claude_oauth_token.',
+    );
+    expect(reason).toContain("No tools are currently allowed");
+  });
+
+  test("denies when allowedTools omits the requesting tool", () => {
+    const reason = serverUseDenialReason(
+      metadata({ allowedTools: ["bash", "web_fetch"] }),
+      "acp_spawn",
+      "acp",
+      "claude_oauth_token",
+    );
+    expect(reason).toContain(
+      'Tool "acp_spawn" is not allowed to use credential acp/claude_oauth_token.',
+    );
+    expect(reason).toContain("Allowed tools: bash, web_fetch.");
+  });
+
+  test("allows when a legacy alias canonicalizes to the requesting tool", () => {
+    expect(
+      serverUseDenialReason(
+        metadata({ allowedTools: ["browser_fill_credential"] }),
+        BROWSER_FILL_CAPABILITY,
+        "acp",
+        "claude_oauth_token",
+      ),
+    ).toBeUndefined();
+  });
+
+  test("denies a domain-restricted credential", () => {
+    expect(
+      serverUseDenialReason(
+        metadata({ allowedDomains: ["example.com", "example.org"] }),
+        "acp_spawn",
+        "acp",
+        "claude_oauth_token",
+      ),
+    ).toBe(
+      "Credential acp/claude_oauth_token has domain restrictions " +
+        "(example.com, example.org) and cannot be used server-side. " +
+        "Remove domain restrictions or use a separate credential without domain policy.",
+    );
+  });
+
+  test("allows fully-permitted metadata", () => {
+    expect(
+      serverUseDenialReason(
+        metadata(),
+        "acp_spawn",
+        "acp",
+        "claude_oauth_token",
+      ),
+    ).toBeUndefined();
+  });
+});

package/src/acp/__tests__/acp-claude-oauth.test.ts

@@ -1,13 +1,21 @@
 /**
  * Tests for the Claude OAuth config + capture/store helpers.
  *
- * The store helper reaches into secure-keys and the ACP credential policy, so
- * we mock both (wired BEFORE importing the module under test via dynamic
- * import) and assert the vault write targets `credential/acp/claude_oauth_token`
- * and throws when the backend rejects the write.
+ * The store helper reaches into secure-keys, so we mock that (wired BEFORE
+ * importing the module under test via dynamic import) and assert the vault
+ * write targets `credential/acp/claude_oauth_token` and throws when the backend
+ * rejects the write.
+ *
+ * The ACP credential policy is NOT mocked: `hasAcpClaudeToken` has to answer
+ * exactly what the spawn-time broker read would, so it is exercised against the
+ * real metadata store (pointed at a temp dir) and the real policy evaluation.
  */
 
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { randomBytes } from "node:crypto";
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks — wired BEFORE importing the module via dynamic import.
@@ -19,20 +27,17 @@ const setSecureKeyAsync = mock(
   async (_account: string, _value: string) => storeReturn,
 );
 const getSecureKeyAsync = mock(async (_account: string) => getReturn);
-const grantAcpSpawnPolicy = mock(
-  (_field: string, _usageDescription: string) => {},
-);
-let spawnCanRead = true;
-const acpSpawnCanReadCredential = mock((_field: string) => spawnCanRead);
 
 mock.module("../../security/secure-keys.js", () => ({
   setSecureKeyAsync,
   getSecureKeyAsync,
 }));
-mock.module("../prepare-agent-env.js", () => ({
-  grantAcpSpawnPolicy,
-  acpSpawnCanReadCredential,
-}));
+
+const { _setMetadataPath, getCredentialMetadata, upsertCredentialMetadata } =
+  await import("../../tools/credentials/metadata-store.js");
+
+const { acpSpawnCredentialDenialReason } =
+  await import("../prepare-agent-env.js");
 
 const {
   CLAUDE_OAUTH_CONFIG,
@@ -43,14 +48,31 @@ const {
   hasAcpClaudeToken,
 } = await import("../acp-claude-oauth.js");
 
+const ACP_SERVICE = "acp";
+const OAUTH_FIELD = "claude_oauth_token";
+const ACP_SPAWN_TOOL = "acp_spawn";
+
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-acp-claude-oauth-test-${randomBytes(4).toString("hex")}`,
+);
+
+function oauthMetadata() {
+  return getCredentialMetadata(ACP_SERVICE, OAUTH_FIELD);
+}
+
 beforeEach(() => {
+  mkdirSync(TEST_DIR, { recursive: true });
+  _setMetadataPath(join(TEST_DIR, "metadata.json"));
   storeReturn = true;
   getReturn = undefined;
-  spawnCanRead = true;
   setSecureKeyAsync.mockClear();
   getSecureKeyAsync.mockClear();
-  grantAcpSpawnPolicy.mockClear();
-  acpSpawnCanReadCredential.mockClear();
+});
+
+afterEach(() => {
+  _setMetadataPath(null);
+  rmSync(TEST_DIR, { recursive: true, force: true });
 });
 
 // ---------------------------------------------------------------------------
@@ -149,7 +171,7 @@ describe("parseManualClaudeCode", () => {
 // ---------------------------------------------------------------------------
 
 describe("storeAcpClaudeToken", () => {
-  test("writes the token and force-grants the acp_spawn policy (repairs a denied policy)", async () => {
+  test("writes the token to the acp/claude_oauth_token vault field", async () => {
     await storeAcpClaudeToken("sk-ant-oat-token");
 
     expect(setSecureKeyAsync).toHaveBeenCalledTimes(1);
@@ -157,10 +179,25 @@ describe("storeAcpClaudeToken", () => {
       "credential/acp/claude_oauth_token",
       "sk-ant-oat-token",
     );
-    // grant (union), not merely ensure (preserve) — so an explicit Connect
-    // repairs a credential whose allowedTools omitted acp_spawn.
-    expect(grantAcpSpawnPolicy).toHaveBeenCalledTimes(1);
-    expect(grantAcpSpawnPolicy.mock.calls[0][0]).toBe("claude_oauth_token");
+  });
+
+  test("takes a domain-restricted credential from not-connected to connected", async () => {
+    // Invariant: when the vault holds a usable token whose domain policy
+    // makes the spawn read fail, the status check keeps the Connect card
+    // offered, and completing Connect repairs the policy so the retry after
+    // a successful sign-in succeeds. The per-shape repair details are covered
+    // by the repairAcpSpawnPolicy suite in prepare-agent-env.test.ts.
+    upsertCredentialMetadata(ACP_SERVICE, OAUTH_FIELD, {
+      allowedTools: [ACP_SPAWN_TOOL],
+      allowedDomains: ["api.anthropic.com"],
+    });
+    getReturn = "sk-ant-oat-token";
+    expect(await hasAcpClaudeToken()).toBe(false);
+
+    await storeAcpClaudeToken("sk-ant-oat-token");
+
+    expect(await hasAcpClaudeToken()).toBe(true);
+    expect(acpSpawnCredentialDenialReason(OAUTH_FIELD)).toBeUndefined();
   });
 
   test("throws when the secure store rejects the write", async () => {
@@ -169,7 +206,7 @@ describe("storeAcpClaudeToken", () => {
     await expect(storeAcpClaudeToken("sk-ant-oat-token")).rejects.toThrow(
       /Failed to store/,
     );
-    expect(grantAcpSpawnPolicy).not.toHaveBeenCalled();
+    expect(oauthMetadata()).toBeUndefined();
   });
 });
 
@@ -202,13 +239,44 @@ describe("hasAcpClaudeToken", () => {
     expect(await hasAcpClaudeToken()).toBe(false);
   });
 
-  test("reports false when the spawn policy can't read the token (denied allowedTools)", async () => {
-    // A valid OAuth token is stored, but an explicit `allowedTools` that omits
-    // `acp_spawn` means the broker denies the spawn read. Reporting "connected"
-    // would self-dismiss the card and trap the user in a missing-token loop, so
-    // it stays not-connected to keep the repair CTA visible.
+  test("reports true for metadata with an empty allowedTools (the spawn would grant acp_spawn)", async () => {
+    // One allow-state case: the full policy matrix is guarded by the parity
+    // suite in prepare-agent-env.test.ts and the tool-policy unit tests.
+    upsertCredentialMetadata(ACP_SERVICE, OAUTH_FIELD, { allowedTools: [] });
     getReturn = "sk-ant-oat-token";
-    spawnCanRead = false;
+
+    expect(await hasAcpClaudeToken()).toBe(true);
+  });
+
+  test("reports false for a domain-restricted credential the broker refuses server-side", async () => {
+    // acp_spawn is allowed, but a non-empty allowedDomains scopes the credential
+    // to browser fills, so every spawn read is denied. The status check has to
+    // see that too, otherwise the Connect card self-dismisses while acp_spawn
+    // keeps failing with the missing-token marker.
+    upsertCredentialMetadata(ACP_SERVICE, OAUTH_FIELD, {
+      allowedTools: [ACP_SPAWN_TOOL],
+      allowedDomains: ["api.anthropic.com"],
+    });
+    getReturn = "sk-ant-oat-token";
+
     expect(await hasAcpClaudeToken()).toBe(false);
   });
+
+  test("writes nothing to the metadata store (the status route is a GET)", async () => {
+    upsertCredentialMetadata(ACP_SERVICE, OAUTH_FIELD, { allowedTools: [] });
+    getReturn = "sk-ant-oat-token";
+    const before = oauthMetadata();
+
+    await hasAcpClaudeToken();
+
+    expect(oauthMetadata()).toEqual(before);
+  });
+
+  test("creates no metadata when there is none to begin with", async () => {
+    getReturn = "sk-ant-oat-token";
+
+    await hasAcpClaudeToken();
+
+    expect(oauthMetadata()).toBeUndefined();
+  });
 });