@mycadet/cli 0.0.1 → 0.12.6-dev.202610080043.b727a33

package/src/__tests__/coverage.test.ts

@@ -0,0 +1,47 @@
+// Bun's coverage reporter only tracks files that are actually loaded during
+// test execution. There is no config option to include all source files.
+// See: https://github.com/oven-sh/bun/issues/5928
+import { resolve } from "node:path";
+import { expect, test } from "bun:test";
+
+const EXCLUDE_PATTERNS = [".test.ts", ".d.ts"];
+const EXCLUDE_DIRS = [
+  // Ink components import yoga-layout whose WASM binary crashes
+  // intermittently during headless import (null reference in za()).
+  "components/",
+];
+const EXCLUDE_FILES = [
+  // index.ts calls main() at module level, causing side effects on import
+  "index.ts",
+];
+
+async function importAllModules(dir: string): Promise<string[]> {
+  const glob = new Bun.Glob("**/*.{ts,tsx}");
+  const files = [...glob.scanSync(dir)].filter(
+    (f) =>
+      !EXCLUDE_PATTERNS.some((pattern) => f.endsWith(pattern)) &&
+      !EXCLUDE_DIRS.some((dir) => f.startsWith(dir)) &&
+      !EXCLUDE_FILES.some((excluded) => f === excluded) &&
+      !f.includes("__tests__"),
+  );
+
+  await Promise.all(files.map((relPath) => import(resolve(dir, relPath))));
+
+  return files;
+}
+
+test("imports all source modules for coverage tracking", async () => {
+  /**
+   * Ensures all source files are loaded so Bun's coverage reporter
+   * includes them in the report, not just files touched by other tests.
+   */
+
+  // GIVEN the src directory containing all source modules
+  const srcDir = resolve(import.meta.dir, "..");
+
+  // WHEN we dynamically import every source module
+  const files = await importAllModules(srcDir);
+
+  // THEN at least one file should have been imported
+  expect(files.length).toBeGreaterThan(0);
+});

