@mycadet/assistant 0.12.7-dev.202610111049.d2b52a8 → 0.12.8

package/src/__tests__/requests-mock.ts

@@ -23,9 +23,11 @@
  * - A function response receives the recorded request and returns the
  *   response dynamically.
  * - An unmatched request throws `NoMockMatchError` listing the request and
- *   the registered handlers (CLI channel + HTTP). The gateway channel falls
- *   through to the legacy `mock-gateway-ipc` behavior instead, because
- *   incidental `get_feature_flags` calls are ubiquitous in this suite.
+ *   the registered handlers (CLI channel + HTTP). The gateway transport is
+ *   the exception: it answers every method — registrations are consulted
+ *   first, then per-test transport defaults, then a kernel
+ *   `get_feature_flags` sentinel — because incidental `get_feature_flags`
+ *   calls are ubiquitous in this suite.
  *
  * Channels reset automatically after every test (`afterEach` registered in
  * test-preload.ts), so registrations are per-test: anything registered at
@@ -38,6 +40,7 @@
  * the real-socket tests rely on that.
  */
 
+import { EventEmitter } from "node:events";
 import { mock } from "bun:test";
 
 // ---------------------------------------------------------------------------
@@ -299,16 +302,50 @@ export interface IpcMockController {
   lastCall(method?: string): IpcCallRecord | undefined;
 }
 
+/**
+ * Transport-level controls unique to the gateway channel. The fake answers
+ * every method (it never throws `NoMockMatchError` — incidental gateway
+ * calls are ubiquitous in the suite), so tests shape what the transport says
+ * to UN-registered requests instead.
+ */
+export interface GatewayTransportControls {
+  /**
+   * Results answered for methods no `.on` registration claimed. A key mapped
+   * to `undefined` suppresses even the `get_feature_flags` sentinel for that
+   * method. Replaces any previously set defaults.
+   */
+  setDefaults(results: Record<string, unknown>): void;
+  /**
+   * Simulate a failed socket connect: the persistent client throws
+   * `IpcConnectError`, the one-shot `ipcCall` returns `undefined` (mirroring
+   * the real module).
+   */
+  failConnect(opts?: { code?: string }): void;
+  /**
+   * Throw a transient (retryable) connect error for the first `n`
+   * persistent-client calls; with `ipcCallError`, a non-retryable
+   * `IpcCallError` instead. Consulted AFTER `.on` registrations, so a
+   * registered response is never "failed" by these knobs.
+   */
+  failFirstN(n: number, opts?: { ipcCallError?: boolean }): void;
+  /** Persistent-client `.call` invocations for `method` since the last reset. */
+  persistentCallCount(method: string): number;
+}
+
 export type IpcMockChannel = "cli" | "gateway";
 
