@agentsky/sky 0.1.0

package/dist/index.js

@@ -0,0 +1,894 @@
+#!/usr/bin/env node
+import {
+  apiBase,
+  apiToken,
+  configPath,
+  currentUniverse,
+  loadConfig,
+  saveConfig
+} from "./chunk-NLEDGUN7.js";
+import {
+  AGENT_TYPES,
+  capabilitiesSchema,
+  customDataSchema,
+  customInstallSchema,
+  external_exports,
+  mcpConfigInstall,
+  skillRefSchema,
+  splitMcpServers
+} from "./chunk-DTVZOF77.js";
+import "./chunk-MLKGABMK.js";
+
+// src/index.ts
+import { existsSync as existsSync3 } from "fs";
+import { basename as basename2, resolve as resolve3 } from "path";
+import { createInterface as createInterface2 } from "readline";
+import { Command } from "commander";
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function authHeaders() {
+  const token = apiToken();
+  if (!token) {
+    throw new ApiError(401, "not_logged_in", "not logged in \u2014 run `sky auth login`");
+  }
+  const headers = { authorization: `Bearer ${token}` };
+  const universe2 = currentUniverse();
+  if (universe2) headers["x-universe"] = universe2;
+  return headers;
+}
+async function parseError(res) {
+  let code = "http_error";
+  let message = `${res.status} ${res.statusText}`;
+  try {
+    const body = await res.json();
+    if (body.error?.message) {
+      code = body.error.code ?? code;
+      message = body.error.message;
+    }
+  } catch {
+  }
+  throw new ApiError(res.status, code, message);
+}
+async function api(method, path, body, opts = {}) {
+  const res = await fetch(`${apiBase()}${path}`, {
+    method,
+    headers: {
+      ...opts.auth === false ? {} : authHeaders(),
+      ...body !== void 0 ? { "content-type": "application/json" } : {}
+    },
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) await parseError(res);
+  return await res.json();
+}
+async function* streamEvents(agentSlug, signal) {
+  const { parseSseStream } = await import("./src-KNBIGOZP.js");
+  const res = await fetch(
+    `${apiBase()}/api/v1/agents/${encodeURIComponent(agentSlug)}/stream`,
+    {
+      headers: { ...authHeaders(), accept: "text/event-stream" },
+      signal
+    }
+  );
+  if (!res.ok) await parseError(res);
+  if (!res.body) throw new ApiError(502, "no_body", "stream returned no body");
+  try {
+    for await (const frame of parseSseStream(res.body)) {
+      if (!frame.data) continue;
+      try {
+        yield { id: frame.id, event: frame.event, data: JSON.parse(frame.data) };
+      } catch {
+      }
+    }
+  } catch (error) {
+    if (!(error instanceof DOMException && error.name === "AbortError")) throw error;
+  }
+}
+
+// src/agent-file.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+var fileInstructionSchema = external_exports.object({
+  name: external_exports.string(),
+  content: external_exports.string().optional(),
+  file: external_exports.string().optional()
+});
+var agentFileSchema = external_exports.object({
+  name: external_exports.string().min(1),
+  slug: external_exports.string().optional(),
+  // stamped by launch/deploy; identifies the live agent
+  description: external_exports.string().optional(),
+  type: external_exports.enum(AGENT_TYPES).optional(),
+  llm: external_exports.string().optional(),
+  capabilities: capabilitiesSchema.optional(),
+  prompt: external_exports.string().optional(),
+  prompt_file: external_exports.string().optional(),
+  instructions: external_exports.array(fileInstructionSchema).optional(),
+  skills: external_exports.array(skillRefSchema).optional(),
+  customInstalls: external_exports.array(customInstallSchema).optional(),
+  customData: external_exports.array(customDataSchema).optional(),
+  /** Advanced machine shape (create-only): 1|2|4|8 vCPUs, 256MB-step memory. */
+  vcpus: external_exports.number().int().optional(),
+  memory_mb: external_exports.number().int().optional()
+});
+function readAgentFile(path) {
+  const raw = readFileSync(path, "utf8");
+  const parsed = agentFileSchema.safeParse(parseToml(raw));
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    throw new Error(`${path}: ${issue?.path.join(".") ?? ""} ${issue?.message ?? "invalid"}`);
+  }
+  const file = parsed.data;
+  const base = dirname(resolve(path));
+  const inline = (ref, inlineContent) => {
+    if (inlineContent !== void 0) return inlineContent;
+    if (!ref) return void 0;
+    return readFileSync(resolve(base, ref), "utf8");
+  };
+  const spec = {
+    name: file.name,
+    description: file.description,
+    agentType: file.type,
+    llm: file.llm,
+    displayName: file.name,
+    capabilities: file.capabilities,
+    prompt: inline(file.prompt_file, file.prompt),
+    instructions: file.instructions?.map((f) => {
+      const content = inline(f.file, f.content);
+      if (content === void 0) throw new Error(`instruction ${f.name}: content or file required`);
+      return { name: f.name, content };
+    }),
+    skills: file.skills,
+    customInstalls: file.customInstalls,
+    customData: file.customData,
+    vcpus: file.vcpus,
+    memoryMb: file.memory_mb
+  };
+  return { file, spec };
+}
+function stampSlug(path, slug) {
+  const doc = parseToml(readFileSync(path, "utf8"));
+  doc.slug = slug;
+  writeFileSync(path, stringifyToml(doc));
+}
+function scaffoldAgentFile(path, name) {
+  if (existsSync(path)) throw new Error(`${path} already exists`);
+  writeFileSync(
+    path,
+    `# agent.toml \u2014 everything the create wizard can set. Only \`name\` is required.
+name = "${name}"
+# type = "hermes"              # hermes | claude_code | codex | openclaw
+# llm = "deepseek-v4-flash"    # must be compatible with type
+# capabilities = []
+
+prompt = """
+You are ${name}, a helpful long-lived agent.
+"""
+`
+  );
+}
+
+// src/clone.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { basename, join } from "path";
+import { createInterface } from "readline";
+var PROMPT_CAP = 1e5;
+var HARNESSES = ["claude_code", "codex", "openclaw"];
+function claudeConfigRoot() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
+function readIfExists(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function readJson(path) {
+  const raw = readIfExists(path);
+  if (raw === void 0) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function claudeModel(configRoot) {
+  const candidates = [
+    join(process.cwd(), ".claude", "settings.local.json"),
+    join(process.cwd(), ".claude", "settings.json"),
+    join(configRoot, "settings.json")
+  ];
+  for (const path of candidates) {
+    const model = readJson(path)?.model;
+    if (typeof model === "string" && model.trim()) return model.trim();
+  }
+  return void 0;
+}
+function claudeMcpServers() {
+  const merged = {};
+  const userConfig = readJson(join(homedir(), ".claude.json"));
+  Object.assign(merged, userConfig?.mcpServers ?? {});
+  Object.assign(merged, userConfig?.projects?.[process.cwd()]?.mcpServers ?? {});
+  const projectConfig = readJson(
+    join(process.cwd(), ".mcp.json")
+  );
+  Object.assign(merged, projectConfig?.mcpServers ?? {});
+  return merged;
+}
+function assemblePrompt(parts) {
+  const joined = parts.map((p) => `# \u2500\u2500 ${p.label} \u2500\u2500
+
+${p.content.trim()}`).join("\n\n").trim();
+  if (joined.length <= PROMPT_CAP) return { prompt: joined, truncated: false };
+  const notice = "\n\n[truncated by sky clone: local instructions exceeded the 100k prompt cap]";
+  return { prompt: joined.slice(0, PROMPT_CAP - notice.length) + notice, truncated: true };
+}
+function readClaudeCode() {
+  const configRoot = claudeConfigRoot();
+  const parts = [];
+  const sources = [];
+  const global = readIfExists(join(configRoot, "CLAUDE.md"));
+  if (global?.trim()) {
+    parts.push({ label: "Global CLAUDE.md", content: global });
+    sources.push("global CLAUDE.md");
+  }
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+    const project = readIfExists(join(process.cwd(), name));
+    if (project?.trim()) {
+      parts.push({ label: `Project ${name}`, content: project });
+      sources.push(`project ${name}`);
+      break;
+    }
+  }
+  const { prompt, truncated } = assemblePrompt(parts);
+  const { kept, dropped } = splitMcpServers(claudeMcpServers());
+  return {
+    harness: "claude_code",
+    configRoot,
+    prompt,
+    promptSources: sources,
+    truncated,
+    model: claudeModel(configRoot),
+    keptServers: kept,
+    droppedServers: dropped
+  };
+}
+function detectHarness(explicit) {
+  if (explicit) {
+    if (!HARNESSES.includes(explicit)) {
+      throw new Error(`unknown harness ${explicit} \u2014 expected ${HARNESSES.join(" | ")}`);
+    }
+    return explicit;
+  }
+  if (existsSync2(claudeConfigRoot())) return "claude_code";
+  if (existsSync2(join(homedir(), ".codex"))) return "codex";
+  if (existsSync2(join(homedir(), ".openclaw"))) return "openclaw";
+  throw new Error(
+    "no local harness found (~/.claude, ~/.codex, ~/.openclaw) \u2014 pass --harness to override"
+  );
+}
+function readLocal(harness) {
+  if (harness === "claude_code") return readClaudeCode();
+  throw new Error(
+    `${harness} cloning lands next \u2014 claude_code is the first supported harness`
+  );
+}
+function linkPath(configRoot) {
+  return join(configRoot, "agentsky-link.json");
+}
+function readLink(configRoot) {
+  const link = readJson(linkPath(configRoot));
+  return link?.agentSlug ? link : void 0;
+}
+function writeLink(configRoot, link) {
+  writeFileSync2(linkPath(configRoot), `${JSON.stringify(link, null, 2)}
+`);
+}
+function confirm(question) {
+  return new Promise((done) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${question} [Y/n] `, (answer) => {
+      rl.close();
+      done(/^(y(es)?)?$/i.test(answer.trim()));
+    });
+  });
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+function kb(text) {
+  return `${Math.max(1, Math.round(text.length / 1024))} KB`;
+}
+async function createClone(local, opts) {
+  const keptNames = Object.keys(local.keptServers);
+  const summary = [
+    local.promptSources.length ? `${local.promptSources.join(" + ")} (${kb(local.prompt)})` : "no instructions found",
+    `model ${local.model ?? "(harness default)"}`,
+    `${keptNames.length} MCP server${keptNames.length === 1 ? "" : "s"}${keptNames.length ? ` (${keptNames.join(", ")})` : ""}`
+  ].join(" \xB7 ");
+  console.log(`Detected ${local.harness} at ${local.configRoot} (project ${basename(process.cwd())})`);
+  console.log(`Will clone: ${summary}`);
+  if (local.truncated) console.log("  note: instructions exceeded 100k chars and were truncated");
+  if (local.droppedServers.length) {
+    console.log(
+      `Dropped (need credentials \u2014 not supported yet): ${local.droppedServers.map((n) => `${n} MCP`).join(", ")}`
+    );
+  }
+  if (opts.dryRun) {
+    console.log("Dry run \u2014 nothing sent.");
+    return;
+  }
+  if (!opts.yes && !await confirm("Launch this as a new cloud agent?")) {
+    console.log("Aborted \u2014 nothing sent.");
+    return;
+  }
+  const installs = keptNames.length ? [mcpConfigInstall(local.keptServers)] : [];
+  const body = {
+    agentType: local.harness,
+    ...local.model ? { llm: local.model } : {},
+    ...local.prompt ? { prompt: local.prompt } : {},
+    ...installs.length ? { customInstalls: installs } : {}
+  };
+  let sentLlm = local.model ?? null;
+  let created;
+  try {
+    ({ agent: created } = await api("POST", "/api/v1/agents", body));
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 422 && local.model) {
+      console.log(`  note: ${local.model} isn't available for ${local.harness} \u2014 using the harness default`);
+      sentLlm = null;
+      ({ agent: created } = await api("POST", "/api/v1/agents", {
+        ...body,
+        llm: void 0
+      }));
+    } else {
+      throw error;
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  writeLink(local.configRoot, {
+    baseUrl: apiBase(),
+    agentSlug: created.slug,
+    clonedAt: now,
+    lastSyncedAt: now,
+    llm: sentLlm,
+    mcpServers: keptNames
+  });
+  const url = `${apiBase()}/agents/${created.slug}`;
+  console.log(`Cloned \u2192 ${created.slug}  ${url}`);
+  console.log(
+    `Linked this machine (${linkPath(local.configRoot)}). Push prompt changes anytime by running \`sky clone\` again.`
+  );
+  if (opts.open) openBrowser(url);
+}
+async function syncClone(local, link, opts) {
+  const since = link.lastSyncedAt ?? link.clonedAt;
+  console.log(
+    `Syncing ${link.agentSlug} from ${local.configRoot} (last synced ${since ? new Date(since).toLocaleDateString() : "never"})`
+  );
+  if (opts.dryRun) {
+    console.log(
+      `  would push prompt (${kb(local.prompt)}) to ${link.agentSlug}. Dry run \u2014 nothing sent.`
+    );
+    return;
+  }
+  let agent2;
+  try {
+    ({ agent: agent2 } = await api(
+      "GET",
+      `/api/v1/agents/${encodeURIComponent(link.agentSlug)}`
+    ));
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      throw new Error(
+        `linked agent ${link.agentSlug} no longer exists \u2014 run \`sky clone --new\` to launch a fresh one`
+      );
+    }
+    throw error;
+  }
+  if (agent2.agentType !== local.harness) {
+    throw new Error(
+      `linked agent ${link.agentSlug} is ${agent2.agentType}, this machine runs ${local.harness} \u2014 run \`sky clone --new\` to launch a fresh agent`
+    );
+  }
+  const result = await api(
+    "PUT",
+    `/api/v1/agents/${encodeURIComponent(link.agentSlug)}/prompt`,
+    { prompt: local.prompt }
+  );
+  console.log(
+    result.unchanged ? "  prompt   unchanged" : `  prompt   updated (v${result.version}${result.applied === "live" ? ", hot-reloaded" : ", applies on next boot"})`
+  );
+  const drift = [];
+  const localModel = local.model ?? null;
+  const linkedModel = link.llm ?? agent2.llm;
+  if (localModel && linkedModel && localModel !== linkedModel) {
+    drift.push(`model changed ${linkedModel} \u2192 ${localModel}`);
+  }
+  const before = new Set(link.mcpServers ?? []);
+  const nowKept = Object.keys(local.keptServers);
+  const newServers = nowKept.filter((n) => !before.has(n));
+  const goneServers = [...before].filter((n) => !nowKept.includes(n));
+  if (newServers.length) drift.push(`${newServers.length} new MCP server${newServers.length === 1 ? "" : "s"} (${newServers.join(", ")})`);
+  if (goneServers.length) drift.push(`${goneServers.length} removed MCP server${goneServers.length === 1 ? "" : "s"} (${goneServers.join(", ")})`);
+  if (drift.length) {
+    console.log(`  skipped (set at launch): ${drift.join("; ")}`);
+    console.log("    \u2192 a running agent can't change these; run `sky clone --new` to launch a fresh agent.");
+  }
+  if (local.droppedServers.length) {
+    console.log(
+      `  dropped (need credentials \u2014 not supported yet): ${local.droppedServers.map((n) => `${n} MCP`).join(", ")}`
+    );
+  }
+  writeLink(local.configRoot, { ...link, lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  console.log(`Synced ${link.agentSlug}.`);
+  if (opts.open) openBrowser(`${apiBase()}/agents/${link.agentSlug}`);
+}
+async function clone(opts) {
+  const harness = detectHarness(opts.harness);
+  const local = readLocal(harness);
+  const link = opts.new ? void 0 : readLink(local.configRoot);
+  if (link) await syncClone(local, link, opts);
+  else await createClone(local, opts);
+}
+
+// src/login.ts
+import { createHash, randomBytes } from "crypto";
+import { createServer } from "http";
+import { hostname } from "os";
+import { spawn as spawn2 } from "child_process";
+function b64url(buf) {
+  return buf.toString("base64url");
+}
+function openBrowser2(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn2(cmd, [url], { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+async function login(opts) {
+  const verifier = b64url(randomBytes(32));
+  const challenge = b64url(createHash("sha256").update(verifier).digest());
+  const result = opts.noBrowser ? await headlessLogin(verifier, challenge) : await browserLogin(verifier, challenge);
+  saveConfig({
+    ...loadConfig(),
+    apiBase: apiBase(),
+    token: result.token,
+    email: result.user.email ?? void 0,
+    currentUniverse: void 0
+    // personal by default
+  });
+  console.log(
+    `Logged in as ${result.user.email ?? "you"}${result.universe ? ` (universe: ${result.universe.slug})` : ""}`
+  );
+}
+async function browserLogin(verifier, challenge) {
+  const state = b64url(randomBytes(16));
+  const code = await new Promise((resolve4, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end();
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end("<p>Logged in \u2014 you can close this tab and return to your terminal.</p>");
+      const got = url.searchParams.get("code");
+      if (url.searchParams.get("state") !== state || !got) {
+        reject(new Error("login callback state mismatch"));
+      } else {
+        resolve4(got);
+      }
+      server.close();
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      const authorizeUrl = `${apiBase()}/cli/authorize?state=${state}&port=${port}&challenge=${encodeURIComponent(challenge)}&scopes=read,write`;
+      console.log("Opening your browser to authorize this machine\u2026");
+      console.log(`If it doesn't open, visit:
+  ${authorizeUrl}`);
+      openBrowser2(authorizeUrl);
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("login timed out after 10 minutes"));
+    }, 10 * 60 * 1e3).unref();
+  });
+  return api(
+    "POST",
+    "/api/v1/cli/token-exchange",
+    { code, verifier, clientName: `cli ${hostname()}` },
+    { auth: false }
+  );
+}
+async function headlessLogin(verifier, challenge) {
+  const request = b64url(randomBytes(24));
+  const authorizeUrl = `${apiBase()}/cli/authorize?request=${request}&challenge=${encodeURIComponent(challenge)}&scopes=read,write`;
+  console.log(`Visit this URL on any device to authorize:
+  ${authorizeUrl}
+`);
+  process.stdout.write("Waiting for approval\u2026");
+  const deadline = Date.now() + 10 * 60 * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 3e3));
+    const res = await fetch(
+      `${apiBase()}/api/v1/cli/poll?request=${request}&verifier=${encodeURIComponent(verifier)}&clientName=${encodeURIComponent(`cli ${hostname()}`)}`
+    );
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => null);
+      throw new Error(body2?.error?.message ?? `poll failed (${res.status})`);
+    }
+    const body = await res.json();
+    if (body.status === "approved") {
+      console.log(" approved.");
+      return body;
+    }
+    process.stdout.write(".");
+  }
+  throw new Error("login timed out after 10 minutes");
+}
+
+// src/render.ts
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var red = (s) => `\x1B[31m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+function clip(value, max = 120) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function renderEvent(event, data) {
+  const part = data.part;
+  switch (event) {
+    case "agent.message":
+      console.log(String(data.text ?? ""));
+      break;
+    case "agent.reasoning":
+      console.log(dim(`\xB7 ${clip(part?.text ?? "")}`));
+      break;
+    case "agent.tool_use":
+      console.log(dim(`\u2192 ${String(part?.tool_name ?? "tool")}(${clip(part?.args ?? {}, 80)})`));
+      break;
+    case "agent.tool_result":
+      console.log(dim(`\u2190 ${String(part?.tool_name ?? "tool")} ${String(part?.status ?? "")}`));
+      break;
+    case "agent.status":
+      console.log(dim(`\u2026 ${String(part?.level ?? "")} ${String(part?.text ?? "")}`.trim()));
+      break;
+    case "user.message": {
+      const channel = String(data.channel ?? "");
+      if (channel && channel !== "api") {
+        console.log(cyan(`[${channel}] ${clip(data.text ?? "")}`));
+      }
+      break;
+    }
+    case "turn.interrupted":
+      console.log(dim("\u23F9 turn interrupted"));
+      break;
+    case "error":
+      console.error(red(`error: ${String(data.message ?? data.code ?? "unknown")}`));
+      break;
+    default:
+      break;
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("sky").description("Launch and talk to long-lived agents \u2014 agentsky.dev").version("0.1.0");
+function fail(error) {
+  if (error instanceof ApiError) console.error(`sky: ${error.message} (${error.code})`);
+  else console.error(`sky: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+}
+var run = (fn) => (...args) => fn(...args).catch(fail);
+var auth = program.command("auth").description("login, logout, whoami");
+auth.command("login").description("authorize this machine via the browser").option("--no-browser", "print a URL and poll instead of opening a browser").action(run(async (opts) => login({ noBrowser: opts.browser === false })));
+auth.command("logout").description("forget the stored token (revoke it in Settings \u2192 API tokens)").action(
+  run(async () => {
+    saveConfig({ ...loadConfig(), token: void 0, email: void 0 });
+    console.log(`Logged out. (Token revocation: Settings \u2192 API tokens.)`);
+  })
+);
+auth.command("whoami").description("who the current token acts as").action(
+  run(async () => {
+    const who = await api("GET", "/api/v1/whoami");
+    console.log(
+      `${who.user.email ?? "unknown"} \xB7 universe ${who.universe.slug}${who.universe.isPersonal ? " (personal)" : ""} \xB7 scopes ${who.scopes.join(",")}`
+    );
+  })
+);
+var universe = program.command("universe").description("grouping boundary for agents");
+universe.command("list").action(
+  run(async () => {
+    const { universes } = await api("GET", "/api/v1/universes");
+    const current = currentUniverse();
+    for (const u of universes) {
+      const marker = u.slug === current || !current && u.isPersonal ? "*" : " ";
+      console.log(`${marker} ${u.slug}${u.isPersonal ? " (personal)" : ""}`);
+    }
+  })
+);
+universe.command("create <slug>").action(
+  run(async (slug) => {
+    const created = await api("POST", "/api/v1/universes", { slug });
+    console.log(`Created universe ${created.universe.slug}`);
+  })
+);
+universe.command("switch <slug>").action(
+  run(async (slug) => {
+    await api("GET", `/api/v1/universes/${encodeURIComponent(slug)}`);
+    saveConfig({ ...loadConfig(), currentUniverse: slug });
+    console.log(`Switched to ${slug}`);
+  })
+);
+universe.command("show").action(
+  run(async () => {
+    const slug = currentUniverse();
+    const path = slug ? `/api/v1/universes/${encodeURIComponent(slug)}` : "/api/v1/whoami";
+    if (slug) {
+      const { universe: u } = await api("GET", path);
+      console.log(`${u.slug} \u2014 ${u.name} \xB7 ${u.agents} agents \xB7 ${u.members} members`);
+    } else {
+      const who = await api("GET", path);
+      console.log(`${who.universe.slug} (personal)`);
+    }
+  })
+);
+var agent = program.command("agent").description("create, inspect, talk to agents");
+agent.command("create").description("create an agent (flags-only; bare create = instant default)").option("--type <type>", "hermes | claude_code | codex | openclaw").option("--llm <llm>", "model id (defaults per type)").option("--name <name>", "agent name").option("--vcpus <n>", "machine vCPUs: 1, 2, 4 or 8 (default 2)").option("--memory <mb>", "machine memory in MB, 256MB steps (default 4096)").option("-f, --file <path>", "create from an agent.toml").action(
+  run(async (opts) => {
+    const spec = opts.file ? readAgentFile(opts.file).spec : {
+      name: opts.name ?? "My agent",
+      agentType: opts.type,
+      llm: opts.llm,
+      displayName: opts.name
+    };
+    if (opts.vcpus !== void 0) spec.vcpus = Number(opts.vcpus);
+    if (opts.memory !== void 0) spec.memoryMb = Number(opts.memory);
+    const { agent: created } = await api("POST", "/api/v1/agents", spec);
+    console.log(`Created ${created.slug} (${created.agentType} \xB7 ${created.llm})`);
+    console.log(`Talk to it:  sky agent message ${created.slug} "hello"`);
+  })
+);
+agent.command("list").action(
+  run(async () => {
+    const { agents } = await api("GET", "/api/v1/agents");
+    if (!agents.length) {
+      console.log("No agents yet. `sky launch` or `sky agent create` to get one.");
+      return;
+    }
+    for (const a of agents) {
+      console.log(
+        `${a.slug.padEnd(24)} ${a.displayName.padEnd(20)} ${a.agentType}/${a.llm} ${a.status.toLowerCase()}`
+      );
+    }
+  })
+);
+agent.command("show <slug>").action(
+  run(async (slug) => {
+    const { agent: a } = await api("GET", `/api/v1/agents/${encodeURIComponent(slug)}`);
+    console.log(`${a.slug} \u2014 ${a.displayName}`);
+    console.log(`  type      ${a.agentType} \xB7 ${a.llm}`);
+    console.log(`  status    ${a.status.toLowerCase()}`);
+    console.log(`  universe  ${a.universe}`);
+    if (a.capabilities.length) console.log(`  caps      ${a.capabilities.join(", ")}`);
+    if (a.prompt) console.log(`  prompt    ${a.prompt.split("\n")[0]?.slice(0, 80)}\u2026`);
+  })
+);
+agent.command("destroy <slug>").description("tear down the pod and delete the agent (admin scope)").action(
+  run(async (slug) => {
+    await api("DELETE", `/api/v1/agents/${encodeURIComponent(slug)}`);
+    console.log(`Destroyed ${slug}`);
+  })
+);
+agent.command("logs <slug>").option("-f, --follow", "follow (SSE)").option("--since <duration>", "how far back, e.g. 1h, 30m", "1h").action(
+  run(async (slug, opts) => {
+    const qs = `?since=${encodeURIComponent(opts.since)}${opts.follow ? "&follow=true" : ""}`;
+    if (!opts.follow) {
+      const { lines } = await api(
+        "GET",
+        `/api/v1/agents/${encodeURIComponent(slug)}/logs${qs}`
+      );
+      for (const entry of lines) console.log(`${entry.at} ${entry.line}`);
+      return;
+    }
+    const { parseSseStream } = await import("./src-KNBIGOZP.js");
+    const { apiBase: apiBase2 } = await import("./config-HRDRNTUU.js");
+    const token = apiToken();
+    const res = await fetch(`${apiBase2()}/api/v1/agents/${encodeURIComponent(slug)}/logs${qs}`, {
+      headers: { authorization: `Bearer ${token}`, accept: "text/event-stream" }
+    });
+    if (!res.ok || !res.body) throw new ApiError(res.status, "logs_failed", await res.text());
+    for await (const frame of parseSseStream(res.body)) {
+      try {
+        const entry = JSON.parse(frame.data);
+        if (entry.line) console.log(`${entry.at ?? ""} ${entry.line}`);
+      } catch {
+      }
+    }
+  })
+);
+async function sendAndFollow(slug, text, detach) {
+  const controller = new AbortController();
+  let opened = null;
+  if (!detach) {
+    opened = (async () => {
+      for await (const frame of streamEvents(slug, controller.signal)) {
+        renderEvent(frame.event, frame.data);
+        if (frame.event === "turn.status_idle" || frame.event === "turn.interrupted") {
+          controller.abort();
+          break;
+        }
+      }
+    })();
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  const { turnId } = await api(
+    "POST",
+    `/api/v1/agents/${encodeURIComponent(slug)}/messages`,
+    { parts: [{ type: "text", index: 0, text }] }
+  );
+  if (detach) {
+    console.log(`accepted ${turnId}`);
+    return;
+  }
+  await opened;
+}
+agent.command("message <slug> <text>").description("send one message and stream the turn until idle").option("--detach", "don't follow the stream; print the turnId and exit").action(
+  run(
+    async (slug, text, opts) => sendAndFollow(slug, text, Boolean(opts.detach))
+  )
+);
+agent.command("chat <slug>").description("interactive REPL over the standing stream").action(
+  run(async (slug) => {
+    console.log(`Chatting with ${slug} \u2014 Ctrl-C to leave.`);
+    const controller = new AbortController();
+    const rl = createInterface2({ input: process.stdin, output: process.stdout, prompt: "> " });
+    void (async () => {
+      try {
+        for await (const frame of streamEvents(slug, controller.signal)) {
+          renderEvent(frame.event, frame.data);
+          if (frame.event === "turn.status_idle") rl.prompt();
+        }
+      } catch (error) {
+        fail(error);
+      }
+    })();
+    rl.prompt();
+    rl.on("line", (line) => {
+      const text = line.trim();
+      if (!text) {
+        rl.prompt();
+        return;
+      }
+      void api("POST", `/api/v1/agents/${encodeURIComponent(slug)}/messages`, {
+        parts: [{ type: "text", index: 0, text }]
+      }).catch((error) => {
+        console.error(`sky: ${error instanceof Error ? error.message : String(error)}`);
+        rl.prompt();
+      });
+    });
+    rl.on("close", () => {
+      controller.abort();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  })
+);
+agent.command("interrupt <slug>").description("abort the in-flight turn").action(
+  run(async (slug) => {
+    const res = await api(
+      "POST",
+      `/api/v1/agents/${encodeURIComponent(slug)}/interrupt`
+    );
+    console.log(res.status === "no_turn" ? "nothing in flight" : `interrupting ${res.turnId}`);
+  })
+);
+var secrets = program.command("secrets").description("agent secrets (values write-only)");
+secrets.command("set <slug> <pairs...>").description("set KEY=VALUE pairs on the agent").action(
+  run(async (slug, pairs) => {
+    for (const pair of pairs) {
+      const eq = pair.indexOf("=");
+      if (eq < 1) throw new Error(`expected KEY=VALUE, got ${pair}`);
+      const key = pair.slice(0, eq);
+      await api("PUT", `/api/v1/agents/${encodeURIComponent(slug)}/secrets/${encodeURIComponent(key)}`, {
+        value: pair.slice(eq + 1)
+      });
+      console.log(`set ${key}`);
+    }
+  })
+);
+secrets.command("list <slug>").action(
+  run(async (slug) => {
+    const { secrets: keys } = await api("GET", `/api/v1/agents/${encodeURIComponent(slug)}/secrets`);
+    if (!keys.length) console.log("no secrets set");
+    for (const s of keys) {
+      console.log(`\u25CF ${s.key}${s.description ? ` \u2014 ${s.description}` : ""}`);
+    }
+  })
+);
+secrets.command("unset <slug> <key>").action(
+  run(async (slug, key) => {
+    await api(
+      "DELETE",
+      `/api/v1/agents/${encodeURIComponent(slug)}/secrets/${encodeURIComponent(key)}`
+    );
+    console.log(`unset ${key}`);
+  })
+);
+program.command("launch").description("scaffold ./agent.toml if absent, create the agent, print its address").option("-f, --file <path>", "agent file", "agent.toml").action(
+  run(async (opts) => {
+    const path = resolve3(opts.file);
+    if (!existsSync3(path)) {
+      const name = basename2(process.cwd()).replace(/[^a-zA-Z0-9 _-]/g, "") || "my-agent";
+      scaffoldAgentFile(path, name);
+      console.log(`Scaffolded ${opts.file} \u2014 edit it anytime; re-apply with \`sky deploy\`.`);
+    }
+    const { file, spec } = readAgentFile(path);
+    if (file.slug) {
+      console.log(`${file.slug} already launched \u2014 use \`sky deploy\` to re-apply.`);
+      return;
+    }
+    const { agent: created } = await api("POST", "/api/v1/agents", spec);
+    stampSlug(path, created.slug);
+    console.log(`Launched ${created.slug} (${created.agentType} \xB7 ${created.llm})`);
+    console.log(`  sky agent message ${created.slug} "hello"`);
+    console.log(`  sky agent chat ${created.slug}`);
+  })
+);
+program.command("deploy").description("re-apply ./agent.toml to the existing agent (idempotent)").option("-f, --file <path>", "agent file", "agent.toml").action(
+  run(async (opts) => {
+    const path = resolve3(opts.file);
+    const { file, spec } = readAgentFile(path);
+    if (!file.slug) {
+      console.log("No slug in the file yet \u2014 running launch instead.");
+      const { agent: created } = await api("POST", "/api/v1/agents", spec);
+      stampSlug(path, created.slug);
+      console.log(`Launched ${created.slug}`);
+      return;
+    }
+    if (spec.prompt !== void 0) {
+      await api("PUT", `/api/v1/agents/${encodeURIComponent(file.slug)}/prompt`, {
+        prompt: spec.prompt
+      });
+    }
+    await api("PATCH", `/api/v1/agents/${encodeURIComponent(file.slug)}`, {
+      displayName: spec.displayName,
+      ...spec.capabilities ? { capabilities: spec.capabilities } : {}
+    });
+    console.log(`Deployed ${file.slug} (prompt + settings re-applied)`);
+  })
+);
+program.command("clone").description("clone your local agent (Claude Code, \u2026) into the cloud; re-run to sync its prompt").option("--harness <type>", "claude_code | codex | openclaw (default: detected)").option("--new", "always launch a fresh agent, even if this machine is linked").option("--dry-run", "print the plan and send nothing").option("-y, --yes", "skip the confirmation").option("--open", "open the agent page when done").action(
+  run(
+    async (opts) => clone(opts)
+  )
+);
+program.command("config").description("show the CLI config location and current values").action(() => {
+  const config = loadConfig();
+  console.log(`config: ${configPath()}`);
+  console.log(`  apiBase:  ${config.apiBase ?? "(default)"}`);
+  console.log(`  token:    ${config.token ? `${config.token.slice(0, 10)}\u2026` : "(none)"}`);
+  console.log(`  universe: ${config.currentUniverse ?? "(personal)"}`);
+});
+program.parseAsync().catch(fail);