@vellumai/assistant 0.11.7 → 0.11.8-staging.1

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

@@ -28,7 +28,13 @@ const setSecureKeyAsync = mock(
 );
 const getSecureKeyAsync = mock(async (_account: string) => getReturn);
 
+// Spread the real module rather than listing two exports. These cases reach
+// the marker tables, which pulls persistence into the graph, and anything in
+// there that imports another secure-keys export would fail to resolve against
+// a partial factory.
+const realSecureKeys = await import("../../security/secure-keys.js");
 mock.module("../../security/secure-keys.js", () => ({
+  ...realSecureKeys,
   setSecureKeyAsync,
   getSecureKeyAsync,
 }));
@@ -39,7 +45,24 @@ const { _setMetadataPath, getCredentialMetadata, upsertCredentialMetadata } =
 const { acpSpawnCredentialDenialReason } =
   await import("../prepare-agent-env.js");
 
+const { hasAcpConnectCardRaised, markAcpConnectCardRaised } =
+  await import("../acp-connect-card-state.js");
+const { installAcpConfigStub } = await import("./helpers/acp-config-stub.js");
+const acpConfig = await installAcpConfigStub();
+
+// The registry is retired per conversation by asking whether that conversation
+// still has a marker worth showing, so these cases need a real (empty)
+// database rather than an error path standing in for one.
+const { initializeDb } = await import("../../persistence/db-init.js");
+await initializeDb();
+
+const { claudeTokenDigest, noteClaudeTokenRefused } =
+  await import("../acp-auth-marker-store.js");
+const { clearHistory, insertHistoryRow } =
+  await import("./helpers/acp-history-db.js");
+
 const {
+  acpConnectCardStillWarranted,
   CLAUDE_OAUTH_CONFIG,
   CLAUDE_MANUAL_REDIRECT_URI,
   buildClaudeAuthorizeUrl,
@@ -48,6 +71,13 @@ const {
   hasAcpClaudeToken,
 } = await import("../acp-claude-oauth.js");
 
+/**
+ * The card notification is detached from the store so it cannot delay a
+ * sign-in, so a test asserting on its effects has to let it run.
+ */
+const settleNotification = () =>
+  new Promise((resolve) => setTimeout(resolve, 10));
+
 const ACP_SERVICE = "acp";
 const OAUTH_FIELD = "claude_oauth_token";
 const ACP_SPAWN_TOOL = "acp_spawn";
@@ -280,3 +310,235 @@ describe("hasAcpClaudeToken", () => {
     expect(oauthMetadata()).toBeUndefined();
   });
 });
