@agentsky/sky 2.2.1 → 2.4.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -4,18 +4,20 @@ import {
   REASONING_EFFORT_VALUES,
   capabilitiesSchema,
   customDataSchema,
+  defaultLlm,
   external_exports,
-  isEffortSupported,
+  isModelEffortSupported,
   mcpServersFromKept,
   modelSubscriptionProviderFor,
   reasoningEffortDocLine,
+  redactLine,
   skillRefSchema,
   splitMcpServers,
   supersededBy
-} from "./chunk-TMLNYYYY.js";
+} from "./chunk-FSAF6HIL.js";
 
 // src/index.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync5, writeFileSync as writeFileSync4 } from "fs";
 import { basename as basename3, resolve as resolve3 } from "path";
 import { createInterface as createInterface3 } from "readline";
 import { Command } from "commander";
@@ -60,7 +62,7 @@ function currentUniverse() {
 }
 
 // src/version.ts
-var CLI_VERSION = "2.2.1";
+var CLI_VERSION = "2.4.0";
 var USER_AGENT = `sky-cli/${CLI_VERSION} (${process.platform}; node/${process.versions.node})`;
 
 // src/api.ts
@@ -108,6 +110,7 @@ async function api(method, path, body, opts = {}) {
     body: body !== void 0 ? JSON.stringify(body) : void 0
   });
   if (!res.ok) await parseError(res);
+  if (res.status === 204) return void 0;
   return await res.json();
 }
 async function postEvents(sessionId, events, idempotencyKey) {
@@ -126,7 +129,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",
@@ -162,7 +165,7 @@ async function resolveSessionRef(ref) {
   return agent2.defaultSessionId;
 }
 async function* streamEvents(sessionId, signal) {
-  const { parseSseStream } = await import("./src-NNPV5GRJ.js");
+  const { parseSseStream } = await import("./src-67OBSB2Q.js");
   const res = await fetch(
     `${apiBase()}/sessions/${encodeURIComponent(sessionId)}/stream`,
     {
@@ -341,7 +344,7 @@ function readAgentFile(path) {
     throw new Error(`${path}: ${issue?.path.join(".") ?? ""} ${issue?.message ?? "invalid"}`);
   }
   const file = parsed.data;
-  if (file.reasoning_effort && file.type && !isEffortSupported(file.type, file.reasoning_effort)) {
+  if (file.reasoning_effort && file.type && !isModelEffortSupported(file.type, file.llm ?? defaultLlm(file.type), file.reasoning_effort)) {
     throw new Error(
       `${path}: reasoning_effort '${file.reasoning_effort}' is not available for ${file.type} \u2014 ${reasoningEffortDocLine()}`
     );
@@ -676,8 +679,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";
@@ -693,7 +991,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(),
@@ -820,9 +1118,9 @@ function renderEvent(event, data) {
 
 // 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 existsSync4, readFileSync as readFileSync6 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 var ALIASES = {
   claude: "anthropic",
@@ -900,12 +1198,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 || join4(homedir4(), ".codex");
+  const path = join4(codexHome, "auth.json");
+  if (!existsSync4(path)) {
     throw new ApiError(404, "no_codex_auth", `no ${path} \u2014 run \`codex login\` first`);
   }
-  const raw = readFileSync5(path, "utf8");
+  const raw = readFileSync6(path, "utf8");
   let accountId;
   try {
     const parsed = JSON.parse(raw);
@@ -1147,7 +1445,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 (the pod is provisioned now)").option("--title <title>", "session title").option("--message <text>", "seed the session and start 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").action(
   run(
     async (agentRef, opts) => {
       const resources = await resourceParams(opts);
@@ -1156,6 +1454,7 @@ session.command("create <agent>").description("create a session (the pod is prov
         ...opts.title ? { title: opts.title } : {},
         ...opts.vcpus !== void 0 ? { vcpus: Number(opts.vcpus) } : {},
         ...opts.memory !== void 0 ? { memoryMb: Number(opts.memory) } : {},
+        ...opts.deferred ? { provision: "deferred" } : {},
         ...resources.length ? { resources } : {},
         ...opts.message ? { initial_events: [{ type: "user.message", content: [{ type: "text", text: opts.message }] }] } : {}
       });
@@ -1277,6 +1576,43 @@ sessionResources.command("rotate <ref> <rid> <token>").description("replace a re
     console.log(`Rotated ${updated.id}`);
   })
 );
+var sessionPorts = session.command("ports").description("local servers in the session's pod, each exposed on an origin of its own");
+var portsPath = (id) => `/sessions/${encodeURIComponent(id)}/ports`;
+function renderPort(p) {
+  return `${String(p.port).padEnd(5)}  ${p.visibility.padEnd(7)}  ${p.url}`;
+}
+sessionPorts.command("list <ref>").description("the session's exposed ports, oldest first").action(
+  run(async (ref) => {
+    const id = await resolveSessionRef(ref);
+    const { ports } = await api("GET", portsPath(id));
+    if (!ports.length) {
+      console.log("No exposed ports. `sky session ports expose <session> <port>` exposes one.");
+      return;
+    }
+    for (const p of ports) console.log(renderPort(p));
+  })
+);
+sessionPorts.command("expose <ref> <port>").description("expose a port the agent's local server listens on; prints its address").option("--public", "anyone with the address may open it; without it the port is private (only entry links admit a browser), and an already public port is made private again").action(
+  run(async (ref, port, opts) => {
+    const id = await resolveSessionRef(ref);
+    const exposed = await api("PUT", `${portsPath(id)}/${encodeURIComponent(port)}`, { visibility: opts.public ? "public" : "private" });
+    console.log(renderPort(exposed));
+  })
+);
+sessionPorts.command("open <ref> <port>").description("print an entry link for an exposed port \u2014 single-use and good for a minute on a private port").action(
+  run(async (ref, port) => {
+    const id = await resolveSessionRef(ref);
+    const grant = await api("POST", `${portsPath(id)}/${encodeURIComponent(port)}/grants`, {});
+    console.log(grant.url);
+  })
+);
+sessionPorts.command("revoke <ref> <port>").description("stop exposing a port; its address answers 404 from then on").action(
+  run(async (ref, port) => {
+    const id = await resolveSessionRef(ref);
+    await api("DELETE", `${portsPath(id)}/${encodeURIComponent(port)}`);
+    console.log(`Revoked port ${port}`);
+  })
+);
 async function uploadAttachments(opts) {
   const files2 = [];
   for (const path of [...opts.image ?? [], ...opts.file ?? []]) {
@@ -1387,7 +1723,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 (!existsSync5(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\`.`);
@@ -1453,6 +1789,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) => {