@agentsky/sky 2.3.0 → 2.5.0

package/dist/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import {
   AGENT_TYPES,
+  MODEL_SUBSCRIPTION_PLAN_PHRASE,
+  MODEL_SUBSCRIPTION_PROVIDER_NAME,
   REASONING_EFFORT_VALUES,
   capabilitiesSchema,
   customDataSchema,
@@ -10,13 +12,14 @@ import {
   mcpServersFromKept,
   modelSubscriptionProviderFor,
   reasoningEffortDocLine,
+  redactLine,
   skillRefSchema,
   splitMcpServers,
   supersededBy
-} from "./chunk-2KQLWHHC.js";
+} from "./chunk-MHL5Z6IQ.js";
 
 // src/index.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync4 } from "fs";
+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 { Command } from "commander";
@@ -61,7 +64,7 @@ function currentUniverse() {
 }
 
 // src/version.ts
-var CLI_VERSION = "2.3.0";
+var CLI_VERSION = "2.5.0";
 var USER_AGENT = `sky-cli/${CLI_VERSION} (${process.platform}; node/${process.versions.node})`;
 
 // src/api.ts
@@ -128,7 +131,7 @@ async function postEvents(sessionId, events, idempotencyKey) {
 }
 async function uploadFile(bytes, filename, mediaType, expiresInSeconds) {
   const form = new FormData();
-  form.append("file", new Blob([bytes], { type: mediaType }), filename);
+  form.append("file", new Blob([new Uint8Array(bytes)], { type: mediaType }), filename);
   if (expiresInSeconds) form.append("expires_in_seconds", String(expiresInSeconds));
   const res = await fetch(`${apiBase()}/files`, {
     method: "POST",
@@ -164,7 +167,7 @@ async function resolveSessionRef(ref) {
   return agent2.defaultSessionId;
 }
 async function* streamEvents(sessionId, signal) {
-  const { parseSseStream } = await import("./src-EGXYUSME.js");
+  const { parseSseStream } = await import("./src-GLBJHVIJ.js");
   const res = await fetch(
     `${apiBase()}/sessions/${encodeURIComponent(sessionId)}/stream`,
     {
@@ -678,8 +681,303 @@ async function clone(opts) {
   else await createClone(local, opts);
 }
 
+// src/import-local.ts
+import { closeSync, existsSync as existsSync3, openSync, readdirSync, readFileSync as readFileSync5, readSync, statSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { createHash } from "crypto";
+function redactLine2(raw) {
+  return redactLine(raw).line;
+}
+function decodeWorkspace(encoded) {
+  try {
+    return decodeURIComponent(encoded.replace(/-/g, "%").replace(/_/g, "%5F"));
+  } catch {
+    return encoded;
+  }
+}
+function readPrefix(filePath) {
+  const fd = openSync(filePath, "r");
+  try {
+    const bytes = Buffer.alloc(256 * 1024);
+    return bytes.subarray(0, readSync(fd, bytes, 0, bytes.length, 0)).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+function sniffTitle(filePath) {
+  try {
+    const data = readPrefix(filePath);
+    for (const raw of data.split("\n")) {
+      if (!raw.trim()) continue;
+      let line;
+      try {
+        line = JSON.parse(redactLine2(raw));
+      } catch {
+        continue;
+      }
+      if (!line || typeof line !== "object") continue;
+      const rec = line;
+      if (rec.type === "user" && rec.message && typeof rec.message === "object") {
+        const msg = rec.message;
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (typeof block === "object" && block !== null) {
+              const b = block;
+              if (b.type === "text" && typeof b.text === "string" && b.text.trim()) {
+                return b.text.trim().slice(0, 120);
+              }
+            }
+          }
+        }
+        if (typeof msg.content === "string" && msg.content.trim()) {
+          return msg.content.trim().slice(0, 120);
+        }
+      }
+      if (rec.type === "event_msg" && rec.payload && typeof rec.payload === "object") {
+        const payload = rec.payload;
+        if (payload.type === "user_message" && typeof payload.message === "string") return redactLine2(payload.message).slice(0, 120);
+      }
+      if (rec.type === "response_item" && rec.payload && typeof rec.payload === "object") {
+        const payload = rec.payload;
+        if (payload.type === "message" && payload.role === "user" && Array.isArray(payload.content)) {
+          const text = payload.content.find((part) => typeof part?.text === "string")?.text;
+          if (typeof text === "string" && text.trim()) return redactLine2(text.trim()).slice(0, 120);
+        }
+      }
+      if (rec.type === "session_meta") continue;
+      if (rec.type === "user_turn" || rec.type === "message" && rec.role === "user") {
+        const content = rec.content;
+        if (typeof content === "string" && content.trim()) return content.trim().slice(0, 120);
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function listClaudeCodeSessions(limit) {
+  const root = process.env.CLAUDE_CONFIG_DIR ?? join3(homedir3(), ".claude");
+  const projectsDir = join3(root, "projects");
+  if (!existsSync3(projectsDir)) return [];
+  const sessions = [];
+  try {
+    for (const encoded of readdirSync(projectsDir)) {
+      const projectDir = join3(projectsDir, encoded);
+      let entries;
+      try {
+        entries = readdirSync(projectDir);
+      } catch {
+        continue;
+      }
+      const workspace = decodeWorkspace(encoded);
+      for (const entry of entries) {
+        if (!entry.endsWith(".jsonl")) continue;
+        const sessionId = entry.slice(0, -6);
+        const mainFile = join3(projectDir, entry);
+        let stat;
+        try {
+          stat = statSync(mainFile);
+        } catch {
+          continue;
+        }
+        if (!stat.isFile()) continue;
+        let discoveryError;
+        const subagentFiles = [];
+        const subagentDir = join3(projectDir, sessionId, "subagents");
+        if (existsSync3(subagentDir)) {
+          try {
+            const subFiles = readdirSync(subagentDir).filter((f) => f.endsWith(".jsonl")).sort();
+            for (const f of subFiles) {
+              subagentFiles.push(join3(subagentDir, f));
+            }
+          } catch {
+            discoveryError = "Cannot read all recorded subagent conversations. Fix local file access before importing this session.";
+          }
+        }
+        sessions.push({
+          harness: "claude_code",
+          sessionId,
+          workspace,
+          title: sniffTitle(mainFile),
+          mtimeMs: stat.mtimeMs,
+          files: [mainFile, ...subagentFiles],
+          ...discoveryError ? { discoveryError } : {}
+        });
+      }
+    }
+  } catch {
+  }
+  return sessions.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, limit);
+}
+function listCodexSessions(limit) {
+  const sessionsDir = join3(process.env.CODEX_HOME ?? process.env.CODEX_CONFIG_DIR ?? join3(homedir3(), ".codex"), "sessions");
+  const records = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl")) continue;
+      try {
+        const first = readPrefix(full).split("\n", 1)[0];
+        const meta = JSON.parse(first);
+        if (meta.type !== "session_meta" || typeof meta.payload?.id !== "string") continue;
+        const data = meta.payload;
+        const parent = data.forked_from_id ?? data.source?.spawn?.parent_thread_id ?? data.source?.subagent?.spawn?.parent_thread_id;
+        records.push({
+          session: {
+            harness: "codex",
+            sessionId: data.id,
+            workspace: typeof data.cwd === "string" ? data.cwd : dir,
+            title: sniffTitle(full),
+            mtimeMs: statSync(full).mtimeMs,
+            files: [full]
+          },
+          ...typeof parent === "string" ? { parent } : {}
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  walk(sessionsDir);
+  function descendants(id, visited) {
+    if (visited.has(id)) return [];
+    visited.add(id);
+    return records.filter((item) => item.parent === id).flatMap((item) => [
+      ...item.session.files,
+      ...descendants(item.session.sessionId, visited)
+    ]);
+  }
+  return records.filter((item) => !item.parent).map(({ session: session2 }) => ({
+    ...session2,
+    files: [.../* @__PURE__ */ new Set([...session2.files, ...descendants(session2.sessionId, /* @__PURE__ */ new Set())])]
+  })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, limit);
+}
+function listRecentSessions(harness, limit) {
+  const claudeSessions = harness === "codex" ? [] : listClaudeCodeSessions(limit);
+  const codexSessions = harness === "claude_code" ? [] : listCodexSessions(limit);
+  return [...claudeSessions, ...codexSessions].sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, limit);
+}
+function agentUseBase() {
+  const env = process.env.AGENT_USE_URL?.trim().replace(/\/$/, "");
+  if (env) return env;
+  const api2 = apiBase().replace(/\/$/, "");
+  const derived = api2.replace(/\/api\/v1$/, "").replace(/\/v1$/, "").replace("api.agentsky.dev", "agentsky.dev");
+  if (derived.includes("localhost:3000")) return derived.replace("localhost:3000", "localhost:3002");
+  return derived;
+}
+async function mintTrace(base, harness) {
+  const token = apiToken();
+  if (!token) throw new ApiError(401, "not_logged_in", "not logged in \u2014 run `sky auth login`");
+  const res = await fetch(`${base}/api/traces`, {
+    method: "POST",
+    redirect: "error",
+    signal: AbortSignal.timeout(15e3),
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      "user-agent": USER_AGENT
+    },
+    body: JSON.stringify({ harness })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    throw new Error(
+      typeof body?.error === "string" ? body.error : `Failed to create import (${res.status}).`
+    );
+  }
+  return await res.json();
+}
+function prepareImport(session2) {
+  if (session2.discoveryError) throw new Error(session2.discoveryError);
+  const maximum = 16 * 1024 * 1024;
+  let inputBytes = 0;
+  let outputBytes = 0;
+  const lines = [];
+  const digest = createHash("sha256");
+  let nativeId;
+  for (const path of session2.files) {
+    const stat = statSync(path);
+    if (!stat.isFile() || (inputBytes += stat.size) > maximum) throw new Error("Selected transcript exceeds the 16 MiB limit or is not a regular file.");
+    const text = readFileSync5(path, "utf8");
+    for (const raw of text.split("\n")) {
+      if (!raw.trim()) continue;
+      const record = JSON.parse(raw);
+      if (!record || typeof record !== "object" || Array.isArray(record)) throw new Error("Transcript records must be JSON objects.");
+      if (String(record.type).startsWith("import.")) throw new Error("Native transcripts cannot supply import protocol records.");
+      const id = record.type === "session_meta" ? record.payload?.id : record.sessionId;
+      if (!nativeId && typeof id === "string") nativeId = id;
+      const clean = redactLine(raw.replace(/\r$/, ""), { requireStructured: true }).line;
+      const line = clean + "\n";
+      outputBytes += Buffer.byteLength(line);
+      if (outputBytes > maximum) throw new Error("Redacted transcript exceeds the 16 MiB limit.");
+      digest.update(line);
+      lines.push(line);
+    }
+  }
+  if (!lines.length) throw new Error("The selected transcript is empty.");
+  const sourceId = nativeId ?? session2.sessionId;
+  if (!/^[A-Za-z0-9_-]{1,200}$/.test(sourceId) || redactLine2(JSON.stringify(sourceId)) !== JSON.stringify(sourceId)) throw new Error("The source conversation has an invalid identifier.");
+  const summary = {
+    format: "asteroids.session-summary",
+    format_version: 1,
+    source_harness: session2.harness,
+    source_harness_version: null,
+    source_session_id: sourceId,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: "The complete selected local conversation is attached as a transcript. Review it before continuing; this automatic handoff does not infer the user's unfinished objective or claim any work is complete.",
+    context: {
+      objective: "Review the imported conversation and continue its latest unfinished authorized objective.",
+      constraints: [],
+      decisions: [],
+      completed: [],
+      pending: ["Read the complete imported transcript, reconcile the latest human instructions and completed work, then continue."],
+      verification: [],
+      blockers: ["This handoff contains the recorded conversation only. Referenced local files, runtime state, and unreadable reasoning are not transferred."],
+      artifacts: [],
+      provenance: { native_checkpoint_sha256: digest.digest("hex"), selected_native_session_id: sourceId, context_bytes: outputBytes }
+    }
+  };
+  return lines.join("") + JSON.stringify({ type: "import.summary", package: summary }) + "\n" + JSON.stringify({ type: "import.end", records: lines.length + 1 }) + "\n";
+}
+async function importSession(opts) {
+  const base = (opts.agentUseUrl ?? agentUseBase()).replace(/\/$/, "");
+  const destination = new URL(base);
+  if (destination.username || destination.password || destination.protocol !== "https:" && !(destination.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(destination.hostname))) {
+    throw new Error("Import requires HTTPS, or a loopback development server.");
+  }
+  opts.onProgress?.("Reading transcript and redacting secrets locally\u2026");
+  const body = prepareImport(opts.session);
+  opts.onProgress?.("Minting import key\u2026");
+  const { traceId, key } = await mintTrace(base, opts.session.harness);
+  opts.onProgress?.("Uploading the complete transcript\u2026");
+  const response = await fetch(`${base}/api/traces/ingest`, {
+    method: "POST",
+    redirect: "error",
+    signal: AbortSignal.timeout(12e4),
+    headers: { authorization: `Bearer ${key}`, "content-type": "application/x-ndjson", "x-source-harness": opts.session.harness, "user-agent": USER_AGENT },
+    body
+  });
+  if (!response.ok) {
+    const result2 = await response.json().catch(() => null);
+    throw new Error(typeof result2?.error === "string" ? result2.error : result2?.error?.message ?? `Upload failed (${response.status}).`);
+  }
+  const result = await response.json();
+  return { traceId: result.traceId ?? traceId, url: `${base}/playground/new?import=${encodeURIComponent(result.traceId ?? traceId)}` };
+}
+
 // src/login.ts
-import { createHash, randomBytes } from "crypto";
+import { createHash as createHash2, randomBytes } from "crypto";
 import { createServer } from "http";
 import { hostname } from "os";
 import { spawn as spawn2 } from "child_process";
@@ -695,7 +993,7 @@ function openBrowser2(url) {
 }
 async function login(opts) {
   const verifier = b64url(randomBytes(32));
-  const challenge = b64url(createHash("sha256").update(verifier).digest());
+  const challenge = b64url(createHash2("sha256").update(verifier).digest());
   const result = opts.noBrowser ? await headlessLogin(verifier, challenge) : await browserLogin(verifier, challenge);
   saveConfig({
     ...loadConfig(),
@@ -777,6 +1075,33 @@ async function headlessLogin(verifier, challenge) {
   throw new Error("login timed out after 10 minutes");
 }
 
+// src/local-agents.ts
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function localAgents(env = process.env, home = homedir4()) {
+  const claude = env.CLAUDE_CONFIG_DIR || join4(home, ".claude");
+  const codex = env.CODEX_HOME || join4(home, ".codex");
+  const cursor = join4(home, ".cursor");
+  return [
+    { id: "claude_code", name: "Claude Code", root: claude, skillsDir: join4(claude, "skills") },
+    { id: "codex", name: "Codex", root: codex, skillsDir: join4(codex, "skills") },
+    { id: "cursor", name: "Cursor", root: cursor, skillsDir: join4(cursor, "skills") }
+  ];
+}
+function detectLocalAgents(env = process.env, home = homedir4()) {
+  return localAgents(env, home).filter((agent2) => existsSync4(agent2.root));
+}
+function selectLocalAgents(ids, env = process.env, home = homedir4()) {
+  if (!ids?.length) return detectLocalAgents(env, home);
+  const known = localAgents(env, home);
+  return ids.map((id) => {
+    const agent2 = known.find((candidate) => candidate.id === id);
+    if (!agent2) throw new Error(`unknown agent ${id} \u2014 expected ${known.map((candidate) => candidate.id).join(" | ")}`);
+    return agent2;
+  });
+}
+
 // src/render.ts
 var dim = (s) => `\x1B[2m${s}\x1B[0m`;
 var red = (s) => `\x1B[31m${s}\x1B[0m`;
@@ -820,11 +1145,159 @@ function renderEvent(event, data) {
   }
 }
 
+// src/session-read.ts
+var TURN_TYPES = ["user.message", "agent.message", "session.status_idle", "session.status_terminated", "session.error"];
+function latestTurn(events) {
+  let start = 0;
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    if (events[index].type === "user.message") {
+      start = index + 1;
+      break;
+    }
+  }
+  const reading = { finished: false, messages: [], errors: [] };
+  for (const event of events.slice(start)) {
+    if (event.type === "agent.message" && event.text?.trim()) reading.messages.push(event.text);
+    else if (event.type === "session.error" && event.error?.retry_status !== "retrying") {
+      reading.errors.push(event.error?.message ?? event.error?.type ?? "unknown error");
+    } else if (event.type === "session.status_terminated") reading.finished = true;
+    else if (event.type === "session.status_idle" && event.stop_reason?.type !== "requires_action") reading.finished = true;
+  }
+  return reading;
+}
+async function history(sessionId) {
+  const events = [];
+  let cursor = null;
+  for (; ; ) {
+    const query = new URLSearchParams({ limit: "500" });
+    for (const type of TURN_TYPES) query.append("types[]", type);
+    if (cursor) query.set("cursor", cursor);
+    const page = await api(
+      "GET",
+      `/sessions/${encodeURIComponent(sessionId)}/events?${query}`
+    );
+    events.push(...page.events);
+    if (!page.hasMore || !page.cursor) return events;
+    cursor = page.cursor;
+  }
+}
+async function readTurn(sessionId, opts = {}) {
+  const deadline = Date.now() + (opts.timeoutSeconds ?? 600) * 1e3;
+  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));
+  }
+}
+
+// src/skill.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+var SKILL_NAME = "agentsky";
+var SKILL_MARKER = ".agentsky.json";
+function skillDocument() {
+  return `---
+name: ${SKILL_NAME}
+description: Hand part of a job to another agent running in the cloud through AgentSky, and bring its result back. Use when the person asks for another agent or a named engine (Claude Code, Codex, Hermes, OpenClaw and others) to do, test or review something, or when independent work could run in parallel.
+---
+
+# Working with other agents through AgentSky
+
+AgentSky runs long-lived agents in the cloud. With the \`sky\` command you can
+find one, give it a job, and read what it produced. You stay responsible for
+the result.
+
+If the \`agentsky\` MCP tools are available in this session (\`search_catalog\`,
+\`start_session\`, \`read_session\`, \`send_message\`), use them instead of the
+commands below; they do the same things.
+
+## Before you start
+
+Run \`sky auth whoami\`. If it says you are not logged in, ask the person to run
+\`sky auth login\` and stop there. Never ask them for a token.
+
+## When to hand work over
+
+- When the person asks another agent to do, test or review something, do that.
+  Honor an agent or engine they name.
+- Otherwise, hand over work another agent is better suited to, or independent
+  parts that can run at the same time as your own.
+- Do the work yourself when it is small, when it depends on what you already
+  have in front of you, or when explaining it would take as long as doing it.
+
+## How to pick
+
+\`sky catalog search <words for the work> --json\`
+
+Each result has a \`handle\`, what the agent does, its \`engine_type\`, its
+categories, how it is paid, and what it needs. If the person names an engine,
+match its \`engine_type\` and do not substitute another one silently. Run the
+command with no words to see every agent. If nothing fits, do the work
+yourself and say so.
+
+## How to brief
+
+\`sky session create @<handle> --title "<short name>" --message "<brief>" --json\`
+
+It prints the new session's \`id\`. The agent starts working at once, on its own
+computer in the cloud. It cannot see this conversation or this machine, so a
+brief is one self-contained message that states:
+
+1. what to produce,
+2. what "done" means,
+3. anything it must not do.
+
+To give it a file, add \`--file <path>\`. Never put a password, key or token in a
+brief.
+
+## How to collect
+
+\`sky session read <session id> --wait --json\`
+
+It waits until the agent finishes its turn and prints its messages, with
+\`finished\` true or false. If \`finished\` is false the wait timed out: run it
+again. A first turn can take a minute to begin while the agent's computer
+starts.
+
+To correct it, answer it or ask for more:
+
+\`sky session message <session id> "<text>" --detach\`
+
+then read again. An agent saying it is done is not evidence: check what it
+produced before you rely on it.
+
+## How to finish
+
+Tell the person what was done and which agent did which part. Every agent you
+start is paid for by the person, so start only what the job needs.
+`;
+}
+function installedVersion(dir) {
+  try {
+    const marker = JSON.parse(readFileSync6(join5(dir, SKILL_MARKER), "utf8"));
+    return typeof marker.version === "string" ? marker.version : null;
+  } catch {
+    return null;
+  }
+}
+function installSkill(agent2, opts = {}) {
+  const dir = join5(agent2.skillsDir, SKILL_NAME);
+  const previous = installedVersion(dir);
+  const outcome = previous === CLI_VERSION ? "current" : previous ? "updated" : "installed";
+  if (outcome !== "current" && !opts.dryRun) {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync4(join5(dir, "SKILL.md"), skillDocument());
+    writeFileSync4(join5(dir, SKILL_MARKER), `${JSON.stringify({ version: CLI_VERSION }, null, 2)}
+`);
+  }
+  return { agent: agent2.id, path: dir, outcome };
+}
+
 // src/subscriptions.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 import { createInterface as createInterface2 } from "readline";
 var ALIASES = {
   claude: "anthropic",
@@ -840,6 +1313,14 @@ function providerFor(name) {
   }
   return provider;
 }
+function managedProviderFor(name) {
+  if (name.toLowerCase() === "cursor") return "cursor";
+  const provider = ALIASES[name.toLowerCase()];
+  if (!provider) {
+    throw new ApiError(400, "unknown_provider", `unknown provider "${name}" \u2014 use claude, chatgpt or cursor`);
+  }
+  return provider;
+}
 function ask(question) {
   return new Promise((done) => {
     const rl = createInterface2({ input: process.stdin, output: process.stdout });
@@ -902,12 +1383,12 @@ async function connectClaude() {
   console.log(`Connected Claude subscription${expiry}. Powers new eligible agents.`);
 }
 async function connectChatgpt(opts) {
-  const codexHome = process.env.CODEX_HOME || join3(homedir3(), ".codex");
-  const path = join3(codexHome, "auth.json");
-  if (!existsSync3(path)) {
+  const codexHome = process.env.CODEX_HOME || join6(homedir5(), ".codex");
+  const path = join6(codexHome, "auth.json");
+  if (!existsSync5(path)) {
     throw new ApiError(404, "no_codex_auth", `no ${path} \u2014 run \`codex login\` first`);
   }
-  const raw = readFileSync5(path, "utf8");
+  const raw = readFileSync7(path, "utf8");
   let accountId;
   try {
     const parsed = JSON.parse(raw);
@@ -937,7 +1418,7 @@ async function listSubscriptions() {
   }
   for (const s of modelSubscriptions) {
     const bits = [
-      s.provider === "anthropic" ? "claude" : "chatgpt",
+      MODEL_SUBSCRIPTION_PROVIDER_NAME[s.provider].toLowerCase(),
       s.status,
       s.expiresAt ? `expires ~${s.expiresAt.slice(0, 10)}` : null,
       s.lastUsedAt ? `last used ${s.lastUsedAt.slice(0, 10)}` : null,
@@ -949,8 +1430,8 @@ async function listSubscriptions() {
   }
 }
 async function disconnect(name, opts) {
-  const provider = providerFor(name);
-  const label = provider === "anthropic" ? "Claude" : "ChatGPT";
+  const provider = managedProviderFor(name);
+  const label = MODEL_SUBSCRIPTION_PROVIDER_NAME[provider];
   if (!opts.yes) {
     const ok = await confirm2(`Disconnect ${label}? Agents running on it will fail until reconnected or switched to Platform.`);
     if (!ok) {
@@ -976,7 +1457,7 @@ function printModelBilling(session2) {
   if (session2.modelBilling !== "account") return;
   const provider = modelSubscriptionProviderFor(session2.agentType, session2.llm);
   if (!provider) return;
-  const label = provider === "anthropic" ? "your Claude subscription" : "your ChatGPT plan";
+  const label = `your ${MODEL_SUBSCRIPTION_PLAN_PHRASE[provider]}`;
   console.log(`Model billing: ${label} \u2014 $0 model usage`);
 }
 var program = new Command();
@@ -1149,7 +1630,7 @@ function renderResource(r) {
   const ref = r.checkout ? `@${r.checkout.type === "branch" ? r.checkout.name : r.checkout.sha}` : "";
   return `${r.id}  repo  ${r.mount_path}  ${r.url}${ref}`;
 }
-session.command("create <agent>").description("create a session (starts provisioning by default)").option("--title <title>", "session title").option("--message <text>", "start the first turn immediately, provisioning even with --deferred").option("--deferred", "leave the session idle without a pod until its first turn").option("--vcpus <n>", "machine vCPUs: 1, 2, 4 or 8 (default 2)").option("--memory <mb>", "machine memory in MB, 256MB steps (default 4096)").option("--file <path...>", "mount local files read-only in the working directory: path[:/mount] (uploaded first)").option("--repo <url...>", "clone GitHub repositories into the working directory: https://github.com/{owner}/{repo}[@branch|@sha]").option("--repo-token <token>", "token for the --repo clones; compiled into the sandbox's egress policy, never sent to it").action(
+session.command("create <agent>").description("create a session (starts provisioning by default)").option("--title <title>", "session title").option("--message <text>", "start the first turn immediately, provisioning even with --deferred").option("--deferred", "leave the session idle without a pod until its first turn").option("--vcpus <n>", "machine vCPUs: 1, 2, 4 or 8 (default 2)").option("--memory <mb>", "machine memory in MB, 256MB steps (default 4096)").option("--file <path...>", "mount local files read-only in the working directory: path[:/mount] (uploaded first)").option("--repo <url...>", "clone GitHub repositories into the working directory: https://github.com/{owner}/{repo}[@branch|@sha]").option("--repo-token <token>", "token for the --repo clones; compiled into the sandbox's egress policy, never sent to it").option("--json", "print the created session as JSON").action(
   run(
     async (agentRef, opts) => {
       const resources = await resourceParams(opts);
@@ -1162,6 +1643,10 @@ session.command("create <agent>").description("create a session (starts provisio
         ...resources.length ? { resources } : {},
         ...opts.message ? { initial_events: [{ type: "user.message", content: [{ type: "text", text: opts.message }] }] } : {}
       });
+      if (opts.json) {
+        console.log(JSON.stringify(created));
+        return;
+      }
       console.log(`Created ${created.id} (${created.agent} \xB7 ${created.status})${created.default ? " [default]" : ""}`);
       printModelBilling(created);
       for (const r of created.resources ?? []) console.log(`  ${renderResource(r)}`);
@@ -1238,6 +1723,21 @@ session.command("interrupt <ref>").description("abort the in-flight turn").actio
     console.log(res.status === "no_turn" ? "nothing in flight" : "interrupting");
   })
 );
+session.command("read <ref>").description("what the agent has said since the last message it was sent").option("--wait", "wait until the agent finishes its turn").option("--timeout <seconds>", "how long --wait waits (default 600)").option("--json", "print { finished, messages, errors } as JSON").action(
+  run(async (ref, opts) => {
+    const reading = await readTurn(await resolveSessionRef(ref), {
+      wait: opts.wait,
+      ...opts.timeout !== void 0 ? { timeoutSeconds: Number(opts.timeout) } : {}
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(reading));
+      return;
+    }
+    for (const message of reading.messages) console.log(message);
+    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.");
+  })
+);
 var sessionResources = session.command("resources").description("files and GitHub repositories mounted into a session's working directory");
 var resourcesPath = (id) => `/sessions/${encodeURIComponent(id)}/resources`;
 sessionResources.command("list <ref>").description("the session's resources, oldest first").action(
@@ -1392,6 +1892,40 @@ async function chatLoop(sessionId, opts = {}) {
   await new Promise(() => {
   });
 }
+program.command("catalog").description("the agents that can be started by handle").command("search [words...]").description("find an agent for a piece of work; no words lists every agent").option("--category <category>", "only this category").option("--json", "print the full listings as JSON").action(
+  run(async (words, opts) => {
+    const query = new URLSearchParams();
+    if (words.length) query.set("q", words.join(" "));
+    if (opts.category) query.set("category", opts.category);
+    const { agents } = await api("GET", `/catalog/agents${query.size ? `?${query}` : ""}`);
+    if (opts.json) {
+      console.log(JSON.stringify(agents));
+      return;
+    }
+    if (!agents.length) {
+      console.log("No agent matches. `sky catalog search` with no words lists every agent.");
+      return;
+    }
+    for (const a of agents) console.log(`@${a.handle.padEnd(24)} ${a.name.padEnd(20)} ${a.tagline}`);
+    console.log(`
+Start one:  sky session create @<handle> --message "<the job>"`);
+  })
+);
+program.command("skill").description("the AgentSky skill for the agents on this machine").command("install").description("add the AgentSky skill to each installed agent (Claude Code, Codex, Cursor)").option("--agent <id...>", "only these agents: claude_code | codex | cursor").option("--dry-run", "say what would be written; write nothing").option("--json", "print the outcome per agent as JSON").action(
+  run(async (opts) => {
+    const installs = selectLocalAgents(opts.agent).map((a) => installSkill(a, { dryRun: opts.dryRun }));
+    if (opts.json) {
+      console.log(JSON.stringify(installs));
+      return;
+    }
+    if (!installs.length) {
+      console.log("No agent found on this machine (looked for Claude Code, Codex and Cursor).");
+      return;
+    }
+    const verb = { installed: opts.dryRun ? "would install" : "installed", updated: opts.dryRun ? "would update" : "updated", current: "up to date" };
+    for (const i of installs) console.log(`${i.agent.padEnd(12)} ${verb[i.outcome].padEnd(14)} ${i.path}`);
+  })
+);
 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) => {
@@ -1427,7 +1961,7 @@ 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 (!existsSync4(path)) {
+    if (!existsSync6(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\`.`);
@@ -1493,6 +2027,103 @@ program.command("clone").description("clone your local agent (Claude Code, \u202
     async (opts) => clone(opts)
   )
 );
+function formatRelative(msAgo) {
+  const seconds = Math.round(msAgo / 1e3);
+  if (seconds < 90) return "just now";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 90) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `${hours}h ago`;
+  return `${Math.round(hours / 24)}d ago`;
+}
+program.command("import").description("import a local Claude Code or Codex session to AgentSky and continue it in the cloud").option("--all", "import all found sessions up to --limit").option("-y, --yes", "confirm transfer of the selected conversations without prompting").option("--limit <n>", "maximum sessions to list or import", "10").option("--session <id>", "import one specific session by its ID").option("--harness <type>", "claude_code | codex | all (default: all)").option("--url <base>", "agent-use app URL (default: derived from SKY_API_URL or AGENT_USE_URL)").action(
+  run(
+    async (opts) => {
+      const limit = Math.max(1, Math.min(50, parseInt(opts.limit ?? "10", 10) || 10));
+      if (opts.harness && !["claude_code", "codex", "all"].includes(opts.harness)) throw new Error("Use --harness claude_code, codex, or all.");
+      const harness = opts.harness ?? "all";
+      const base = opts.url ?? agentUseBase();
+      const candidates = opts.session ? listRecentSessions(harness === "all" ? void 0 : harness, Number.POSITIVE_INFINITY).filter(
+        (s) => s.sessionId === opts.session
+      ) : listRecentSessions(harness === "all" ? void 0 : harness, limit);
+      if (candidates.length === 0) {
+        if (opts.session) {
+          throw new Error(`Session "${opts.session}" not found in ~/.claude or ~/.codex.`);
+        }
+        console.log(
+          "No recent sessions found. Make sure you have run Claude Code (sessions in ~/.claude) or Codex (sessions in ~/.codex)."
+        );
+        return;
+      }
+      let toImport;
+      if (opts.all || opts.session || candidates.length === 1) {
+        toImport = candidates;
+      } else {
+        if (!process.stdin.isTTY) throw new Error("Use --session or --all to select conversations in a non-interactive terminal.");
+        console.log("\nRecent local sessions:\n");
+        candidates.forEach((s, i) => {
+          const label = s.title ? `"${s.title.slice(0, 70)}"` : "(no title)";
+          const ago = formatRelative(Date.now() - s.mtimeMs);
+          const harnessBadge = s.harness === "codex" ? "[Codex]" : "[Claude Code]";
+          const ws = s.workspace.replace(process.env.HOME ?? "", "~").slice(0, 60);
+          console.log(`  ${i + 1}.  ${harnessBadge}  ${ago}  ${label}`);
+          console.log(`       ${ws}`);
+        });
+        console.log();
+        const rl = createInterface3({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(
+          (resolve4) => rl.question(
+            `Import which session? [1-${candidates.length}, or comma-separated, or "all"]: `,
+            (a) => {
+              rl.close();
+              resolve4(a.trim());
+            }
+          )
+        );
+        if (answer.toLowerCase() === "all") {
+          toImport = candidates;
+        } else {
+          const picks = answer.split(",").map((s) => parseInt(s.trim(), 10) - 1).filter((n) => !isNaN(n) && n >= 0 && n < candidates.length);
+          if (picks.length === 0) {
+            console.log("Nothing selected.");
+            return;
+          }
+          toImport = picks.map((i) => candidates[i]);
+        }
+      }
+      toImport = [...new Map(toImport.map((session2) => [`${session2.harness}:${session2.sessionId}`, session2])).values()];
+      console.log(`Selected ${toImport.length} conversation(s), ${toImport.reduce((count, session2) => count + session2.files.length, 0)} transcript file(s). Destination: ${base}`);
+      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) => {
+          prompt.close();
+          resolve4(value);
+        }));
+        if (!/^y(?:es)?$/i.test(answer.trim())) {
+          console.log("Cancelled. Nothing uploaded.");
+          return;
+        }
+      }
+      for (const session2 of toImport) {
+        const label = session2.title ? `"${session2.title.slice(0, 60)}"` : session2.sessionId;
+        process.stdout.write(`
+Importing ${label} \u2026
+`);
+        const result = await importSession({
+          session: session2,
+          agentUseUrl: base,
+          onProgress: (msg) => process.stdout.write(`  ${msg}
+`)
+        });
+        console.log(`  \u2713 Imported. Continue here:
+    ${result.url}
+`);
+      }
+    }
+  )
+);
 var files = program.command("files").description("files: upload once, reference by id from any message");
 files.command("upload <path>").description("upload a local file; prints the file id to reference from a message").option("--expires <seconds>", "expire the upload after this many seconds (3600\u20137776000)").action(
   run(async (path, opts) => {
@@ -1528,7 +2159,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);
-    writeFileSync4(opts.out, bytes);
+    writeFileSync5(opts.out, bytes);
     console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
   })
 );