@vellumai/assistant 0.5.6 → 0.5.8

package/src/__tests__/credential-security-invariants.test.ts

@@ -138,45 +138,6 @@ describe("Invariant 1: secrets never enter LLM context", () => {
       });
     }
   }
-
-  // PR 27 — secret ingress block scans inbound messages
-  test("user message containing secret is blocked from entering history", () => {
-    // Mock config to enable block mode
-    mock.module("../config/loader.js", () => ({
-      applyNestedDefaults: (config: unknown) => config,
-      getConfig: () => ({
-        ui: {},
-        secretDetection: {
-          enabled: true,
-          action: "block",
-          blockIngress: true,
-        },
-      }),
-      invalidateConfigCache: () => {},
-      loadConfig: () => ({
-        ui: {},
-        secretDetection: {
-          enabled: true,
-          action: "block",
-          blockIngress: true,
-        },
-      }),
-    }));
-
-    // Re-import to pick up the mock
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { checkIngressForSecrets } = require("../security/secret-ingress.js");
-
-    // Build a fake AWS key at runtime to avoid pre-commit hook
-    const fakeKey = ["AKIA", "IOSFODNN7", "REALKEY"].join("");
-    const result = checkIngressForSecrets(`My key is ${fakeKey}`);
-
-    expect(result.blocked).toBe(true);
-    expect(result.detectedTypes.length).toBeGreaterThan(0);
-    // User notice must not echo the secret
-    expect(result.userNotice).toBeDefined();
-    expect(result.userNotice).not.toContain(fakeKey);
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -208,6 +169,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "tools/credentials/broker.ts", // brokered credential access
       "tools/network/web-search.ts", // web search API key lookup
       "daemon/handlers/config-telegram.ts", // Telegram bot token management
+      "daemon/handlers/config-vercel.ts", // Vercel API token management
       "runtime/routes/integrations/twilio.ts", // Twilio credential management (HTTP control-plane)
       "security/token-manager.ts", // OAuth token refresh flow
       "email/providers/index.ts", // email provider API key lookup
@@ -216,15 +178,16 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "calls/twilio-config.ts", // call infrastructure credential lookup
       "calls/twilio-provider.ts", // call infrastructure credential lookup
       "calls/twilio-rest.ts", // Twilio REST API credential lookup
+      "calls/fish-audio-client.ts", // Fish Audio TTS API key lookup
       "runtime/channel-invite-transports/telegram.ts", // Telegram invite transport bot token lookup
-      "cli/commands/keys.ts", // CLI credential management commands
-      "cli/commands/credentials.ts", // CLI credential management commands
+      "cli/lib/daemon-credential-client.ts", // CLI-to-daemon credential routing intermediary
       "messaging/providers/telegram-bot/adapter.ts", // Telegram bot token lookup for connectivity check
       "runtime/channel-readiness-service.ts", // channel readiness probes for Telegram connectivity
       "messaging/providers/whatsapp/adapter.ts", // WhatsApp credential lookup for connectivity check
       "messaging/providers/slack/adapter.ts", // Slack bot token lookup for Socket Mode connectivity check
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
       "providers/managed-proxy/context.ts", // managed proxy API key lookup for provider initialization
+      "platform/client.ts", // platform client keychain fallback for standalone CLI auth
       "mcp/mcp-oauth-provider.ts", // MCP OAuth token/client/discovery persistence
       "runtime/routes/integrations/slack/share.ts", // Slack share routes credential lookup
       "mcp/client.ts", // MCP client cached-token lookup
@@ -234,10 +197,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/conversation-messaging.ts", // credential storage during session messaging
       "runtime/routes/settings-routes.ts", // settings routes OAuth credential lookup (client_secret)
       "oauth/oauth-store.ts", // OAuth provider disconnect (delete stored tokens)
-      "cli/commands/oauth/connections.ts", // CLI OAuth connection delete (legacy credential cleanup)
       "oauth/manual-token-connection.ts", // manual-token provider backfill (keychain credential existence check)
-      "cli/commands/doctor.ts", // CLI diagnostic API key verification via secure storage
-      "swarm/backend-claude-code.ts", // Claude Code swarm backend API key lookup
       "workspace/provider-commit-message-generator.ts", // commit message generation provider key lookup
       "config/bundled-skills/transcribe/tools/transcribe-media.ts", // transcription tool API key lookup
       "config/bundled-skills/image-studio/tools/media-generate-image.ts", // image generation tool API key lookup
@@ -249,13 +209,13 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "media/avatar-router.ts", // avatar generation API key lookup
       "memory/embedding-backend.ts", // embedding backend API key lookup
       "daemon/providers-setup.ts", // provider initialization API key lookup
-      "tools/claude-code/claude-code.ts", // Claude Code tool API key lookup
       "workspace/migrations/006-services-config.ts", // services config migration reads provider API keys
-      "cli/commands/avatar.ts", // CLI avatar generation API key lookup
+      "workspace/migrations/018-rekey-compound-credential-keys.ts", // re-key compound credential storage keys
       "config/bundled-skills/slack/tools/shared.ts", // Slack skill bot token lookup
       "daemon/conversation-process.ts", // masked provider key display
       "daemon/handlers/config-model.ts", // masked provider key display
       "providers/speech-to-text/resolve.ts", // STT provider API key lookup
+      "daemon/lifecycle.ts", // CES client injection into secure-keys at startup
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));
@@ -613,10 +573,6 @@ describe("One-time send override", () => {
   test("default secretDetection.action is redact", () => {
     expect(DEFAULT_CONFIG.secretDetection.action).toBe("redact");
   });
-
-  test("default secretDetection.blockIngress is true", () => {
-    expect(DEFAULT_CONFIG.secretDetection.blockIngress).toBe(true);
-  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/credentials-cli.test.ts

@@ -12,6 +12,7 @@ import type { CredentialMetadata } from "../tools/credentials/metadata-store.js"
 let secureKeyStore = new Map<string, string>();
 let metadataStore: CredentialMetadata[] = [];
 let idCounter = 0;
+let mockBrokerUnreachable = false;
 
 function nextUUID(): string {
   idCounter += 1;
@@ -39,12 +40,19 @@ mock.module("../security/secure-keys.js", () => ({
     }
     return "not-found";
   },
-  listSecureKeysAsync: async (): Promise<string[]> => {
-    return [...secureKeyStore.keys()];
-  },
+  listSecureKeysAsync: async () => ({
+    accounts: [...secureKeyStore.keys()],
+    unreachable: false,
+  }),
   getSecureKeyAsync: async (account: string): Promise<string | undefined> => {
     return secureKeyStore.get(account);
   },
+  getSecureKeyResultAsync: async (
+    account: string,
+  ): Promise<{ value: string | undefined; unreachable: boolean }> => ({
+    value: secureKeyStore.get(account),
+    unreachable: mockBrokerUnreachable,
+  }),
   _resetBackend: (): void => {},
 }));
 
@@ -264,6 +272,7 @@ describe("assistant credentials CLI", () => {
     secureKeyStore = new Map();
     metadataStore = [];
     idCounter = 0;
+    mockBrokerUnreachable = false;
     disconnectOAuthProviderCalls = [];
     disconnectOAuthProviderResult = "not-found";
     process.exitCode = 0;
@@ -870,6 +879,42 @@ describe("assistant credentials CLI", () => {
       expect(parsed.hasSecret).toBe(false);
       expect(parsed.scrubbedValue).toBe("(not set)");
     });
+
+    test("shows broker unreachable when metadata exists but broker is down", async () => {
+      seedMetadataOnly("twilio", "account_sid");
+      mockBrokerUnreachable = true;
+
+      const result = await runCli([
+        "inspect",
+        "--service",
+        "twilio",
+        "--field",
+        "account_sid",
+        "--json",
+      ]);
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.ok).toBe(true);
+      expect(parsed.scrubbedValue).toBe("(broker unreachable)");
+      expect(parsed.brokerUnreachable).toBe(true);
+    });
+
+    test("shows unreachable error when no metadata and broker is down", async () => {
+      mockBrokerUnreachable = true;
+
+      const result = await runCli([
+        "inspect",
+        "--service",
+        "nonexistent",
+        "--field",
+        "field",
+        "--json",
+      ]);
+      expect(result.exitCode).toBe(1);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.ok).toBe(false);
+      expect(parsed.error).toContain("Keychain broker is unreachable");
+    });
   });
 
   // =========================================================================
@@ -969,6 +1014,40 @@ describe("assistant credentials CLI", () => {
       expect(parsed.ok).toBe(false);
       expect(parsed.error).toContain("not found");
     });
+
+    test("returns unreachable error when broker is down", async () => {
+      mockBrokerUnreachable = true;
+
+      const result = await runCli([
+        "reveal",
+        "--service",
+        "twilio",
+        "--field",
+        "auth_token",
+        "--json",
+      ]);
+      expect(result.exitCode).toBe(1);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.ok).toBe(false);
+      expect(parsed.error).toContain("Keychain broker is unreachable");
+    });
+
+    test("returns credential-not-found when broker is up", async () => {
+      mockBrokerUnreachable = false;
+
+      const result = await runCli([
+        "reveal",
+        "--service",
+        "twilio",
+        "--field",
+        "nonexistent",
+        "--json",
+      ]);
+      expect(result.exitCode).toBe(1);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.ok).toBe(false);
+      expect(parsed.error).toBe("Credential not found");
+    });
   });
 
   // =========================================================================

