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

package/src/commands/exec.ts

@@ -0,0 +1,249 @@
+import { isManagedCloud } from "../lib/managed-cloud.js";
+import { spawn } from "child_process";
+
+import { resolveAssistant } from "../lib/assistant-config";
+import { dockerResourceNames } from "../lib/docker";
+import type { ServiceName } from "../lib/docker";
+import { execAppleContainer } from "../lib/exec-apple-container";
+import { getPlatformUrl, readPlatformToken } from "../lib/platform-client";
+import { sshAppleContainer } from "../lib/ssh-apple-container";
+import {
+  interactiveSession,
+  nonInteractiveExec,
+  shellEscapeArgs,
+} from "../lib/terminal-session";
+
+const SERVICE_ALIASES: Record<string, ServiceName> = {
+  assistant: "assistant",
+  "mycadet": "assistant",
+  gateway: "gateway",
+  "cadet-gateway": "gateway",
+  "credential-executor": "credential-executor",
+  "cadet-credential-executor": "credential-executor",
+};
+
+function normalizeService(raw: string): ServiceName {
+  const normalized = SERVICE_ALIASES[raw];
+  if (!normalized) {
+    console.error(
+      `Unknown service '${raw}'. Valid services: assistant, gateway, credential-executor`,
+    );
+    process.exit(1);
+  }
+  return normalized;
+}
+
+function resolveDockerContainer(
+  instanceName: string,
+  service: ServiceName,
+): string {
+  const res = dockerResourceNames(instanceName);
+  switch (service) {
+    case "assistant":
+      return res.assistantContainer;
+    case "gateway":
+      return res.gatewayContainer;
+    case "credential-executor":
+      return res.cesContainer;
+  }
+}
+
+export async function exec(): Promise<void> {
+  const rawArgs = process.argv.slice(3);
+
+  // Only check for help flags before the -- separator so that
+  // `cadet exec -- curl --help` passes through correctly.
+  const dashDashIndex = rawArgs.indexOf("--");
+  const preArgs =
+    dashDashIndex === -1 ? rawArgs : rawArgs.slice(0, dashDashIndex);
+
+  if (
+    preArgs.includes("--help") ||
+    preArgs.includes("-h") ||
+    rawArgs.length === 0
+  ) {
+    console.log(
+      "Usage: cadet exec [<name>] [--service <svc>] [-it] -- <command...>",
+    );
+    console.log("");
+    console.log("Execute a command inside an assistant's container.");
+    console.log("");
+    console.log("Arguments:");
+    console.log(
+      "  <name>              Name of the assistant (defaults to active)",
+    );
+    console.log(
+      "  <command...>        Command and arguments to run (after --)",
+    );
+    console.log("");
+    console.log("Options:");
+    console.log("  --service <svc>     Target service (default: assistant)");
+    console.log(
+      "  -it                 Interactive mode with TTY (like docker exec -it)",
+    );
+    console.log(
+      "  --timeout <secs>    Timeout in seconds (default: 30, 0 = no timeout)",
+    );
+    console.log(
+      "  --verbose           Show debug output (SSE events, sentinel parsing)",
+    );
+    console.log("");
+    console.log("Services:");
+    console.log("  assistant (or mycadet)");
+    console.log("  gateway (or cadet-gateway)");
+    console.log("  credential-executor (or cadet-credential-executor)");
+    console.log("");
+    console.log("Examples:");
+    console.log("  cadet exec -- ls -la /workspace");
+    console.log("  cadet exec -- cat /workspace/NOW.md");
+    console.log("  cadet exec -it -- /bin/bash");
+    console.log("  cadet exec --service gateway -- cat /tmp/gateway.log");
+    process.exit(0);
+  }
+
+  if (dashDashIndex === -1) {
+    console.error(
+      "Error: missing '--' separator before command.\n" +
+        "Usage: cadet exec [<name>] -- <command...>",
+    );
+    process.exit(1);
+  }
+
+  const command = rawArgs.slice(dashDashIndex + 1);
+
+  if (command.length === 0) {
+    console.error("Error: no command specified after '--'.");
+    process.exit(1);
+  }
+
+  let nameArg: string | undefined;
+  let serviceRaw = "assistant";
+  let interactive = false;
+  let verbose = false;
+  let timeoutMs = 30_000;
+
+  for (let i = 0; i < preArgs.length; i++) {
+    if (preArgs[i] === "--service" && preArgs[i + 1]) {
+      serviceRaw = preArgs[++i];
+    } else if (preArgs[i] === "-it" || preArgs[i] === "-ti") {
+      interactive = true;
+    } else if (preArgs[i] === "--timeout" && preArgs[i + 1]) {
+      const secs = Number(preArgs[++i]);
+      if (!Number.isFinite(secs) || secs < 0) {
+        console.error("Error: --timeout must be a non-negative number.");
+        process.exit(1);
+      }
+      timeoutMs = secs === 0 ? 0 : secs * 1000;
+    } else if (preArgs[i] === "--verbose") {
+      verbose = true;
+    } else if (!preArgs[i].startsWith("-")) {
+      nameArg = preArgs[i];
+    }
+  }
+
+  const service = normalizeService(serviceRaw);
+
+  const entry = resolveAssistant(nameArg);
+
+  if (!entry) {
+    if (nameArg) {
+      console.error(`No assistant instance found with name '${nameArg}'.`);
+    } else {
+      console.error("No assistant instance found. Run `cadet hatch` first.");
+    }
+    process.exit(1);
+  }
+
+  const cloud = entry.cloud;
+
+  if (cloud === "local") {
+    const child = spawn(command[0], command.slice(1), {
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    await new Promise<void>((resolve) => {
+      child.on("close", (code) => {
+        process.exitCode = code ?? 0;
+        resolve();
+      });
+      child.on("error", (err) => {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+        resolve();
+      });
+    });
+    return;
+  }
+
+  if (cloud === "apple-container") {
+    const fullServiceName = `cadet-${service}`;
+    if (interactive) {
+      await sshAppleContainer(entry, command, fullServiceName);
+    } else {
+      await execAppleContainer(entry, command, fullServiceName);
+    }
+    return;
+  }
+
+  if (cloud === "docker") {
+    const container = resolveDockerContainer(entry.assistantId, service);
+    const dockerArgs = interactive
+      ? ["exec", "-it", container, ...command]
+      : ["exec", container, ...command];
+
+    const child = spawn("docker", dockerArgs, {
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    await new Promise<void>((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else {
+          process.exitCode = code ?? 1;
+          resolve();
+        }
+      });
+      child.on("error", reject);
+    });
+    return;
+  }
+
+  if (isManagedCloud(cloud)) {
+    const token = readPlatformToken();
+    if (!token) {
+      console.error(
+        "Not logged in. Run `cadet login` first to authenticate with the platform.",
+      );
+      process.exit(1);
+    }
+
+    const assistant = {
+      assistantId: entry.assistantId,
+      token,
+      platformUrl: getPlatformUrl(),
+    };
+
+    const serviceParam = service === "assistant" ? undefined : service;
+
+    if (interactive) {
+      // Interactive mode: shell-escape argv and delegate to full terminal
+      await interactiveSession(
+        assistant,
+        shellEscapeArgs(command),
+        serviceParam,
+      );
+      return;
+    }
+
+    // Non-interactive: sentinel-based output capture with exit code
+    await nonInteractiveExec(assistant, command, {
+      verbose,
+      timeoutMs,
+      service: serviceParam,
+    });
+    return;
+  }
+
+  console.error(`Error: 'cadet exec' is not supported for ${cloud} instances.`);
+  process.exit(1);
+}

package/src/commands/flags.ts

@@ -0,0 +1,251 @@
+import { extractAssistantFlag } from "../lib/arg-utils.js";
+import { AssistantClient } from "../lib/assistant-client.js";
+import {
+  formatAssistantLookupError,
+  lookupAssistantByIdentifier,
+} from "../lib/assistant-config.js";
+import { crossEnvironmentAssistantHint } from "../lib/environments/detect.js";
+
+type FeatureFlagEntry = {
+  key: string;
+  label: string;
+  enabled: boolean;
+  defaultEnabled: boolean;
+  description: string;
+};
+
+type FlagsResponse = {
+  flags: FeatureFlagEntry[];
+};
+
+function pad(s: string, w: number): string {
+  return s + " ".repeat(Math.max(0, w - s.length));
+}
+
+function printFlagTable(flags: FeatureFlagEntry[]): void {
+  const headers = {
+    key: "KEY",
+    enabled: "ENABLED",
+    default: "DEFAULT",
+    label: "LABEL",
+  };
+
+  const rows = flags
+    .slice()
+    .sort((a, b) => a.key.localeCompare(b.key))
+    .map((f) => ({
+      key: f.enabled !== f.defaultEnabled ? `* ${f.key}` : `  ${f.key}`,
+      enabled: String(f.enabled),
+      default: String(f.defaultEnabled),
+      label: f.label,
+    }));
+
+  const all = [headers, ...rows];
+  const colWidths = {
+    key: Math.max(...all.map((r) => r.key.length)),
+    enabled: Math.max(...all.map((r) => r.enabled.length)),
+    default: Math.max(...all.map((r) => r.default.length)),
+    label: Math.max(...all.map((r) => r.label.length)),
+  };
+
+  const formatRow = (r: typeof headers) =>
+    `${pad(r.key, colWidths.key)}  ${pad(r.enabled, colWidths.enabled)}  ${pad(r.default, colWidths.default)}  ${r.label}`;
+
+  console.log(formatRow(headers));
+  console.log(
+    `${"-".repeat(colWidths.key)}  ${"-".repeat(colWidths.enabled)}  ${"-".repeat(colWidths.default)}  ${"-".repeat(colWidths.label)}`,
+  );
+  for (const row of rows) {
+    console.log(formatRow(row));
+  }
+  console.log("");
+  console.log("* = overridden (differs from default)");
+}
+
+function printHelp(): void {
+  console.log("Usage: cadet flags [subcommand] [options]");
+  console.log("");
+  console.log("Show and toggle feature flags for the active assistant.");
+  console.log(
+    "Reads from the gateway's merged flag state (persisted overrides > remote > defaults).",
+  );
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  (none)              List all feature flags in a table");
+  console.log("  get <key>           Show details for a single flag");
+  console.log("  set <key> <bool>    Set a flag override to true or false");
+  console.log("");
+  console.log("Options:");
+  console.log(
+    "  --assistant <name>  Target a specific assistant (display name or ID)",
+  );
+  console.log(
+    "                      instead of the active one. Useful for scripted",
+  );
+  console.log(
+    "                      flows like eval harnesses that must not mutate",
+  );
+  console.log("                      the user's active-assistant pointer.");
+  console.log("  --help, -h          Show this help");
+  console.log("");
+  console.log("Examples:");
+  console.log(
+    "  $ cadet flags                                              # list flags for active assistant",
+  );
+  console.log(
+    "  $ cadet flags get browser                                     # inspect one flag",
+  );
+  console.log(
+    "  $ cadet flags set browser true                               # enable a flag",
+  );
+  console.log(
+    "  $ cadet flags set browser true     --assistant eval-1       # target by name/id",
+  );
+}
+
+function createClient(assistantName?: string): AssistantClient {
+  // When `--assistant <name>` is provided, resolve the display name or
+  // explicit ID through the standard lookup helper (see cli/AGENTS.md
+  // "Assistant targeting convention"). Exact ID wins over display-name
+  // matches; ambiguous names fail loudly.
+  let assistantId: string | undefined;
+  if (assistantName) {
+    const result = lookupAssistantByIdentifier(assistantName);
+    if (result.status !== "found") {
+      throw new Error(formatAssistantLookupError(assistantName, result));
+    }
+    assistantId = result.entry.assistantId;
+  }
+  try {
+    return new AssistantClient(assistantId ? { assistantId } : undefined);
+  } catch {
+    throw new Error(
+      assistantName
+        ? `No assistant found matching '${assistantName}'.`
+        : "No assistant found. Hatch one with 'cadet hatch' first.",
+    );
+  }
+}
+
+function rethrowFetchError(err: unknown): never {
+  if (
+    err instanceof TypeError &&
+    (err.message.includes("fetch") || err.message.includes("connect"))
+  ) {
+    throw new Error(
+      `Could not reach the assistant gateway. Is it running? Try 'cadet wake'.${
+        crossEnvironmentAssistantHint() ?? ""
+      }`,
+    );
+  }
+  throw err;
+}
+
+async function listFlags(assistantName?: string): Promise<void> {
+  const client = createClient(assistantName);
+  let res: Response;
+  try {
+    res = await client.get("/feature-flags");
+  } catch (err) {
+    rethrowFetchError(err);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Failed to fetch flags: HTTP ${res.status} ${body}`.trim());
+  }
+  const data = (await res.json()) as FlagsResponse;
+  if (data.flags.length === 0) {
+    console.log("No feature flags found.");
+    return;
+  }
+  printFlagTable(data.flags);
+}
+
+async function getFlag(key: string, assistantName?: string): Promise<void> {
+  const client = createClient(assistantName);
+  let res: Response;
+  try {
+    res = await client.get("/feature-flags");
+  } catch (err) {
+    rethrowFetchError(err);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Failed to fetch flags: HTTP ${res.status} ${body}`.trim());
+  }
+  const data = (await res.json()) as FlagsResponse;
+  const flag = data.flags.find((f) => f.key === key);
+  if (!flag) {
+    throw new Error(`Flag "${key}" not found.`);
+  }
+  console.log(`Key:            ${flag.key}`);
+  console.log(`Enabled:        ${flag.enabled}`);
+  console.log(`Default:        ${flag.defaultEnabled}`);
+  console.log(`Description:    ${flag.description || "(none)"}`);
+}
+
+async function setFlag(
+  key: string,
+  value: boolean,
+  assistantName?: string,
+): Promise<void> {
+  const client = createClient(assistantName);
+  let res: Response;
+  try {
+    res = await client.patch(`/feature-flags/${key}`, { enabled: value });
+  } catch (err) {
+    rethrowFetchError(err);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Failed to set flag: HTTP ${res.status} ${body}`.trim());
+  }
+  console.log(`Flag "${key}" set to ${value}`);
+}
+
+export async function flags(): Promise<void> {
+  const args = process.argv.slice(3);
+
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+
+  const assistantName = extractAssistantFlag(args);
+
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    await listFlags(assistantName);
+    return;
+  }
+
+  if (subcommand === "get") {
+    const key = args[1];
+    if (!key) {
+      console.error("Usage: cadet flags get <key>");
+      process.exit(1);
+    }
+    await getFlag(key, assistantName);
+    return;
+  }
+
+  if (subcommand === "set") {
+    const key = args[1];
+    const rawValue = args[2];
+    if (!key || rawValue === undefined) {
+      console.error("Usage: cadet flags set <key> <true|false>");
+      process.exit(1);
+    }
+    if (rawValue !== "true" && rawValue !== "false") {
+      console.error(`Invalid value "${rawValue}". Must be "true" or "false".`);
+      process.exit(1);
+    }
+    await setFlag(key, rawValue === "true", assistantName);
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${subcommand}`);
+  printHelp();
+  process.exit(1);
+}

package/src/commands/gateway/token.ts

@@ -0,0 +1,81 @@
+import { formatGuardianRefreshCliFailure } from "@mycadet/local-mode";
+
+import {
+  lookupAssistantByIdentifier,
+  formatAssistantLookupError,
+} from "../../lib/assistant-config.js";
+import {
+  loadGuardianToken,
+  refreshGuardianTokenResult,
+} from "../../lib/guardian-token.js";
+
+function printUsage(): void {
+  console.log("Usage: cadet gateway token <subcommand> <assistantId>");
+  console.log("");
+  console.log("Manage gateway authentication tokens.");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  get       Print the current guardian access token");
+  console.log("  refresh   Refresh an expired access token and print it");
+}
+
+export async function gatewayToken(): Promise<void> {
+  const args = process.argv.slice(4);
+  const subcommand = args[0];
+
+  if (subcommand === "--help" || subcommand === "-h" || !subcommand) {
+    printUsage();
+    process.exit(0);
+  }
+
+  if (subcommand !== "get" && subcommand !== "refresh") {
+    console.error(`Unknown subcommand: ${subcommand}`);
+    printUsage();
+    process.exit(1);
+  }
+
+  const assistantId = args[1];
+  if (!assistantId) {
+    console.error("Missing required argument: <assistantId>");
+    printUsage();
+    process.exit(1);
+  }
+
+  const result = lookupAssistantByIdentifier(assistantId);
+  if (result.status !== "found") {
+    console.error(formatAssistantLookupError(assistantId, result));
+    process.exit(1);
+  }
+  const entry = result.entry;
+
+  const tokenData = loadGuardianToken(entry.assistantId);
+  if (!tokenData) {
+    console.error("No guardian token found for this assistant.");
+    process.exit(1);
+  }
+
+  if (subcommand === "get") {
+    console.log(tokenData.accessToken);
+    return;
+  }
+
+  const gatewayUrl = entry.localUrl || entry.runtimeUrl;
+  if (!gatewayUrl) {
+    console.error("No gateway URL found for this assistant.");
+    process.exit(1);
+  }
+
+  const refreshed = await refreshGuardianTokenResult(
+    gatewayUrl,
+    entry.assistantId,
+  );
+  if (!refreshed.ok) {
+    console.error(refreshed.error);
+    console.error(
+      formatGuardianRefreshCliFailure(refreshed.status, refreshed.error),
+    );
+    process.exit(1);
+  }
+
+  console.log(refreshed.token.accessToken);
+}

package/src/commands/gateway.ts

@@ -0,0 +1,29 @@
+import { gatewayToken } from "./gateway/token.js";
+
+function printUsage(): void {
+  console.log("Usage: cadet gateway <subcommand>");
+  console.log("");
+  console.log("Gateway management commands.");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  token    Manage gateway authentication tokens");
+}
+
+export async function gateway(): Promise<void> {
+  const args = process.argv.slice(3);
+  const subcommand = args[0];
+
+  if (subcommand === "--help" || subcommand === "-h" || !subcommand) {
+    printUsage();
+    process.exit(0);
+  }
+
+  if (subcommand === "token") {
+    await gatewayToken();
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${subcommand}`);
+  printUsage();
+  process.exit(1);
+}