@mycadet/cli 0.12.6-dev.202610082233.54244ee → 0.12.7

package/src/lib/default-main-screen-formatting.ts

@@ -9,7 +9,7 @@ export const LEFT_PANEL_WIDTH = 36;
 export const DEFAULT_TERMINAL_COLUMNS = 80;
 export const COMPACT_THRESHOLD = 60;
 
-const LEFT_HEADER_LINES = 4;
+const LEFT_HEADER_LINES = 3;
 const LEFT_FOOTER_LINES = 1;
 const HEADER_TOP_BORDER_LINES = 1;
 const HEADER_BOTTOM_BORDER_LINES = 2;
@@ -24,19 +24,47 @@ const RIGHT_PANEL_TIPS_HEADING = 1;
 const TOOL_CALL_CHROME_LINES = 2;
 const MESSAGE_SPACING = 1;
 
+/**
+ * Kept in sync with the web client's command set
+ * (clients/web slash-command-catalog) plus the CLI-local commands.
+ */
 export const HELP_COMMANDS = [
   {
     command: "/btw <question>",
     description: "Ask a side question while the assistant is working",
   },
   {
-    command: "/quit, /exit, /q",
-    description: "Disconnect and exit",
+    command: "/config [path] [value]",
+    description: "Read or set a runtime config value",
+  },
+  {
+    command: "/clean",
+    description: "Strip injected runtime context from the conversation",
+  },
+  {
+    command: "/commands",
+    description: "List all available commands",
+  },
+  {
+    command: "/compact",
+    description: "Force context compaction immediately",
+  },
+  {
+    command: "/models",
+    description: "List all available models",
+  },
+  {
+    command: "/status",
+    description: "Show conversation status and context usage",
   },
   {
     command: "/clear",
     description: "Clear the screen",
   },
+  {
+    command: "/quit, /exit, /q",
+    description: "Disconnect and exit",
+  },
   {
     command: "/help, ?",
     description: "Show this help",
@@ -186,7 +214,7 @@ export function truncateValue(value: unknown, maxLength: number): string {
 }
 
 export function formatHeaderTitle(assistantName?: string): string {
-  const rawTitle = assistantName?.trim() || "Meet your Assistant!";
+  const rawTitle = assistantName?.trim() || "Meet your Cadet!";
   const title = rawTitle.replace(/\s+/g, " ");
   const maxTitleLength = LEFT_PANEL_WIDTH - 2;
   const displayTitle =
@@ -196,10 +224,6 @@ export function formatHeaderTitle(assistantName?: string): string {
   return `  ${displayTitle}`;
 }
 
-export function formatHeaderEyebrow(): string {
-  return "  Assistant";
-}
-
 export function stripAnsi(value: string): string {
   return value.replace(/\x1b\[[0-9;]*m/g, "");
 }

package/src/lib/environments/__tests__/paths.test.ts

@@ -130,8 +130,10 @@ describe("path helpers", () => {
   });
 
   describe("getLockfilePath", () => {
-    test("production returns ~/.cadet.lock.json", () => {
-      expect(getLockfilePath(prod)).toBe(join(TEST_HOME, ".cadet.lock.json"));
+    test("production returns the config-dir lockfile.json", () => {
+      expect(getLockfilePath(prod)).toBe(
+        join(TEST_HOME, ".config", "cadet", "lockfile.json"),
+      );
     });
 
     test("dev returns ~/.config/cadet-dev/lockfile.json", () => {
@@ -153,7 +155,7 @@ describe("path helpers", () => {
         ...prod,
         lockfileDirOverride: "/tmp/lock",
       };
-      expect(getLockfilePath(env)).toBe("/tmp/lock/.cadet.lock.json");
+      expect(getLockfilePath(env)).toBe("/tmp/lock/lockfile.json");
     });
 
     test("non-prod respects lockfileDirOverride (overrides configDir)", () => {
@@ -167,10 +169,9 @@ describe("path helpers", () => {
   });
 
   describe("getLockfilePaths", () => {
-    test("production returns both current and legacy filenames in priority order", () => {
+    test("production returns a single canonical path", () => {
       expect(getLockfilePaths(prod)).toEqual([
-        join(TEST_HOME, ".cadet.lock.json"),
-        join(TEST_HOME, ".cadet.lockfile.json"),
+        join(TEST_HOME, ".config", "cadet", "lockfile.json"),
       ]);
     });
 
@@ -180,15 +181,12 @@ describe("path helpers", () => {
       ]);
     });
 
-    test("production with lockfileDirOverride applies to both candidates", () => {
+    test("production with lockfileDirOverride applies to the canonical path", () => {
       const env: EnvironmentDefinition = {
         ...prod,
         lockfileDirOverride: "/tmp/lock",
       };
-      expect(getLockfilePaths(env)).toEqual([
-        "/tmp/lock/.cadet.lock.json",
-        "/tmp/lock/.cadet.lockfile.json",
-      ]);
+      expect(getLockfilePaths(env)).toEqual(["/tmp/lock/lockfile.json"]);
     });
 
     test("non-prod with lockfileDirOverride overrides the config dir", () => {

package/src/lib/environments/paths.ts

@@ -33,31 +33,13 @@ export function getConfigDirs(env: EnvironmentDefinition): string[] {
   return resolveConfigDirPaths(process.env, localPathOptions(env));
 }
 
-/**
- * Lockfile candidate paths for an environment, in priority order.
- *
- * For production, returns both the current `.cadet.lock.json` and the
- * legacy `.cadet.lockfile.json` so read-side callers can fall back to the
- * legacy filename on installs that predate the rename. Non-production
- * environments are new and have a single canonical path under the env-scoped
- * XDG config directory.
- *
- * Read-side callers should iterate this array and use the first existing
- * file (matching `cli/src/lib/assistant-config.ts:readLockfile`). Write-side
- * callers should use {@link getLockfilePath}, which returns the first
- * (canonical) entry.
- *
- * `env.lockfileDirOverride` (populated by the resolver from
- * `CADET_LOCKFILE_DIR`) overrides the directory the lockfile lives in for
- * both production and non-production environments.
- */
 export function getLockfilePaths(env: EnvironmentDefinition): string[] {
   return resolveLockfilePaths(process.env, localPathOptions(env));
 }
 
 /**
- * Canonical lockfile path for writes. For production this is the current
- * `.cadet.lock.json` (legacy reads handled by {@link getLockfilePaths}).
+ * Canonical lockfile path for writes — always the config-dir
+ * `lockfile.json`.
  */
 export function getLockfilePath(env: EnvironmentDefinition): string {
   return getLockfilePaths(env)[0]!;

package/src/lib/guardian-token.ts

@@ -28,6 +28,39 @@ import {
 import { getConfigDir, getConfigDirs } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
 import { loopbackSafeFetch } from "./loopback-fetch.js";
+import { z } from "zod";
+
+/**
+ * The guardian token fields as they arrive untrusted (gateway refresh/init
+ * responses, persisted token files). Every field is independently optional
+ * and independently caught: one malformed field must not invalidate the
+ * others — callers fall back per field.
+ */
+const GuardianTokenFieldsSchema = z
+  .object({
+    guardianPrincipalId: z.string().optional().catch(undefined),
+    accessToken: z.string().optional().catch(undefined),
+    accessTokenExpiresAt: z
+      .union([z.string(), z.number()])
+      .optional()
+      .catch(undefined),
+    refreshToken: z.string().optional().catch(undefined),
+    refreshTokenExpiresAt: z
+      .union([z.string(), z.number()])
+      .optional()
+      .catch(undefined),
+    refreshAfter: z.string().optional().catch(undefined),
+    isNew: z.boolean().optional().catch(undefined),
+    deviceId: z.string().optional().catch(undefined),
+  })
+  .catch({});
+
+/** Narrow untrusted JSON to the token fields whose values have the right
+ * shape; fields absent or malformed come back undefined for callers to
+ * fall back on or reject. */
+function parseGuardianTokenFields(value: unknown): Partial<GuardianTokenData> {
+  return GuardianTokenFieldsSchema.parse(value);
+}
 
 const DEVICE_ID_SALT = "mycadet-host-id";
 
@@ -470,19 +503,24 @@ export async function refreshGuardianTokenResult(
       return classifyRefreshHttpStatus(response.status);
     }
 
-    const json = (await response.json()) as Record<string, unknown>;
+    const parsed = parseGuardianTokenFields(await response.json());
+    if (parsed.accessToken == null) {
+      return {
+        ok: false,
+        status: 502,
+        error: "Assistant gateway returned a malformed token refresh response",
+      };
+    }
     const refreshed: GuardianTokenData = {
       guardianPrincipalId:
-        (json.guardianPrincipalId as string) ?? tokenData.guardianPrincipalId,
-      accessToken: json.accessToken as string,
+        parsed.guardianPrincipalId ?? tokenData.guardianPrincipalId,
+      accessToken: parsed.accessToken,
       accessTokenExpiresAt:
-        (json.accessTokenExpiresAt as string | number) ??
-        tokenData.accessTokenExpiresAt,
-      refreshToken: (json.refreshToken as string) ?? tokenData.refreshToken,
+        parsed.accessTokenExpiresAt ?? tokenData.accessTokenExpiresAt,
+      refreshToken: parsed.refreshToken ?? tokenData.refreshToken,
       refreshTokenExpiresAt:
-        (json.refreshTokenExpiresAt as string | number) ??
-        tokenData.refreshTokenExpiresAt,
-      refreshAfter: (json.refreshAfter as string) ?? tokenData.refreshAfter,
+        parsed.refreshTokenExpiresAt ?? tokenData.refreshTokenExpiresAt,
+      refreshAfter: parsed.refreshAfter ?? tokenData.refreshAfter,
       isNew: false,
       deviceId: tokenData.deviceId,
       leasedAt: new Date().toISOString(),
@@ -583,15 +621,28 @@ export async function leaseGuardianToken(
     throw new Error(`guardian/init failed (${response.status}): ${body}`);
   }
 
-  const json = (await response.json()) as Record<string, unknown>;
+  const parsed = parseGuardianTokenFields(await response.json());
+  if (
+    parsed.guardianPrincipalId == null ||
+    parsed.accessToken == null ||
+    parsed.accessTokenExpiresAt == null ||
+    parsed.refreshToken == null ||
+    parsed.refreshTokenExpiresAt == null ||
+    parsed.refreshAfter == null ||
+    parsed.isNew == null
+  ) {
+    throw new Error(
+      `guardian/init returned a malformed token response (${response.status})`,
+    );
+  }
   const tokenData: GuardianTokenData = {
-    guardianPrincipalId: json.guardianPrincipalId as string,
-    accessToken: json.accessToken as string,
-    accessTokenExpiresAt: json.accessTokenExpiresAt as string | number,
-    refreshToken: json.refreshToken as string,
-    refreshTokenExpiresAt: json.refreshTokenExpiresAt as string | number,
-    refreshAfter: json.refreshAfter as string,
-    isNew: json.isNew as boolean,
+    guardianPrincipalId: parsed.guardianPrincipalId,
+    accessToken: parsed.accessToken,
+    accessTokenExpiresAt: parsed.accessTokenExpiresAt,
+    refreshToken: parsed.refreshToken,
+    refreshTokenExpiresAt: parsed.refreshTokenExpiresAt,
+    refreshAfter: parsed.refreshAfter,
+    isNew: parsed.isNew,
     deviceId,
     leasedAt: new Date().toISOString(),
   };
@@ -675,7 +726,10 @@ export function seedGuardianTokenFromSiblingEnv(assistantId: string): boolean {
   for (const { path: sibling } of candidates) {
     try {
       const raw = readFileSync(sibling);
-      const parsed = JSON.parse(raw.toString("utf-8")) as GuardianTokenData;
+      const parsed = parseGuardianTokenFields(
+        JSON.parse(raw.toString("utf-8")),
+      );
+      if (parsed.refreshTokenExpiresAt == null) continue;
       const refreshExpiry = new Date(parsed.refreshTokenExpiresAt).getTime();
       if (!Number.isFinite(refreshExpiry) || refreshExpiry <= now) continue;
       const dir = dirname(destPath);

package/src/lib/hatch-local.ts

@@ -49,6 +49,12 @@ import { logHatchNextSteps } from "./hatch-next-steps.js";
 import { printInstanceDetails } from "./instance-details.js";
 import { checkProviderApiKey } from "./api-key-check.js";
 import { loopbackSafeFetch } from "./loopback-fetch.js";
+import {
+  describeLoginError,
+  ensureCloudLoginInteractive,
+  registerLocalAssistantWithPlatform,
+} from "./cloud-login.js";
+import { fetchCurrentUser, readPlatformToken } from "./platform-client.js";
 import { withLocalHatchLock } from "./local-hatch-lock.js";
 
 /**
@@ -179,6 +185,8 @@ export interface HatchLocalResult {
   guardianAccessToken?: string;
 }
 
+
+
 export async function hatchLocal(
   params: HatchLocalParams = {},
 ): Promise<HatchLocalResult> {
@@ -247,6 +255,32 @@ export async function hatchLocal(
           // Collect the key immediately, while the choice is fresh — the
           // startup logs are quiet now, so nothing separates the two prompts.
           precollectedApiKey = await collectProviderApiKey(picked);
+
+          // Picking Cadet Cloud should feel like signing in, not like a
+          // mystery later — open the browser login right here. Skipped for
+          // the desktop app (it runs its own login UI) and non-TTY runs.
+          if (
+            picked === "cadet" &&
+            !process.env.CADET_DESKTOP_APP &&
+            process.stdin.isTTY &&
+            !readPlatformToken()
+          ) {
+            reporter.log("");
+            reporter.log(
+              "Cadet Cloud selected — opening your browser to log in...",
+            );
+            try {
+              await ensureCloudLoginInteractive();
+              reporter.log("✅ Logged in to Cadet Cloud");
+            } catch (error) {
+              reporter.warn(
+                `⚠️  Cadet Cloud login failed: ${describeLoginError(error)}`,
+              );
+              reporter.warn(
+                "   You can retry later with `cadet login`.",
+              );
+            }
+          }
         }
       }
 
@@ -267,7 +301,7 @@ export async function hatchLocal(
         process.env.APP_VERSION = cliPkg.version;
       }
 
-      reporter.progress(2, 6, "Writing configuration...");
+      reporter.progress(2, 6, "Setting up local assistant...");
       const hatchConfigValues = buildHatchConfigValues(configValues, provider);
       const defaultWorkspaceConfigPath = writeInitialConfig(hatchConfigValues);
 
@@ -381,6 +415,23 @@ export async function hatchLocal(
     });
   }
 
+  // Picking Cadet Cloud ends with the assistant registered on the platform
+  // and its cloud credentials injected — the same post-login flow
+  // `cadet login` runs — so messages route through the managed connection
+  // immediately after hatch. Non-fatal: the assistant is up either way.
+  if (provider === "cadet" && readPlatformToken()) {
+    try {
+      const token = readPlatformToken()!;
+      const user = await fetchCurrentUser(token);
+      await registerLocalAssistantWithPlatform(token, user, {
+        bearerToken: guardianAccessToken,
+        log: (m) => reporter.log(m),
+      });
+    } catch {
+      // Non-fatal — `cadet login` can complete the registration later.
+    }
+  }
+
   reporter.log("");
   reporter.log(`✅ Local assistant hatched!`);
   printInstanceDetails(

package/src/lib/health-check.ts

@@ -1,12 +1,13 @@
 import { loopbackSafeFetch } from "./loopback-fetch.js";
+import { z } from "zod";
 
-export const HEALTH_CHECK_TIMEOUT_MS = 1500;
+const HealthResponseSchema = z.object({
+  status: z.string().optional(),
+  message: z.string().optional(),
+  version: z.string().optional(),
+});
 
-interface HealthResponse {
-  status: string;
-  message?: string;
-  version?: string;
-}
+export const HEALTH_CHECK_TIMEOUT_MS = 1500;
 
 export interface HealthCheckResult {
   status: string;
@@ -57,7 +58,9 @@ export async function checkManagedHealth(
       return { status: `error (${response.status})`, detail: null };
     }
 
-    const data = (await response.json()) as HealthResponse;
+    const data = HealthResponseSchema
+      .catch({})
+      .parse(await response.json());
     const status = data.status || "unknown";
     return {
       status,
@@ -168,12 +171,12 @@ export async function fetchManagedPs(
   }
 }
 
-interface LegacyConnectionStatus {
-  state: string;
-  is_awake: boolean;
-  pod_status: string | null;
-  detail: string | null;
-}
+const LegacyConnectionStatusSchema = z.object({
+  state: z.string(),
+  is_awake: z.boolean(),
+  pod_status: z.string().nullable(),
+  detail: z.string().nullable(),
+});
 
 async function fetchLegacyConnectionStatus(
   runtimeUrl: string,
@@ -194,7 +197,11 @@ async function fetchLegacyConnectionStatus(
     clearTimeout(timeoutId);
     if (!response.ok) return null;
 
-    const data = (await response.json()) as LegacyConnectionStatus;
+    const parsed = LegacyConnectionStatusSchema.safeParse(
+      await response.json(),
+    );
+    if (!parsed.success) return null;
+    const data = parsed.data;
 
     // Translate legacy shape into the ps process tree
     const status: ManagedProcessEntry["status"] = data.is_awake
@@ -240,7 +247,9 @@ export async function checkHealth(
       return { status: `error (${response.status})`, detail: null };
     }
 
-    const data = (await response.json()) as HealthResponse;
+    const data = HealthResponseSchema
+      .catch({})
+      .parse(await response.json());
     const status = data.status || "unknown";
     return {
       status,

package/src/lib/lifecycle-reporter.ts

@@ -24,7 +24,15 @@ export interface LifecycleReporter {
  * that existing subprocess consumers parse.
  */
 export const consoleLifecycleReporter: LifecycleReporter = {
-  progress: (step, total, label) => emitProgress(step, total, label),
+  progress: (step, total, label) => {
+    emitProgress(step, total, label);
+    // Plain terminals get an active status line per step — without this the
+    // startup goes silent between prompts (the desktop channel is the only
+    // consumer of emitProgress otherwise).
+    if (!process.env.CADET_DESKTOP_APP) {
+      console.log(`[${step}/${total}] ${label}`);
+    }
+  },
   log: (message) => console.log(message),
   warn: (message) => console.warn(message),
   error: (message) => console.error(message),

package/src/lib/local-hatch-lock.ts

@@ -1,5 +1,6 @@
 import { execFileSync } from "child_process";
 import { createHash, randomUUID } from "crypto";
+import { z } from "zod";
 import {
   closeSync,
   mkdirSync,
@@ -57,7 +58,7 @@ function processIsAlive(pid: number): boolean {
     process.kill(pid, 0);
     return true;
   } catch (error) {
-    return (error as NodeJS.ErrnoException).code === "EPERM";
+    return errnoCode(error) === "EPERM";
   }
 }
 
@@ -87,30 +88,21 @@ function processStartedAt(pid: number): string | undefined {
   }
 }
 
+function errnoCode(error: unknown): string | undefined {
+  if (!(error instanceof Error)) return undefined;
+  if (!("code" in error) || typeof error.code !== "string") return undefined;
+  return error.code;
+}
+
+const LockOwnerFileSchema = z.object({
+  pid: z.number().int().positive(),
+  processStartedAt: z.string().min(1).optional().catch(undefined),
+  token: z.string().min(1),
+});
+
 function parseOwner(raw: string): LockOwner | undefined {
   try {
-    const parsed = JSON.parse(raw) as {
-      pid?: unknown;
-      processStartedAt?: unknown;
-      token?: unknown;
-    };
-    if (
-      typeof parsed.pid === "number" &&
-      Number.isInteger(parsed.pid) &&
-      parsed.pid > 0 &&
-      typeof parsed.token === "string" &&
-      parsed.token.length > 0
-    ) {
-      return {
-        pid: parsed.pid,
-        processStartedAt:
-          typeof parsed.processStartedAt === "string" &&
-          parsed.processStartedAt.length > 0
-            ? parsed.processStartedAt
-            : undefined,
-        token: parsed.token,
-      };
-    }
+    return LockOwnerFileSchema.parse(JSON.parse(raw));
   } catch {}
   return undefined;
 }
@@ -195,7 +187,7 @@ function acquireRecoveryClaim(
       writeOwnerFile(claimPath, owner);
       return () => releaseLock(claimPath, owner.token);
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
+      if (errnoCode(error) !== "EEXIST") {
         throw error;
       }
       if (
@@ -248,7 +240,7 @@ function removeStaleLock(
       unlinkSync(lockPath);
       return true;
     } catch (error) {
-      return (error as NodeJS.ErrnoException).code === "ENOENT";
+      return errnoCode(error) === "ENOENT";
     }
   } finally {
     releaseRecoveryClaim();
@@ -262,7 +254,7 @@ function releaseLock(lockPath: string, token: string): void {
   try {
     unlinkSync(lockPath);
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+    if (errnoCode(error) !== "ENOENT") {
       throw error;
     }
   }
@@ -306,7 +298,7 @@ export async function withLocalHatchLock<T>(
     try {
       writeOwnerFile(lockPath, owner);
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
+      if (errnoCode(error) !== "EEXIST") {
         throw error;
       }
       if (removeStaleLock(lockPath, owner, liveOwnerRecoveryGraceMs)) {

package/src/lib/local-runtime-client.ts

@@ -11,6 +11,9 @@ import {
   resolveRuntimeUrl,
 } from "./runtime-url.js";
 import { loopbackSafeFetch } from "./loopback-fetch.js";
+import { z } from "zod";
+
+const RuntimeIdentitySchema = z.object({ version: z.string().min(1) });
 
 /**
  * Thrown when the local runtime returns 409 for an export/import request
@@ -66,15 +69,23 @@ async function migrationRequestHeaders(
   return bearerHeaders(token);
 }
 
-interface Raw409Body {
-  detail?: string;
+const Raw409BodySchema = z.object({
+  detail: z.string().optional(),
   // The runtime's current 409 contract nests the payload under `error`:
   //   { error: { code: "export_in_progress" | "import_in_progress", job_id } }
   // We also tolerate a legacy flat shape ({ code, job_id }) for resilience.
-  error?: string | { code?: string; job_id?: string };
-  code?: string;
-  job_id?: string;
-}
+  error: z
+    .union([
+      z.string(),
+      z.object({
+        code: z.string().optional(),
+        job_id: z.string().optional(),
+      }),
+    ])
+    .optional(),
+  code: z.string().optional(),
+  job_id: z.string().optional(),
+});
 
 /** Common 409 → MigrationInProgressError parsing used by the two POST helpers. */
 async function throwIfInProgress(
@@ -82,11 +93,11 @@ async function throwIfInProgress(
   defaultKind: "export_in_progress" | "import_in_progress",
 ): Promise<void> {
   if (response.status !== 409) return;
-  const body = (await response.json().catch(() => ({}))) as Raw409Body;
-  const nested =
-    typeof body.error === "object" && body.error !== null
-      ? body.error
-      : undefined;
+  const parsed = Raw409BodySchema.safeParse(
+    await response.json().catch(() => ({})),
+  );
+  const body = parsed.success ? parsed.data : {};
+  const nested = typeof body.error === "object" ? body.error : undefined;
   const jobId = nested?.job_id ?? body.job_id ?? "";
   const rawKind =
     nested?.code ??
@@ -355,9 +366,9 @@ export async function localRuntimeIdentity(
       `Failed to fetch runtime identity: ${response.status} ${response.statusText}`,
     );
   }
-  const body = (await response.json()) as { version?: unknown };
-  if (typeof body.version !== "string" || !body.version) {
+  const parsed = RuntimeIdentitySchema.safeParse(await response.json());
+  if (!parsed.success) {
     throw new Error("Runtime identity response missing version");
   }
-  return { version: body.version };
+  return { version: parsed.data.version };
 }