package/src/__tests__/daemon-credential-client.test.ts

@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { credentialKey } from "../security/credential-key.js";
+
+let fallbackValues = new Map<string, string>();
+
+mock.module("../config/env.js", () => ({
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeHttpPort: () => 4123,
+}));
+
+mock.module("../daemon/daemon-control.js", () => ({
+  healthCheckHost: (host: string) => host,
+  isHttpHealthy: async () => true,
+}));
+
+mock.module("../runtime/auth/token-service.js", () => ({
+  initAuthSigningKey: () => {},
+  loadOrCreateSigningKey: () => "signing-key",
+  mintDaemonDeliveryToken: () => "daemon-token",
+}));
+
+mock.module("../security/secure-keys.js", () => ({
+  deleteSecureKeyAsync: async () => "deleted" as const,
+  getSecureKeyAsync: async (account: string) => fallbackValues.get(account),
+  getSecureKeyResultAsync: async (account: string) => ({
+    value: fallbackValues.get(account),
+    unreachable: false,
+  }),
+  setSecureKeyAsync: async () => true,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  getSecureKeyResultViaDaemon,
+  getSecureKeyViaDaemon,
+} from "../cli/lib/daemon-credential-client.js";
+
+const originalFetch = globalThis.fetch;
+const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
+
+function getRequestBody(index = 0): Record<string, unknown> {
+  const body = fetchCalls[index]?.init?.body;
+  if (typeof body !== "string") {
+    throw new Error("Expected fetch body to be a JSON string");
+  }
+  return JSON.parse(body) as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  fallbackValues = new Map();
+  fetchCalls.length = 0;
+  const mockFetch = mock(
+    async (input: string | URL | Request, init?: RequestInit) => {
+      const url =
+        typeof input === "string"
+          ? input
+          : input instanceof URL
+            ? input.toString()
+            : input.url;
+      fetchCalls.push({ url, init });
+      return new Response(
+        JSON.stringify({ found: true, value: "secret-value" }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    },
+  );
+  globalThis.fetch = mockFetch as unknown as typeof globalThis.fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("daemon credential read requests", () => {
+  test("keeps provider secrets on the api_key path", async () => {
+    const value = await getSecureKeyViaDaemon("openai");
+
+    expect(value).toBe("secret-value");
+    expect(fetchCalls).toHaveLength(1);
+    expect(fetchCalls[0]?.url).toBe("http://127.0.0.1:4123/v1/secrets/read");
+    expect(getRequestBody()).toEqual({
+      type: "api_key",
+      name: "openai",
+      reveal: true,
+    });
+  });
+
+  test("converts canonical credential keys into credential reads", async () => {
+    const value = await getSecureKeyViaDaemon(
+      credentialKey("vellum", "platform_base_url"),
+    );
+
+    expect(value).toBe("secret-value");
+    expect(getRequestBody()).toEqual({
+      type: "credential",
+      name: "vellum:platform_base_url",
+      reveal: true,
+    });
+  });
+
+  test("preserves compound credential service names on metadata reads", async () => {
+    const result = await getSecureKeyResultViaDaemon(
+      credentialKey("integration:google", "client_secret"),
+    );
+
+    expect(result).toEqual({ value: "secret-value", unreachable: false });
+    expect(getRequestBody()).toEqual({
+      type: "credential",
+      name: "integration:google:client_secret",
+      reveal: true,
+    });
+  });
+});