+
+describe("storeAcpClaudeToken: retiring the card registry", () => {
+  test("clears the registry after the policy repair, not before it", () => {
+    // The write happens first and the policy repair second, so at the moment
+    // the credential seam asks, a token whose `acp_spawn` read is denied is
+    // not usable and nothing is retired. The repair on the next line is what
+    // makes it usable, so the notification has to run again after it.
+    upsertCredentialMetadata(ACP_SERVICE, OAUTH_FIELD, {
+      allowedTools: ["some_other_tool"],
+      allowedDomains: [],
+    });
+    expect(acpSpawnCredentialDenialReason(OAUTH_FIELD)).toBeDefined();
+    markAcpConnectCardRaised("conv-with-card");
+    getReturn = "sk-ant-oat-token";
+
+    return storeAcpClaudeToken("sk-ant-oat-token")
+      .then(settleNotification)
+      .then(() => {
+        expect(acpSpawnCredentialDenialReason(OAUTH_FIELD)).toBeUndefined();
+        expect(hasAcpConnectCardRaised("conv-with-card")).toBe(false);
+      });
+  });
+
+  test("leaves the registry alone when the stored value is unusable", () => {
+    // A bulk restore can land an api-key-shaped value. The marker comparison
+    // keeps the card up for that reason, so forgetting the registry would open
+    // the second prompt it exists to suppress.
+    markAcpConnectCardRaised("conv-keeps-card");
+    getReturn = "sk-ant-api-key-shaped";
+
+    return storeAcpClaudeToken("sk-ant-api-key-shaped")
+      .then(settleNotification)
+      .then(() => {
+        expect(hasAcpConnectCardRaised("conv-keeps-card")).toBe(true);
+      });
+  });
+});
+
+describe("storeAcpClaudeToken: a re-written rejected token retires nothing", () => {
+  test("keeps the registry entry while the marker still stands", () => {
+    // A bulk restore can store the very token Claude rejected. It passes the
+    // shape and policy checks, so usability says yes, but nothing about the
+    // failure changed: the snapshot goes on serving that marker and the card
+    // stays up. Forgetting the entry would open a second prompt beside it.
+    clearHistory();
+    const token = "sk-ant-oat-still-rejected";
+    getReturn = token;
+    insertHistoryRow({
+      id: "run-still-rejected",
+      parentConversationId: "conv-still-broken",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: claudeTokenDigest(token),
+    });
+    markAcpConnectCardRaised("conv-still-broken");
+
+    return storeAcpClaudeToken(token)
+      .then(settleNotification)
+      .then(() => {
+        expect(hasAcpConnectCardRaised("conv-still-broken")).toBe(true);
+      });
+  });
+
+  test("drops it once a different token makes the marker stale", () => {
+    clearHistory();
+    getReturn = "sk-ant-oat-replacement";
+    insertHistoryRow({
+      id: "run-repaired",
+      parentConversationId: "conv-repaired",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: claudeTokenDigest("sk-ant-oat-old-rejected"),
+    });
+    markAcpConnectCardRaised("conv-repaired");
+
+    return storeAcpClaudeToken("sk-ant-oat-replacement")
+      .then(settleNotification)
+      .then(() => {
+        expect(hasAcpConnectCardRaised("conv-repaired")).toBe(false);
+      });
+  });
+});
+
+describe("acpConnectCardStillWarranted", () => {
+  test("a mid-run card stands while its marker names the credential in use", () => {
+    clearHistory();
+    const token = "sk-ant-oat-in-use";
+    getReturn = token;
+    insertHistoryRow({
+      id: "run-warranted",
+      parentConversationId: "conv-warranted",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: claudeTokenDigest(token),
+    });
+
+    return acpConnectCardStillWarranted("conv-warranted").then((warranted) => {
+      expect(warranted).toBe(true);
+    });
+  });
+
+  test("a mid-run card falls once a different token is stored", () => {
+    // The repair need not be a credential write: editing the agent's
+    // configured token moves this answer too, which is why it is asked rather
+    // than remembered.
+    clearHistory();
+    getReturn = "sk-ant-oat-replacement";
+    insertHistoryRow({
+      id: "run-repaired",
+      parentConversationId: "conv-repaired-warrant",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: claudeTokenDigest("sk-ant-oat-old"),
+    });
+
+    return acpConnectCardStillWarranted("conv-repaired-warrant").then(
+      (warranted) => {
+        expect(warranted).toBe(false);
+      },
+    );
+  });
+
+  test("a pre-spawn card stands while there is no usable token", () => {
+    // The missing-token path has no session to record a marker on, so the
+    // absence of one says nothing; what keeps its card meaningful is that a
+    // spawn still has nothing to authenticate with.
+    clearHistory();
+    getReturn = undefined;
+
+    return acpConnectCardStillWarranted("conv-no-token").then((warranted) => {
+      expect(warranted).toBe(true);
+    });
+  });
+
+  test("a pre-spawn card falls once a usable token exists", () => {
+    clearHistory();
+    getReturn = "sk-ant-oat-now-present";
+
+    return acpConnectCardStillWarranted("conv-no-marker").then((warranted) => {
+      expect(warranted).toBe(false);
+    });
+  });
+});
+
+describe("acpConnectCardStillWarranted: a pre-spawn card and configured tokens", () => {
+  test("falls once the agent's configured token supplies a credential", () => {
+    // Repairing by setting `acp.agents.<id>.env.CLAUDE_CODE_OAUTH_TOKEN` never
+    // touches the vault, so asking the vault would call this card warranted
+    // forever even though the next spawn authenticates fine.
+    clearHistory();
+    getReturn = undefined;
+    acpConfig.setConfig({
+      agents: {
+        claude: {
+          command: "claude-agent-acp",
+          args: [],
+          env: { CLAUDE_CODE_OAUTH_TOKEN: "sk-ant-oat-from-config" },
+        },
+      },
+    });
+    markAcpConnectCardRaised("conv-config-repair", "claude");
+
+    return acpConnectCardStillWarranted("conv-config-repair").then(
+      (warranted) => {
+        expect(warranted).toBe(false);
+      },
+    );
+  });
+
+  test("stands while neither config nor the vault offers one", () => {
+    clearHistory();
+    getReturn = undefined;
+    acpConfig.setConfig({ agents: {} });
+    markAcpConnectCardRaised("conv-still-nothing", "claude");
+
+    return acpConnectCardStillWarranted("conv-still-nothing").then(
+      (warranted) => {
+        expect(warranted).toBe(true);
+      },
+    );
+  });
+});
+
+describe("acpConnectCardStillWarranted: a resolved credential Claude already refused", () => {
+  test("stands while the only credential a spawn would pick is the refused one", () => {
+    // Standing down needs a replacement to stand down *to*. With none stored,
+    // the resolver still reports the refused configured token, and the next
+    // spawn rejects it exactly as this one did. Reading that as repaired drops
+    // the card and lets a second prompt open beside it.
+    clearHistory();
+    const token = "sk-ant-oat-config-refused";
+    getReturn = undefined;
+    acpConfig.setConfig({
+      agents: {
+        claude: {
+          command: "claude-agent-acp",
+          args: [],
+          env: { CLAUDE_CODE_OAUTH_TOKEN: token },
+        },
+      },
+    });
+    noteClaudeTokenRefused(claudeTokenDigest(token), 1000);
+    markAcpConnectCardRaised("conv-refused-config", "claude");
+
+    return acpConnectCardStillWarranted("conv-refused-config").then(
+      (warranted) => {
+        expect(warranted).toBe(true);
+      },
+    );
+  });
+
+  test("falls once the resolved credential is one Claude has not refused", () => {
+    clearHistory();
+    getReturn = undefined;
+    acpConfig.setConfig({
+      agents: {
+        claude: {
+          command: "claude-agent-acp",
+          args: [],
+          env: { CLAUDE_CODE_OAUTH_TOKEN: "sk-ant-oat-config-fresh" },
+        },
+      },
+    });
+    markAcpConnectCardRaised("conv-fresh-config", "claude");
+
+    return acpConnectCardStillWarranted("conv-fresh-config").then(
+      (warranted) => {
+        expect(warranted).toBe(false);
+      },
+    );
+  });
+});

