@mycadet/assistant 0.13.0-dev.202611142107.f5e00a2 → 0.13.0-dev.202611151727.8310b2c

package/Dockerfile

@@ -189,6 +189,7 @@ COPY packages/egress-proxy /app/packages/egress-proxy
 COPY packages/environments /app/packages/environments
 COPY packages/gateway-client /app/packages/gateway-client
 COPY packages/ipc-server-utils /app/packages/ipc-server-utils
+COPY packages/shared /app/packages/shared
 COPY packages/slack-text /app/packages/slack-text
 COPY packages/twilio-client /app/packages/twilio-client
 

package/node_modules/@mycadet/ces-client/node_modules/@mycadet/service-contracts/src/remote-web-pairing.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 /**
  * Wire contracts for the remote-web pairing flow — the RFC 8628-style
  * device-code exchange that connects a browser (or the iOS app) to a
@@ -59,6 +61,16 @@ export interface RemoteWebPairingChallengeResponse {
   intervalSeconds: number;
 }
 
+export const RemoteWebPairingChallengeResponseSchema = z.object({
+  deviceCode: z.string(),
+  userCode: z.string(),
+  verificationUri: z.string(),
+  publicBaseUrl: z.string(),
+  expiresAt: z.string(),
+  expiresInSeconds: z.number(),
+  intervalSeconds: z.number(),
+}) satisfies z.ZodType<RemoteWebPairingChallengeResponse>;
+
 /** `POST /v1/remote-web/pairing-verification` request body. */
 export interface RemoteWebPairingVerificationRequest {
   /** The `userCode` from the challenge, entered/scanned on the host. */

package/node_modules/@mycadet/ces-client/src/index.ts

@@ -47,6 +47,5 @@ export {
 
 export {
   CES_SOCKET_DIR_DEFAULT,
-  getCesSocketDir,
   getCesSocketPath,
 } from "./socket-path.js";

package/node_modules/@mycadet/ces-client/src/socket-path.ts

@@ -18,7 +18,7 @@ export const CES_SOCKET_DIR_DEFAULT = "/run/ces-ipc";
  * The directory holding `ces.sock`: `CES_SOCKET_DIR` when set, otherwise
  * `/run/ces-ipc`.
  */
-export function getCesSocketDir(): string {
+function getCesSocketDir(): string {
   return process.env["CES_SOCKET_DIR"]?.trim() || CES_SOCKET_DIR_DEFAULT;
 }
 

package/node_modules/@mycadet/gateway-client/node_modules/@mycadet/service-contracts/src/remote-web-pairing.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 /**
  * Wire contracts for the remote-web pairing flow — the RFC 8628-style
  * device-code exchange that connects a browser (or the iOS app) to a
@@ -59,6 +61,16 @@ export interface RemoteWebPairingChallengeResponse {
   intervalSeconds: number;
 }
 
+export const RemoteWebPairingChallengeResponseSchema = z.object({
+  deviceCode: z.string(),
+  userCode: z.string(),
+  verificationUri: z.string(),
+  publicBaseUrl: z.string(),
+  expiresAt: z.string(),
+  expiresInSeconds: z.number(),
+  intervalSeconds: z.number(),
+}) satisfies z.ZodType<RemoteWebPairingChallengeResponse>;
+
 /** `POST /v1/remote-web/pairing-verification` request body. */
 export interface RemoteWebPairingVerificationRequest {
   /** The `userCode` from the challenge, entered/scanned on the host. */

package/node_modules/@mycadet/service-contracts/src/remote-web-pairing.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 /**
  * Wire contracts for the remote-web pairing flow — the RFC 8628-style
  * device-code exchange that connects a browser (or the iOS app) to a
@@ -59,6 +61,16 @@ export interface RemoteWebPairingChallengeResponse {
   intervalSeconds: number;
 }
 
+export const RemoteWebPairingChallengeResponseSchema = z.object({
+  deviceCode: z.string(),
+  userCode: z.string(),
+  verificationUri: z.string(),
+  publicBaseUrl: z.string(),
+  expiresAt: z.string(),
+  expiresInSeconds: z.number(),
+  intervalSeconds: z.number(),
+}) satisfies z.ZodType<RemoteWebPairingChallengeResponse>;
+
 /** `POST /v1/remote-web/pairing-verification` request body. */
 export interface RemoteWebPairingVerificationRequest {
   /** The `userCode` from the challenge, entered/scanned on the host. */

package/node_modules/@mycadet/shared/seeds.ts

@@ -207,28 +207,11 @@ function readPersistedDefault(): CadetEnvironment | undefined {
 }
 
 /**
- * The environment name every surface shares — the single resolution chain
- * local-mode hosts and the mobile config loader both ride:
- *
- *   1. `CADET_ENVIRONMENT` (explicit override, also inherited by the
- *      hatch/retire child processes the CLI spawns), then
- *      `VITE_ENVIRONMENT` (the build-time inlined var bundled surfaces bake)
- *   2. the release channel the running copy's version carries —
- *      `__CADET_OWN_VERSION__`, which the entrypoints that know their
- *      package root inject (the CLI's bin computes its git/local stamp,
- *      the Electron builds define it at build time). A released `-dev.`
- *      install resolves `dev` even on a machine that never wrote a
- *      persisted default
- *   3. the persisted default written by pre-version-tied CLIs (old files
- *      are still honored)
- *   4. `production`
- *
- * The version step is what keeps every released install from silently
- * reading production's state: the channel is decided by the release
- * pipeline, not by whatever default an older CLI happened to leave behind.
- * Names outside `CadetEnvironment` are ignored rather than returned: an
- * unrecognized value falls through to the next arm instead of leaking an
- * unkeyable string into `SEEDS` lookups.
+ * The environment name every surface shares: `CADET_ENVIRONMENT`, then
+ * `VITE_ENVIRONMENT`, then the release channel the copy's version carries
+ * (`__CADET_OWN_VERSION__`, defined at build time by hosts that bundle
+ * local-mode), then the persisted default written by pre-version-tied CLIs,
+ * then production.
  */
 export function resolveEnvironmentName(): CadetEnvironment {
   const env = processEnv();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/assistant",
-  "version": "0.13.0-dev.202611142107.f5e00a2",
+  "version": "0.13.0-dev.202611151727.8310b2c",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vargasjr-dev/mycadet-temp.git"

package/src/__tests__/conversation-slash-commands.test.ts

@@ -8,6 +8,12 @@ import {
   type SlashContext,
 } from "../daemon/conversation-slash.js";
 import { getWorkspaceConfigPath } from "../util/layout.js";
+import { useMemorySecureKeys } from "./helpers/secure-keys.js";
+
+// The /models resolution probes configured providers through secure storage;
+// pin the memory backend so the classification-parity tests never route
+// through CES RPC discovery, which has no daemon to reach in a test process.
+useMemorySecureKeys();
 
 function makeSlashContext(overrides: Partial<SlashContext> = {}): SlashContext {
   return {

package/src/__tests__/dockerfile-workspace-packages.test.ts

@@ -0,0 +1,39 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * The assistant image copies workspace package sources after `bun install`,
+ * and the container smoke step resolves each declared `workspace:*`
+ * dependency. A declared dependency that is not COPYed fails the image
+ * build with `Cannot find module '@mycadet/<name>'` — the DR134 red.
+ */
+describe("assistant Dockerfile workspace packages", () => {
+  test("copies every workspace dependency into the image", () => {
+    const repoRoot = join(import.meta.dir, "../../..");
+    const pkg = JSON.parse(
+      readFileSync(join(repoRoot, "assistant/package.json"), "utf8"),
+    ) as { dependencies?: Record<string, string> };
+    const dockerfile = readFileSync(
+      join(repoRoot, "assistant/Dockerfile"),
+      "utf8",
+    );
+
+    const missing: string[] = [];
+    for (const [name, version] of Object.entries(pkg.dependencies ?? {})) {
+      if (version !== "workspace:*") {
+        continue;
+      }
+      if (!name.startsWith("@mycadet/")) {
+        missing.push(`${name} (unexpected workspace package)`);
+        continue;
+      }
+      const dir = `packages/${name.slice("@mycadet/".length)}`;
+      if (!dockerfile.includes(`COPY ${dir} `)) {
+        missing.push(dir);
+      }
+    }
+
+    expect(missing).toEqual([]);
+  });
+});

package/src/credential-execution/client.test.ts

@@ -2,21 +2,36 @@
  * Tests for the shared CES RPC session factory used by assistant boot and
  * child-process credential resolution.
  */
-import { describe, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, describe, expect, test } from "bun:test";
 
 import { createCesClient } from "./client.js";
 
+// Socket discovery is the process manager's concern, and it reads
+// `CES_SOCKET_DIR` — an empty socket dir makes the real discovery exhaust
+// its poll budget and come back unavailable, no module mocking needed.
+const socketDir = mkdtempSync(join(tmpdir(), "ces-no-socket-"));
+const prevSocketDir = process.env["CES_SOCKET_DIR"];
+process.env["CES_SOCKET_DIR"] = socketDir;
+
+afterAll(() => {
+  if (prevSocketDir === undefined) {
+    delete process.env["CES_SOCKET_DIR"];
+  } else {
+    process.env["CES_SOCKET_DIR"] = prevSocketDir;
+  }
+});
+
 describe("createCesClient", () => {
-  test("returns undefined when discovery fails without polling", async () => {
+  test("returns undefined when discovery finds no socket", async () => {
     const start = Date.now();
-    const client = await createCesClient({
-      discover: async () => ({
-        mode: "unavailable",
-        reason: "missing test socket",
-      }),
-    });
+    const client = await createCesClient();
 
     expect(client).toBeUndefined();
-    expect(Date.now() - start).toBeLessThan(1_000);
+    // The discovery poll budget (3s) is the dominant cost — the point is
+    // that the factory settles on its own rather than hanging.
+    expect(Date.now() - start).toBeLessThan(10_000);
   });
 });

package/src/credential-execution/client.ts

@@ -59,8 +59,6 @@ export interface CesSessionClient extends CesRpcClient, CesClientLifecycle {}
 export interface CesSessionClientOptions {
   /** Handshake material reused verbatim across reconnections. */
   handshake?: CesRpcHandshakeOptions;
-  /** Socket discovery override. Tests inject a stub. */
-  discover?: Parameters<typeof createCesProcessManager>[0]["discover"];
   /** RPC/handshake timeouts forwarded to the shared client. */
   config?: CesRpcClientConfig;
 }
@@ -79,7 +77,9 @@ export interface CesSessionClientOptions {
 export async function createCesClient(
   options: CesSessionClientOptions = {},
 ): Promise<CesSessionClient | undefined> {
-  const pm = createCesProcessManager({ discover: options.discover });
+  // Socket discovery is the process manager's own concern — this factory
+  // only supplies the session-level handshake and timeouts.
+  const pm = createCesProcessManager();
   const handshake = options.handshake;
 
   let inner: CesRpcClient | undefined;

package/src/credential-execution/process-manager.test.ts

@@ -5,7 +5,10 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { waitFor } from "../__tests__/helpers/wait-for.js";
-import { createCesProcessManager } from "./process-manager.js";
+import {
+  type CesProcessManagerConfig,
+  createCesProcessManager,
+} from "./process-manager.js";
 
 const untilClosed = (predicate: () => boolean) =>
   waitFor(predicate, {
@@ -124,10 +127,11 @@ describe("CesProcessManager.onTransportClose", () => {
 // ---------------------------------------------------------------------------
 
 type LogCall = { level: string; msg: string };
+type PmLogger = NonNullable<CesProcessManagerConfig["logger"]>;
 
 function makeRecordingLogger(): {
   calls: LogCall[];
-  logger: NonNullable<Parameters<typeof createCesProcessManager>[0]["logger"]>;
+  logger: PmLogger;
 } {
   const calls: LogCall[] = [];
   const rec =
@@ -141,9 +145,7 @@ function makeRecordingLogger(): {
     warn: rec("warn"),
     debug: rec("debug"),
     error: rec("error"),
-  } as unknown as NonNullable<
-    Parameters<typeof createCesProcessManager>[0]["logger"]
-  >;
+  } as unknown as PmLogger;
   return { calls, logger };
 }
 

package/src/credential-execution/process-manager.ts

@@ -110,7 +110,7 @@ export interface CesProcessManager {
 // ---------------------------------------------------------------------------
 
 export function createCesProcessManager(
-  config: CesProcessManagerConfig,
+  config: CesProcessManagerConfig = {},
 ): CesProcessManager {
   const pmLog = config.logger ?? log;
   const discover = config.discover ?? discoverCesWithRetry;

package/src/security/ces-rpc-record-backend.ts

@@ -21,30 +21,18 @@ import { getLogger } from "../util/logger.js";
 
 const log = getLogger("ces-rpc-record-backend");
 
-/** Minimum interval between CES connection attempts after a failure. */
-const LAZY_SESSION_COOLDOWN_MS = 3_000;
-
-/** How long ensureClient waits on a self-healing session before giving up. */
-const RECONNECT_WAIT_MS = 15_000;
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 class CesRpcRecordBackend {
   /**
    * The live IPC session, opened by this backend's first record operation.
    * The session owns its transport and reconnection: after a CES restart the
-   * same reference becomes ready again, so this backend never re-opens or
-   * swaps clients itself.
+   * same reference becomes ready again, so this backend never re-opens,
+   * swaps, or even waits on clients — it opens once and every operation
+   * either talks to that session or throws.
    */
   private client: CesSessionClient | undefined;
 
-  /** Memoized in-flight session attempt (single-flight across callers). */
-  private sessionAttempt: Promise<CesClient> | undefined;
-
-  /** When the last connection attempt failed; gates re-attempts. */
-  private lastFailedAttemptAt = 0;
+  /** Memoized open (single-flight across concurrent first operations). */
+  private clientPromise: Promise<CesClient> | undefined;
 
   /** Sync snapshot of the live client; `undefined` until connected. */
   getClient(): CesClient | undefined {
@@ -55,62 +43,32 @@ class CesRpcRecordBackend {
    * Resolve the client, opening our own CES IPC connection on first use.
    * Throws {@link CesUnavailableError} when CES is unreachable — callers
    * surface that rather than degrading, so a lost write is never mistaken
-   * for a successful one. Failed attempts are not re-attempted within the
-   * cooldown window: every operation would otherwise re-pay the discovery
-   * polling while CES is down. A held session whose transport died is NOT
-   * dropped here — the session reconnects itself; we just wait for it.
+   * for a successful one.
    */
   async ensureClient(): Promise<CesClient> {
-    if (this.client?.isReady()) {
-      return this.client;
-    }
-    if (this.client && !this.client.isReady()) {
-      // The session is self-healing (in-session reconnect loop) — wait for
-      // it to come back rather than opening a competing session.
-      for (let waited = 0; waited < RECONNECT_WAIT_MS; waited += 250) {
-        await sleep(250);
-        if (this.client.isReady()) {
-          return this.client;
+    this.clientPromise ??= createCesClient()
+      .then((client) => {
+        if (!client) {
+          throw new CesUnavailableError(
+            "CES is unreachable (socket discovery failed or handshake rejected)",
+          );
         }
-      }
-      throw new CesUnavailableError(
-        "CES is unreachable (session reconnect did not become ready)",
-      );
-    }
-    if (Date.now() - this.lastFailedAttemptAt < LAZY_SESSION_COOLDOWN_MS) {
-      throw new CesUnavailableError(
-        "CES is unreachable (recent connection attempt failed)",
-      );
-    }
-    if (!this.sessionAttempt) {
-      this.sessionAttempt = createCesClient()
-        .then((client) => {
-          if (!client) {
-            throw new CesUnavailableError(
-              "CES is unreachable (socket discovery failed or handshake rejected)",
-            );
-          }
-          this.client = client;
-          return client;
-        })
-        .catch((err) => {
-          this.lastFailedAttemptAt = Date.now();
-          throw err;
-        })
-        .finally(() => {
-          this.sessionAttempt = undefined;
-        });
-    }
-    return this.sessionAttempt;
+        this.client = client;
+        return client;
+      })
+      .catch((err) => {
+        // A failed open is not sticky: the next operation opens fresh.
+        this.clientPromise = undefined;
+        throw err;
+      });
+    return this.clientPromise;
   }
 
   /** Close the backend's connection (one-shot CLI processes call this on exit). */
   async close(): Promise<void> {
     const client = this.client;
     this.client = undefined;
-    this.sessionAttempt = undefined;
-    // A deliberate close is a fresh start: clear any open-failure cooldown.
-    this.lastFailedAttemptAt = 0;
+    this.clientPromise = undefined;
     await client?.stop().catch(() => {});
   }