package/src/__tests__/daemon-readiness-probe.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Tests for the CLI's migration-aware daemon readiness probe.
+ *
+ * `/readyz` keeps its HTTP status at 200 while DB migrations run (the k8s
+ * contract — the pod must stay in service), so the CLI classifies readiness
+ * from the response BODY instead: ready / migrating / failed / unreachable.
+ * The `failed` state is terminal for the daemon process, so the polling wait
+ * must return immediately instead of burning its full deadline.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+  probeDaemonReadiness,
+  waitForDaemonMigrationsReady,
+} from "../lib/http-client.js";
+
+type ReadyzResponder = () => Response;
+
+let server: ReturnType<typeof Bun.serve> | null = null;
+
+function serveReadyz(responder: ReadyzResponder): number {
+  server = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    fetch(req) {
+      if (new URL(req.url).pathname === "/readyz") return responder();
+      return new Response("not found", { status: 404 });
+    },
+  });
+  const { port } = server;
+  if (port === undefined) throw new Error("test server did not bind a port");
+  return port;
+}
+
+afterEach(() => {
+  server?.stop(true);
+  server = null;
+});
+
+describe("probeDaemonReadiness", () => {
+  test("classifies the ready body as ready", async () => {
+    const port = serveReadyz(() =>
+      Response.json({ status: "ok", ready: true }),
+    );
+    expect(await probeDaemonReadiness(port)).toBe("ready");
+  });
+
+  test("classifies a 200 migrating body as migrating", async () => {
+    const port = serveReadyz(() =>
+      Response.json({
+        status: "migrating",
+        ready: false,
+        dbMigrations: { ready: false, state: "running" },
+      }),
+    );
+    expect(await probeDaemonReadiness(port)).toBe("migrating");
+  });
+
+  test("classifies the 503 failed body as failed", async () => {
+    const port = serveReadyz(() =>
+      Response.json(
+        {
+          status: "error",
+          ready: false,
+          reason: "db_migrations_failed",
+          dbMigrations: { ready: false, state: "failed" },
+        },
+        { status: 503 },
+      ),
+    );
+    expect(await probeDaemonReadiness(port)).toBe("failed");
+  });
+
+  test("treats a legacy 200 body without a ready field as ready", async () => {
+    // Daemons that predate the migration-state body return { status: "ok" }.
+    const port = serveReadyz(() => Response.json({ status: "ok" }));
+    expect(await probeDaemonReadiness(port)).toBe("ready");
+  });
+
+  test("classifies a legacy strict-503 startup body as migrating, not unreachable", async () => {
+    // Pre-migration-body daemons return 503 { status, ready, notReady }
+    // throughout startup. The daemon ANSWERED, so it is alive — classifying
+    // it unreachable would make callers treat a starting daemon as dead.
+    const port = serveReadyz(() =>
+      Response.json(
+        { status: "unready", ready: false, notReady: ["startup", "db"] },
+        { status: 503 },
+      ),
+    );
+    expect(await probeDaemonReadiness(port)).toBe("migrating");
+  });
+
+  test("reports unreachable when nothing is listening", async () => {
+    const port = serveReadyz(() => Response.json({ ready: true }));
+    server?.stop(true);
+    server = null;
+    expect(await probeDaemonReadiness(port)).toBe("unreachable");
+  });
+});
+
+describe("waitForDaemonMigrationsReady", () => {
+  test("returns failed immediately without waiting out the deadline", async () => {
+    const port = serveReadyz(() =>
+      Response.json(
+        {
+          status: "error",
+          ready: false,
+          dbMigrations: { ready: false, state: "failed" },
+        },
+        { status: 503 },
+      ),
+    );
+    const started = Date.now();
+    const readiness = await waitForDaemonMigrationsReady(
+      port,
+      Date.now() + 60_000,
+    );
+    expect(readiness).toBe("failed");
+    // Terminal state short-circuits: nowhere near the 60s deadline.
+    expect(Date.now() - started).toBeLessThan(5_000);
+  });
+
+  test("keeps polling through migrating and resolves ready", async () => {
+    let calls = 0;
+    const port = serveReadyz(() => {
+      calls++;
+      return calls < 3
+        ? Response.json({
+            status: "migrating",
+            ready: false,
+            dbMigrations: { ready: false, state: "running" },
+          })
+        : Response.json({ status: "ok", ready: true });
+    });
+    const readiness = await waitForDaemonMigrationsReady(
+      port,
+      Date.now() + 10_000,
+    );
+    expect(readiness).toBe("ready");
+    expect(calls).toBeGreaterThanOrEqual(3);
+  });
+
+  test("returns migrating when the deadline passes mid-migration", async () => {
+    const port = serveReadyz(() =>
+      Response.json({
+        status: "migrating",
+        ready: false,
+        dbMigrations: { ready: false, state: "running" },
+      }),
+    );
+    const readiness = await waitForDaemonMigrationsReady(
+      port,
+      Date.now() + 600,
+    );
+    expect(readiness).toBe("migrating");
+  });
+});

package/src/__tests__/debug-bundle.test.ts

@@ -0,0 +1,256 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Lockfile isolation (mirrors backup.test.ts)
+const testDir = mkdtempSync(join(tmpdir(), "cli-debug-bundle-test-"));
+process.env.CADET_LOCKFILE_DIR = testDir;
+
+import * as assistantConfig from "../lib/assistant-config.js";
+import * as guardianToken from "../lib/guardian-token.js";
+import * as localRuntimeClient from "../lib/local-runtime-client.js";
+import * as platformClient from "../lib/platform-client.js";
+
+const resolveTargetMock = spyOn(
+  assistantConfig,
+  "resolveTargetAssistant",
+).mockImplementation(() => {
+  throw new Error("process.exit:1");
+});
+const readPlatformTokenMock = spyOn(
+  platformClient,
+  "readPlatformToken",
+).mockReturnValue("platform-token");
+const exportMock = spyOn(
+  localRuntimeClient,
+  "localRuntimeExportToGcs",
+).mockResolvedValue({ jobId: "job-1" });
+const identityMock = spyOn(
+  localRuntimeClient,
+  "localRuntimeIdentity",
+).mockResolvedValue({ version: "0.12.3" });
+const pollMock = spyOn(
+  localRuntimeClient,
+  "localRuntimePollJobStatus",
+).mockResolvedValue({
+  jobId: "job-1",
+  type: "export",
+  status: "complete",
+} as unknown as Awaited<
+  ReturnType<typeof localRuntimeClient.localRuntimePollJobStatus>
+>);
+const loadGuardianTokenSpy = spyOn(
+  guardianToken,
+  "loadGuardianToken",
+).mockReturnValue({
+  accessToken: "local-token",
+  accessTokenExpiresAt: new Date(Date.now() + 10 * 60_000).toISOString(),
+} as unknown as ReturnType<typeof guardianToken.loadGuardianToken>);
+const leaseGuardianTokenSpy = spyOn(
+  guardianToken,
+  "leaseGuardianToken",
+).mockResolvedValue({
+  accessToken: "leased-token",
+  accessTokenExpiresAt: new Date(Date.now() + 10 * 60_000).toISOString(),
+} as unknown as Awaited<ReturnType<typeof guardianToken.leaseGuardianToken>>);
+
+const { debugBundle } = await import("../commands/debug-bundle.js");
+
+const LOCAL_ENTRY = {
+  name: "mine",
+  assistantId: "local-asst-1",
+  runtimeUrl: "http://127.0.0.1:7821",
+  cloud: "local",
+  hatchedAt: new Date().toISOString(),
+  platformAssistantId: "11111111-2222-3333-4444-555555555555",
+  platformBaseUrl: "https://cloud.mycadet.ai",
+  platformOrganizationId: "org-1",
+} as unknown as assistantConfig.AssistantEntry;
+
+let originalFetch: typeof globalThis.fetch;
+let originalExit: typeof process.exit;
+let fetchCalls: { url: string; init?: RequestInit }[] = [];
+let uploadUrlStatus = 201;
+
+beforeEach(() => {
+  process.argv = ["bun", "cadet", "debug-bundle"];
+  originalFetch = globalThis.fetch;
+  originalExit = process.exit;
+  process.exit = mock((code?: number) => {
+    throw new Error(`process.exit:${code}`);
+  }) as unknown as typeof process.exit;
+  fetchCalls = [];
+  uploadUrlStatus = 201;
+  globalThis.fetch = mock(
+    async (input: RequestInfo | URL, init?: RequestInit) => {
+      fetchCalls.push({ url: String(input), init });
+      return new Response(
+        JSON.stringify({ url: "https://storage.googleapis.com/b/signed" }),
+        {
+          status: uploadUrlStatus,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    },
+  ) as unknown as typeof globalThis.fetch;
+  resolveTargetMock.mockReset();
+  resolveTargetMock.mockReturnValue(LOCAL_ENTRY);
+  identityMock.mockReset();
+  identityMock.mockResolvedValue({ version: "0.12.3" });
+  leaseGuardianTokenSpy.mockClear();
+  readPlatformTokenMock.mockReset();
+  readPlatformTokenMock.mockReturnValue("platform-token");
+  exportMock.mockClear();
+  pollMock.mockClear();
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  process.exit = originalExit;
+});
+
+afterAll(() => {
+  resolveTargetMock.mockRestore();
+  identityMock.mockRestore();
+  leaseGuardianTokenSpy.mockRestore();
+  readPlatformTokenMock.mockRestore();
+  exportMock.mockRestore();
+  pollMock.mockRestore();
+  loadGuardianTokenSpy.mockRestore();
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("cadet debug-bundle", () => {
+  test("mints the URL on the platform, exports with the debug profile, and waits", async () => {
+    await debugBundle();
+
+    expect(fetchCalls).toHaveLength(1);
+    expect(fetchCalls[0].url).toBe(
+      "https://cloud.mycadet.ai/v1/assistants/11111111-2222-3333-4444-555555555555/debug-bundle-upload-url/",
+    );
+    expect(fetchCalls[0].init?.method).toBe("POST");
+    expect(
+      (fetchCalls[0].init?.headers as Record<string, string>)[
+        "Cadet-Organization-Id"
+      ],
+    ).toBe("org-1");
+
+    expect(exportMock).toHaveBeenCalledTimes(1);
+    const [entry, token, params] = exportMock.mock.calls[0];
+    expect(entry).toBe(LOCAL_ENTRY);
+    expect(token).toBe("local-token");
+    expect(params).toEqual({
+      uploadUrl: "https://storage.googleapis.com/b/signed",
+      description: "debug bundle for Cadet staff",
+      profile: "debug",
+    });
+    expect(pollMock).toHaveBeenCalled();
+    // The daemon was checked for the debug profile before the platform call.
+    expect(identityMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("passes an unquoted multi-word display name through to the shared resolver", async () => {
+    process.argv = ["bun", "cadet", "debug-bundle", "Support", "Bot"];
+    await debugBundle();
+    expect(resolveTargetMock).toHaveBeenCalledWith("Support Bot");
+  });
+
+  test("refuses a daemon older than the debug profile before any URL is minted", async () => {
+    // Such a daemon strips `profile` and would upload the owner's
+    // credentials to the staff bucket.
+    identityMock.mockResolvedValue({ version: "0.12.2" });
+    const errors: string[] = [];
+    const errorSpy = spyOn(console, "error").mockImplementation((msg) => {
+      errors.push(String(msg));
+    });
+    try {
+      await expect(debugBundle()).rejects.toThrow("process.exit:1");
+    } finally {
+      errorSpy.mockRestore();
+    }
+    expect(errors.join("\n")).toContain("0.12.3");
+    expect(fetchCalls).toHaveLength(0);
+    expect(exportMock).not.toHaveBeenCalled();
+  });
+
+  test("re-leases the guardian token when the daemon answers 401 mid-poll", async () => {
+    pollMock.mockReset();
+    let polls = 0;
+    pollMock.mockImplementation(async (_entry, token) => {
+      polls += 1;
+      if (polls === 1) {
+        throw new Error("Local job status check failed: 401 Unauthorized");
+      }
+      expect(token).toBe("leased-token");
+      return {
+        jobId: "job-1",
+        type: "export",
+        status: "complete",
+      } as unknown as Awaited<
+        ReturnType<typeof localRuntimeClient.localRuntimePollJobStatus>
+      >;
+    });
+
+    await debugBundle();
+
+    expect(leaseGuardianTokenSpy).toHaveBeenCalledTimes(1);
+    expect(polls).toBe(2);
+  });
+
+  test("explains what to turn on when the platform refuses", async () => {
+    uploadUrlStatus = 403;
+    const errors: string[] = [];
+    const errorSpy = spyOn(console, "error").mockImplementation((msg) => {
+      errors.push(String(msg));
+    });
+    try {
+      await expect(debugBundle()).rejects.toThrow("process.exit:1");
+    } finally {
+      errorSpy.mockRestore();
+    }
+    expect(errors.join("\n")).toContain("Allow Staff Access");
+    expect(exportMock).not.toHaveBeenCalled();
+  });
+
+  test("refuses a Cadet-hosted assistant, which needs no bundle", async () => {
+    resolveTargetMock.mockReturnValue({
+      ...LOCAL_ENTRY,
+      cloud: "cadet",
+    } as unknown as assistantConfig.AssistantEntry);
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+    try {
+      await expect(debugBundle()).rejects.toThrow("process.exit:1");
+    } finally {
+      errorSpy.mockRestore();
+    }
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("asks for a login when the assistant is not registered", async () => {
+    resolveTargetMock.mockReturnValue({
+      ...LOCAL_ENTRY,
+      platformAssistantId: undefined,
+    } as unknown as assistantConfig.AssistantEntry);
+    const errors: string[] = [];
+    const errorSpy = spyOn(console, "error").mockImplementation((msg) => {
+      errors.push(String(msg));
+    });
+    try {
+      await expect(debugBundle()).rejects.toThrow("process.exit:1");
+    } finally {
+      errorSpy.mockRestore();
+    }
+    expect(errors.join("\n")).toContain("cadet login");
+    expect(fetchCalls).toHaveLength(0);
+  });
+});

package/src/__tests__/default-main-screen-formatting.test.ts

@@ -0,0 +1,165 @@
+import { describe, expect, test } from "bun:test";
+import {
+  calculateHeaderHeight,
+  estimateItemHeight,
+  formatConfirmationPreview,
+  formatHeaderEyebrow,
+  formatHeaderTitle,
+  formatTimestamp,
+  formatToolCallPreview,
+  stripAnsi,
+  truncateValue,
+  type RuntimeMessage,
+} from "../lib/default-main-screen-formatting.js";
+
+function message(overrides: Partial<RuntimeMessage> = {}): RuntimeMessage {
+  return {
+    id: "message-1",
+    role: "user",
+    content: "Hello",
+    timestamp: "2026-09-29T16:00:00.000Z",
+    ...overrides,
+  };
+}
+
+describe("formatTimestamp", () => {
+  test("formats a timestamp with hour and minute fields", () => {
+    const timestamp = "2026-09-29T16:05:00.000Z";
+
+    expect(formatTimestamp(timestamp)).toBe(
+      new Date(timestamp).toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit",
+      }),
+    );
+  });
+});
+
+describe("tool-call previews", () => {
+  test("formats known tool inputs", () => {
+    expect(
+      formatToolCallPreview({
+        name: "file_read",
+        input: { path: "/workspace/report.txt" },
+      }),
+    ).toBe("read /workspace/report.txt");
+    expect(
+      formatToolCallPreview({
+        name: "browser_click",
+        input: { element_id: "submit-button" },
+      }),
+    ).toBe("click submit-button");
+    expect(
+      formatConfirmationPreview("browser_press_key", { key: "Enter" }),
+    ).toBe('press "Enter"');
+  });
+
+  test("truncates long preview fields at their existing limits", () => {
+    expect(
+      formatToolCallPreview({
+        name: "bash",
+        input: { command: "x".repeat(90) },
+      }),
+    ).toBe("x".repeat(80));
+    expect(
+      formatToolCallPreview({
+        name: "browser_type",
+        input: { selector: "y".repeat(70) },
+      }),
+    ).toBe(`type into ${"y".repeat(60)}`);
+  });
+
+  test("serializes unknown tool inputs", () => {
+    expect(
+      formatToolCallPreview({ name: "custom_tool", input: { value: 7 } }),
+    ).toBe('{"value":7}');
+    expect(formatConfirmationPreview("custom_tool", { value: 7 })).toBe(
+      'custom_tool: {"value":7}',
+    );
+  });
+});
+
+describe("truncateValue", () => {
+  test("returns values that fit without changing them", () => {
+    expect(truncateValue("short", 8)).toBe("short");
+    expect(truncateValue({ ok: true }, 20)).toBe('{"ok":true}');
+  });
+
+  test("adds an ellipsis within the requested maximum length", () => {
+    expect(truncateValue("abcdefghij", 8)).toBe("abcde...");
+    expect(truncateValue({ value: "abcdefghij" }, 12)).toBe('{"value":...');
+  });
+});
+
+describe("header formatting", () => {
+  test("uses the default title and eyebrow", () => {
+    expect(formatHeaderEyebrow()).toBe("  Assistant");
+    expect(formatHeaderTitle()).toBe("  Meet your Assistant!");
+  });
+
+  test("normalizes title whitespace", () => {
+    expect(formatHeaderTitle("  Example\n  Assistant  ")).toBe(
+      "  Example Assistant",
+    );
+  });
+
+  test("truncates titles to the left panel width", () => {
+    const title = formatHeaderTitle("A".repeat(40));
+
+    expect(title).toBe(`  ${"A".repeat(31)}...`);
+    expect(title).toHaveLength(36);
+  });
+
+  test("strips ANSI color and style sequences from header art", () => {
+    expect(stripAnsi("\x1b[31mred\x1b[0m plain")).toBe("red plain");
+  });
+});
+
+describe("estimateItemHeight", () => {
+  test("accounts for message prefixes, wrapping, and spacing", () => {
+    expect(estimateItemHeight(message({ content: "abcdefghij" }), 10)).toBe(4);
+    expect(estimateItemHeight(message({ content: "a\nb" }), 80)).toBe(3);
+  });
+
+  test("accounts for tool-call chrome, parameters, and results", () => {
+    expect(
+      estimateItemHeight(
+        message({
+          role: "assistant",
+          toolCalls: [
+            {
+              name: "file_read",
+              input: { path: "/workspace/a", max_chars: 100 },
+              result: "done",
+            },
+          ],
+        }),
+        80,
+      ),
+    ).toBe(7);
+  });
+
+  test("estimates non-message feed items", () => {
+    expect(estimateItemHeight({ type: "help" }, 80)).toBe(5);
+    expect(estimateItemHeight({ type: "status", text: "123456\n12" }, 5)).toBe(
+      3,
+    );
+    expect(estimateItemHeight({ type: "spinner", text: "Working" }, 80)).toBe(
+      1,
+    );
+  });
+});
+
+describe("calculateHeaderHeight", () => {
+  test("uses one row in compact terminals", () => {
+    expect(calculateHeaderHeight(59)).toBe(1);
+  });
+
+  test("uses the larger of the art and right-panel layouts", () => {
+    expect(calculateHeaderHeight(80)).toBe(16);
+  });
+
+  test("defaults to the standard terminal width", () => {
+    expect(calculateHeaderHeight()).toBe(16);
+  });
+});