@agentsky/sky 2.6.0 → 2.7.1

package/dist/{chunk-MHL5Z6IQ.js → chunk-IC4N2ZPL.js}

@@ -22176,17 +22176,20 @@ function modelSubscriptionProviderFor(agentType, llm) {
   if (agentType === "claude_code" && CLAUDE_PLAN_MODELS.has(llm)) return "anthropic";
   if (agentType === "codex" && CHATGPT_PLAN_MODELS.has(llm)) return "openai";
   if (agentType === "cursor" && llm === "harness-default") return "cursor";
+  if (agentType === "grok_build" && llm === "harness-default") return "xai";
   return null;
 }
 var MODEL_SUBSCRIPTION_PROVIDER_NAME = {
   anthropic: "Claude",
   openai: "ChatGPT",
-  cursor: "Cursor"
+  cursor: "Cursor",
+  xai: "Grok"
 };
 var MODEL_SUBSCRIPTION_PLAN_PHRASE = {
   anthropic: "Claude subscription",
   openai: "ChatGPT plan",
-  cursor: "Cursor plan"
+  cursor: "Cursor plan",
+  xai: "Grok subscription"
 };
 var AGENT_TYPE_META = {
   ...Object.fromEntries(ACP_AGENT_TYPES.map((agentType) => [agentType, {

package/dist/index.js

@@ -16,12 +16,12 @@ import {
   skillRefSchema,
   splitMcpServers,
   supersededBy
-} from "./chunk-MHL5Z6IQ.js";
+} from "./chunk-IC4N2ZPL.js";
 
 // src/index.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync5 } from "fs";
-import { basename as basename3, resolve as resolve3 } from "path";
-import { createInterface as createInterface3 } from "readline";
+import { existsSync as existsSync7, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename3, resolve as resolve4 } from "path";
+import { createInterface as createInterface4 } from "readline";
 import { Command } from "commander";
 
 // src/config.ts
@@ -64,13 +64,13 @@ function currentUniverse() {
 }
 
 // src/version.ts
-var CLI_VERSION = "2.6.0";
+var CLI_VERSION = "2.7.1";
 var USER_AGENT = `sky-cli/${CLI_VERSION} (${process.platform}; node/${process.versions.node})`;
 
 // src/api.ts
 var ApiError = class extends Error {
-  constructor(status, code, message) {
-    super(message);
+  constructor(status, code, message2) {
+    super(message2);
     this.status = status;
     this.code = code;
   }
@@ -89,16 +89,16 @@ function authHeaders() {
 }
 async function parseError(res) {
   let code = "http_error";
-  let message = `${res.status} ${res.statusText}`;
+  let message2 = `${res.status} ${res.statusText}`;
   try {
     const body = await res.json();
     if (body.error?.message) {
       code = body.error.code ?? code;
-      message = body.error.message;
+      message2 = body.error.message;
     }
   } catch {
   }
-  throw new ApiError(res.status, code, message);
+  throw new ApiError(res.status, code, message2);
 }
 async function api(method, path, body, opts = {}) {
   const res = await fetch(`${apiBase()}${path}`, {
@@ -167,7 +167,7 @@ async function resolveSessionRef(ref) {
   return agent2.defaultSessionId;
 }
 async function* streamEvents(sessionId, signal) {
-  const { parseSseStream } = await import("./src-GLBJHVIJ.js");
+  const { parseSseStream } = await import("./src-S76Y7GHZ.js");
   const res = await fetch(
     `${apiBase()}/sessions/${encodeURIComponent(sessionId)}/stream`,
     {
@@ -1065,7 +1065,7 @@ async function login(opts) {
 }
 async function browserLogin(verifier, challenge) {
   const state = b64url(randomBytes(16));
-  const code = await new Promise((resolve4, reject) => {
+  const code = await new Promise((resolve5, reject) => {
     const server = createServer((req, res) => {
       const url = new URL(req.url ?? "/", "http://127.0.0.1");
       if (url.pathname !== "/callback") {
@@ -1078,7 +1078,7 @@ async function browserLogin(verifier, challenge) {
       if (url.searchParams.get("state") !== state || !got) {
         reject(new Error("login callback state mismatch"));
       } else {
-        resolve4(got);
+        resolve5(got);
       }
       server.close();
     });
@@ -1188,9 +1188,9 @@ function renderEvent(event, data) {
       break;
     case "session.error": {
       const error = data.error;
-      const message = String(error?.message ?? error?.type ?? "unknown");
-      if (error?.retry_status === "retrying") console.error(dim(`retrying: ${message}`));
-      else console.error(red(`error: ${message}`));
+      const message2 = String(error?.message ?? error?.type ?? "unknown");
+      if (error?.retry_status === "retrying") console.error(dim(`retrying: ${message2}`));
+      else console.error(red(`error: ${message2}`));
       break;
     }
     case "session.status_terminated":
@@ -1242,10 +1242,21 @@ async function readTurn(sessionId, opts = {}) {
   for (; ; ) {
     const reading = latestTurn(await history(sessionId));
     if (reading.finished || !opts.wait || Date.now() >= deadline) return reading;
-    await new Promise((resolve4) => setTimeout(resolve4, opts.intervalMs ?? 3e3));
+    await new Promise((resolve5) => setTimeout(resolve5, opts.intervalMs ?? 3e3));
   }
 }
 
+// src/setup.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+import { createInterface as createInterface3 } from "readline";
+
+// src/setup-local.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname3, isAbsolute, join as join6, resolve as resolve3 } from "path";
+import { parse as parseToml2 } from "smol-toml";
+
 // src/skill.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5 } from "path";
@@ -1336,6 +1347,9 @@ function installedVersion(dir) {
     return null;
   }
 }
+function isInstalledSkill(dir) {
+  return installedVersion(dir) !== null;
+}
 function installSkill(agent2, opts = {}) {
   const dir = join5(agent2.skillsDir, SKILL_NAME);
   const previous = installedVersion(dir);
@@ -1349,11 +1363,154 @@ function installSkill(agent2, opts = {}) {
   return { agent: agent2.id, path: dir, outcome };
 }
 
+// src/setup-local.ts
+var MAX_SKILL_FILE_BYTES = 1024 * 1024;
+var MAX_IMPORT_DEPTH = 5;
+var SKIPPED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function frontmatterName(skillMd) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd)?.[1];
+  const name = block?.match(/^name:\s*["']?([^"'\r\n]+?)["']?\s*$/m)?.[1];
+  return name?.trim() || null;
+}
+function sensitive(name) {
+  return name.startsWith(".env") || name.endsWith(".pem") || name.endsWith(".key");
+}
+function skillFiles(root, prefix) {
+  const files2 = [];
+  for (const entry of readdirSync2(root, { withFileTypes: true })) {
+    const path = join6(root, entry.name);
+    if (entry.isDirectory()) {
+      if (!SKIPPED_DIRS.has(entry.name)) files2.push(...skillFiles(path, `${prefix}/${entry.name}`));
+    } else if (entry.isFile() && !sensitive(entry.name) && statSync2(path).size <= MAX_SKILL_FILE_BYTES) {
+      files2.push({ path: `${prefix}/${entry.name}`, bytes: new Uint8Array(readFileSync7(path)) });
+    }
+  }
+  return files2;
+}
+function readLocalSkills(agents) {
+  const skills = [];
+  const ignored = [];
+  for (const agent2 of agents) {
+    if (!existsSync5(agent2.skillsDir)) continue;
+    for (const entry of readdirSync2(agent2.skillsDir, { withFileTypes: true })) {
+      const dir = join6(agent2.skillsDir, entry.name);
+      let isDir = entry.isDirectory();
+      if (entry.isSymbolicLink()) {
+        try {
+          isDir = statSync2(dir).isDirectory();
+        } catch {
+          isDir = false;
+        }
+      }
+      if (!isDir || !existsSync5(join6(dir, "SKILL.md")) || isInstalledSkill(dir)) continue;
+      const name = frontmatterName(readFileSync7(join6(dir, "SKILL.md"), "utf8"));
+      if (!name) {
+        ignored.push({ agent: agent2.id, dir, reason: "SKILL.md has no name" });
+        continue;
+      }
+      const taken = skills.find((skill) => skill.name === name);
+      if (taken) {
+        ignored.push({ agent: agent2.id, dir, reason: `${taken.agent} already has a skill named ${name}` });
+        continue;
+      }
+      const files2 = skillFiles(dir, entry.name);
+      skills.push({ name, agent: agent2.id, dir, files: files2, bytes: files2.reduce((sum, file) => sum + file.bytes.length, 0) });
+    }
+  }
+  return { skills, ignored };
+}
+var INSTRUCTION_FILES = { claude_code: "CLAUDE.md", codex: "AGENTS.md" };
+function inlineImports(content, from, home, depth, seen) {
+  let fence;
+  return content.split(/\r?\n/).map((line) => {
+    const marker = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    if (marker) {
+      if (!fence) fence = { character: marker[1][0], length: marker[1].length };
+      else if (marker[1][0] === fence.character && marker[1].length >= fence.length && !marker[2].trim()) fence = void 0;
+      return line;
+    }
+    const target = fence ? void 0 : line.match(/^@(\S+\.(?:md|markdown|txt))$/i)?.[1];
+    if (!target || depth >= MAX_IMPORT_DEPTH) return line;
+    const path = target.startsWith("~/") ? join6(home, target.slice(2)) : isAbsolute(target) ? target : resolve3(dirname3(from), target);
+    if (seen.includes(path)) return "";
+    let imported;
+    try {
+      imported = readFileSync7(path, "utf8");
+    } catch {
+      return line;
+    }
+    seen.push(path);
+    return inlineImports(imported, path, home, depth + 1, seen).trim();
+  }).join("\n");
+}
+function readGlobalInstructions(agents, home = homedir5()) {
+  const found = [];
+  for (const agent2 of agents) {
+    const file = INSTRUCTION_FILES[agent2.id];
+    if (!file) continue;
+    const path = join6(agent2.root, file);
+    let raw;
+    try {
+      raw = readFileSync7(path, "utf8");
+    } catch {
+      continue;
+    }
+    if (!raw.trim()) continue;
+    const imports = [];
+    found.push({ agent: agent2.id, agentName: agent2.name, path, content: inlineImports(raw, path, home, 0, imports), imports });
+  }
+  return found;
+}
+function combineInstructions(found) {
+  const distinct = found.filter((item, index) => found.findIndex((other) => other.content.trim() === item.content.trim()) === index);
+  if (distinct.length <= 1) return distinct[0]?.content ?? "";
+  return distinct.map((item) => `# From ${item.agentName}
+
+${item.content.trim()}`).join("\n\n");
+}
+function readJson2(path) {
+  try {
+    return JSON.parse(readFileSync7(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function bearerOf(def) {
+  if (typeof def.bearer_token === "string" && def.bearer_token.trim()) return def.bearer_token.trim();
+  const headers = def.headers ?? def.http_headers;
+  if (!headers || typeof headers !== "object") return null;
+  const entry = Object.entries(headers).find(([name]) => name.toLowerCase() === "authorization");
+  const match = typeof entry?.[1] === "string" ? /^Bearer\s+(\S+)$/i.exec(entry[1].trim()) : null;
+  return match?.[1] ?? null;
+}
+function serversOf(agent2, home) {
+  if (agent2.id === "claude_code") return readJson2(join6(home, ".claude.json"))?.mcpServers ?? {};
+  if (agent2.id === "cursor") return readJson2(join6(agent2.root, "mcp.json"))?.mcpServers ?? {};
+  try {
+    return parseToml2(readFileSync7(join6(agent2.root, "config.toml"), "utf8")).mcp_servers ?? {};
+  } catch {
+    return {};
+  }
+}
+function findLocalSecrets(agents, home = homedir5()) {
+  const secrets2 = [];
+  for (const agent2 of agents) {
+    for (const [name, def] of Object.entries(serversOf(agent2, home))) {
+      if (!def || typeof def !== "object" || typeof def.url !== "string" || !/^https:\/\//i.test(def.url)) continue;
+      const token = bearerOf(def);
+      if (!token || /^\$\{?[A-Za-z_]/.test(token)) continue;
+      if (secrets2.some((secret) => secret.url === def.url)) continue;
+      secrets2.push({ name: secrets2.some((secret) => secret.name === name) ? `${name}-${agent2.id}` : name, agent: agent2.id, url: def.url, token });
+    }
+  }
+  return secrets2;
+}
+
 // src/subscriptions.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 import { createInterface as createInterface2 } from "readline";
 var ALIASES = {
   claude: "anthropic",
@@ -1438,20 +1595,35 @@ async function connectClaude() {
   const expiry = sub.expiresAt ? ` (expires ~${sub.expiresAt.slice(0, 10)})` : "";
   console.log(`Connected Claude subscription${expiry}. Powers new eligible agents.`);
 }
-async function connectChatgpt(opts) {
-  const codexHome = process.env.CODEX_HOME || join6(homedir5(), ".codex");
-  const path = join6(codexHome, "auth.json");
-  if (!existsSync5(path)) {
+function codexSignIn(env = process.env, home = homedir6()) {
+  const path = join7(env.CODEX_HOME || join7(home, ".codex"), "auth.json");
+  if (!existsSync6(path)) {
     throw new ApiError(404, "no_codex_auth", `no ${path} \u2014 run \`codex login\` first`);
   }
-  const raw = readFileSync7(path, "utf8");
-  let accountId;
+  const raw = readFileSync8(path, "utf8");
   try {
     const parsed = JSON.parse(raw);
-    accountId = parsed.tokens?.account_id;
+    return { path, raw, account: parsed.tokens?.account_id };
   } catch {
     throw new ApiError(400, "invalid_codex_auth", `${path} isn't valid JSON \u2014 re-run \`codex login\``);
   }
+}
+function cursorSignIn(env = process.env, home = homedir6()) {
+  const path = join7(env.XDG_CONFIG_HOME || join7(home, ".config"), "cursor", "auth.json");
+  if (!existsSync6(path)) {
+    throw new ApiError(404, "no_cursor_auth", `no ${path} \u2014 run \`cursor-agent login\` first`);
+  }
+  const raw = readFileSync8(path, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.accessToken !== "string" || typeof parsed.refreshToken !== "string") throw new Error("shape");
+    return { path, raw };
+  } catch {
+    throw new ApiError(400, "invalid_cursor_auth", `${path} isn't a Cursor sign-in \u2014 re-run \`cursor-agent login\``);
+  }
+}
+async function connectChatgpt(opts) {
+  const { path, raw, account: accountId } = codexSignIn();
   console.log(`Found Codex sign-in at ${path}${accountId ? ` (account ${accountId})` : ""}.`);
   if (!opts.yes) {
     const ok = await confirm2("Upload it so your cloud Codex agents run on your ChatGPT plan?");
@@ -1508,6 +1680,292 @@ async function disconnect(name, opts) {
   }
 }
 
+// src/setup.ts
+var SETUP_STEPS = ["skill", "logins", "import", "secrets"];
+function reportPath() {
+  return join8(dirname4(configPath()), "setup.json");
+}
+function loadReport() {
+  try {
+    const saved = JSON.parse(readFileSync9(reportPath(), "utf8"));
+    return { agents: saved.agents ?? [], plans: saved.plans ?? [], ...saved.secrets ? { secrets: saved.secrets } : {} };
+  } catch {
+    return { agents: [], plans: [] };
+  }
+}
+function mergeReport(base, next) {
+  const agents = [...base.agents.filter((old) => !next.agents.some((item) => item.id === old.id)), ...next.agents];
+  const plans = [...base.plans.filter((old) => !next.plans.some((item) => item.provider === old.provider)), ...next.plans];
+  const secrets2 = base.secrets || next.secrets ? { saved: (base.secrets?.saved ?? 0) + (next.secrets?.saved ?? 0), skipped: next.secrets?.skipped ?? base.secrets?.skipped ?? 0 } : void 0;
+  return { agents, plans, ...secrets2 ? { secrets: secrets2 } : {} };
+}
+function saveReport(report) {
+  mkdirSync3(dirname4(reportPath()), { recursive: true });
+  writeFileSync5(reportPath(), `${JSON.stringify(report, null, 2)}
+`, { mode: 384 });
+}
+function confirm3(question) {
+  return new Promise((done) => {
+    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    rl.question(`${question} [Y/n] `, (answer) => {
+      rl.close();
+      done(/^(y(es)?)?$/i.test(answer.trim()));
+    });
+  });
+}
+function kb2(bytes) {
+  return `${Math.max(1, Math.round(bytes / 1024))} KB`;
+}
+function describe(event) {
+  switch (event.type) {
+    case "agents":
+      return event.agents.length ? `Found on this computer: ${event.agents.map((agent2) => agent2.name).join(", ")}` : "No agent found on this computer (looked for Claude Code, Codex and Cursor).";
+    case "skill":
+      return `  AgentSky skill ${event.outcome === "current" ? "already up to date" : event.outcome} for ${event.agent}`;
+    case "plan":
+      return `  ${event.provider} plan: ${event.outcome === "already" ? "already connected" : event.outcome}${event.detail ? ` (${event.detail})` : ""}`;
+    case "found": {
+      const lines = [
+        `  ${event.skills.length} skill${event.skills.length === 1 ? "" : "s"}${event.skills.length ? `: ${event.skills.map((skill) => skill.name).join(", ")}` : ""}`,
+        ...event.instructions.map((item) => `  instructions from ${item.agent}: ${item.path} (${kb2(item.bytes)}${item.imports.length ? `, with ${item.imports.length} imported file${item.imports.length === 1 ? "" : "s"}` : ""})`),
+        ...event.instructions.length ? [] : ["  no global instructions file"],
+        ...event.ignored.map((item) => `  left out ${item.dir}: ${item.reason}`),
+        ...event.secrets.map((secret) => `  key for ${secret.name} (${secret.url}), from ${secret.agent}`)
+      ];
+      return lines.join("\n");
+    }
+    case "imported_skill":
+      return `  skill ${event.name}: ${event.outcome}`;
+    case "instructions":
+      return event.outcome === "none" ? null : `  instructions: ${event.outcome}${event.detail ? ` (${event.detail})` : ""}`;
+    case "secret":
+      return `  key for ${event.name}: ${event.outcome === "already" ? "already in your vault" : event.outcome}${event.detail ? ` (${event.detail})` : ""}`;
+    case "error":
+      return `sky: ${event.message} (${event.code})`;
+    case "done":
+      return "Done. Your agentsky.dev tab has updated itself.";
+  }
+}
+async function cloneCall(key, path, init = {}) {
+  const res = await fetch(`${agentUseBase()}/api/clone/${path}`, {
+    method: "POST",
+    headers: {
+      "user-agent": USER_AGENT,
+      authorization: `Bearer ${key}`,
+      ...init.json !== void 0 ? { "content-type": "application/json" } : {}
+    },
+    body: init.form ?? (init.json !== void 0 ? JSON.stringify(init.json) : void 0)
+  });
+  const body = await res.json().catch(() => ({}));
+  if (res.ok) return { ok: true, body };
+  return { ok: false, status: res.status, code: body.error?.code ?? "http_error", message: body.error?.message ?? `${res.status} ${res.statusText}` };
+}
+async function mintKey() {
+  const token = apiToken();
+  if (!token) throw new ApiError(401, "not_logged_in", "not logged in \u2014 run `sky auth login`");
+  const res = await fetch(`${agentUseBase()}/api/clone/grants`, { method: "POST", headers: { "user-agent": USER_AGENT, authorization: `Bearer ${token}` } });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.key) throw new ApiError(res.status, body.error?.code ?? "http_error", body.error?.message ?? `${res.status} ${res.statusText}`);
+  return body.key;
+}
+async function connectedProviders() {
+  const { modelSubscriptions } = await api("GET", "/model-subscriptions");
+  return new Set(modelSubscriptions.map((subscription) => subscription.provider));
+}
+async function defaultVaultId() {
+  const { vaults } = await api("GET", "/vaults");
+  const existing = vaults.find((vault) => vault.display_name === "default");
+  if (existing) return existing.id;
+  return (await api("POST", "/vaults", { display_name: "default" })).vault.id;
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runSetup(opts) {
+  const steps = opts.steps?.length ? opts.steps : [...SETUP_STEPS];
+  const interactive = !opts.json && !opts.yes && !opts.dryRun;
+  const emit = (event) => {
+    if (opts.json) console.log(JSON.stringify(event));
+    else {
+      const line = describe(event);
+      if (line) console.log(line);
+    }
+  };
+  const agreed = async (question) => !interactive || confirm3(question);
+  const has = (step) => steps.includes(step);
+  const agents = selectLocalAgents(opts.agents);
+  emit({ type: "agents", agents: agents.map((agent2) => ({ id: agent2.id, name: agent2.name })) });
+  const needsToken = !opts.dryRun && (has("logins") || has("secrets") || has("import") && !opts.key);
+  if (needsToken && !apiToken()) {
+    if (opts.json) throw new ApiError(401, "not_logged_in", "not logged in \u2014 run `sky auth login`");
+    console.log("First, sign this computer in to AgentSky.");
+    await login({});
+  }
+  const run2 = { agents: [], plans: [] };
+  const earlier = loadReport();
+  const wantsImport = has("import");
+  const wantsSecrets = has("secrets");
+  const tellsWorkspace = !opts.dryRun && (wantsImport || Boolean(opts.key));
+  let key;
+  let held = /* @__PURE__ */ new Map();
+  const tell = async () => {
+    if (!tellsWorkspace) return;
+    key ??= opts.key ?? await mintKey();
+    const claimed = await cloneCall(key, "claim", { json: { setup: mergeReport(earlier, run2) } });
+    if (!claimed.ok) throw new ApiError(claimed.status, claimed.code, claimed.message);
+    held = new Map((claimed.body.skills ?? []).map((skill) => [skill.name, skill.fingerprint]));
+  };
+  await tell();
+  if (has("skill") && agents.length && await agreed("Add the AgentSky skill to these agents, so they can hand work to others?")) {
+    for (const agent2 of agents) {
+      try {
+        const installed = installSkill(agent2, { dryRun: opts.dryRun });
+        emit({ type: "skill", agent: agent2.id, outcome: installed.outcome, path: installed.path });
+        if (!opts.dryRun) run2.agents.push({ id: agent2.id, skill: installed.outcome });
+      } catch (error) {
+        emit({ type: "skill", agent: agent2.id, outcome: "failed", path: agent2.skillsDir });
+        emit({ type: "error", code: "skill_install_failed", message: message(error) });
+        run2.agents.push({ id: agent2.id, skill: "failed" });
+      }
+    }
+    await tell();
+  }
+  if (has("logins") && agents.length) {
+    await connectPlans(agents, opts, interactive, emit, run2);
+    await tell();
+  }
+  const { skills, ignored } = wantsImport ? readLocalSkills(agents) : { skills: [], ignored: [] };
+  const instructions = wantsImport ? readGlobalInstructions(agents) : [];
+  const secrets2 = wantsSecrets ? findLocalSecrets(agents) : [];
+  if (wantsImport || wantsSecrets) {
+    emit({
+      type: "found",
+      skills: skills.map((skill) => ({ name: skill.name, agent: skill.agent, files: skill.files.length, bytes: skill.bytes })),
+      ignored: ignored.map((item) => ({ dir: item.dir, reason: item.reason })),
+      instructions: instructions.map((item) => ({ agent: item.agent, path: item.path, bytes: Buffer.byteLength(item.content), imports: item.imports })),
+      secrets: secrets2.map((secret) => ({ name: secret.name, agent: secret.agent, url: secret.url }))
+    });
+  }
+  if (opts.dryRun) return;
+  if (wantsSecrets && secrets2.length) {
+    run2.secrets = await saveSecrets(secrets2, opts, interactive, emit);
+    await tell();
+  }
+  const report = mergeReport(earlier, run2);
+  saveReport(report);
+  if (key) {
+    const sendFiles = wantsImport && (skills.length > 0 || instructions.length > 0) && await agreed("Send these skills and instructions to your AgentSky workspace?");
+    await importToWorkspace(key, held, sendFiles ? skills : [], sendFiles ? combineInstructions(instructions) : "", emit);
+  }
+  emit({ type: "done", report });
+}
+async function connectPlans(agents, opts, interactive, emit, run2) {
+  const connected = opts.dryRun && !apiToken() ? /* @__PURE__ */ new Set() : await connectedProviders();
+  const record = (provider, outcome, detail) => {
+    emit({ type: "plan", provider, outcome, ...detail ? { detail } : {} });
+    if (outcome === "available") return;
+    run2.plans.push({ provider, outcome: outcome === "already" ? "connected" : outcome });
+  };
+  const copy = async (provider, name, read) => {
+    if (connected.has(provider)) return record(provider, "already");
+    let found;
+    try {
+      found = read();
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 404) return;
+      return record(provider, "failed", message(error));
+    }
+    if (opts.dryRun) return record(provider, "available", found.account ? `account ${found.account}` : void 0);
+    if (interactive && !await confirm3(`Use the ${name} sign-in on this computer${found.account ? ` (account ${found.account})` : ""} for your cloud agents?`)) {
+      return record(provider, "skipped");
+    }
+    try {
+      await put(provider, found.raw);
+      record(provider, "connected");
+    } catch (error) {
+      record(provider, "failed", message(error));
+    }
+  };
+  if (agents.some((agent2) => agent2.id === "claude_code")) {
+    if (connected.has("anthropic")) record("anthropic", "already");
+    else if (opts.dryRun) record("anthropic", "available");
+    else if (opts.json || opts.yes || opts.claude === false) record("anthropic", "skipped", "needs a browser approval");
+    else if (!await confirm3("Connect your Claude plan? It opens the browser for one approval and does not sign Claude Code out.")) record("anthropic", "skipped");
+    else {
+      const token = await mintClaudeToken();
+      if (!token) record("anthropic", "failed", "`claude setup-token` did not return a token");
+      else {
+        try {
+          await put("anthropic", token);
+          record("anthropic", "connected");
+        } catch (error) {
+          record("anthropic", "failed", message(error));
+        }
+      }
+    }
+  }
+  if (agents.some((agent2) => agent2.id === "codex")) await copy("openai", "ChatGPT", () => codexSignIn());
+  if (agents.some((agent2) => agent2.id === "cursor")) await copy("cursor", "Cursor", () => cursorSignIn());
+}
+async function saveSecrets(found, opts, interactive, emit) {
+  const counts = { saved: 0, skipped: 0 };
+  let vaultId;
+  for (const secret of found) {
+    const chosen = interactive ? await confirm3(`Save the key your ${secret.agent} uses for ${secret.name} (${secret.url}) to your vault?`) : (opts.secrets ?? []).includes(secret.name);
+    if (!chosen) {
+      counts.skipped += 1;
+      emit({ type: "secret", name: secret.name, outcome: "skipped" });
+      continue;
+    }
+    try {
+      vaultId ??= await defaultVaultId();
+      await api("POST", `/vaults/${encodeURIComponent(vaultId)}/secrets`, {
+        display_name: secret.name,
+        auth: { type: "static_bearer", mcp_server_url: secret.url, token: secret.token }
+      });
+      counts.saved += 1;
+      emit({ type: "secret", name: secret.name, outcome: "saved" });
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 409) emit({ type: "secret", name: secret.name, outcome: "already" });
+      else emit({ type: "secret", name: secret.name, outcome: "failed", detail: message(error) });
+    }
+  }
+  return counts;
+}
+async function importToWorkspace(key, held, skills, instructions, emit) {
+  const outcomes = [];
+  let signedOut = false;
+  for (const skill of skills) {
+    if (signedOut) {
+      outcomes.push({ name: skill.name, outcome: "skipped: sign in to agentsky.dev again" });
+      continue;
+    }
+    const form = new FormData();
+    form.append("name", skill.name);
+    form.append("expectedFingerprint", held.get(skill.name) ?? "");
+    for (const file of skill.files) form.append("files", new Blob([new Uint8Array(file.bytes)]), file.path);
+    const sent = await cloneCall(key, "skills", { form });
+    const outcome = sent.ok ? String(sent.body.status ?? "created") : `skipped: ${sent.message}`;
+    if (!sent.ok && sent.code === "sign_in_required") signedOut = true;
+    outcomes.push({ name: skill.name, outcome });
+    emit({ type: "imported_skill", name: skill.name, outcome });
+  }
+  let instructionsOutcome = null;
+  let instructionError;
+  if (instructions.trim()) {
+    const sent = await cloneCall(key, "instructions", { json: { instructions } });
+    instructionsOutcome = sent.ok ? "applied" : "failed";
+    if (!sent.ok) instructionError = sent.message;
+    emit({ type: "instructions", outcome: instructionsOutcome, ...instructionError ? { detail: instructionError } : {} });
+  } else {
+    emit({ type: "instructions", outcome: "none" });
+  }
+  const finished = await cloneCall(key, "finish", {
+    json: { summary: { skills: outcomes, instructions: instructionsOutcome, ...instructionError ? { instructionError } : {} } }
+  });
+  if (!finished.ok) emit({ type: "error", code: finished.code, message: finished.message });
+}
+
 // src/index.ts
 function printModelBilling(session2) {
   if (session2.modelBilling !== "account") return;
@@ -1789,7 +2247,7 @@ session.command("read <ref>").description("what the agent has said since the las
       console.log(JSON.stringify(reading));
       return;
     }
-    for (const message of reading.messages) console.log(message);
+    for (const message2 of reading.messages) console.log(message2);
     for (const error of reading.errors) console.error(`error: ${error}`);
     if (!reading.finished) console.error("The agent is still working. Run this again to read more.");
   })
@@ -1914,7 +2372,7 @@ async function sendAndFollow(sessionId, text, opts) {
 async function chatLoop(sessionId, opts = {}) {
   console.log(`Chatting with ${sessionId} \u2014 Ctrl-C to leave.`);
   const controller = new AbortController();
-  const rl = createInterface3({ input: process.stdin, output: process.stdout, prompt: "> " });
+  const rl = createInterface4({ input: process.stdin, output: process.stdout, prompt: "> " });
   let system = opts.system;
   void (async () => {
     try {
@@ -1980,6 +2438,20 @@ program.command("skill").description("the AgentSky skill for the agents on this
     for (const i of installs) console.log(`${i.agent.padEnd(12)} ${verb[i.outcome].padEnd(14)} ${i.path}`);
   })
 );
+program.command("setup [steps...]").description("bring this machine's agents to AgentSky: the skill, your plans, your skills and instructions, your tool keys").addHelpText("after", `
+Steps (all when none is named): ${SETUP_STEPS.join(" | ")}`).option("--key <key>", "a setup key from agentsky.dev/setup").option("--agent <id...>", "only these agents: claude_code | codex | cursor").option("--secret <name...>", "save these tool keys to your vault (asked one by one when omitted)").option("--no-claude", "leave the Claude plan alone").option("--dry-run", "say what would be done; write and send nothing").option("-y, --yes", "do not ask before each step").option("--json", "print progress as one JSON object per line; never asks").action(
+  run(async (steps, opts) => {
+    const unknown = steps.find((step) => !SETUP_STEPS.includes(step));
+    if (unknown) throw new Error(`unknown step ${unknown} \u2014 expected ${SETUP_STEPS.join(" | ")}`);
+    try {
+      await runSetup({ steps, key: opts.key, agents: opts.agent, secrets: opts.secret, claude: opts.claude, dryRun: opts.dryRun, yes: opts.yes, json: opts.json });
+    } catch (error) {
+      if (!opts.json) throw error;
+      console.log(JSON.stringify({ type: "error", code: error instanceof ApiError ? error.code : "failed", message: error instanceof Error ? error.message : String(error) }));
+      process.exit(1);
+    }
+  })
+);
 var secrets = program.command("secrets").description("agent secrets (values write-only)");
 secrets.command("set <id> <pairs...>").description("set KEY=VALUE pairs on the agent").action(
   run(async (id, pairs) => {
@@ -2014,8 +2486,8 @@ secrets.command("unset <id> <key>").action(
 );
 program.command("launch").description("scaffold ./agent.toml if absent, create the agent, print its address").option("-f, --file <path>", "agent file", "agent.toml").option("--type <type>", "override the file's harness: hermes | claude_code | codex | openclaw | pi | dsh | kimi_code | opencode").option("--llm <llm>", "override the file's model (must suit the harness)").action(
   run(async (opts) => {
-    const path = resolve3(opts.file);
-    if (!existsSync6(path)) {
+    const path = resolve4(opts.file);
+    if (!existsSync7(path)) {
       const name = basename3(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\`.`);
@@ -2047,7 +2519,7 @@ program.command("launch").description("scaffold ./agent.toml if absent, create t
 );
 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 path = resolve4(opts.file);
     const { file, spec } = readAgentFile(path);
     if (!file.id) {
       console.log("No agent id in the file yet \u2014 running launch instead.");
@@ -2124,13 +2596,13 @@ program.command("import").description("import a local Claude Code or Codex sessi
           console.log(`       ${ws}`);
         });
         console.log();
-        const rl = createInterface3({ input: process.stdin, output: process.stdout });
+        const rl = createInterface4({ input: process.stdin, output: process.stdout });
         const answer = await new Promise(
-          (resolve4) => rl.question(
+          (resolve5) => rl.question(
             `Import which session? [1-${candidates.length}, or comma-separated, or "all"]: `,
             (a) => {
               rl.close();
-              resolve4(a.trim());
+              resolve5(a.trim());
             }
           )
         );
@@ -2150,10 +2622,10 @@ program.command("import").description("import a local Claude Code or Codex sessi
       console.log("The recorded conversation is redacted locally. Local project files and login credentials are not transferred.");
       if (!opts.yes) {
         if (!process.stdin.isTTY) throw new Error("Use --yes to confirm this transfer in a non-interactive terminal.");
-        const prompt = createInterface3({ input: process.stdin, output: process.stdout });
-        const answer = await new Promise((resolve4) => prompt.question("Upload these selected conversations? [y/N] ", (value) => {
+        const prompt = createInterface4({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve5) => prompt.question("Upload these selected conversations? [y/N] ", (value) => {
           prompt.close();
-          resolve4(value);
+          resolve5(value);
         }));
         if (!/^y(?:es)?$/i.test(answer.trim())) {
           console.log("Cancelled. Nothing uploaded.");
@@ -2213,7 +2685,7 @@ files.command("rm <id>").description("delete a file (a session that already rece
 files.command("download <id>").description("download a session file's bytes").requiredOption("-o, --out <path>", "where to write the bytes").action(
   run(async (id, opts) => {
     const { bytes } = await downloadFile(id);
-    writeFileSync5(opts.out, bytes);
+    writeFileSync6(opts.out, bytes);
     console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
   })
 );

package/dist/products.js

@@ -8,7 +8,7 @@ import {
   skillsArraySchema,
   systemMessageEventSchema,
   userMessageEventSchema
-} from "./chunk-MHL5Z6IQ.js";
+} from "./chunk-IC4N2ZPL.js";
 
 // ../../packages/spec/src/compatibility.ts
 var capabilityInputsSchema = capabilitiesSchema;

package/dist/{src-GLBJHVIJ.js → src-S76Y7GHZ.js}

@@ -1,7 +1,7 @@
 import {
   external_exports,
   messagePartSchema
-} from "./chunk-MHL5Z6IQ.js";
+} from "./chunk-IC4N2ZPL.js";
 
 // ../../packages/chat/src/stream.ts
 async function* parseSseStream(body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsky/sky",
-  "version": "2.6.0",
+  "version": "2.7.1",
   "description": "sky — the AgentSky developer CLI: launch and talk to long-lived agents from your terminal.",
   "license": "MIT",
   "type": "module",