package/src/acp/__tests__/acp-connect-card-state.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from "bun:test";
 import {
   hasAcpConnectCardRaised,
   markAcpConnectCardRaised,
+  takeConversationsWithAcpConnectCard,
 } from "../acp-connect-card-state.js";
 
 describe("acp-connect-card-state", () => {
@@ -20,4 +21,20 @@ describe("acp-connect-card-state", () => {
     markAcpConnectCardRaised("");
     expect(hasAcpConnectCardRaised("")).toBe(false);
   });
+
+  test("take hands back every raised conversation and forgets them", () => {
+    // A new token retires these conversations' persisted markers, so an entry
+    // left behind would keep redirecting the fallback at a card nothing can
+    // re-raise.
+    markAcpConnectCardRaised("conv-take-a");
+    markAcpConnectCardRaised("conv-take-b");
+
+    const taken = takeConversationsWithAcpConnectCard();
+
+    expect(taken).toContain("conv-take-a");
+    expect(taken).toContain("conv-take-b");
+    expect(hasAcpConnectCardRaised("conv-take-a")).toBe(false);
+    expect(hasAcpConnectCardRaised("conv-take-b")).toBe(false);
+    expect(takeConversationsWithAcpConnectCard()).toEqual([]);
+  });
 });

package/src/acp/__tests__/helpers/acp-history-db.ts

