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

package/src/components/DefaultMainScreen.tsx

@@ -25,7 +25,6 @@ import {
   DEFAULT_TERMINAL_COLUMNS,
   estimateItemHeight,
   formatConfirmationPreview,
-  formatHeaderEyebrow,
   formatHeaderTitle,
   formatTimestamp,
   isRuntimeMessage,
@@ -65,15 +64,37 @@ export const ANSI = {
   gray: "\x1b[90m",
 } as const;
 
+/**
+ * The completion catalog: the CLI's own commands plus the web client's set
+ * (clients/web slash-command-catalog: /commands /compact /clean /models
+ * /status /doctor /btw). /clean /commands /models /status resolve through
+ * the daemon's meta-command endpoint; /compact and /doctor run as real
+ * turns (same as web); /config is CLI-local (runtime config get/set).
+ */
 export const SLASH_COMMANDS = [
   "/btw",
+  "/clean",
   "/clear",
+  "/commands",
+  "/compact",
+  "/config",
+  "/doctor",
   "/exit",
   "/help",
+  "/models",
   "/q",
   "/quit",
+  "/status",
 ];
 
+/** Commands the daemon resolves via POST /v1/conversations/{id}/slash. */
+const DAEMON_META_COMMANDS = new Set([
+  "/clean",
+  "/commands",
+  "/models",
+  "/status",
+]);
+
 const SEND_TIMEOUT_MS = 5000;
 /** Fresh deadline for a request retried after a mid-session token refresh —
  *  the original caller signal may have already timed out during the refresh. */
@@ -82,8 +103,7 @@ const RETRY_TIMEOUT_MS = 30_000;
 // ── Layout constants ──────────────────────────────────────
 const MAX_TOTAL_WIDTH = 72;
 const DEFAULT_TERMINAL_ROWS = 24;
-const HEADER_PREFIX_UNICODE = "── Cadet ";
-const HEADER_PREFIX_ASCII = "-- Cadet ";
+// The header opens with a plain full-width rule (no word prefix).
 
 // Left panel structure: HEADER lines + art + FOOTER lines
 // Header chrome (borders around panel content)
@@ -260,6 +280,99 @@ async function runtimeRequest<T>(
   return response.json() as Promise<T>;
 }
 
+interface MetaSlashResponse {
+  kind: "clean" | "info";
+  text: string;
+  contextUsage?: { tokens: number; maxTokens: number | null; fillRatio: number | null };
+}
+
+/**
+ * Resolve a local meta slash command (/clean, /commands, /models, /status)
+ * through the daemon — no turn starts, nothing persists. The CLI addresses
+ * its conversation by the client-minted conversation key (a uuid, web's
+ * temp-client-id pattern).
+ */
+async function resolveMetaCommand(
+  baseUrl: string,
+  assistantId: string,
+  conversationKey: string,
+  command: string,
+  auth?: Record<string, string>,
+): Promise<MetaSlashResponse> {
+  const url = `${baseUrl}/v1/conversations/${encodeURIComponent(conversationKey)}/slash`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...auth },
+    body: JSON.stringify({ command }),
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(friendlyErrorMessage(response.status, body));
+  }
+  return response.json() as Promise<MetaSlashResponse>;
+}
+
+async function fetchRuntimeConfig(
+  baseUrl: string,
+  auth?: Record<string, string>,
+): Promise<unknown> {
+  const url = `${baseUrl}/v1/config`;
+  const response = await fetch(url, {
+    headers: { "Content-Type": "application/json", ...auth },
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(friendlyErrorMessage(response.status, body));
+  }
+  return response.json();
+}
+
+async function setRuntimeConfigValue(
+  baseUrl: string,
+  path: string,
+  value: unknown,
+  auth?: Record<string, string>,
+): Promise<void> {
+  const url = `${baseUrl}/v1/config/set`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...auth },
+    body: JSON.stringify({ path, value }),
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(friendlyErrorMessage(response.status, body));
+  }
+}
+
+/** Resolve a dotted config path within the fetched config object. */
+function resolveConfigPath(config: unknown, dottedPath: string): unknown {
+  let current: unknown = config;
+  for (const segment of dottedPath.split(".")) {
+    if (
+      current === null ||
+      typeof current !== "object" ||
+      !(segment in (current as Record<string, unknown>))
+    ) {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[segment];
+  }
+  return current;
+}
+
+/** Parse a /config value: JSON when it parses, plain string otherwise. */
+function parseConfigValue(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
 async function checkHealthRuntime(baseUrl: string): Promise<HealthResponse> {
   const url = `${baseUrl}/healthz`;
   const controller = new AbortController();
@@ -282,9 +395,10 @@ async function checkHealthRuntime(baseUrl: string): Promise<HealthResponse> {
 async function pollMessages(
   baseUrl: string,
   assistantId: string,
+  conversationKey: string,
   auth?: Record<string, string>,
 ): Promise<ListMessagesResponse> {
-  const params = new URLSearchParams({ conversationKey: assistantId });
+  const params = new URLSearchParams({ conversationKey });
   const response = await runtimeRequest<ListMessagesResponse>(
     baseUrl,
     assistantId,
@@ -304,6 +418,7 @@ async function pollMessages(
 async function sendMessage(
   baseUrl: string,
   assistantId: string,
+  conversationKey: string,
   content: string,
   signal?: AbortSignal,
   auth?: Record<string, string>,
@@ -315,7 +430,7 @@ async function sendMessage(
     {
       method: "POST",
       body: JSON.stringify({
-        conversationKey: assistantId,
+        conversationKey,
         content,
         sourceChannel: "cadet",
         interface: "cli",
@@ -702,7 +817,7 @@ interface DefaultMainScreenProps {
 
 interface StyledLine {
   text: string;
-  style: "heading" | "dim" | "normal" | "eyebrow" | "title" | "art";
+  style: "heading" | "dim" | "normal" | "title" | "art";
 }
 
 function CompactHeader({
@@ -747,14 +862,12 @@ function DefaultMainScreen({
 }: DefaultMainScreenProps): ReactElement {
   const accentColor = "magenta";
   const caps = getTerminalCapabilities();
-  const headerPrefix = caps.unicodeSupported
-    ? HEADER_PREFIX_UNICODE
-    : HEADER_PREFIX_ASCII;
   const headerSep = caps.unicodeSupported ? "─" : "-";
 
   const { stdout } = useStdout();
   const terminalColumns = stdout.columns || DEFAULT_TERMINAL_COLUMNS;
-  const totalWidth = Math.min(MAX_TOTAL_WIDTH, terminalColumns);
+  // The header spans the full terminal width (previously capped at 72).
+  const totalWidth = terminalColumns;
   const isCompact = terminalColumns < COMPACT_THRESHOLD;
 
   if (isCompact) {
@@ -772,7 +885,6 @@ function DefaultMainScreen({
 
   const leftLines: StyledLine[] = [
     { text: " ", style: "normal" },
-    { text: formatHeaderEyebrow(), style: "eyebrow" },
     { text: formatHeaderTitle(assistantName), style: "title" },
     { text: " ", style: "normal" },
     ...art.map((line) => ({
@@ -800,25 +912,15 @@ function DefaultMainScreen({
 
   return (
     <Box flexDirection="column" width={totalWidth}>
-      <Text dimColor>
-        {headerPrefix +
-          headerSep.repeat(Math.max(0, totalWidth - headerPrefix.length))}
-      </Text>
+      <Text dimColor>{headerSep.repeat(totalWidth)}</Text>
       <Box flexDirection="row">
         <Box flexDirection="column" width={LEFT_PANEL_WIDTH}>
           {Array.from({ length: maxLines }, (_, i) => {
             const item = leftLines[i];
             if (!item) return <Text key={i}> </Text>;
-            if (item.style === "eyebrow") {
-              return (
-                <Text key={i} color={caps.isDumb ? undefined : accentColor}>
-                  {item.text}
-                </Text>
-              );
-            }
             if (item.style === "title") {
               return (
-                <Text key={i} bold>
+                <Text key={i} bold color={caps.isDumb ? undefined : accentColor}>
                   {item.text}
                 </Text>
               );
@@ -1109,6 +1211,8 @@ export interface ChatAppHandle {
 interface ChatAppProps {
   runtimeUrl: string;
   assistantId: string;
+  /** Client-minted conversation key the CLI addresses its conversation by. */
+  conversationKey: string;
   assistantName?: string;
   /** Assistant data root for the header details panel (home-collapsed). */
   workspaceRoot?: string;
@@ -1122,6 +1226,7 @@ interface ChatAppProps {
 function ChatApp({
   runtimeUrl,
   assistantId,
+  conversationKey,
   assistantName,
   workspaceRoot,
   auth,
@@ -1463,6 +1568,7 @@ function ChatApp({
         const historyResponse = await pollMessages(
           runtimeUrl,
           assistantId,
+          conversationKey,
           auth,
         );
         h.hideSpinner();
@@ -1486,7 +1592,7 @@ function ChatApp({
           for await (const event of streamEvents(
             runtimeUrl,
             assistantId,
-            assistantId,
+            conversationKey,
             sseAc.signal,
             auth,
           )) {
@@ -1744,6 +1850,105 @@ function ChatApp({
         return;
       }
 
+      // Daemon meta commands (/clean /commands /models /status) — the same
+      // set web resolves through the daemon's slash endpoint. No turn
+      // starts; the answer renders as an ephemeral status line.
+      const metaCommand = trimmed.split(/\s+/)[0]?.toLowerCase();
+      if (metaCommand && DAEMON_META_COMMANDS.has(metaCommand)) {
+        const isConnected = await ensureConnected();
+        if (!isConnected) return;
+
+        h.showSpinner(`Running ${metaCommand}...`);
+        try {
+          const result = await resolveMetaCommand(
+            runtimeUrl,
+            assistantId,
+            conversationKey,
+            trimmed,
+            auth,
+          );
+          h.hideSpinner();
+          h.addStatus(result.text || "(no output)");
+          if (result.contextUsage) {
+            const usage = result.contextUsage;
+            const pct =
+              usage.maxTokens && usage.maxTokens > 0
+                ? ` (${Math.round((usage.tokens / usage.maxTokens) * 100)}% of context)`
+                : "";
+            h.addStatus(
+              `Context: ${usage.tokens.toLocaleString()} tokens${pct}`,
+              "gray",
+            );
+          }
+        } catch (err) {
+          h.hideSpinner();
+          h.showError(
+            `${metaCommand} failed: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+        setInputFocused(true);
+        return;
+      }
+
+      // /config — read and write runtime config values (GET /v1/config,
+      // POST /v1/config/set — the same API `assistant config set` uses).
+      if (metaCommand === "/config") {
+        const argString = trimmed.slice("/config".length).trim();
+        const isConnected = await ensureConnected();
+        if (!isConnected) return;
+
+        h.showSpinner("Reading config...");
+        try {
+          if (!argString) {
+            const config = await fetchRuntimeConfig(runtimeUrl, auth);
+            h.hideSpinner();
+            const printed = JSON.stringify(config, null, 2);
+            const lines = printed.split("\n");
+            h.addStatus(
+              lines.length > 40
+                ? lines.slice(0, 40).join("\n") + `\n... (${lines.length - 40} more lines)`
+                : printed,
+            );
+          } else {
+            // Split "<path>" or "<path> <value>" — the path is dotted and
+            // never contains spaces; the value is everything after it.
+            const spaceIndex = argString.indexOf(" ");
+            const configPath = (
+              spaceIndex === -1 ? argString : argString.slice(0, spaceIndex)
+            ).trim();
+            const rawValue =
+              spaceIndex === -1 ? undefined : argString.slice(spaceIndex + 1).trim();
+
+            if (rawValue === undefined) {
+              const config = await fetchRuntimeConfig(runtimeUrl, auth);
+              h.hideSpinner();
+              const value = resolveConfigPath(config, configPath);
+              h.addStatus(
+                value === undefined
+                  ? `config.${configPath} is not set`
+                  : `config.${configPath} = ${JSON.stringify(value, null, 2)}`,
+              );
+            } else {
+              await setRuntimeConfigValue(
+                runtimeUrl,
+                configPath,
+                parseConfigValue(rawValue),
+                auth,
+              );
+              h.hideSpinner();
+              h.addStatus(`Set config.${configPath} = ${rawValue}`, "green");
+            }
+          }
+        } catch (err) {
+          h.hideSpinner();
+          h.showError(
+            `/config failed: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+        setInputFocused(true);
+        return;
+      }
+
       // If a connection attempt is already in progress, don't silently drop input
       if (connectingRef.current) {
         h.addStatus(
@@ -1771,7 +1976,7 @@ function ChatApp({
                 ...auth,
               },
               body: JSON.stringify({
-                conversationKey: assistantId,
+                conversationKey,
                 content: question,
               }),
               signal: AbortSignal.timeout(30_000),
@@ -1836,8 +2041,10 @@ function ChatApp({
       }
 
       if (busyRef.current) {
-        // /btw is already handled above this block
-        if (!trimmed.startsWith("/")) {
+        // /btw and the other local commands are already handled above this
+        // block — anything reaching here (including unknown /commands, which
+        // run as real turns) echoes as a user message.
+        {
           const userMsg: RuntimeMessage = {
             id: "local-user-" + Date.now(),
             role: "user",
@@ -1861,6 +2068,7 @@ function ChatApp({
           const sendResult = await sendMessage(
             runtimeUrl,
             assistantId,
+            conversationKey,
             trimmed,
             controller.signal,
             auth,
@@ -1883,15 +2091,16 @@ function ChatApp({
         return;
       }
 
-      if (!trimmed.startsWith("/")) {
-        const userMsg: RuntimeMessage = {
-          id: "local-user-" + Date.now(),
-          role: "user",
-          content: trimmed,
-          timestamp: new Date().toISOString(),
-        };
-        h.addMessage(userMsg);
-      }
+      // Unknown /commands run as real turns (web-consistent: /compact and
+      // /doctor are turns too) and show up in the transcript like any other
+      // user message.
+      const userMsg: RuntimeMessage = {
+        id: "local-user-" + Date.now(),
+        role: "user",
+        content: trimmed,
+        timestamp: new Date().toISOString(),
+      };
+      h.addMessage(userMsg);
 
       const isConnected = await ensureConnected();
       if (!isConnected) {
@@ -1910,6 +2119,7 @@ function ChatApp({
         const sendResult = await sendMessage(
           runtimeUrl,
           assistantId,
+          conversationKey,
           trimmed,
           controller.signal,
           auth,
@@ -2249,6 +2459,9 @@ export function renderChatApp(
     auth?: Record<string, string>;
     assistantName?: string;
     workspaceRoot?: string;
+    /** Client-minted conversation key (resolved from the assistant entry).
+     *  Unregistered targets (--url) get an ephemeral uuid. */
+    conversationKey?: string;
   },
 ): ChatAppInstance {
   let chatHandle: ChatAppHandle | null = null;
@@ -2257,6 +2470,7 @@ export function renderChatApp(
     <ChatApp
       runtimeUrl={runtimeUrl}
       assistantId={assistantId}
+      conversationKey={options?.conversationKey ?? crypto.randomUUID()}
       assistantName={options?.assistantName}
       workspaceRoot={options?.workspaceRoot}
       auth={options?.auth}

package/src/index.ts

@@ -3,7 +3,12 @@
 import { join } from "path";
 import { readFileSync } from "node:fs";
 
-import { resolveConfigDir } from "@mycadet/local-mode";
+import {
+  resolveConfigDir,
+  SigningKeyContinuityError,
+} from "@mycadet/local-mode";
+
+import { emitCliError } from "./lib/cli-error.js";
 
 import cliPkg from "../package.json";
 import { backup } from "./commands/backup";
@@ -30,27 +35,30 @@ import { rollback } from "./commands/rollback";
 import { setup } from "./commands/setup";
 import { sleep } from "./commands/sleep";
 import { ssh } from "./commands/ssh";
-import { debugBundle } from "./commands/debug";
+import { debug } from "./commands/debug";
 import { teleport } from "./commands/teleport";
 import { terminal } from "./commands/terminal";
 import { tunnel } from "./commands/tunnel";
+import { uninstall } from "./commands/uninstall";
 import { unpair } from "./commands/unpair";
 import { upgrade } from "./commands/upgrade";
 import { use } from "./commands/use";
 import { voice } from "./commands/voice";
 import { wake } from "./commands/wake";
 import { workflows } from "./commands/workflows";
+import { red } from "./lib/color";
 import { resolveAssistant, setActiveAssistant } from "./lib/assistant-config";
 import { loadGuardianToken } from "./lib/guardian-token";
 import { checkHealth } from "./lib/health-check";
 
+
 const commands = {
   backup,
   clean,
   client,
   confirm,
   connect,
-  debug: debugBundle,
+  debug,
   devices,
   events,
   exec,
@@ -74,6 +82,7 @@ const commands = {
   teleport,
   terminal,
   tunnel,
+  uninstall,
   unpair,
   upgrade,
   use,
@@ -81,7 +90,7 @@ const commands = {
   wake,
   whoami,
   workflows,
-} as const;
+};
 
 type CommandName = keyof typeof commands;
 
@@ -89,56 +98,12 @@ function printHelp(): void {
   console.log("Usage: cadet <command> [options]");
   console.log("");
   console.log("Commands:");
-  console.log("  backup   Export a backup of a running assistant");
-  console.log("  clean    Kill orphaned cadet processes");
-  console.log("  client   Connect to a hatched assistant");
-  console.log("  confirm  Resolve a pending tool confirmation on an assistant");
-  console.log(
-    "  connect  Pair with an assistant running on another machine [beta]",
-  );
-  console.log(
-    "  debug    Send Cadet staff a debug bundle of a self-hosted assistant",
-  );
-  console.log(
-    "  devices  List or revoke devices paired to a local assistant [beta]",
-  );
-  console.log("  events   Stream events from a running assistant");
-  console.log("  exec     Execute a command inside an assistant's container");
-  console.log("  flags    Show and toggle feature flags");
-  console.log("  gateway  Gateway management commands");
-  console.log("  hatch    Create a new assistant instance");
-  console.log("  logs     View logs from an assistant instance");
-  console.log("  login    Log in to Cadet Cloud");
-  console.log("  logout   Log out of Cadet Cloud");
-  console.log("  message  Send a message to a running assistant");
-  console.log(
-    "  pair     Print a pairing link and QR code for another device [beta]",
+  const nameWidth = Math.max(
+    ...Object.keys(commands).map((name) => name.length),
   );
-  console.log(
-    "  ps       List assistants (or processes for a specific assistant)",
-  );
-  console.log("  recover  Restore a previously retired local assistant");
-  console.log(
-    "  restore  Restore data (and optionally version) from a .vbundle backup",
-  );
-  console.log("  retire   Delete an assistant instance");
-  console.log("  roadmap  Manage roadmap items");
-  console.log("  rollback  Roll back an assistant to a previous version");
-  console.log("  setup    Configure API keys interactively");
-  console.log("  sleep    Stop the assistant process");
-  console.log("  ssh      SSH into a remote assistant instance");
-  console.log("  teleport Transfer assistant data between environments");
-  console.log("  terminal Open a terminal into a managed assistant container");
-  console.log("  tunnel   Create a tunnel for a locally hosted assistant");
-  console.log(
-    "  unpair   Forget a paired assistant imported from another machine [beta]",
-  );
-  console.log("  upgrade  Upgrade an assistant to a newer version");
-  console.log("  use      Set the active assistant for commands");
-  console.log("  voice    Type to an assistant and hear it answer out loud");
-  console.log("  wake     Start the assistant and gateway");
-  console.log("  whoami   Show current logged-in user");
-  console.log("  workflows Inspect and control workflow runs");
+  for (const [name, command] of Object.entries(commands)) {
+    console.log(`  ${name.padEnd(nameWidth)}  ${command.description}`);
+  }
   console.log("");
   console.log("Options:");
   console.log(
@@ -275,14 +240,17 @@ async function main() {
   const command = commands[commandName as CommandName];
 
   if (!command) {
-    console.error(`Unknown command: ${commandName}`);
+    console.error(red(`Unknown command: ${commandName}`));
     process.exit(1);
   }
 
   try {
     await command();
   } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
+    if (error instanceof SigningKeyContinuityError) {
+      emitCliError("AUTH_IDENTITY_UNAVAILABLE", error.message, error.code);
+    }
+    console.error(red(`Error: ${error instanceof Error ? error.message : error}`));
     process.exit(1);
   }
 }