+export async function mockIpc(
+  channel: "gateway",
+): Promise<IpcMockController & GatewayTransportControls>;
+export async function mockIpc(channel: "cli"): Promise<IpcMockController>;
 export async function mockIpc(
   channel: IpcMockChannel,
-): Promise<IpcMockController> {
+): Promise<IpcMockController & Partial<GatewayTransportControls>> {
   if (channel === "cli") {
     await ensureCliClientMock();
   }
   const target = channel === "cli" ? cliChannel : gatewayChannel;
-  return {
+  const base: IpcMockController = {
     on: (matcher, response) => target.on(matcher, response),
     calls: (method) => filterIpcCalls(target, method),
     callCount: (method) => filterIpcCalls(target, method).length,
@@ -317,6 +354,26 @@ export async function mockIpc(
       return list[list.length - 1];
     },
   };
+  if (channel !== "gateway") {
+    return base;
+  }
+  return {
+    ...base,
+    setDefaults: (results) => {
+      gatewayDefaults = { ...results };
+    },
+    failConnect: (opts) => {
+      gatewayConnectError = true;
+      if (opts?.code !== undefined) {
+        gatewayConnectErrorCode = opts.code;
+      }
+    },
+    failFirstN: (n, opts) => {
+      gatewayFailFirstN = n;
+      gatewayFailFirstNIpcCallError = opts?.ipcCallError ?? false;
+    },
+    persistentCallCount: (method) => gatewayPersistentCallCounts[method] ?? 0,
+  };
 }
 
 /**
@@ -346,10 +403,10 @@ export function ipcError(
 }
 
 /**
- * Hook for `mock-gateway-ipc.ts`: consult the gateway channel FIRST, falling
- * through to the legacy sentinel/results-map behavior when nothing matches.
- * An `Error`-instance response comes back as the resolved value so the caller
- * can apply the one-shot/persistent failure contract.
+ * Hook for the gateway transport fake (below): consult the gateway channel
+ * FIRST, falling through to the per-test transport defaults when nothing
+ * matches. An `Error`-instance response comes back as the resolved value so
+ * the caller can apply the one-shot/persistent failure contract.
  */
 export function dispatchGatewayIpcRequest(
   method: string,
@@ -371,6 +428,163 @@ export function dispatchGatewayIpcRequest(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Gateway transport fake (installed globally once by test-preload.ts)
+// ---------------------------------------------------------------------------
+
+/**
+ * Sentinel answered for `get_feature_flags` when neither a registration nor
+ * a per-test default covers it. Keeps the response non-empty so
+ * `initFeatureFlagOverrides()` does not enter its 7.75 s empty-result retry
+ * loop in tests that build the CLI program or otherwise trigger flag
+ * initialization. The key starts with a double underscore so it cannot
+ * collide with any real registry-declared flag.
+ */
+const GET_FEATURE_FLAGS_SENTINEL: Record<string, boolean> = {
+  __test_default__: false,
+};
+
+class FakeIpcCallError extends Error {
+  readonly statusCode?: number;
+  readonly errorCode?: string;
+  readonly errorDetails?: unknown;
+
+  constructor(
+    message: string,
+    fields: {
+      statusCode?: number;
+      errorCode?: string;
+      errorDetails?: unknown;
+    } = {},
+  ) {
+    super(message);
+    this.name = "IpcCallError";
+    if (fields.statusCode !== undefined) {
+      this.statusCode = fields.statusCode;
+    }
+    if (fields.errorCode !== undefined) {
+      this.errorCode = fields.errorCode;
+    }
+    if (fields.errorDetails !== undefined) {
+      this.errorDetails = fields.errorDetails;
+    }
+  }
+}
+
+class FakeIpcConnectError extends Error {
+  readonly code?: string;
+
+  constructor(message: string, code?: string) {
+    super(message);
+    this.name = "IpcConnectError";
+    if (code !== undefined) {
+      this.code = code;
+    }
+  }
+}
+
+const RETRYABLE_CONNECT_CODES = new Set(["ENOENT", "ECONNREFUSED"]);
+
+function isRetryableIpcConnectError(err: unknown): boolean {
+  if (typeof err === "object" && err !== null && "code" in err) {
+    const code = (err as { code?: unknown }).code;
+    return typeof code === "string" && RETRYABLE_CONNECT_CODES.has(code);
+  }
+  return false;
+}
+
+// Per-test transport state — cleared by resetRequestMockChannels.
+let gatewayDefaults: Record<string, unknown> = {};
+let gatewayConnectError = false;
+let gatewayConnectErrorCode: string | undefined;
+let gatewayFailFirstN = 0;
+let gatewayFailFirstNIpcCallError = false;
+const gatewayPersistentCallCounts: Record<string, number> = {};
+
+function mockConnectError(): FakeIpcConnectError {
+  return new FakeIpcConnectError(
+    "Mock IPC socket error",
+    gatewayConnectErrorCode ?? "ENOENT",
+  );
+}
+
+/** The transport's answer for a method no `.on` registration claimed. */
+function gatewayDefaultAnswer(method: string): unknown {
+  if (method in gatewayDefaults) {
+    return gatewayDefaults[method];
+  }
+  if (method === "get_feature_flags") {
+    return GET_FEATURE_FLAGS_SENTINEL;
+  }
+  return undefined;
+}
+
+class FakePersistentIpcClient extends EventEmitter {
+  async call(
+    method: string,
+    _params?: Record<string, unknown>,
+    _timeoutMs?: number,
+  ): Promise<unknown> {
+    gatewayPersistentCallCounts[method] =
+      (gatewayPersistentCallCounts[method] ?? 0) + 1;
+    const dispatched = dispatchGatewayIpcRequest(method, _params);
+    if (dispatched.handled) {
+      if (dispatched.value instanceof Error) {
+        throw dispatched.value;
+      }
+      return dispatched.value;
+    }
+    if (gatewayFailFirstN > 0) {
+      gatewayFailFirstN--;
+      if (gatewayFailFirstNIpcCallError) {
+        throw new FakeIpcCallError("Mock deterministic gateway error");
+      }
+      throw mockConnectError();
+    }
+    if (gatewayConnectError) {
+      throw mockConnectError();
+    }
+    return gatewayDefaultAnswer(method);
+  }
+
+  destroy(): void {
+    /* no-op */
+  }
+}
+
+/**
+ * Swap `@mycadet/gateway-client/ipc-client` for the channel-backed fake.
+ * Registered once in the test preload so every test file gets a no-op IPC
+ * layer by default — no test accidentally connects to a real gateway socket.
+ */
+export function installGatewayIpcMock(): void {
+  // Named exports here must cover every ipc-client symbol the package barrel
+  // re-exports. Bun's mock replaces that module for relative and package
+  // imports, so a missing name fails assistant tests at load time.
+  mock.module("@mycadet/gateway-client/ipc-client", () => ({
+    ipcCall: async (
+      _socketPath: string,
+      method: string,
+      params?: Record<string, unknown>,
+    ): Promise<unknown> => {
+      const dispatched = dispatchGatewayIpcRequest(method, params);
+      if (dispatched.handled) {
+        // Real ipcCall returns undefined on failure — mirror that behavior.
+        return dispatched.value instanceof Error ? undefined : dispatched.value;
+      }
+      if (gatewayConnectError) {
+        // Real ipcCall returns undefined on failure — mirror that behavior.
+        return undefined;
+      }
+      return gatewayDefaultAnswer(method);
+    },
+    IpcCallError: FakeIpcCallError,
+    IpcConnectError: FakeIpcConnectError,
+    isRetryableIpcConnectError,
+    PersistentIpcClient: FakePersistentIpcClient,
+  }));
+}
+
 // ---------------------------------------------------------------------------
 // CLI client transport fake (lazy — only files that call mockIpc("cli"))
 // ---------------------------------------------------------------------------
@@ -742,6 +956,14 @@ export function mockHttp(): HttpMockController {
 export function resetRequestMockChannels(): void {
   cliChannel.reset();
   gatewayChannel.reset();
+  gatewayDefaults = {};
+  gatewayConnectError = false;
+  gatewayConnectErrorCode = undefined;
+  gatewayFailFirstN = 0;
+  gatewayFailFirstNIpcCallError = false;
+  for (const key of Object.keys(gatewayPersistentCallCounts)) {
+    delete gatewayPersistentCallCounts[key];
+  }
   if (originalFetch !== undefined) {
     globalThis.fetch = originalFetch;
     originalFetch = undefined;

package/src/__tests__/secret-routes-cloud-proxy.test.ts

@@ -349,30 +349,14 @@ describe("secret routes cloud proxy registry sync", () => {
     cloudOrganizationIdOverride = "existing-org";
     platformUserIdOverride = "existing-user";
 
+    // Identity ids are not credentials at all — they resolve from the
+    // assistant_api_key via validate and live in the in-memory identity.
     await expect(
-      addCredential("cadet:platform_assistant_id", "asst-1"),
-    ).rejects.toThrow("Unknown cadet credential: platform_assistant_id");
-    await expect(
-      addCredential("cadet:platform_organization_id", "org-1"),
-    ).rejects.toThrow("Unknown cadet credential: platform_organization_id");
-    await expect(
-      addCredential("cadet:platform_user_id", "user-1"),
-    ).rejects.toThrow("Unknown cadet credential: platform_user_id");
-    await expect(
-      addCredential("cadet:platform_base_url", "https://managed.example.com"),
-    ).rejects.toThrow("Unknown cadet credential: platform_base_url");
+      addCredential("cadet:cloud_assistant_id", "asst-1"),
+    ).rejects.toThrow("Unknown cadet credential: cloud_assistant_id");
 
     expect(
-      secureKeyStore.get(credentialKey("cadet", "platform_assistant_id")),
-    ).toBeUndefined();
-    expect(
-      secureKeyStore.get(credentialKey("cadet", "platform_organization_id")),
-    ).toBeUndefined();
-    expect(
-      secureKeyStore.get(credentialKey("cadet", "platform_user_id")),
-    ).toBeUndefined();
-    expect(
-      secureKeyStore.get(credentialKey("cadet", "platform_base_url")),
+      secureKeyStore.get(credentialKey("cadet", "cloud_assistant_id")),
     ).toBeUndefined();
     expect(metadataUpserts).toEqual([]);
     expect(cloudAssistantIdOverride).toBe("existing-asst");
@@ -383,13 +367,13 @@ describe("secret routes cloud proxy registry sync", () => {
   });
 
   test("an unknown cadet credential does not delete leftover vault copies", async () => {
-    const key = credentialKey("cadet", "platform_assistant_id");
+    const key = credentialKey("cadet", "cloud_assistant_id");
     secureKeyStore.set(key, "leftover-asst");
     cloudAssistantIdOverride = "asst-1";
 
     await expect(
-      addCredential("cadet:platform_assistant_id", "   "),
-    ).rejects.toThrow("Unknown cadet credential: platform_assistant_id");
+      addCredential("cadet:cloud_assistant_id", "   "),
+    ).rejects.toThrow("Unknown cadet credential: cloud_assistant_id");
 
     expect(secureKeyStore.get(key)).toBe("leftover-asst");
     expect(cloudAssistantIdOverride).toBe("asst-1");

package/src/__tests__/secret-routes-scrub.test.ts

@@ -6,7 +6,6 @@
  *   - scrubs the stored value exactly once, immediately after the
  *     secure-store write
  *   - never scrubs when validation rejects the request (nothing was stored)
- *   - still succeeds when the scrub itself rejects (best-effort hygiene)
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -21,7 +20,6 @@ import { useMemorySecureKeyMap } from "./helpers/secure-keys.js";
 const secureStore = useMemorySecureKeyMap();
 
 let scrubbedValues: string[];
-let scrubRejects: boolean;
 let anthropicKeyValid: boolean;
 let providersRefreshed: number;
 
@@ -32,9 +30,6 @@ let providersRefreshed: number;
 mock.module("../daemon/credential-transcript-scrub.js", () => ({
   scrubStoredCredentialFromTranscripts: mock(async (value: string) => {
     scrubbedValues.push(value);
-    if (scrubRejects) {
-      throw new Error("transcript sweep failed");
-    }
     return { dbMessagesScrubbed: 0, residentMessagesScrubbed: 0 };
   }),
 }));
@@ -87,7 +82,6 @@ describe("secrets_add api_key transcript scrub", () => {
   beforeEach(() => {
     secureStore.clear();
     scrubbedValues = [];
-    scrubRejects = false;
     anthropicKeyValid = true;
     providersRefreshed = 0;
   });
@@ -104,6 +98,8 @@ describe("secrets_add api_key transcript scrub", () => {
       API_KEY_VALUE,
     );
     expect(scrubbedValues).toEqual([API_KEY_VALUE]);
+    // The provider refresh still happens after the scrub.
+    expect(providersRefreshed).toBe(1);
   });
 
   test("an unknown provider is rejected and never triggers a scrub", async () => {
@@ -134,23 +130,6 @@ describe("secrets_add api_key transcript scrub", () => {
     expect(secureStore.size).toBe(0);
     expect(scrubbedValues).toEqual([]);
   });
-
-  test("the route still succeeds (and refreshes providers) when the scrub rejects", async () => {
-    scrubRejects = true;
-
-    const result = await addRoute.handler({
-      body: { type: "api_key", name: "fireworks", value: API_KEY_VALUE },
-    });
-
-    expect(result).toEqual(expect.objectContaining({ success: true }));
-    expect(secureStore.get(credentialKey("fireworks", "api_key"))).toBe(
-      API_KEY_VALUE,
-    );
-    // The scrub ran (once) even though it failed, and the failure stayed
-    // invisible to the caller — the provider refresh still happened.
-    expect(scrubbedValues).toEqual([API_KEY_VALUE]);
-    expect(providersRefreshed).toBe(1);
-  });
 });
 
 const CREDENTIAL_VALUE = "synthetic-credential-value-0987654321";
@@ -159,7 +138,6 @@ describe("secrets_add credential transcript scrub", () => {
   beforeEach(() => {
     secureStore.clear();
     scrubbedValues = [];
-    scrubRejects = false;
     anthropicKeyValid = true;
     providersRefreshed = 0;
   });
@@ -180,24 +158,6 @@ describe("secrets_add credential transcript scrub", () => {
     expect(scrubbedValues).toEqual([CREDENTIAL_VALUE]);
   });
 
-  test("the route still succeeds when the credential scrub rejects", async () => {
-    scrubRejects = true;
-
-    const result = await addRoute.handler({
-      body: {
-        type: "credential",
-        name: "github:api_token",
-        value: CREDENTIAL_VALUE,
-      },
-    });
-
-    expect(result).toEqual(expect.objectContaining({ success: true }));
-    expect(secureStore.get(credentialKey("github", "api_token"))).toBe(
-      CREDENTIAL_VALUE,
-    );
-    expect(scrubbedValues).toEqual([CREDENTIAL_VALUE]);
-  });
-
   test("an unknown cadet credential is rejected and never triggers a scrub", async () => {
     await expect(
       addRoute.handler({

package/src/__tests__/test-preload.ts

@@ -22,8 +22,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, afterEach } from "bun:test";
 
-import { installGatewayIpcMock } from "./mock-gateway-ipc.js";
-import { resetRequestMockChannels } from "./requests-mock.js";
+import {
+  installGatewayIpcMock,
+  resetRequestMockChannels,
+} from "./requests-mock.js";
 
 // --- Phase 1: env override (zero source-module imports above this point) ---
 
@@ -67,9 +69,10 @@ delete process.env.CES_CREDENTIAL_URL;
 // --- Phase 2: install the IPC mock (no source-module imports) ---
 
 // Mock gateway IPC so no test accidentally connects to a real gateway socket.
-// The mock returns a sentinel for `get_feature_flags` to short-circuit the
-// retry loop in `initFeatureFlagOverrides()`. Tests that need specific IPC
-// responses use `mockGatewayIpc()` / `resetMockGatewayIpc()`.
+// The transport answers a sentinel for `get_feature_flags` to short-circuit
+// the retry loop in `initFeatureFlagOverrides()`. Tests that need specific
+// IPC behavior use `mockIpc("gateway")` (`.on`, `.setDefaults`,
+// `.failConnect`, `.failFirstN`).
 installGatewayIpcMock();
 
 // requests-mock channels (mockIpc/mockHttp) are per-test by construction: