@mycadet/assistant 0.12.7 → 0.12.8

package/src/__tests__/mock-gateway-ipc.ts

@@ -1,260 +0,0 @@
-/**
- * Global test utility for mocking gateway IPC calls via
- * `@mycadet/gateway-client/ipc-client`.
- *
- * Usage:
- *   import { mockGatewayIpc, resetMockGatewayIpc } from "./mock-gateway-ipc.js";
- *
- *   beforeEach(() => resetMockGatewayIpc());
- *   afterEach(() => resetMockGatewayIpc());
- *
- *   it("uses IPC flags", async () => {
- *     mockGatewayIpc({ "my-flag": true });
- *     await initFeatureFlagOverrides();
- *     ...
- *   });
- *
- *   it("simulates socket error", async () => {
- *     mockGatewayIpc(null, { error: true, code: "ENOENT" });
- *     ...
- *   });
- *
- * The mock is registered in the test preload (test-preload.ts) so every test
- * file gets a no-op IPC layer by default — no test accidentally connects to
- * a real gateway socket. Call `mockGatewayIpc()` to configure specific
- * responses when the test cares about the IPC result.
- *
- * Mocks `@mycadet/gateway-client/ipc-client` at the package level so the
- * assistant's thin wrapper in `ipc/gateway-client.ts` (which delegates to
- * the package) gets the fake implementation. Non-gateway IPC paths (e.g.
- * CLI IPC) are unaffected since they don't import from the package.
- */
-
-import { EventEmitter } from "node:events";
-import { mock } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Configurable state
-// ---------------------------------------------------------------------------
-
-/** IPC result the fake gateway will return (keyed by method name). */
-
-let ipcResults: Record<string, unknown> = {};
-
-/** Whether the fake ipcCall should simulate a connection error. */
-let simulateError = false;
-
-/** `IpcConnectError.code` used when `simulateError` is set. */
-let simulateErrorCode: string | undefined;
-
-/** Throw a transient (retryable) error for the first N persistent calls, then succeed. */
-let failFirstN = 0;
-
-/** When set, the simulated persistent-call failure is a non-retryable IpcCallError. */
-let failWithIpcCallError = false;
-
-/** Per-method persistent-client `.call` counter, so retry tests can assert attempts. */
-const persistentCallCounts: Record<string, number> = {};
-
-// ---------------------------------------------------------------------------
-// FakePersistentIpcClient — mirrors PersistentIpcClient API
-// ---------------------------------------------------------------------------
-
-class FakePersistentIpcClient extends EventEmitter {
-  async call(
-    method: string,
-    _params?: Record<string, unknown>,
-    _timeoutMs?: number,
-  ): Promise<unknown> {
-    persistentCallCounts[method] = (persistentCallCounts[method] ?? 0) + 1;
-    if (failFirstN > 0) {
-      failFirstN--;
-      if (failWithIpcCallError) {
-        throw new FakeIpcCallError("Mock deterministic gateway error");
-      }
-      throw mockConnectError();
-    }
-    if (simulateError) {
-      throw mockConnectError();
-    }
-    if (method in ipcResults) {
-      return ipcResults[method];
-    }
-    if (method === "get_feature_flags") {
-      return GET_FEATURE_FLAGS_DEFAULT;
-    }
-    return undefined;
-  }
-
-  destroy(): void {
-    /* no-op */
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Register the mock (called once from test-preload.ts)
-// ---------------------------------------------------------------------------
-
-/**
- * Sentinel returned by the mock for `get_feature_flags` when a test has not
- * explicitly configured a result. Keeps the response non-empty so
- * `initFeatureFlagOverrides()` does not enter its 7.75 s empty-result retry
- * loop during tests that build the CLI program or otherwise trigger flag
- * initialization. The sentinel key starts with a double underscore so it
- * cannot collide with any real registry-declared flag.
- */
-const GET_FEATURE_FLAGS_DEFAULT: 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;
-}
-
-function mockConnectError(): FakeIpcConnectError {
-  return new FakeIpcConnectError(
-    "Mock IPC socket error",
-    simulateErrorCode ?? "ENOENT",
-  );
-}
-
-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> => {
-      if (simulateError) {
-        // Real ipcCall returns undefined on failure — mirror that behavior.
-        return undefined;
-      }
-      if (method in ipcResults) {
-        return ipcResults[method];
-      }
-      if (method === "get_feature_flags") {
-        return GET_FEATURE_FLAGS_DEFAULT;
-      }
-      return undefined;
-    },
-    IpcCallError: FakeIpcCallError,
-    IpcConnectError: FakeIpcConnectError,
-    isRetryableIpcConnectError,
-    PersistentIpcClient: FakePersistentIpcClient,
-  }));
-}
-
-// ---------------------------------------------------------------------------
-// Public API for tests
-// ---------------------------------------------------------------------------
-
-/**
- * Configure the fake gateway IPC response.
- *
- * @param flags — feature flag map returned by `get_feature_flags`. Pass
- *   `null` to skip setting a result (useful when only simulating errors).
- * @param opts.error — simulate a socket connection error
- * @param opts.code - `IpcConnectError.code` when simulating a connect failure
- * @param opts.results — raw method->result map for arbitrary IPC methods
- */
-export function mockGatewayIpc(
-  flags?: Record<string, boolean> | null,
-  opts?: {
-    error?: boolean;
-    code?: string;
-    results?: Record<string, unknown>;
-    /** Throw a transient (retryable) error for the first N persistent calls. */
-    failFirstN?: number;
-    /** Make the simulated persistent-call failure a non-retryable IpcCallError. */
-    ipcCallError?: boolean;
-  },
-): void {
-  if (flags != null) {
-    ipcResults["get_feature_flags"] = flags;
-  }
-  if (opts?.results) {
-    Object.assign(ipcResults, opts.results);
-  }
-  if (opts?.error) {
-    simulateError = true;
-  }
-  if (opts?.code !== undefined) {
-    simulateErrorCode = opts.code;
-  }
-  if (opts?.failFirstN !== undefined) {
-    failFirstN = opts.failFirstN;
-  }
-  if (opts?.ipcCallError) {
-    failWithIpcCallError = true;
-  }
-}
-
-/**
- * Number of persistent-client `.call(method)` invocations since the last reset.
- * Lets retry tests assert the exact attempt count.
- */
-export function getMockPersistentCallCount(method: string): number {
-  return persistentCallCounts[method] ?? 0;
-}
-
-/**
- * Reset all IPC mock state back to defaults (empty flags, no errors).
- */
-export function resetMockGatewayIpc(): void {
-  ipcResults = {};
-  simulateError = false;
-  simulateErrorCode = undefined;
-  failFirstN = 0;
-  failWithIpcCallError = false;
-  for (const key of Object.keys(persistentCallCounts)) {
-    delete persistentCallCounts[key];
-  }
-}

package/src/api/events/platform-disconnected.ts

@@ -1,21 +0,0 @@
-/**
- * `platform_disconnected` SSE event.
- *
- * Emitted by the platform-disconnect route after stored platform
- * credentials are deleted, notifying connected clients that the platform
- * connection is gone.
- *
- * Canonical wire-contract source. Daemon code imports the type
- * directly from this file; external consumers import via
- * `@mycadet/assistant-api`.
- */
-
-import { z } from "zod";
-
-export const PlatformDisconnectedEventSchema = z.object({
-  type: z.literal("platform_disconnected"),
-});
-
-export type PlatformDisconnectedEvent = z.infer<
-  typeof PlatformDisconnectedEventSchema
->;

package/src/config/platform-rehydration.ts

@@ -1,60 +0,0 @@
-/**
- * Rehydrate the in-memory platform identity/URL overrides at process startup.
- *
- * These overrides (`setPlatformBaseUrl` and the platform ID setters in
- * `config/env.ts`) are normally only populated at runtime by the secret-routes
- * handlers when the platform pushes values. Any standalone process that talks
- * to the platform — the daemon and the schedule worker — must rehydrate them
- * before its first request, otherwise `getPlatformBaseUrl()` falls back to the
- * environment default (e.g. dev-platform) while the credential store holds the
- * real production values, and requests are sent to the wrong environment.
- *
- * Bound platform ids come from `POST /v1/internal/assistants/validate/`,
- * which trades the assistant API key for assistant/organization/user ids.
- *
- * Each field is best-effort: a credential-store read failure is logged and
- * skipped so a single missing value never blocks startup.
- */
-import { credentialKey } from "../security/credential-key.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
-import { getLogger } from "../util/logger.js";
-import { setPlatformBaseUrl } from "./env.js";
-import { ensurePlatformIdentityIds } from "./platform-identity.js";
-
-const log = getLogger("platform-rehydration");
-
-async function rehydrateField(
-  name: string,
-  apply: (value: string) => void,
-  label: string,
-): Promise<void> {
-  try {
-    const key = credentialKey("cadet", name);
-    const persisted = (await getSecureKeyAsync(key))?.trim();
-    if (persisted) {
-      apply(persisted);
-      log.info(`Rehydrated ${label} from credential store`);
-    }
-  } catch (err) {
-    log.warn(
-      { error: err instanceof Error ? err.message : String(err) },
-      `Failed to rehydrate ${label} from credential store (non-fatal)`,
-    );
-  }
-}
-
-/**
- * Rehydrate the platform base URL and the related platform IDs (assistant,
- * organization, user). Safe to call more than once.
- */
-export async function rehydratePlatformCredentials(): Promise<void> {
-  // Base URL first so managed proxy activation and identity validate resolve
-  // the correct environment for every request that follows.
-  await rehydrateField(
-    "platform_base_url",
-    setPlatformBaseUrl,
-    "platform base URL",
-  );
-
-  await ensurePlatformIdentityIds();
-}

