aicomputer 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command7 } from "commander";
-import chalk7 from "chalk";
-import { createRequire } from "module";
+import { Command as Command9 } from "commander";
+import chalk8 from "chalk";
+import { readFileSync as readFileSync3 } from "fs";
 import { basename as basename2 } from "path";
 
 // src/commands/access.ts
@@ -159,6 +159,9 @@ async function createComputer(input) {
     body: JSON.stringify(input)
   });
 }
+async function getFilesystemSettings() {
+  return api("/v1/me/filesystem");
+}
 async function getConnectionInfo(computerID) {
   return api(`/v1/computers/${computerID}/connection`);
 }
@@ -216,7 +219,7 @@ function vncURL(computer) {
     return null;
   }
   const domain = computer.primary_web_host.replace(/^[^.]+\./, "");
-  return `https://6080--${computer.handle}.${domain}/vnc.html?autoconnect=1&resize=remote`;
+  return `https://6080--${computer.handle}.${domain}`;
 }
 function terminalURL(computer) {
   if (computer.runtime_family !== "managed-worker") {
@@ -233,21 +236,89 @@ function normalizePrimaryPath(primaryPath) {
   return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
 }
 
+// src/lib/ssh-config.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+var MANAGED_BLOCK_START = "# >>> agentcomputer ssh setup >>>";
+var MANAGED_BLOCK_END = "# <<< agentcomputer ssh setup <<<";
+async function ensureSSHAliasConfig(options) {
+  const sshDir = join2(homedir2(), ".ssh");
+  const configPath = join2(sshDir, "config");
+  await mkdir(sshDir, { recursive: true, mode: 448 });
+  let existing = "";
+  try {
+    existing = await readFile(configPath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const nextBlock = renderManagedBlock(options);
+  const managedBlockPattern = new RegExp(
+    `${escapeRegex(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegex(MANAGED_BLOCK_END)}\\n?`,
+    "m"
+  );
+  let nextContents;
+  if (managedBlockPattern.test(existing)) {
+    nextContents = existing.replace(managedBlockPattern, nextBlock);
+  } else {
+    const normalized = existing.length === 0 ? "" : existing.endsWith("\n") ? existing : `${existing}
+`;
+    nextContents = normalized.length === 0 ? nextBlock : `${normalized}
+${nextBlock}`;
+  }
+  const changed = nextContents !== existing;
+  if (changed) {
+    await writeFile(configPath, nextContents, { mode: 384 });
+  }
+  return {
+    configPath,
+    changed
+  };
+}
+function renderManagedBlock(options) {
+  const user = options.user?.trim() || "agentcomputer";
+  const identityFile = formatIdentityFilePath(options.identityFilePath);
+  return `${MANAGED_BLOCK_START}
+Host ${options.alias}
+  HostName ${options.host}
+  Port ${options.port}
+  User ${user}
+  IdentityFile ${identityFile}
+  IdentitiesOnly yes
+  ServerAliveInterval 30
+  ServerAliveCountMax 4
+${MANAGED_BLOCK_END}
+`;
+}
+function formatIdentityFilePath(path) {
+  const normalized = path.trim();
+  const homePath = `${homedir2()}/`;
+  if (normalized.startsWith(homePath)) {
+    return `~/${normalized.slice(homePath.length)}`;
+  }
+  return normalized.replaceAll(" ", "\\ ");
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/lib/ssh-keys.ts
 import { basename } from "path";
-import { homedir as homedir2 } from "os";
-import { readFile, mkdir } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { readFile as readFile2, mkdir as mkdir2 } from "fs/promises";
 import { execFileSync } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 var DEFAULT_PUBLIC_KEY_PATHS = [
-  `${homedir2()}/.ssh/id_ed25519.pub`,
-  `${homedir2()}/.ssh/id_ecdsa.pub`,
-  `${homedir2()}/.ssh/id_rsa.pub`
+  `${homedir3()}/.ssh/id_ed25519.pub`,
+  `${homedir3()}/.ssh/id_ecdsa.pub`,
+  `${homedir3()}/.ssh/id_rsa.pub`
 ];
 async function ensureDefaultSSHKeyRegistered() {
   for (const path of DEFAULT_PUBLIC_KEY_PATHS) {
     try {
-      const publicKey2 = (await readFile(path, "utf8")).trim();
+      const publicKey2 = (await readFile2(path, "utf8")).trim();
       if (!publicKey2) {
         continue;
       }
@@ -271,7 +342,7 @@ async function ensureDefaultSSHKeyRegistered() {
     }
   }
   const generated = await generateSSHKey();
-  const publicKey = (await readFile(generated.publicKeyPath, "utf8")).trim();
+  const publicKey = (await readFile2(generated.publicKeyPath, "utf8")).trim();
   const key = await api("/v1/ssh-keys", {
     method: "POST",
     body: JSON.stringify({
@@ -286,9 +357,9 @@ async function ensureDefaultSSHKeyRegistered() {
   };
 }
 async function generateSSHKey() {
-  const sshDir = `${homedir2()}/.ssh`;
+  const sshDir = `${homedir3()}/.ssh`;
   if (!existsSync2(sshDir)) {
-    await mkdir(sshDir, { mode: 448 });
+    await mkdir2(sshDir, { mode: 448 });
   }
   const privateKeyPath = `${sshDir}/id_ed25519`;
   const publicKeyPath = `${privateKeyPath}.pub`;
@@ -419,7 +490,11 @@ var openCommand = new Command("open").description("Open a computer in your brows
     process.exit(1);
   }
 });
-var sshCommand = new Command("ssh").description("Open an SSH session to a computer").argument("[id-or-handle]", "Computer id or handle").action(async (identifier) => {
+var sshCommand = new Command("ssh").description("Open an SSH session to a computer").argument("[id-or-handle]", "Computer id or handle").option("--setup", "Register key and configure a global SSH alias").option("--alias <alias>", "SSH host alias", "agentcomputer.ai").option("--host <host>", "SSH gateway host", "ssh.agentcomputer.ai").option("--port <port>", "SSH gateway port", "22").action(async (identifier, options) => {
+  if (options.setup) {
+    await setupSSHAlias(options);
+    return;
+  }
   const spinner = ora(
     identifier ? "Preparing SSH access..." : "Fetching computers..."
   ).start();
@@ -431,9 +506,7 @@ var sshCommand = new Command("ssh").description("Open an SSH session to a comput
     }
     const registered = await ensureDefaultSSHKeyRegistered();
     spinner.succeed(`Connecting to ${chalk2.bold(computer.handle)}`);
-    console.log(
-      chalk2.dim(`  ssh -p ${info.connection.ssh_port} ${info.connection.ssh_user}@${info.connection.ssh_host}`)
-    );
+    console.log(chalk2.dim(`  ${formatSSHCommand(info.connection.ssh_user, info.connection.ssh_host, info.connection.ssh_port)}`));
     console.log();
     await runSSH([
       "-i",
@@ -534,6 +607,69 @@ async function runSSH(args) {
     });
   });
 }
+async function setupSSHAlias(options) {
+  const spinner = ora("Configuring global SSH access...").start();
+  try {
+    const alias = normalizeSSHAlias(options.alias ?? "agentcomputer.ai");
+    const host = normalizeSSHHost(options.host ?? "ssh.agentcomputer.ai");
+    const port = parseSSHPort(options.port ?? "22");
+    const registered = await ensureDefaultSSHKeyRegistered();
+    const configResult = await ensureSSHAliasConfig({
+      alias,
+      host,
+      port,
+      user: "agentcomputer",
+      identityFilePath: registered.privateKeyPath
+    });
+    spinner.succeed(`SSH alias '${alias}' is ready`);
+    console.log();
+    console.log(chalk2.dim(`  SSH config: ${configResult.configPath}`));
+    console.log(chalk2.dim(`  Identity:   ${registered.privateKeyPath}`));
+    console.log();
+    console.log(`  ${chalk2.bold("Shell:")}   ssh ${alias}`);
+    console.log(`  ${chalk2.bold("Direct:")}  ssh <handle>@${alias}`);
+    console.log();
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : "Failed to configure SSH alias");
+    process.exit(1);
+  }
+}
+function normalizeSSHAlias(value) {
+  const alias = value.trim();
+  if (!alias) {
+    throw new Error("ssh alias cannot be empty");
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(alias)) {
+    throw new Error("ssh alias may contain only letters, numbers, dot, dash, or underscore");
+  }
+  return alias;
+}
+function normalizeSSHHost(value) {
+  const host = value.trim();
+  if (!host) {
+    throw new Error("ssh host cannot be empty");
+  }
+  if (host.includes(" ")) {
+    throw new Error("ssh host cannot contain spaces");
+  }
+  return host;
+}
+function parseSSHPort(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
+    throw new Error("ssh port must be between 1 and 65535");
+  }
+  return parsed;
+}
+function formatSSHCommand(user, host, port) {
+  if (!user.trim() || !host.trim()) {
+    return "ssh unavailable";
+  }
+  if (port <= 0 || port === 22) {
+    return `ssh ${user}@${host}`;
+  }
+  return `ssh -p ${port} ${user}@${host}`;
+}
 async function resolveSSHComputer(identifier, spinner) {
   const trimmed = identifier?.trim();
   if (trimmed) {
@@ -578,10 +714,807 @@ function describeSSHChoice(computer) {
   return `${computer.runtime_family}  ${timeAgo(computer.updated_at)}`;
 }
 
-// src/commands/computers.ts
+// src/commands/acp.ts
+import { readFileSync as readFileSync2 } from "fs";
+import readline from "readline";
 import { Command as Command2 } from "commander";
+
+// src/lib/agents.ts
+async function listComputerAgents(computerID) {
+  const response = await api(`/v1/computers/${computerID}/agents`);
+  return response.agents;
+}
+async function listAgentSessions(computerID) {
+  const response = await api(`/v1/computers/${computerID}/agent-sessions`);
+  return response.sessions;
+}
+async function listFleetAgentSessions() {
+  const response = await api("/v1/fleet/agent-sessions");
+  return response.sessions;
+}
+async function createAgentSession(computerID, input) {
+  const response = await api(`/v1/computers/${computerID}/agent-sessions`, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  return response.session;
+}
+async function getAgentSession(computerID, sessionID) {
+  const response = await api(
+    `/v1/computers/${computerID}/agent-sessions/${sessionID}`
+  );
+  return response.session;
+}
+async function promptAgentSession(computerID, sessionID, input) {
+  return api(
+    `/v1/computers/${computerID}/agent-sessions/${sessionID}/prompt`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    }
+  );
+}
+async function cancelAgentSession(computerID, sessionID) {
+  const response = await api(
+    `/v1/computers/${computerID}/agent-sessions/${sessionID}/cancel`,
+    {
+      method: "POST"
+    }
+  );
+  return response.session;
+}
+async function interruptAgentSession(computerID, sessionID) {
+  const response = await api(
+    `/v1/computers/${computerID}/agent-sessions/${sessionID}/interrupt`,
+    {
+      method: "POST"
+    }
+  );
+  return response.session;
+}
+async function deleteAgentSession(computerID, sessionID) {
+  return api(`/v1/computers/${computerID}/agent-sessions/${sessionID}`, {
+    method: "DELETE"
+  });
+}
+async function openAgentSessionEventsStream(computerID, sessionID, options = {}) {
+  const apiKey = getAPIKey();
+  if (!apiKey) {
+    throw new ApiError(401, "not logged in; run 'computer login' first");
+  }
+  const endpoint = new URL(`${getBaseURL()}/v1/computers/${computerID}/agent-sessions/${sessionID}/events`);
+  if (options.lastEventId?.trim()) {
+    endpoint.searchParams.set("last_event_id", options.lastEventId.trim());
+  }
+  const response = await fetch(endpoint, {
+    method: "GET",
+    headers: {
+      Accept: "text/event-stream",
+      Authorization: `Bearer ${apiKey}`
+    },
+    signal: options.signal
+  });
+  if (!response.ok) {
+    const message = await readErrorMessage2(response);
+    throw new ApiError(response.status, message);
+  }
+  return response;
+}
+async function waitForSessionToSettle(computerID, sessionID, promptID, options = {}) {
+  const intervalMs = options.intervalMs ?? 1e3;
+  const timeoutMs = options.timeoutMs ?? 30 * 60 * 1e3;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const session = await getAgentSession(computerID, sessionID);
+    if (session.status !== "running" && session.status !== "cancelling" && (!promptID || session.active_prompt_id !== promptID)) {
+      return session;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error("timed out waiting for agent session to finish");
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+async function readErrorMessage2(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      const payload = await response.json();
+      return payload.error ?? JSON.stringify(payload);
+    } catch {
+      return response.statusText || "request failed";
+    }
+  }
+  const body = await response.text();
+  return body || response.statusText || "request failed";
+}
+
+// src/commands/acp.ts
+var pkg = JSON.parse(
+  readFileSync2(new URL("../package.json", import.meta.url), "utf8")
+);
+function emit(message) {
+  process.stdout.write(`${JSON.stringify(message)}
+`);
+}
+function emitResult(id, result) {
+  if (id === void 0 || id === null) {
+    return;
+  }
+  emit({
+    jsonrpc: "2.0",
+    id,
+    result
+  });
+}
+function emitError(id, code, message) {
+  emit({
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: {
+      code,
+      message
+    }
+  });
+}
+function forwardBridgePayload(payload, publicSessionID, backendSessionID) {
+  let message;
+  try {
+    message = JSON.parse(payload);
+  } catch {
+    return;
+  }
+  const method = typeof message.method === "string" ? message.method : "";
+  if (method !== "session/update" && method !== "session/request_permission") {
+    return;
+  }
+  const params = typeof message.params === "object" && message.params !== null ? { ...message.params } : {};
+  const payloadSessionID = typeof params.sessionId === "string" ? params.sessionId.trim() : "";
+  if (backendSessionID?.trim() && payloadSessionID && payloadSessionID !== backendSessionID.trim()) {
+    return;
+  }
+  params.sessionId = publicSessionID;
+  process.stdout.write(`${JSON.stringify({ ...message, params })}
+`);
+}
+async function forwardRawEventStream(computerID, publicSessionID, backendSessionID, signal) {
+  const response = await openAgentSessionEventsStream(computerID, publicSessionID, { signal });
+  if (!response.body) {
+    return;
+  }
+  const decoder = new TextDecoder();
+  const reader = response.body.getReader();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      return;
+    }
+    buffer += decoder.decode(value, { stream: true }).replaceAll("\r\n", "\n");
+    while (true) {
+      const splitIndex = buffer.indexOf("\n\n");
+      if (splitIndex === -1) {
+        break;
+      }
+      const chunk = buffer.slice(0, splitIndex);
+      buffer = buffer.slice(splitIndex + 2);
+      const payload = chunk.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+      if (!payload || payload === "heartbeat") {
+        continue;
+      }
+      forwardBridgePayload(payload, publicSessionID, backendSessionID);
+    }
+  }
+}
+async function ensureBridgeSession(computerID, agent, baseName, cwd, requestCwd, counter) {
+  const resolvedCwd = typeof requestCwd === "string" && requestCwd.trim() ? requestCwd.trim() : cwd;
+  return createAgentSession(computerID, {
+    agent,
+    name: `${baseName}-${counter}`,
+    cwd: resolvedCwd,
+    resume: false
+  });
+}
+async function handlePromptRequest(computerID, sessionID, id, params) {
+  if (id === void 0 || id === null) {
+    throw new Error("session/prompt requires a request id");
+  }
+  const prompt = Array.isArray(params?.prompt) ? params?.prompt : [];
+  if (prompt.length === 0) {
+    throw new Error("session/prompt requires prompt content");
+  }
+  const accepted = await promptAgentSession(computerID, sessionID, { prompt });
+  const current = await getAgentSession(computerID, sessionID);
+  const controller = new AbortController();
+  const streamPromise = forwardRawEventStream(
+    computerID,
+    sessionID,
+    current.backend_session_id,
+    controller.signal
+  ).catch((error) => {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    return;
+  });
+  try {
+    const settled = await waitForSessionToSettle(computerID, sessionID, accepted.prompt_id);
+    emitResult(id, {
+      stopReason: settled.last_stop_reason || "end_turn"
+    });
+  } finally {
+    controller.abort();
+    await streamPromise.catch(() => void 0);
+  }
+}
+var acpCommand = new Command2("acp").description("Expose Agent Computer sessions through a local ACP bridge");
+acpCommand.command("serve").description("Serve a local stdio ACP bridge backed by one machine").argument("<machine>", "Computer id or handle").requiredOption("--agent <agent>", "Agent id to use for remote sessions").option("--name <name>", "Base session name prefix", "acp").option("--cwd <cwd>", "Default working directory").action(async (identifier, options) => {
+  try {
+    const computer = await resolveComputer(identifier);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      crlfDelay: Infinity
+    });
+    let nextSession = 0;
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      let message;
+      try {
+        message = JSON.parse(trimmed);
+      } catch {
+        emitError(null, -32700, "invalid JSON");
+        continue;
+      }
+      try {
+        switch (message.method) {
+          case "initialize": {
+            emitResult(message.id, {
+              protocolVersion: 1,
+              agentInfo: {
+                name: "computer-acp-bridge",
+                version: pkg.version ?? "0.0.0"
+              },
+              serverInfo: {
+                name: "computer-acp-bridge",
+                version: pkg.version ?? "0.0.0"
+              },
+              agentCapabilities: {
+                loadSession: true,
+                sessionCapabilities: {
+                  list: {}
+                }
+              },
+              capabilities: {}
+            });
+            break;
+          }
+          case "session/list": {
+            const sessions = await listAgentSessions(computer.id);
+            const requestedCwd = typeof message.params?.cwd === "string" ? message.params.cwd.trim() : "";
+            emitResult(message.id, {
+              sessions: sessions.filter((session) => session.agent === options.agent).filter((session) => !requestedCwd || session.cwd === requestedCwd).map((session) => ({
+                sessionId: session.id,
+                cwd: session.cwd,
+                title: session.name || void 0,
+                updatedAt: session.updated_at
+              }))
+            });
+            break;
+          }
+          case "session/new": {
+            nextSession += 1;
+            const session = await ensureBridgeSession(
+              computer.id,
+              options.agent,
+              options.name?.trim() || "acp",
+              options.cwd,
+              message.params?.cwd,
+              nextSession
+            );
+            emitResult(message.id, {
+              sessionId: session.id
+            });
+            break;
+          }
+          case "session/load": {
+            if (typeof message.params?.sessionId !== "string" || !message.params.sessionId.trim()) {
+              throw new Error("session/load requires sessionId");
+            }
+            await getAgentSession(computer.id, message.params.sessionId.trim());
+            emitResult(message.id, {});
+            break;
+          }
+          case "session/prompt": {
+            if (typeof message.params?.sessionId !== "string" || !message.params.sessionId.trim()) {
+              throw new Error("session/prompt requires sessionId");
+            }
+            await handlePromptRequest(computer.id, message.params.sessionId.trim(), message.id, message.params);
+            break;
+          }
+          case "session/cancel": {
+            if (typeof message.params?.sessionId !== "string" || !message.params.sessionId.trim()) {
+              throw new Error("session/cancel requires sessionId");
+            }
+            await cancelAgentSession(computer.id, message.params.sessionId.trim());
+            emitResult(message.id, {});
+            break;
+          }
+          default:
+            emitError(message.id, -32601, `method not found: ${message.method ?? "<unknown>"}`);
+            break;
+        }
+      } catch (error) {
+        emitError(
+          message.id,
+          -32e3,
+          error instanceof Error ? error.message : "request failed"
+        );
+      }
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Failed to start ACP bridge");
+    process.exit(1);
+  }
+});
+
+// src/commands/agent.ts
+import { Command as Command3 } from "commander";
 import chalk3 from "chalk";
 import ora2 from "ora";
+function formatAgentSessionStatus(status) {
+  switch (status) {
+    case "idle":
+      return chalk3.green(status);
+    case "running":
+      return chalk3.blue(status);
+    case "cancelling":
+      return chalk3.yellow(status);
+    case "interrupted":
+      return chalk3.yellow(status);
+    case "failed":
+      return chalk3.red(status);
+    case "closed":
+      return chalk3.gray(status);
+    default:
+      return status;
+  }
+}
+function printAgents(agents) {
+  const idWidth = Math.max(5, ...agents.map((agent) => agent.id.length));
+  console.log();
+  console.log(
+    `  ${chalk3.dim(padEnd("Agent", idWidth + 2))}${chalk3.dim(padEnd("Installed", 12))}${chalk3.dim(padEnd("Creds", 8))}${chalk3.dim("Version")}`
+  );
+  console.log(
+    `  ${chalk3.dim("-".repeat(idWidth + 2))}${chalk3.dim("-".repeat(12))}${chalk3.dim("-".repeat(8))}${chalk3.dim("-".repeat(12))}`
+  );
+  for (const agent of agents) {
+    console.log(
+      `  ${padEnd(agent.id, idWidth + 2)}${padEnd(agent.installed ? chalk3.green("yes") : chalk3.gray("no"), 12)}${padEnd(agent.credentialsAvailable ? chalk3.green("yes") : chalk3.yellow("no"), 8)}${agent.version ?? chalk3.dim("unknown")}`
+    );
+  }
+  console.log();
+}
+function printSessions(sessions, handleByComputerID = /* @__PURE__ */ new Map()) {
+  if (sessions.length === 0) {
+    console.log();
+    console.log(chalk3.dim("  No agent sessions found."));
+    console.log();
+    return;
+  }
+  const nameWidth = Math.max(7, ...sessions.map((session) => (session.name || "default").length));
+  const agentWidth = Math.max(5, ...sessions.map((session) => session.agent.length));
+  const statusWidth = 13;
+  console.log();
+  console.log(
+    `  ${chalk3.dim(padEnd("Session", 14))}${chalk3.dim(padEnd("Name", nameWidth + 2))}${chalk3.dim(padEnd("Agent", agentWidth + 2))}${chalk3.dim(padEnd("Status", statusWidth + 2))}${chalk3.dim("Location")}`
+  );
+  console.log(
+    `  ${chalk3.dim("-".repeat(14))}${chalk3.dim("-".repeat(nameWidth + 2))}${chalk3.dim("-".repeat(agentWidth + 2))}${chalk3.dim("-".repeat(statusWidth + 2))}${chalk3.dim("-".repeat(20))}`
+  );
+  for (const session of sessions) {
+    const location = handleByComputerID.get(session.computer_id) ?? session.computer_id;
+    console.log(
+      `  ${padEnd(session.id.slice(0, 12), 14)}${padEnd(session.name || "default", nameWidth + 2)}${padEnd(session.agent, agentWidth + 2)}${padEnd(formatAgentSessionStatus(session.status), statusWidth + 2)}${location}`
+    );
+    console.log(`  ${chalk3.dim(`  cwd=${session.cwd}  updated=${timeAgo(session.updated_at)}`)}`);
+    if (session.last_stop_reason || session.last_error) {
+      console.log(`  ${chalk3.dim(`  ${session.last_error ? `error=${session.last_error}` : `stop=${session.last_stop_reason}`}`)}`);
+    }
+  }
+  console.log();
+}
+var StreamPrinter = class {
+  inlineOpen = false;
+  writeText(text) {
+    if (!text) return;
+    process.stdout.write(text);
+    this.inlineOpen = !text.endsWith("\n");
+  }
+  writeDim(text) {
+    this.ensureBreak();
+    process.stdout.write(chalk3.dim(text));
+    this.inlineOpen = !text.endsWith("\n");
+  }
+  writeLine(text) {
+    this.ensureBreak();
+    console.log(text);
+    this.inlineOpen = false;
+  }
+  ensureBreak() {
+    if (!this.inlineOpen) {
+      return;
+    }
+    process.stdout.write("\n");
+    this.inlineOpen = false;
+  }
+};
+async function streamSessionEvents(computerID, sessionID, options = {}) {
+  const response = await openAgentSessionEventsStream(computerID, sessionID, {
+    lastEventId: options.lastEventId?.trim() || void 0,
+    signal: options.signal
+  });
+  if (!response.body) {
+    return;
+  }
+  const decoder = new TextDecoder();
+  const reader = response.body.getReader();
+  const printer = new StreamPrinter();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true }).replaceAll("\r\n", "\n");
+    while (true) {
+      const splitIndex = buffer.indexOf("\n\n");
+      if (splitIndex === -1) {
+        break;
+      }
+      const chunk = buffer.slice(0, splitIndex);
+      buffer = buffer.slice(splitIndex + 2);
+      renderSSEChunk(chunk, printer, options.json === true);
+    }
+  }
+  printer.ensureBreak();
+}
+function renderSSEChunk(chunk, printer, asJson) {
+  const dataLines = chunk.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
+  if (dataLines.length === 0) {
+    return;
+  }
+  const payload = dataLines.join("\n").trim();
+  if (!payload || payload === "heartbeat") {
+    return;
+  }
+  if (asJson) {
+    try {
+      const parsed = JSON.parse(payload);
+      console.log(JSON.stringify(parsed));
+    } catch {
+      console.log(payload);
+    }
+    return;
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(payload);
+  } catch {
+    printer.writeLine(chalk3.dim(payload));
+    return;
+  }
+  const method = typeof envelope.method === "string" ? envelope.method : "";
+  if (method === "session/update") {
+    const params = envelope.params;
+    const update = params?.update;
+    const sessionUpdate = typeof update?.sessionUpdate === "string" ? update.sessionUpdate : "";
+    switch (sessionUpdate) {
+      case "agent_message_chunk": {
+        const content = update?.content;
+        if (content?.type === "text" && content.text) {
+          printer.writeText(content.text);
+        }
+        return;
+      }
+      case "agent_thought_chunk": {
+        const content = update?.content;
+        if (content?.type === "text" && content.text) {
+          printer.writeDim(content.text);
+        }
+        return;
+      }
+      case "tool_call":
+      case "tool_call_update": {
+        const title = typeof update?.title === "string" && update.title ? update.title : "tool";
+        const status = typeof update?.status === "string" && update.status ? update.status : "in_progress";
+        printer.writeLine(chalk3.dim(`[tool:${status}] ${title}`));
+        return;
+      }
+      case "plan": {
+        const entries = Array.isArray(update?.entries) ? update.entries : [];
+        const detail = entries.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => `- [${entry.status ?? "pending"}] ${entry.content ?? ""}`).join("\n");
+        if (detail) {
+          printer.writeLine(chalk3.dim(`Plan
+${detail}`));
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  if (method === "session/request_permission") {
+    printer.writeLine(chalk3.yellow("Permission requested by remote agent"));
+    return;
+  }
+}
+async function resolvePromptSession(computerID, options) {
+  if (options.session?.trim()) {
+    return getAgentSession(computerID, options.session.trim());
+  }
+  if (!options.agent?.trim()) {
+    throw new Error("either --session or --agent is required");
+  }
+  return createAgentSession(computerID, {
+    agent: options.agent.trim(),
+    name: options.name?.trim() || "default",
+    cwd: options.cwd?.trim(),
+    resume: true
+  });
+}
+var agentCommand = new Command3("agent").description("Manage cloud agent sessions");
+agentCommand.command("agents").description("List available agents on a machine").argument("<machine>", "Computer id or handle").option("--json", "Print raw JSON").action(async (identifier, options) => {
+  const spinner = options.json ? null : ora2("Fetching machine agents...").start();
+  try {
+    const computer = await resolveComputer(identifier);
+    const agents = await listComputerAgents(computer.id);
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ agents }, null, 2));
+      return;
+    }
+    printAgents(agents);
+  } catch (error) {
+    spinner?.fail(error instanceof Error ? error.message : "Failed to fetch agents");
+    if (!spinner) {
+      console.error(error instanceof Error ? error.message : "Failed to fetch agents");
+    }
+    process.exit(1);
+  }
+});
+var sessionsCommand = new Command3("sessions").description("Manage agent sessions on one machine");
+sessionsCommand.command("list").description("List agent sessions for a machine").argument("<machine>", "Computer id or handle").option("--json", "Print raw JSON").action(async (identifier, options) => {
+  const spinner = options.json ? null : ora2("Fetching agent sessions...").start();
+  try {
+    const computer = await resolveComputer(identifier);
+    const sessions = await listAgentSessions(computer.id);
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ sessions }, null, 2));
+      return;
+    }
+    printSessions(sessions, /* @__PURE__ */ new Map([[computer.id, computer.handle]]));
+  } catch (error) {
+    spinner?.fail(error instanceof Error ? error.message : "Failed to fetch sessions");
+    if (!spinner) {
+      console.error(error instanceof Error ? error.message : "Failed to fetch sessions");
+    }
+    process.exit(1);
+  }
+});
+sessionsCommand.command("new").description("Create or resume an agent session on a machine").argument("<machine>", "Computer id or handle").requiredOption("--agent <agent>", "Agent id").option("--name <name>", "Session name", "default").option("--cwd <cwd>", "Session working directory").option("--no-resume", "Always create a new session").option("--json", "Print raw JSON").action(async (identifier, options) => {
+  const spinner = options.json ? null : ora2("Creating agent session...").start();
+  try {
+    const computer = await resolveComputer(identifier);
+    const session = await createAgentSession(computer.id, {
+      agent: options.agent,
+      name: options.name,
+      cwd: options.cwd,
+      resume: options.resume
+    });
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ session }, null, 2));
+      return;
+    }
+    printSessions([session], /* @__PURE__ */ new Map([[computer.id, computer.handle]]));
+  } catch (error) {
+    spinner?.fail(error instanceof Error ? error.message : "Failed to create session");
+    if (!spinner) {
+      console.error(error instanceof Error ? error.message : "Failed to create session");
+    }
+    process.exit(1);
+  }
+});
+agentCommand.addCommand(sessionsCommand);
+agentCommand.command("prompt").description("Send a prompt to a machine agent session").argument("<machine>", "Computer id or handle").argument("<text>", "Prompt text").option("--session <id>", "Existing session id").option("--agent <agent>", "Agent to use when creating/resuming a session").option("--name <name>", "Session name when creating/resuming", "default").option("--cwd <cwd>", "Session working directory when creating/resuming").option("--no-stream", "Do not stream session events while waiting").option("--json", "Print raw JSON").action(async (identifier, text, options) => {
+  const spinner = options.json ? null : ora2("Preparing agent prompt...").start();
+  const controller = new AbortController();
+  let streamPromise;
+  try {
+    const computer = await resolveComputer(identifier);
+    const session = await resolvePromptSession(computer.id, options);
+    spinner?.stop();
+    const canStreamImmediately = !options.noStream && Boolean(session.backend_session_id?.trim());
+    if (canStreamImmediately) {
+      streamPromise = streamSessionEvents(computer.id, session.id, {
+        json: options.json,
+        signal: controller.signal
+      }).catch((error) => {
+        if (error instanceof Error && error.name === "AbortError") {
+          return;
+        }
+        return;
+      });
+      await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+    const promptResponse = await promptAgentSession(computer.id, session.id, {
+      prompt: [{ type: "text", text }]
+    });
+    if (!options.noStream && !canStreamImmediately) {
+      streamPromise = streamSessionEvents(computer.id, session.id, {
+        json: options.json,
+        signal: controller.signal
+      }).catch((error) => {
+        if (error instanceof Error && error.name === "AbortError") {
+          return;
+        }
+        return;
+      });
+    }
+    const settled = await waitForSessionToSettle(computer.id, session.id, promptResponse.prompt_id);
+    controller.abort();
+    if (streamPromise) {
+      await streamPromise;
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ prompt: promptResponse, session: settled }, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${chalk3.bold(session.name || "default")}  ${formatAgentSessionStatus(settled.status)}`);
+    if (settled.last_stop_reason) {
+      console.log(chalk3.dim(`  stop_reason=${settled.last_stop_reason}`));
+    }
+    if (settled.last_error) {
+      console.log(chalk3.red(`  error=${settled.last_error}`));
+    }
+    console.log();
+  } catch (error) {
+    controller.abort();
+    if (spinner) {
+      spinner.fail(error instanceof Error ? error.message : "Failed to prompt agent session");
+    } else {
+      console.error(error instanceof Error ? error.message : "Failed to prompt agent session");
+    }
+    process.exit(1);
+  }
+});
+agentCommand.command("watch").description("Watch a machine agent session event stream").argument("<machine>", "Computer id or handle").requiredOption("--session <id>", "Session id").option("--last-event-id <id>", "Replay buffered events after this event id").option("--json", "Print raw event envelopes").action(async (identifier, options) => {
+  try {
+    const computer = await resolveComputer(identifier);
+    if (options.lastEventId && !/^[1-9]\d*$/.test(options.lastEventId.trim())) {
+      throw new Error("--last-event-id must be a positive integer");
+    }
+    await streamSessionEvents(computer.id, options.session.trim(), {
+      lastEventId: options.lastEventId,
+      json: options.json
+    });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Failed to watch session");
+    process.exit(1);
+  }
+});
+agentCommand.command("status").description("Show one session or list sessions on a machine").argument("<machine>", "Computer id or handle").option("--session <id>", "Session id").option("--json", "Print raw JSON").action(async (identifier, options) => {
+  const spinner = options.json ? null : ora2("Fetching session status...").start();
+  try {
+    const computer = await resolveComputer(identifier);
+    if (options.session) {
+      const session = await getAgentSession(computer.id, options.session.trim());
+      spinner?.stop();
+      if (options.json) {
+        console.log(JSON.stringify({ session }, null, 2));
+        return;
+      }
+      printSessions([session], /* @__PURE__ */ new Map([[computer.id, computer.handle]]));
+      return;
+    }
+    const sessions = await listAgentSessions(computer.id);
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ sessions }, null, 2));
+      return;
+    }
+    printSessions(sessions, /* @__PURE__ */ new Map([[computer.id, computer.handle]]));
+  } catch (error) {
+    spinner?.fail(error instanceof Error ? error.message : "Failed to fetch session status");
+    if (!spinner) {
+      console.error(error instanceof Error ? error.message : "Failed to fetch session status");
+    }
+    process.exit(1);
+  }
+});
+agentCommand.command("cancel").description("Send session/cancel to a machine agent session").argument("<machine>", "Computer id or handle").requiredOption("--session <id>", "Session id").option("--json", "Print raw JSON").action(async (identifier, options) => {
+  const spinner = options.json ? null : ora2("Cancelling agent session...").start();
+  try {
+    const computer = await resolveComputer(identifier);
+    const session = await cancelAgentSession(computer.id, options.session.trim());
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ session }, null, 2));
+      return;
+    }
+    printSessions([session], /* @__PURE__ */ new Map([[computer.id, computer.handle]]));
+  } catch (error) {
+    spinner?.fail(error instanceof Error ? error.message : "Failed to cancel session");
+    if (!spinner) {
+      console.error(error instanceof Error ? error.message : "Failed to cancel session");
+    }
+    process.exit(1);
+  }
+});
+agentCommand.command("interrupt").description("Force-stop a machine agent session runtime").argument("<machine>", "Computer id or handle").requiredOption("--session <id>", "Session id").option("--json", "Print raw JSON").action(async (identifier, options) => {
+  const spinner = options.json ? null : ora2("Interrupting agent session...").start();
+  try {
+    const computer = await resolveComputer(identifier);
+    const session = await interruptAgentSession(computer.id, options.session.trim());
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ session }, null, 2));
+      return;
+    }
+    printSessions([session], /* @__PURE__ */ new Map([[computer.id, computer.handle]]));
+  } catch (error) {
+    spinner?.fail(error instanceof Error ? error.message : "Failed to interrupt session");
+    if (!spinner) {
+      console.error(error instanceof Error ? error.message : "Failed to interrupt session");
+    }
+    process.exit(1);
+  }
+});
+agentCommand.command("close").description("Close and delete a machine agent session").argument("<machine>", "Computer id or handle").requiredOption("--session <id>", "Session id").action(async (identifier, options) => {
+  const spinner = ora2("Closing agent session...").start();
+  try {
+    const computer = await resolveComputer(identifier);
+    await deleteAgentSession(computer.id, options.session.trim());
+    spinner.succeed("Agent session closed");
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : "Failed to close session");
+    process.exit(1);
+  }
+});
+var fleetCommand = new Command3("fleet").description("View agent activity across your fleet");
+fleetCommand.command("status").description("List open agent sessions across all machines").option("--json", "Print raw JSON").action(async (options) => {
+  const spinner = options.json ? null : ora2("Fetching fleet status...").start();
+  try {
+    const [sessions, computers] = await Promise.all([
+      listFleetAgentSessions(),
+      listComputers()
+    ]);
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ sessions }, null, 2));
+      return;
+    }
+    const handleByComputerID = new Map(computers.map((computer) => [computer.id, computer.handle]));
+    printSessions(sessions, handleByComputerID);
+  } catch (error) {
+    spinner?.fail(error instanceof Error ? error.message : "Failed to fetch fleet status");
+    if (!spinner) {
+      console.error(error instanceof Error ? error.message : "Failed to fetch fleet status");
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/computers.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora3 from "ora";
 import { select as select2, input as textInput, confirm } from "@inquirer/prompts";
 function isInternalCondition(value) {
   return /^[A-Z][a-zA-Z]+$/.test(value);
@@ -589,53 +1522,62 @@ function isInternalCondition(value) {
 function printComputer(computer) {
   const vnc = vncURL(computer);
   const terminal = terminalURL(computer);
-  const ssh = computer.ssh_enabled ? `ssh -p ${computer.ssh_port} ${computer.handle}@${computer.ssh_host}` : "disabled";
+  const ssh = computer.ssh_enabled ? formatSSHCommand2(computer.handle, computer.ssh_host, computer.ssh_port) : "disabled";
   const isCustom = computer.runtime_family === "custom-machine";
   console.log();
-  console.log(`  ${chalk3.bold.white(computer.handle)}  ${formatStatus(computer.status)}`);
+  console.log(`  ${chalk4.bold.white(computer.handle)}  ${formatStatus(computer.status)}`);
   console.log();
-  console.log(`  ${chalk3.dim("ID")}        ${computer.id}`);
-  console.log(`  ${chalk3.dim("Tier")}      ${computer.tier}`);
+  console.log(`  ${chalk4.dim("ID")}        ${computer.id}`);
+  console.log(`  ${chalk4.dim("Tier")}      ${computer.tier}`);
   if (isCustom) {
-    console.log(`  ${chalk3.dim("Runtime")}   ${computer.runtime_family}`);
-    console.log(`  ${chalk3.dim("Source")}    ${computer.source_kind}`);
-    console.log(`  ${chalk3.dim("Image")}     ${computer.image_family}`);
+    console.log(`  ${chalk4.dim("Runtime")}   ${computer.runtime_family}`);
+    console.log(`  ${chalk4.dim("Source")}    ${computer.source_kind}`);
+    console.log(`  ${chalk4.dim("Image")}     ${computer.image_family}`);
   }
-  console.log(`  ${chalk3.dim("Primary")}   :${computer.primary_port}${computer.primary_path}`);
-  console.log(`  ${chalk3.dim("Health")}    ${computer.healthcheck_type}${computer.healthcheck_value ? ` (${computer.healthcheck_value})` : ""}`);
+  console.log(`  ${chalk4.dim("Primary")}   :${computer.primary_port}${computer.primary_path}`);
+  console.log(`  ${chalk4.dim("Health")}    ${computer.healthcheck_type}${computer.healthcheck_value ? ` (${computer.healthcheck_value})` : ""}`);
   console.log();
-  console.log(`  ${chalk3.dim("Gateway")}   ${chalk3.cyan(webURL(computer))}`);
-  console.log(`  ${chalk3.dim("VNC")}       ${vnc ? chalk3.cyan(vnc) : chalk3.dim("not available")}`);
-  console.log(`  ${chalk3.dim("Terminal")}  ${terminal ? chalk3.cyan(terminal) : chalk3.dim("not available")}`);
-  console.log(`  ${chalk3.dim("SSH")}       ${computer.ssh_enabled ? chalk3.white(ssh) : chalk3.dim(ssh)}`);
+  console.log(`  ${chalk4.dim("Gateway")}   ${chalk4.cyan(webURL(computer))}`);
+  console.log(`  ${chalk4.dim("VNC")}       ${vnc ? chalk4.cyan(vnc) : chalk4.dim("not available")}`);
+  console.log(`  ${chalk4.dim("Terminal")}  ${terminal ? chalk4.cyan(terminal) : chalk4.dim("not available")}`);
+  console.log(`  ${chalk4.dim("SSH")}       ${computer.ssh_enabled ? chalk4.white(ssh) : chalk4.dim(ssh)}`);
   if (computer.last_error) {
     console.log();
     if (isInternalCondition(computer.last_error)) {
-      console.log(`  ${chalk3.dim("Condition")} ${chalk3.dim(computer.last_error)}`);
+      console.log(`  ${chalk4.dim("Condition")} ${chalk4.dim(computer.last_error)}`);
     } else {
-      console.log(`  ${chalk3.dim("Error")}     ${chalk3.red(computer.last_error)}`);
+      console.log(`  ${chalk4.dim("Error")}     ${chalk4.red(computer.last_error)}`);
     }
   }
   console.log();
-  console.log(`  ${chalk3.dim("Created")}   ${timeAgo(computer.created_at)}`);
+  console.log(`  ${chalk4.dim("Created")}   ${timeAgo(computer.created_at)}`);
   console.log();
 }
+function formatSSHCommand2(user, host, port) {
+  if (!user.trim() || !host.trim()) {
+    return "ssh unavailable";
+  }
+  if (port <= 0 || port === 22) {
+    return `ssh ${user}@${host}`;
+  }
+  return `ssh -p ${port} ${user}@${host}`;
+}
 function printComputerTable(computers) {
   const handleWidth = Math.max(6, ...computers.map((c) => c.handle.length));
   const statusWidth = 12;
   const createdWidth = 10;
   console.log();
   console.log(
-    `  ${chalk3.dim(padEnd("Handle", handleWidth + 2))}${chalk3.dim(padEnd("Status", statusWidth + 2))}${chalk3.dim(padEnd("Created", createdWidth + 2))}${chalk3.dim("URL")}`
+    `  ${chalk4.dim(padEnd("Handle", handleWidth + 2))}${chalk4.dim(padEnd("Status", statusWidth + 2))}${chalk4.dim(padEnd("Created", createdWidth + 2))}${chalk4.dim("URL")}`
   );
   console.log(
-    `  ${chalk3.dim("-".repeat(handleWidth + 2))}${chalk3.dim("-".repeat(statusWidth + 2))}${chalk3.dim("-".repeat(createdWidth + 2))}${chalk3.dim("-".repeat(20))}`
+    `  ${chalk4.dim("-".repeat(handleWidth + 2))}${chalk4.dim("-".repeat(statusWidth + 2))}${chalk4.dim("-".repeat(createdWidth + 2))}${chalk4.dim("-".repeat(20))}`
   );
   for (const computer of computers) {
     const status = formatStatus(computer.status);
-    const created = chalk3.dim(timeAgo(computer.created_at));
+    const created = chalk4.dim(timeAgo(computer.created_at));
     console.log(
-      `  ${chalk3.white(padEnd(computer.handle, handleWidth + 2))}${padEnd(status, statusWidth + 2)}${padEnd(created, createdWidth + 2)}${chalk3.cyan(webURL(computer))}`
+      `  ${chalk4.white(padEnd(computer.handle, handleWidth + 2))}${padEnd(status, statusWidth + 2)}${padEnd(created, createdWidth + 2)}${chalk4.cyan(webURL(computer))}`
     );
   }
   console.log();
@@ -645,29 +1587,29 @@ function printComputerTableVerbose(computers) {
   const statusWidth = 10;
   console.log();
   console.log(
-    `  ${chalk3.dim(padEnd("Handle", handleWidth + 2))}${chalk3.dim(padEnd("Status", statusWidth + 2))}${chalk3.dim("URLs")}`
+    `  ${chalk4.dim(padEnd("Handle", handleWidth + 2))}${chalk4.dim(padEnd("Status", statusWidth + 2))}${chalk4.dim("URLs")}`
   );
   console.log(
-    `  ${chalk3.dim("-".repeat(handleWidth + 2))}${chalk3.dim("-".repeat(statusWidth + 2))}${chalk3.dim("-".repeat(20))}`
+    `  ${chalk4.dim("-".repeat(handleWidth + 2))}${chalk4.dim("-".repeat(statusWidth + 2))}${chalk4.dim("-".repeat(20))}`
   );
   for (const computer of computers) {
     const status = formatStatus(computer.status);
     const vnc = vncURL(computer);
     const terminal = terminalURL(computer);
     console.log(
-      `  ${chalk3.white(padEnd(computer.handle, handleWidth + 2))}${padEnd(status, statusWidth + 2)}${chalk3.cyan(webURL(computer))}`
+      `  ${chalk4.white(padEnd(computer.handle, handleWidth + 2))}${padEnd(status, statusWidth + 2)}${chalk4.cyan(webURL(computer))}`
     );
     console.log(
-      `  ${padEnd("", handleWidth + 2)}${padEnd("", statusWidth + 2)}${chalk3.dim(vnc ?? "VNC not available")}`
+      `  ${padEnd("", handleWidth + 2)}${padEnd("", statusWidth + 2)}${chalk4.dim(vnc ?? "VNC not available")}`
     );
     console.log(
-      `  ${padEnd("", handleWidth + 2)}${padEnd("", statusWidth + 2)}${chalk3.dim(terminal ?? "Terminal not available")}`
+      `  ${padEnd("", handleWidth + 2)}${padEnd("", statusWidth + 2)}${chalk4.dim(terminal ?? "Terminal not available")}`
     );
   }
   console.log();
 }
-var lsCommand = new Command2("ls").description("List computers").option("--json", "Print raw JSON").option("-v, --verbose", "Show all URLs for each computer").action(async (options) => {
-  const spinner = options.json ? null : ora2("Fetching computers...").start();
+var lsCommand = new Command4("ls").description("List computers").option("--json", "Print raw JSON").option("-v, --verbose", "Show all URLs for each computer").action(async (options) => {
+  const spinner = options.json ? null : ora3("Fetching computers...").start();
   try {
     const computers = await listComputers();
     spinner?.stop();
@@ -677,7 +1619,7 @@ var lsCommand = new Command2("ls").description("List computers").option("--json"
     }
     if (computers.length === 0) {
       console.log();
-      console.log(chalk3.dim("  No computers found."));
+      console.log(chalk4.dim("  No computers found."));
       console.log();
       return;
     }
@@ -697,8 +1639,8 @@ var lsCommand = new Command2("ls").description("List computers").option("--json"
     process.exit(1);
   }
 });
-var getCommand = new Command2("get").description("Show computer details").argument("<id-or-handle>", "Computer id or handle").option("--json", "Print raw JSON").action(async (identifier, options) => {
-  const spinner = options.json ? null : ora2("Fetching computer...").start();
+var getCommand = new Command4("get").description("Show computer details").argument("<id-or-handle>", "Computer id or handle").option("--json", "Print raw JSON").action(async (identifier, options) => {
+  const spinner = options.json ? null : ora3("Fetching computer...").start();
   try {
     const computer = await resolveComputer(identifier);
     spinner?.stop();
@@ -718,25 +1660,31 @@ var getCommand = new Command2("get").description("Show computer details").argume
     process.exit(1);
   }
 });
-var createCommand = new Command2("create").description("Create a computer").argument("[handle]", "Optional computer handle").option("--name <display-name>", "Display name").option("--tier <tier>", "Tier override").option("--interactive", "Prompt for runtime choices").option("--runtime-family <runtime-family>", "managed-worker or custom-machine").option("--source-kind <source-kind>", "none or oci-image").option("--image-family <family>", "Image family override").option("--image-ref <image>", "Resolved image override").option("--primary-port <port>", "Primary app port").option("--primary-path <path>", "Primary app path").option("--healthcheck-type <type>", "http or tcp").option("--healthcheck-value <value>", "Health check path or port").option("--ssh-enabled", "Enable SSH access").option("--ssh-disabled", "Disable SSH access").option("--vnc-enabled", "Enable VNC access").option("--vnc-disabled", "Disable VNC access").action(async (handle, options) => {
+var createCommand = new Command4("create").description("Create a computer").argument("[handle]", "Optional computer handle").option("--name <display-name>", "Display name").option("--tier <tier>", "Tier override").option("--interactive", "Prompt for runtime choices").option("--runtime-family <runtime-family>", "managed-worker or custom-machine").option("--source-kind <source-kind>", "none or oci-image").option("--image-family <family>", "Image family override").option("--image-ref <image>", "Resolved image override").option("--primary-port <port>", "Primary app port").option("--primary-path <path>", "Primary app path").option("--healthcheck-type <type>", "http or tcp").option("--healthcheck-value <value>", "Health check path or port").option("--ssh-enabled", "Enable SSH access").option("--ssh-disabled", "Disable SSH access").option("--vnc-enabled", "Enable VNC access").option("--vnc-disabled", "Disable VNC access").action(async (handle, options) => {
   let spinner;
   let timer;
   let startTime = 0;
   try {
     const selectedOptions = await resolveCreateOptions(options);
-    spinner = ora2("Creating computer...").start();
+    const runtimeFamily = effectiveRuntimeFamily(selectedOptions.runtimeFamily);
+    const filesystemSettings = await loadFilesystemSettingsForCreate(runtimeFamily);
+    const provisioningNote = createProvisioningNote(runtimeFamily, filesystemSettings);
+    if (provisioningNote) {
+      console.log(chalk4.dim(provisioningNote));
+    }
+    spinner = ora3(createSpinnerText(runtimeFamily, filesystemSettings, 0)).start();
     startTime = Date.now();
     timer = setInterval(() => {
-      const elapsed2 = ((Date.now() - startTime) / 1e3).toFixed(1);
+      const elapsed2 = (Date.now() - startTime) / 1e3;
       if (spinner) {
-        spinner.text = `Creating computer... ${chalk3.dim(`${elapsed2}s`)}`;
+        spinner.text = createSpinnerText(runtimeFamily, filesystemSettings, elapsed2);
       }
     }, 100);
     const computer = await createComputer({
       handle,
       display_name: selectedOptions.name,
       tier: selectedOptions.tier,
-      runtime_family: parseRuntimeFamilyOption(selectedOptions.runtimeFamily),
+      runtime_family: runtimeFamily,
       source_kind: parseSourceKindOption(selectedOptions.sourceKind),
       image_family: selectedOptions.imageFamily,
       image_ref: selectedOptions.imageRef,
@@ -760,7 +1708,7 @@ var createCommand = new Command2("create").description("Create a computer").argu
     }
     const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
     spinner.succeed(
-      chalk3.green(`Created ${chalk3.bold(computer.handle)} ${chalk3.dim(`[${elapsed}s]`)}`)
+      chalk4.green(`Created ${chalk4.bold(computer.handle)} ${chalk4.dim(`[${elapsed}s]`)}`)
     );
     printComputer(computer);
   } catch (error) {
@@ -769,10 +1717,10 @@ var createCommand = new Command2("create").description("Create a computer").argu
     }
     const message = error instanceof Error ? error.message : "Failed to create computer";
     if (spinner) {
-      const suffix = startTime ? ` ${chalk3.dim(`[${((Date.now() - startTime) / 1e3).toFixed(1)}s]`)}` : "";
+      const suffix = startTime ? ` ${chalk4.dim(`[${((Date.now() - startTime) / 1e3).toFixed(1)}s]`)}` : "";
       spinner.fail(`${message}${suffix}`);
     } else {
-      console.error(chalk3.red(message));
+      console.error(chalk4.red(message));
     }
     process.exit(1);
   }
@@ -827,28 +1775,28 @@ async function resolveCreateOptions(options) {
   validateCreateOptions(selectedOptions);
   return selectedOptions;
 }
-var removeCommand = new Command2("rm").description("Delete a computer").argument("<id-or-handle>", "Computer id or handle").option("-y, --yes", "Skip confirmation prompt").action(async (identifier, options, cmd) => {
+var removeCommand = new Command4("rm").description("Delete a computer").argument("<id-or-handle>", "Computer id or handle").option("-y, --yes", "Skip confirmation prompt").action(async (identifier, options, cmd) => {
   const globalYes = cmd.parent?.opts()?.yes;
   const skipConfirm = Boolean(options.yes || globalYes);
-  const spinner = ora2("Resolving computer...").start();
+  const spinner = ora3("Resolving computer...").start();
   try {
     const computer = await resolveComputer(identifier);
     spinner.stop();
     if (!skipConfirm && process.stdin.isTTY) {
       const confirmed = await confirm({
-        message: `Delete computer ${chalk3.bold(computer.handle)}?`,
+        message: `Delete computer ${chalk4.bold(computer.handle)}?`,
         default: false
       });
       if (!confirmed) {
-        console.log(chalk3.dim("  Cancelled."));
+        console.log(chalk4.dim("  Cancelled."));
         return;
       }
     }
-    const deleteSpinner = ora2("Deleting computer...").start();
+    const deleteSpinner = ora3("Deleting computer...").start();
     await api(`/v1/computers/${computer.id}`, {
       method: "DELETE"
     });
-    deleteSpinner.succeed(chalk3.green(`Deleted ${chalk3.bold(computer.handle)}`));
+    deleteSpinner.succeed(chalk4.green(`Deleted ${chalk4.bold(computer.handle)}`));
   } catch (error) {
     spinner.fail(
       error instanceof Error ? error.message : "Failed to delete computer"
@@ -866,6 +1814,35 @@ function parseRuntimeFamilyOption(value) {
       throw new Error("--runtime-family must be managed-worker or custom-machine");
   }
 }
+function effectiveRuntimeFamily(value) {
+  return parseRuntimeFamilyOption(value) ?? "managed-worker";
+}
+async function loadFilesystemSettingsForCreate(runtimeFamily) {
+  if (runtimeFamily !== "managed-worker") {
+    return null;
+  }
+  try {
+    return await getFilesystemSettings();
+  } catch {
+    return null;
+  }
+}
+function createProvisioningNote(runtimeFamily, filesystemSettings) {
+  if (runtimeFamily !== "managed-worker") {
+    return null;
+  }
+  if (filesystemSettings?.shared_enabled) {
+    return "Shared home is enabled. Mounting /home/node from EFS can take around 20s.";
+  }
+  return "Using isolated storage for this desktop.";
+}
+function createSpinnerText(runtimeFamily, filesystemSettings, elapsedSeconds) {
+  const elapsedLabel = chalk4.dim(`${elapsedSeconds.toFixed(1)}s`);
+  if (runtimeFamily === "managed-worker" && filesystemSettings?.shared_enabled && elapsedSeconds >= 5) {
+    return `Creating computer... ${elapsedLabel} ${chalk4.dim("mounting shared home")}`;
+  }
+  return `Creating computer... ${elapsedLabel}`;
+}
 function validateCreateOptions(options) {
   const runtimeFamily = parseRuntimeFamilyOption(options.runtimeFamily);
   const sourceKind = parseSourceKindOption(options.sourceKind);
@@ -923,7 +1900,7 @@ function resolveOptionalToggle(enabled, disabled, label) {
 }
 
 // src/commands/completion.ts
-import { Command as Command3 } from "commander";
+import { Command as Command5 } from "commander";
 var ZSH_SCRIPT = `#compdef computer agentcomputer aicomputer
 
 _computer() {
@@ -938,6 +1915,9 @@ _computer() {
     'open:Open in browser'
     'ssh:SSH into a computer'
     'ports:Manage published ports'
+    'agent:Manage cloud agent sessions'
+    'fleet:View agent activity across your fleet'
+    'acp:Run a local ACP bridge for remote agent sessions'
     'rm:Delete a computer'
     'completion:Generate shell completions'
     'help:Display help'
@@ -1064,7 +2044,7 @@ var BASH_SCRIPT = `_computer() {
   local cur prev words cword
   _init_completion || return
 
-  local commands="login logout whoami create ls get open ssh ports rm completion help"
+  local commands="login logout whoami create ls get open ssh ports agent fleet acp rm completion help"
   local ports_commands="ls publish rm"
 
   if [[ $cword -eq 1 ]]; then
@@ -1118,7 +2098,7 @@ var BASH_SCRIPT = `_computer() {
 }
 
 complete -F _computer computer agentcomputer aicomputer`;
-var completionCommand = new Command3("completion").description("Generate shell completions").argument("<shell>", "Shell type (bash or zsh)").action((shell) => {
+var completionCommand = new Command5("completion").description("Generate shell completions").argument("<shell>", "Shell type (bash or zsh)").action((shell) => {
   switch (shell) {
     case "zsh":
       console.log(ZSH_SCRIPT);
@@ -1133,9 +2113,9 @@ var completionCommand = new Command3("completion").description("Generate shell c
 });
 
 // src/commands/login.ts
-import { Command as Command4 } from "commander";
-import chalk4 from "chalk";
-import ora3 from "ora";
+import { Command as Command6 } from "commander";
+import chalk5 from "chalk";
+import ora4 from "ora";
 
 // src/lib/browser-login.ts
 import { randomBytes } from "crypto";
@@ -1363,11 +2343,11 @@ function escapeHTML(value) {
 }
 
 // src/commands/login.ts
-var loginCommand = new Command4("login").description("Authenticate the CLI").option("--api-key <key>", "API key starting with ac_live_").option("--stdin", "Read the API key from stdin").option("-f, --force", "Overwrite an existing stored API key").action(async (options) => {
+var loginCommand = new Command6("login").description("Authenticate the CLI").option("--api-key <key>", "API key starting with ac_live_").option("--stdin", "Read the API key from stdin").option("-f, --force", "Overwrite an existing stored API key").action(async (options) => {
   const existingKey = getStoredAPIKey();
   if (existingKey && !options.force) {
     console.log();
-    console.log(chalk4.yellow("  Already logged in. Use --force to overwrite."));
+    console.log(chalk5.yellow("  Already logged in. Use --force to overwrite."));
     console.log();
     return;
   }
@@ -1375,8 +2355,8 @@ var loginCommand = new Command4("login").description("Authenticate the CLI").opt
   const apiKey = await resolveAPIKeyInput(options.apiKey, options.stdin);
   if (!apiKey && wantsManualLogin) {
     console.log();
-    console.log(chalk4.dim("  Usage: computer login --api-key <ac_live_...>"));
-    console.log(chalk4.dim(`  API:   ${getBaseURL()}`));
+    console.log(chalk5.dim("  Usage: computer login --api-key <ac_live_...>"));
+    console.log(chalk5.dim(`  API:   ${getBaseURL()}`));
     console.log();
     process.exit(1);
   }
@@ -1386,15 +2366,15 @@ var loginCommand = new Command4("login").description("Authenticate the CLI").opt
   }
   if (!apiKey.startsWith("ac_live_")) {
     console.log();
-    console.log(chalk4.red("  API key must start with ac_live_"));
+    console.log(chalk5.red("  API key must start with ac_live_"));
     console.log();
     process.exit(1);
   }
-  const spinner = ora3("Authenticating...").start();
+  const spinner = ora4("Authenticating...").start();
   try {
     const me = await apiWithKey(apiKey, "/v1/me");
     setAPIKey(apiKey);
-    spinner.succeed(`Logged in as ${chalk4.bold(me.user.email)}`);
+    spinner.succeed(`Logged in as ${chalk5.bold(me.user.email)}`);
   } catch (error) {
     spinner.fail(
       error instanceof Error ? error.message : "Failed to validate API key"
@@ -1403,7 +2383,7 @@ var loginCommand = new Command4("login").description("Authenticate the CLI").opt
   }
 });
 async function runBrowserLogin() {
-  const spinner = ora3("Starting browser login...").start();
+  const spinner = ora4("Starting browser login...").start();
   let attempt = null;
   try {
     attempt = await createBrowserLoginAttempt();
@@ -1413,14 +2393,14 @@ async function runBrowserLogin() {
     } catch {
       spinner.stop();
       console.log();
-      console.log(chalk4.yellow("  Browser auto-open failed. Open this URL to continue:"));
-      console.log(chalk4.dim(`  ${attempt.loginURL}`));
+      console.log(chalk5.yellow("  Browser auto-open failed. Open this URL to continue:"));
+      console.log(chalk5.dim(`  ${attempt.loginURL}`));
       console.log();
       spinner.start("Waiting for browser login...");
     }
     spinner.text = "Waiting for browser login...";
     const result = await attempt.waitForResult();
-    spinner.succeed(`Logged in as ${chalk4.bold(result.me.user.email)}`);
+    spinner.succeed(`Logged in as ${chalk5.bold(result.me.user.email)}`);
   } catch (error) {
     spinner.fail(error instanceof Error ? error.message : "Browser login failed");
     process.exit(1);
@@ -1446,33 +2426,33 @@ async function resolveAPIKeyInput(flagValue, readFromStdin) {
 }
 
 // src/commands/logout.ts
-import { Command as Command5 } from "commander";
-import chalk5 from "chalk";
-var logoutCommand = new Command5("logout").description("Remove stored API key").action(() => {
+import { Command as Command7 } from "commander";
+import chalk6 from "chalk";
+var logoutCommand = new Command7("logout").description("Remove stored API key").action(() => {
   if (!getStoredAPIKey()) {
     console.log();
-    console.log(chalk5.dim("  Not logged in."));
+    console.log(chalk6.dim("  Not logged in."));
     if (hasEnvAPIKey()) {
-      console.log(chalk5.dim("  Environment API key is still active in this shell."));
+      console.log(chalk6.dim("  Environment API key is still active in this shell."));
     }
     console.log();
     return;
   }
   clearAPIKey();
   console.log();
-  console.log(chalk5.green("  Logged out."));
+  console.log(chalk6.green("  Logged out."));
   if (hasEnvAPIKey()) {
-    console.log(chalk5.dim("  Environment API key is still active in this shell."));
+    console.log(chalk6.dim("  Environment API key is still active in this shell."));
   }
   console.log();
 });
 
 // src/commands/whoami.ts
-import { Command as Command6 } from "commander";
-import chalk6 from "chalk";
-import ora4 from "ora";
-var whoamiCommand = new Command6("whoami").description("Show current user").option("--json", "Print raw JSON").action(async (options) => {
-  const spinner = options.json ? null : ora4("Loading user...").start();
+import { Command as Command8 } from "commander";
+import chalk7 from "chalk";
+import ora5 from "ora";
+var whoamiCommand = new Command8("whoami").description("Show current user").option("--json", "Print raw JSON").action(async (options) => {
+  const spinner = options.json ? null : ora5("Loading user...").start();
   try {
     const me = await api("/v1/me");
     spinner?.stop();
@@ -1481,14 +2461,14 @@ var whoamiCommand = new Command6("whoami").description("Show current user").opti
       return;
     }
     console.log();
-    console.log(`  ${chalk6.bold.white(me.user.display_name || me.user.email)}`);
+    console.log(`  ${chalk7.bold.white(me.user.display_name || me.user.email)}`);
     if (me.user.display_name) {
-      console.log(`  ${chalk6.dim(me.user.email)}`);
+      console.log(`  ${chalk7.dim(me.user.email)}`);
     }
     if (me.api_key.name) {
-      console.log(`  ${chalk6.dim("Key:")}  ${me.api_key.name}`);
+      console.log(`  ${chalk7.dim("Key:")}  ${me.api_key.name}`);
     }
-    console.log(`  ${chalk6.dim("API:")}  ${chalk6.dim(getBaseURL())}`);
+    console.log(`  ${chalk7.dim("API:")}  ${chalk7.dim(getBaseURL())}`);
     console.log();
   } catch (error) {
     if (spinner) {
@@ -1501,70 +2481,146 @@ var whoamiCommand = new Command6("whoami").description("Show current user").opti
 });
 
 // src/index.ts
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
+var pkg2 = JSON.parse(
+  readFileSync3(new URL("../package.json", import.meta.url), "utf8")
+);
 var cliName = process.argv[1] ? basename2(process.argv[1]) : "agentcomputer";
-var program = new Command7();
-program.name(cliName).description("Agent Computer CLI").version(pkg.version ?? "0.0.0").option("-y, --yes", "Skip confirmation prompts").configureHelp({
-  formatHelp(cmd, helper) {
-    const version = pkg.version ?? "0.0.0";
-    const lines = [];
-    lines.push(`${chalk7.bold(cliName)} ${chalk7.dim(`v${version}`)}`);
+var program = new Command9();
+function appendTextSection(lines, title, values) {
+  if (values.length === 0) {
+    return;
+  }
+  lines.push(`  ${chalk8.dim(title)}`);
+  lines.push("");
+  for (const value of values) {
+    lines.push(`    ${chalk8.white(value)}`);
+  }
+  lines.push("");
+}
+function appendTableSection(lines, title, entries) {
+  if (entries.length === 0) {
+    return;
+  }
+  const width = Math.max(...entries.map((entry) => entry.term.length), 0) + 2;
+  lines.push(`  ${chalk8.dim(title)}`);
+  lines.push("");
+  for (const entry of entries) {
+    lines.push(`    ${chalk8.white(padEnd(entry.term, width))}${chalk8.dim(entry.desc)}`);
+  }
+  lines.push("");
+}
+function commandPath(cmd) {
+  const parts = [];
+  let current = cmd;
+  while (current) {
+    parts.unshift(current.name());
+    current = current.parent ?? null;
+  }
+  return parts.join(" ");
+}
+function formatRootHelp(cmd) {
+  const version = pkg2.version ?? "0.0.0";
+  const lines = [];
+  const groups = [
+    ["Auth", []],
+    ["Computers", []],
+    ["Access", []],
+    ["Agents", []],
+    ["Other", []]
+  ];
+  const otherGroup = groups.find(([name]) => name === "Other")[1];
+  lines.push(`${chalk8.bold(cliName)} ${chalk8.dim(`v${version}`)}`);
+  lines.push("");
+  if (cmd.description()) {
+    lines.push(`  ${chalk8.dim(cmd.description())}`);
     lines.push("");
-    if (cmd.commands.length > 0) {
-      const groups = {
-        Auth: [],
-        Computers: [],
-        Access: [],
-        Other: []
-      };
-      for (const sub of cmd.commands) {
-        const name = sub.name();
-        const desc = sub.description();
-        const entry = { name, desc };
-        if (["login", "logout", "whoami"].includes(name)) {
-          groups.Auth.push(entry);
-        } else if (["create", "ls", "get", "rm"].includes(name)) {
-          groups.Computers.push(entry);
-        } else if (["open", "ssh", "ports"].includes(name)) {
-          groups.Access.push(entry);
-        } else {
-          groups.Other.push(entry);
-        }
-      }
-      for (const [groupName, entries] of Object.entries(groups)) {
-        if (entries.length === 0) continue;
-        lines.push(`  ${chalk7.dim(groupName)}`);
-        for (const entry of entries) {
-          const padded = entry.name.padEnd(14);
-          lines.push(`    ${chalk7.white(padded)}${chalk7.dim(entry.desc)}`);
-        }
-        lines.push("");
-      }
-    }
-    const globalOpts = [
-      { flags: "-y, --yes", desc: "Skip confirmation prompts" },
-      { flags: "-V, --version", desc: "Show version" },
-      { flags: "-h, --help", desc: "Show help" }
-    ];
-    lines.push(`  ${chalk7.dim("Options")}`);
-    for (const opt of globalOpts) {
-      const padded = opt.flags.padEnd(14);
-      lines.push(`    ${chalk7.white(padded)}${chalk7.dim(opt.desc)}`);
+  }
+  appendTextSection(lines, "Usage", [`${cliName} <command> [options]`]);
+  for (const sub of cmd.commands) {
+    const name = sub.name();
+    const entry = { term: name, desc: sub.description() };
+    if (["login", "logout", "whoami"].includes(name)) {
+      groups[0][1].push(entry);
+    } else if (["create", "ls", "get", "rm"].includes(name)) {
+      groups[1][1].push(entry);
+    } else if (["open", "ssh", "ports"].includes(name)) {
+      groups[2][1].push(entry);
+    } else if (["agent", "fleet", "acp"].includes(name)) {
+      groups[3][1].push(entry);
+    } else {
+      otherGroup.push(entry);
     }
+  }
+  for (const [groupName, entries] of groups) {
+    appendTableSection(
+      lines,
+      groupName,
+      entries
+    );
+  }
+  appendTableSection(lines, "Options", [
+    { term: "-y, --yes", desc: "Skip confirmation prompts" },
+    { term: "-V, --version", desc: "Show version" },
+    { term: "-h, --help", desc: "Show help" }
+  ]);
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function formatSubcommandHelp(cmd, helper) {
+  const lines = [];
+  const description = helper.commandDescription(cmd);
+  const argumentsList = helper.visibleArguments(cmd).map((argument) => ({
+    term: helper.argumentTerm(argument),
+    desc: helper.argumentDescription(argument)
+  }));
+  const commandList = helper.visibleCommands(cmd).map((subcommand) => ({
+    term: helper.subcommandTerm(subcommand),
+    desc: helper.subcommandDescription(subcommand)
+  }));
+  const optionList = helper.visibleOptions(cmd).map((option) => ({
+    term: helper.optionTerm(option),
+    desc: helper.optionDescription(option)
+  }));
+  lines.push(chalk8.bold(commandPath(cmd)));
+  lines.push("");
+  if (description) {
+    lines.push(`  ${chalk8.dim(description)}`);
     lines.push("");
-    return lines.join("\n");
   }
-});
+  appendTextSection(lines, "Usage", [helper.commandUsage(cmd)]);
+  appendTableSection(lines, "Arguments", argumentsList);
+  appendTableSection(lines, "Commands", commandList);
+  appendTableSection(lines, "Options", optionList);
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function applyHelpFormatting(cmd) {
+  cmd.configureHelp({
+    formatHelp(current, helper) {
+      if (!current.parent) {
+        return formatRootHelp(current);
+      }
+      return formatSubcommandHelp(current, helper);
+    }
+  });
+  for (const subcommand of cmd.commands) {
+    applyHelpFormatting(subcommand);
+  }
+}
+program.name(cliName).description("Agent Computer CLI").version(pkg2.version ?? "0.0.0").option("-y, --yes", "Skip confirmation prompts");
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(whoamiCommand);
 program.addCommand(createCommand);
 program.addCommand(lsCommand);
 program.addCommand(getCommand);
+program.addCommand(agentCommand);
+program.addCommand(fleetCommand);
+program.addCommand(acpCommand);
 program.addCommand(openCommand);
 program.addCommand(sshCommand);
 program.addCommand(portsCommand);
 program.addCommand(removeCommand);
 program.addCommand(completionCommand);
+applyHelpFormatting(program);
 program.parse();