@mycadet/cli 0.12.7 → 0.12.8

package/src/commands/ssh.ts

@@ -1,144 +0,0 @@
-import { isManagedCloud } from "../lib/managed-cloud.js";
-import { spawn } from "child_process";
-
-import { extractHostFromUrl, resolveAssistant } from "../lib/assistant-config";
-import { dockerResourceNames } from "../lib/docker";
-import { getPlatformUrl, readPlatformToken } from "../lib/platform-client";
-import { sshAppleContainer } from "../lib/ssh-apple-container";
-import { interactiveSession } from "../lib/terminal-session";
-
-const SSH_OPTS = [
-  "-o",
-  "StrictHostKeyChecking=no",
-  "-o",
-  "UserKnownHostsFile=/dev/null",
-  "-o",
-  "ConnectTimeout=10",
-  "-o",
-  "LogLevel=ERROR",
-];
-
-export const ssh = Object.assign(
-  async function ssh(): Promise<void> {
-  const args = process.argv.slice(3);
-  if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: cadet ssh [<name>]");
-    console.log("");
-    console.log("SSH into a remote assistant instance.");
-    console.log("");
-    console.log("Arguments:");
-    console.log(
-      "  <name>    Name of the assistant to connect to (defaults to latest)",
-    );
-    process.exit(0);
-  }
-
-  const name = process.argv[3];
-  const entry = resolveAssistant(name);
-
-  if (!entry) {
-    if (name) {
-      console.error(`No assistant instance found with name '${name}'.`);
-    } else {
-      console.error("No assistant instance found. Run `cadet hatch` first.");
-    }
-    process.exit(1);
-  }
-
-  const cloud = entry.cloud;
-
-  if (cloud === "local") {
-    console.error(
-      "Cannot SSH into a local assistant. Local assistants run directly on this machine.\n" +
-        `Use 'cadet ps ${entry.assistantId}' to check its processes instead.`,
-    );
-    process.exit(1);
-  }
-
-  if (cloud === "aws") {
-    console.error("SSH to AWS instances is not yet supported.");
-    process.exit(1);
-  }
-
-  // Apple container: connect to the management socket for an interactive shell.
-  if (cloud === "apple-container") {
-    await sshAppleContainer(entry);
-    return;
-  }
-
-  let child;
-
-  if (cloud === "docker") {
-    const res = dockerResourceNames(entry.assistantId);
-    console.log(`🔗 Connecting to ${entry.assistantId} via docker exec...\n`);
-
-    child = spawn(
-      "docker",
-      ["exec", "-it", res.assistantContainer, "/bin/sh"],
-      { stdio: "inherit", windowsHide: true },
-    );
-  } else if (cloud === "gcp") {
-    const project = entry.project;
-    const zone = entry.zone;
-    if (!project || !zone) {
-      console.error(
-        "Error: GCP project and zone not found in assistant config.",
-      );
-      process.exit(1);
-    }
-
-    const sshTarget = entry.sshUser
-      ? `${entry.sshUser}@${entry.assistantId}`
-      : entry.assistantId;
-
-    console.log(`🔗 Connecting to ${entry.assistantId} via gcloud...\n`);
-
-    child = spawn(
-      "gcloud",
-      ["compute", "ssh", sshTarget, `--project=${project}`, `--zone=${zone}`],
-      { stdio: "inherit", windowsHide: true },
-    );
-  } else if (isManagedCloud(cloud)) {
-    const token = readPlatformToken();
-    if (!token) {
-      console.error(
-        "Not logged in. Run `cadet login` first to authenticate with Cadet Cloud.",
-      );
-      process.exit(1);
-    }
-    await interactiveSession({
-      assistantId: entry.assistantId,
-      token,
-      platformUrl: getPlatformUrl(),
-    });
-    return;
-  } else if (cloud === "custom") {
-    const host = extractHostFromUrl(entry.runtimeUrl);
-    const sshUser = entry.sshUser ?? "root";
-    const sshTarget = `${sshUser}@${host}`;
-
-    console.log(`🔗 Connecting to ${entry.assistantId} via ssh...\n`);
-
-    child = spawn("ssh", [...SSH_OPTS, sshTarget], {
-      stdio: "inherit",
-      windowsHide: true,
-    });
-  } else {
-    console.error(`Error: Unknown cloud type '${cloud}'.`);
-    process.exit(1);
-  }
-
-  await new Promise<void>((resolve, reject) => {
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`ssh exited with code ${code}`));
-      }
-    });
-    child.on("error", reject);
-  });
-},
-  { description: "SSH into a remote assistant instance" },
-);
-

package/src/commands/workflows.ts