package/src/platform/feature-gate.ts

@@ -1,8 +0,0 @@
-import { getDisablePlatform, getIsPlatform } from "../config/env-registry.js";
-
-export function arePlatformFeaturesEnabled(): boolean {
-  if (getIsPlatform()) {
-    return true;
-  }
-  return !getDisablePlatform();
-}

package/src/plugins/defaults/platform-hosted/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "default-platform-hosted",
-  "version": "1.0.0",
-  "description": "First-party default plugin contributing platform-hosted capabilities. Exposes the /reengage route, which asks the assistant to compose a re-engagement email in its own voice and returns the subject line and body for the platform to send.",
-  "private": true,
-  "license": "MIT",
-  "type": "module",
-  "engines": {
-    "node": ">=20.12.0"
-  },
-  "peerDependencies": {
-    "@mycadet/plugin-api": "^0.10.9"
-  }
-}

package/src/runtime/routes/platform-managed-credentials.ts

@@ -1,50 +0,0 @@
-/**
- * Credentials Cadet Cloud provisions onto a managed assistant pod for
- * its own use: the API key the daemon authenticates to the managed LLM proxy
- * with, and the base URL that proxy lives at.
- *
- * The platform writes them over `POST /v1/secrets`, and the daemon, the
- * gateway, and CES read them straight out of the vault. The user never sets
- * them through the credentials API and can do nothing useful with them there,
- * so that API treats the pair as neither readable nor writable: omitted from
- * listings, and refused by inspect, reveal, set, and delete, whatever the
- * calling principal.
- *
- * The two fields travel together because they are one capability. The API key
- * spends inference on Cadet's account, and the base URL decides which host
- * receives it: the gateway resolves the platform host from
- * `cadet:platform_base_url` (see `gateway/src/platform-url.ts`) and then
- * sends `cadet:assistant_api_key` to it as the bearer. Leaving the URL
- * writable while hiding the key would hand back the same key by another
- * route, pointed at a host of the writer's choosing.
- */
-// The platform pushes the pre-rebrand display name ("cadet:*"); the
-// canonical storage service is "cadet".
-const MANAGED_PROXY_CREDENTIALS = [
-  { service: "cadet", field: "assistant_api_key" },
-  { service: "cadet", field: "platform_base_url" },
-] as const;
-
-export function isPlatformManagedCredential(
-  service: string,
-  field: string,
-): boolean {
-  return MANAGED_PROXY_CREDENTIALS.some(
-    (c) => c.service === service && c.field === field,
-  );
-}
-
-/** What a caller was trying to do with a platform-managed credential. */
-export type PlatformManagedCredentialAction = "read" | "change";
-
-/** Message the credentials API refuses one of these with. */
-export function platformManagedCredentialRefusal(
-  service: string | undefined,
-  field: string | undefined,
-  action: PlatformManagedCredentialAction,
-): string {
-  const name = service && field ? `${service}:${field}` : "This credential";
-  const verb =
-    action === "read" ? "inspected or revealed" : "changed or deleted";
-  return `${name} is provisioned and owned by Cadet Cloud. It cannot be ${verb} through the credentials API.`;
-}