@@ -30,6 +30,8 @@ export interface HistoryRow {
   cost_currency: string | null;
   input_tokens: number | null;
   output_tokens: number | null;
+  auth_error_code: string | null;
+  auth_error_credential: string | null;
 }
 
 export function clearHistory(): void {
@@ -62,6 +64,8 @@ export function insertHistoryRow(row: {
   costCurrency?: string | null;
   inputTokens?: number | null;
   outputTokens?: number | null;
+  authErrorCode?: string | null;
+  authErrorCredential?: string | null;
 }): void {
   getSqlite()
     .query(
@@ -70,8 +74,8 @@ export function insertHistoryRow(row: {
          started_at, completed_at, status, stop_reason, error,
          event_log_json, cwd, task, parent_tool_use_id,
          used_tokens, context_size, cost_amount, cost_currency,
-         input_tokens, output_tokens
-       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+         input_tokens, output_tokens, auth_error_code, auth_error_credential
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     )
     .run(
       row.id,
@@ -93,6 +97,8 @@ export function insertHistoryRow(row: {
       row.costCurrency ?? null,
       row.inputTokens ?? null,
       row.outputTokens ?? null,
+      row.authErrorCode ?? null,
+      row.authErrorCredential ?? null,
     );
 }
 
@@ -103,7 +109,8 @@ export function readHistoryRow(id: string): HistoryRow | null {
               started_at, completed_at, status, stop_reason, error,
               event_log_json, cwd, task, parent_tool_use_id,
               used_tokens, context_size, cost_amount, cost_currency,
-              input_tokens, output_tokens
+              input_tokens, output_tokens, auth_error_code,
+              auth_error_credential
        FROM acp_session_history WHERE id = ?`,
     )
     .get(id) as HistoryRow | null;

package/src/acp/acp-auth-marker-store.ts

@@ -0,0 +1,196 @@
+import { createHash } from "node:crypto";
+
+import { and, desc, eq, isNotNull } from "drizzle-orm";
+
+import { getDb } from "../persistence/db-connection.js";
+import {
+  acpRefusedCredentials,
+  acpSessionHistory,
+} from "../persistence/schema/index.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("acp-auth-marker-store");
+
+/**
+ * How many of a conversation's newest markers are examined before giving up on
+ * finding a current one.
+ *
+ * A conversation keeps every marker it has ever had, so this bounds the read
+ * to a fixed cost. Beyond the newest few the answer is nearly always the same,
+ * and erring toward "no current marker" only forgets bookkeeping that the next
+ * failure recreates.
+ */
+export const MARKER_SCAN_LIMIT = 20;
+
+/** Digest a Claude token for identity comparison. Never stores the token. */
+export function claudeTokenDigest(token: string): string {
+  return createHash("sha256").update(token).digest("hex").slice(0, 32);
+}
+
+/**
+ * Whether a credential-failure marker is still worth showing a card for.
+ *
+ * The marker names the credential the run was refused on. It stops being worth
+ * showing the moment a spawn would resolve a different one, because that is
+ * the user having repaired the auth the card exists to send them to.
+ *
+ * Answered by comparing, not by remembering. Nothing has to run at the right
+ * moment for a repaired marker to stop rendering, which is the difference
+ * between this and a retirement sweep: a sweep has to be ordered against every
+ * in-flight write and in-flight read, and a daemon restart loses whatever it
+ * was tracking. A comparison has no ordering to get wrong and no lifetime.
+ *
+ * Fails toward showing the card. A marker with no credential named predates
+ * this column or was written by a path that had none, and an unknown
+ * credential is no evidence the failure was repaired.
+ */
+export function acpAuthMarkerStillCurrent(
+  markerCredential: string | null | undefined,
+  resolvedCredential: string | undefined,
+): boolean {
+  if (markerCredential == null || resolvedCredential === undefined) {
+    return true;
+  }
+  return markerCredential === resolvedCredential;
+}
+
+/**
+ * Record that Claude refused this token, so no later spawn resolves it again.
+ *
+ * Kept in its own table rather than read back off the marker rows. A marker is
+ * about showing a card for one run and the user may delete it with that run,
+ * while this decides which credential a spawn selects, and clearing session
+ * history must not change that. A configured
+ * `acp.agents.<id>.env.CLAUDE_CODE_OAUTH_TOKEN` lives in config, so forgetting
+ * a refusal lets the revoked value win over the vault replacement again.
+ *
+ * Never throws: a run has already failed by the time this is called, and
+ * losing the record costs one more failed spawn rather than the failure
+ * handling itself.
+ */
+export function noteClaudeTokenRefused(
+  digest: string | undefined,
+  refusedAt: number,
+): void {
+  if (digest === undefined) {
+    return;
+  }
+  try {
+    getDb()
+      .insert(acpRefusedCredentials)
+      .values({ digest, refusedAt })
+      .onConflictDoNothing()
+      .run();
+  } catch (err) {
+    log.error(
+      { err },
+      "recording a refused Claude credential failed; it may be resolved again",
+    );
+  }
+}
+
+/**
+ * Whether Claude has refused this token before.
+ *
+ * Never throws: this only narrows which token a spawn prefers, and a read
+ * failure must not take the spawn with it. Failing open resolves the
+ * configured token, which is what would have happened before it was ever
+ * refused.
+ */
+export function claudeTokenRefusedByClaude(token: string): boolean {
+  return claudeCredentialRefused(claudeTokenDigest(token));
+}
+
+/**
+ * Whether Claude has refused the credential with this digest.
+ *
+ * The same question as {@link claudeTokenRefusedByClaude}, for callers that
+ * hold an identity rather than the token itself: a resolver reports which
+ * credential a spawn would pick, and "would pick it" is not the same as
+ * "it works".
+ */
+export function claudeCredentialRefused(digest: string): boolean {
+  try {
+    const row = getDb()
+      .select({ digest: acpRefusedCredentials.digest })
+      .from(acpRefusedCredentials)
+      .where(eq(acpRefusedCredentials.digest, digest))
+      .limit(1)
+      .get();
+    return row !== undefined;
+  } catch (err) {
+    log.error(
+      { err },
+      "reading refused Claude credentials failed; treating the token as untried",
+    );
+    return false;
+  }
+}
+
+/**
+ * Whether this conversation still has a credential failure worth showing a
+ * card for.
+ *
+ * The same question the session list answers per row, asked for one
+ * conversation. Callers that hold their own idea of which conversations have a
+ * card up use this to decide whether that idea is still true, rather than
+ * guessing from whether a token was written: a writer can store the very token
+ * Claude rejected, which changes nothing about the failure and must not be
+ * mistaken for repairing it.
+ *
+ * Never throws, and answers `false` when it cannot tell. The caller uses this
+ * to decide whether to forget that a conversation has a card up, and the two
+ * mistakes are not equal: forgetting wrongly costs a redundant secure prompt
+ * beside a card, while remembering wrongly suppresses that prompt and points
+ * the user at a card that may no longer be there.
+ */
+export async function conversationHasCurrentAcpMarker(
+  conversationId: string,
+): Promise<boolean> {
+  try {
+    const rows = getDb()
+      .select({
+        agentId: acpSessionHistory.agentId,
+        credential: acpSessionHistory.authErrorCredential,
+      })
+      .from(acpSessionHistory)
+      .where(
+        and(
+          eq(acpSessionHistory.parentConversationId, conversationId),
+          isNotNull(acpSessionHistory.authErrorCode),
+        ),
+      )
+      .orderBy(desc(acpSessionHistory.startedAt))
+      .limit(MARKER_SCAN_LIMIT)
+      .all();
+    if (rows.length === 0) {
+      return false;
+    }
+    // Imported at call time: `prepare-agent-env` owns the precedence a spawn
+    // applies, and reaching it from here at load would put the whole spawn
+    // graph behind this module.
+    const { resolvedClaudeCredentialDigest } =
+      await import("./prepare-agent-env.js");
+    const resolved = new Map<string, string | undefined>();
+    for (const row of rows) {
+      if (!resolved.has(row.agentId)) {
+        resolved.set(
+          row.agentId,
+          await resolvedClaudeCredentialDigest(row.agentId),
+        );
+      }
+      if (
+        acpAuthMarkerStillCurrent(row.credential, resolved.get(row.agentId))
+      ) {
+        return true;
+      }
+    }
+    return false;
+  } catch (err) {
+    log.error(
+      { err },
+      "reading ACP auth markers failed; treating the card as no longer raised",
+    );
+    return false;
+  }
+}