@@ -1,305 +0,0 @@
-import { extractAssistantFlag, extractValueFlag } from "../lib/arg-utils.js";
-import { AssistantClient } from "../lib/assistant-client.js";
-import {
-  formatAssistantLookupError,
-  lookupAssistantByIdentifier,
-} from "../lib/assistant-config.js";
-
-/**
- * Client-side mirror of the server's wire-run projection
- * (`WorkflowRunWire` from `assistant/src/runtime/routes/workflow-routes.ts`).
- * The CLI is an independent build unit and deliberately does NOT import from
- * `assistant/` (see `cli/src/shared/provider-env-vars.ts`), so the shape is
- * mirrored here. Only the fields the CLI renders are declared — the server may
- * send a superset. Keep in sync with `workflowRunSchema`.
- */
-type WorkflowRun = {
-  id: string;
-  name: string | null;
-  status: string;
-  agentsSpawned: number;
-  inputTokens: number;
-  outputTokens: number;
-  error: string | null;
-  createdAt: number | null;
-  finishedAt: number | null;
-};
-
-type SavedWorkflow = {
-  name: string;
-  description: string;
-  path: string;
-};
-
-function pad(s: string, w: number): string {
-  return s + " ".repeat(Math.max(0, w - s.length));
-}
-
-function fmtTime(ms: number | null): string {
-  return ms == null ? "-" : new Date(ms).toISOString();
-}
-
-function printRunsTable(runs: WorkflowRun[]): void {
-  const headers = {
-    id: "ID",
-    name: "NAME",
-    status: "STATUS",
-    agents: "AGENTS",
-    created: "CREATED",
-  };
-  const rows = runs.map((r) => ({
-    id: r.id,
-    name: r.name ?? "-",
-    status: r.status,
-    agents: String(r.agentsSpawned),
-    created: fmtTime(r.createdAt),
-  }));
-  const all = [headers, ...rows];
-  const w = {
-    id: Math.max(...all.map((r) => r.id.length)),
-    name: Math.max(...all.map((r) => r.name.length)),
-    status: Math.max(...all.map((r) => r.status.length)),
-    agents: Math.max(...all.map((r) => r.agents.length)),
-    created: Math.max(...all.map((r) => r.created.length)),
-  };
-  const formatRow = (r: typeof headers) =>
-    `${pad(r.id, w.id)}  ${pad(r.name, w.name)}  ${pad(r.status, w.status)}  ${pad(r.agents, w.agents)}  ${r.created}`;
-  console.log(formatRow(headers));
-  console.log(
-    `${"-".repeat(w.id)}  ${"-".repeat(w.name)}  ${"-".repeat(w.status)}  ${"-".repeat(w.agents)}  ${"-".repeat(w.created)}`,
-  );
-  for (const row of rows) console.log(formatRow(row));
-}
-
-function printSavedTable(workflows: SavedWorkflow[]): void {
-  const headers = { name: "NAME", description: "DESCRIPTION" };
-  const rows = workflows.map((w) => ({
-    name: w.name,
-    description: w.description,
-  }));
-  const all = [headers, ...rows];
-  const w = {
-    name: Math.max(...all.map((r) => r.name.length)),
-    description: Math.max(...all.map((r) => r.description.length)),
-  };
-  const formatRow = (r: typeof headers) =>
-    `${pad(r.name, w.name)}  ${r.description}`;
-  console.log(formatRow(headers));
-  console.log(`${"-".repeat(w.name)}  ${"-".repeat(w.description)}`);
-  for (const row of rows) console.log(formatRow(row));
-}
-
-function printHelp(): void {
-  console.log("Usage: cadet workflows <subcommand> [options]");
-  console.log("");
-  console.log("Inspect and control workflow runs on the active assistant.");
-  console.log("");
-  console.log("Subcommands:");
-  console.log("  list              List saved (named) workflows");
-  console.log("  runs              List recent workflow runs");
-  console.log("  show <run-id>     Show details for a single run");
-  console.log("  abort <run-id>    Abort an in-flight run");
-  console.log(
-    "  resume <run-id>   Resume an interrupted run (orphaned by a restart)",
-  );
-  console.log("");
-  console.log("Options:");
-  console.log(
-    "  --assistant <name>  Target a specific assistant (display name or ID)",
-  );
-  console.log("  --limit <n>         (runs) Max runs to list");
-  console.log("  --status <status>   (runs) Filter by run status");
-  console.log("  --help, -h          Show this help");
-}
-
-function createClient(assistantName?: string): AssistantClient {
-  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. Is it running? Try 'cadet wake'.",
-    );
-  }
-  throw err;
-}
-
-async function requestJson<T>(
-  client: AssistantClient,
-  method: "get" | "post",
-  path: string,
-  query?: Record<string, string>,
-): Promise<T> {
-  let res: Response;
-  try {
-    res =
-      method === "get"
-        ? await client.get(path, query ? { query } : undefined)
-        : await client.post(path, undefined);
-  } catch (err) {
-    rethrowFetchError(err);
-  }
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(`Request failed: HTTP ${res.status} ${body}`.trim());
-  }
-  return (await res.json()) as T;
-}
-
-async function listSaved(assistantName?: string): Promise<void> {
-  const client = createClient(assistantName);
-  const data = await requestJson<{ workflows: SavedWorkflow[] }>(
-    client,
-    "get",
-    "/workflows",
-  );
-  if (data.workflows.length === 0) {
-    console.log("No saved workflows found.");
-    return;
-  }
-  printSavedTable(data.workflows);
-}
-
-async function listRuns(
-  opts: { limit?: string; status?: string },
-  assistantName?: string,
-): Promise<void> {
-  const client = createClient(assistantName);
-  const query: Record<string, string> = {};
-  if (opts.limit) query.limit = opts.limit;
-  if (opts.status) query.status = opts.status;
-  const data = await requestJson<{ runs: WorkflowRun[] }>(
-    client,
-    "get",
-    "/workflows/runs",
-    Object.keys(query).length ? query : undefined,
-  );
-  if (data.runs.length === 0) {
-    console.log("No workflow runs found.");
-    return;
-  }
-  printRunsTable(data.runs);
-}
-
-async function showRun(runId: string, assistantName?: string): Promise<void> {
-  const client = createClient(assistantName);
-  const run = await requestJson<WorkflowRun>(
-    client,
-    "get",
-    `/workflows/runs/${runId}`,
-  );
-  console.log(`ID:             ${run.id}`);
-  console.log(`Name:           ${run.name ?? "(unnamed)"}`);
-  console.log(`Status:         ${run.status}`);
-  console.log(`Agents spawned: ${run.agentsSpawned}`);
-  console.log(
-    `Tokens:         ${run.inputTokens} in / ${run.outputTokens} out`,
-  );
-  console.log(`Created:        ${fmtTime(run.createdAt)}`);
-  console.log(`Finished:       ${fmtTime(run.finishedAt)}`);
-  if (run.error) console.log(`Error:          ${run.error}`);
-}
-
-async function abortRun(runId: string, assistantName?: string): Promise<void> {
-  const client = createClient(assistantName);
-  await requestJson<{ ok: boolean; runId: string }>(
-    client,
-    "post",
-    `/workflows/runs/${runId}/abort`,
-  );
-  console.log(`Abort signalled for workflow run ${runId}.`);
-}
-
-async function resumeRun(runId: string, assistantName?: string): Promise<void> {
-  const client = createClient(assistantName);
-  await requestJson<{ ok: boolean; runId: string }>(
-    client,
-    "post",
-    `/workflows/runs/${runId}/resume`,
-  );
-  console.log(
-    `Resumed workflow run ${runId}. It replays its completed steps and continues from where it was interrupted.`,
-  );
-}
-
-export const workflows = Object.assign(
-  async function workflows(): Promise<void> {
-  const args = process.argv.slice(3);
-
-  if (args.includes("--help") || args.includes("-h")) {
-    printHelp();
-    return;
-  }
-
-  const assistantName = extractAssistantFlag(args);
-  const limit = extractValueFlag(args, "limit");
-  const status = extractValueFlag(args, "status");
-  const subcommand = args[0];
-
-  if (!subcommand || subcommand === "list") {
-    await listSaved(assistantName);
-    return;
-  }
-
-  if (subcommand === "runs") {
-    await listRuns({ limit, status }, assistantName);
-    return;
-  }
-
-  if (subcommand === "show") {
-    const runId = args[1];
-    if (!runId) {
-      console.error("Usage: cadet workflows show <run-id>");
-      process.exit(1);
-    }
-    await showRun(runId, assistantName);
-    return;
-  }
-
-  if (subcommand === "abort") {
-    const runId = args[1];
-    if (!runId) {
-      console.error("Usage: cadet workflows abort <run-id>");
-      process.exit(1);
-    }
-    await abortRun(runId, assistantName);
-    return;
-  }
-
-  if (subcommand === "resume") {
-    const runId = args[1];
-    if (!runId) {
-      console.error("Usage: cadet workflows resume <run-id>");
-      process.exit(1);
-    }
-    await resumeRun(runId, assistantName);
-    return;
-  }
-
-  console.error(`Unknown subcommand: ${subcommand}`);
-  printHelp();
-  process.exit(1);
-},
-  { description: "Inspect and control workflow runs" },
-);
-

package/src/lib/managed-cloud.ts

@@ -1,3 +0,0 @@
-export function isManagedCloud(cloud: unknown): boolean {
-  return cloud === "cloud" || cloud === "cadet";
-}