@hellix-ai/cubes 0.2.1 → 0.3.0

package/README.md

@@ -1,7 +1,10 @@
 # cubes
 
-Attach to your [Cubes](https://cubes.hellix.ai) sessions from your own terminal (Warp, iTerm2, Ghostty,
-Terminal.app, anything) with your own font, colors and keyboard shortcuts.
+The [Cubes](https://cubes.hellix.ai) command line. Work in your Cubes sessions from your own terminal
+(Warp, iTerm2, Ghostty, Terminal.app, anything) with your own font, colors and keyboard shortcuts: attach
+to one, or keep all of them in a split view, with image paste, your clipboard, and a tab that tells you
+when a session needs you. And move Claude Code conversations between your computer and Cubes: import
+one into a new session, or export a session's conversation to continue it here with `claude --resume`.
 
 ```sh
 npm install -g @hellix-ai/cubes      # needs Node.js 22.4+
@@ -10,6 +13,8 @@ cubes login --host cubes.hellix.ai   # prints a code; approve it in the browser
 cubes ls                             # sessions, under a heading per group (--mine, --live)
 cubes attach                         # pick a running one
 cubes attach 7ff4                    # or name one: an id prefix, or part of its title
+cubes import                         # continue one of your local Claude Code conversations in Cubes
+cubes export 7ff4                    # bring a session's conversation here (then claude --resume)
 ```
 
 No install: `npx @hellix-ai/cubes attach <session>`. Later, `cubes upgrade` updates it in place.
@@ -23,8 +28,15 @@ use is never touched), so close the terminal and run `cubes` again to land right
 - **The list** is grouped like the web's Sessions page, with a session's spawned sessions nested under it
   and a coloured dot for its state: working, idle, **needs you**, starting, ended.
 - **Above the session**, a header says which one it is: name · group · runner · state.
-- **Keys:** `⏎` (or a click) opens a session · `Ctrl-]` in a session jumps back to the list · `l` live only
-  · `m` mine only · `/` find · `←` `→` fold a session's children · `q` quits (sessions keep running).
+- **Browsing:** `⏎` (or a click) shows a session on the right and leaves you in the list, so `↑` `↓` and
+  `⏎` again show the next one.
+- **`F1` switches** between the list and the session, from either side. It is the one single key Claude
+  Code does not use (in a session every other key, `Ctrl-]` included, goes to Claude). On a MacBook the
+  top row sends it with `fn` held, unless *Use F1, F2, etc. keys as standard function keys* is on. From
+  the list, `⏎` on the session already showing (or `Tab`) goes in too, and a click on either side moves
+  you there.
+- **Other keys:** `l` live only · `m` mine only · `/` find · `←` `→` fold a session's children · `q` quits
+  (sessions keep running).
 
 ## While attached
 
@@ -61,6 +73,49 @@ viewers) and `r` reconnects when you choose to.
 Scrollback lives in the session's tmux: scroll with the mouse wheel or trackpad (tmux copy-mode), not
 your terminal's own scrollback.
 
+## Moving a conversation between your computer and Cubes
+
+**`cubes import`** starts a Cubes session that continues a Claude Code conversation from this computer.
+
+```sh
+cubes import                 # pick one of your recent conversations (this directory's first)
+cubes import 0f3c1d52        # or name it: its id, the start of it, or the path to its .jsonl
+```
+
+It asks which org (if you are in more than one), then everything the web's New session dialog asks:
+title, group, repositories, a cube to start from, agents, model, runner, Remote Control and extra
+`claude` arguments, with the same defaults and the same rules (a group pre-selects its repositories, an
+agent that declares a model decides it). The repository your conversation's checkout points at is
+pre-selected. Then it uploads the conversation, starts the session continuing it, and offers to attach.
+
+Any question can be answered up front, so it also works in a script:
+
+```sh
+cubes import 0f3c1d52 --yes --title "importer, continued" --repo acme/api --runner k3s --no-rc
+```
+
+`--title`, `--group`, `--repo` (repeatable), `--cube` and `--input name=value` (repeatable), `--agent`
+(repeatable), `--model` (or `default`), `--runner`, `--rc` / `--no-rc`, `--cli-args="..."`, plus
+`--package ID`, `--mcp-config FILE` and `--hooks FILE`, which the dialog does not offer. `--yes` takes
+the default for anything not given.
+
+**`cubes export`** copies a session's conversation onto this computer, where `claude --resume` finds it.
+
+```sh
+cd ~/code/api
+cubes export 7ff4            # then: claude --resume <id>, as printed
+cubes export 7ff4 --dir ~/code/api
+```
+
+It is filed under `~/.claude/projects` (or `$CLAUDE_CONFIG_DIR`) for the directory you run it in, or
+`--dir`. Exporting again brings your copy up to date; if you have continued it locally since, it is not
+replaced unless you pass `--force`. A stopped session on a cluster runner keeps its conversation on its
+own machine, so it is resumed first (you are asked).
+
+Only the **conversation** travels, in both directions. An imported session checks its repositories out
+fresh on its runner, and an export does not bring the session's files: push them from the session and
+pull them here.
+
 ## Commands
 
 ```
@@ -71,6 +126,8 @@ cubes whoami
 cubes org [ALIAS]
 cubes ls [--mine] [--live] [--all] [--json]
 cubes attach [SESSION] [--view] [--no-resume] [--no-status]
+cubes import [CONVERSATION] [--yes] [--attach | --no-attach] [form flags]
+cubes export [SESSION] [--dir DIR] [--force]
 cubes upgrade [--check]
 ```
 

package/dist/api.js

@@ -1,8 +1,8 @@
 // The REST half: the same routes the web app calls, with the same Bearer + `x-org` pair.
 import { CliError } from "./auth.js";
 export function makeApi(s, fetchImpl = fetch) {
-    async function call(method, path, body, init) {
-        const send = async (force) => {
+    async function send(method, path, body, init, signal) {
+        const once = async (force) => {
             const headers = { authorization: `Bearer ${await s.token(force)}` };
             if (s.org)
                 headers["x-org"] = s.org;
@@ -16,43 +16,76 @@ export function makeApi(s, fetchImpl = fetch) {
                 payload = JSON.stringify(body);
             }
             try {
-                return await fetchImpl(`${s.host}/api${path}`, { method, headers, body: payload });
+                return await fetchImpl(`${s.host}/api${path}`, { method, headers, body: payload, signal });
             }
             catch (e) {
+                if (signal?.aborted)
+                    throw e;
                 throw new CliError(`cannot reach ${s.host}: ${e.message}`);
             }
         };
-        let res = await send(false);
+        const res = await once(false);
         // A token the server refuses may simply be one our clock thinks is still good. One forced
         // refresh, then the refusal stands.
-        if (res.status === 401)
-            res = await send(true);
-        const text = await res.text();
+        if (res.status !== 401)
+            return res;
+        await res.body?.cancel().catch(() => undefined);
+        return once(true);
+    }
+    async function refusal(res, path) {
+        const text = await res.text().catch(() => "");
         let data = undefined;
         try {
             data = text ? JSON.parse(text) : undefined;
         }
         catch { /* not JSON */ }
-        if (!res.ok) {
-            const msg = data?.error;
-            throw new ApiError(res.status, typeof msg === "string" ? msg : `HTTP ${res.status}`, path);
+        const msg = data?.error;
+        const detail = data?.detail;
+        const code = data?.code;
+        throw new ApiError(res.status, typeof msg === "string" ? (typeof detail === "string" ? `${msg}: ${detail}` : msg) : `HTTP ${res.status}`, path, typeof code === "string" ? code : undefined, data);
+    }
+    async function call(method, path, body, init) {
+        const res = await send(method, path, body, init);
+        if (!res.ok)
+            return refusal(res, path);
+        const text = await res.text();
+        let data = undefined;
+        try {
+            data = text ? JSON.parse(text) : undefined;
         }
+        catch { /* not JSON */ }
         return data;
     }
     return {
         get: (path) => call("GET", path),
         post: (path, body, init) => call("POST", path, body, init),
+        put: (path, body, init) => call("PUT", path, body, init),
+        del: (path) => call("DELETE", path),
+        async stream(path, signal) {
+            const res = await send("GET", path, undefined, undefined, signal);
+            if (!res.ok)
+                return refusal(res, path);
+            return res;
+        },
     };
 }
 export class ApiError extends CliError {
     status;
     path;
-    constructor(status, message, path) {
+    code;
+    body;
+    constructor(status, message, path, 
+    /** The server's machine-readable `code`, when it sent one. */
+    code, 
+    /** The whole refusal body, for the few callers that need a field beside `error`. */
+    body) {
         super(status === 400 && /organization/.test(message)
             ? `${message} - pick one with \`cubes org <alias>\``
             : message);
         this.status = status;
         this.path = path;
+        this.code = code;
+        this.body = body;
         this.name = "ApiError";
     }
 }

package/dist/args.js

@@ -1,10 +1,22 @@
 // Argument parsing, small enough not to need a dependency.
 import { CliError } from "./auth.js";
 /** Flags that take a value (`--host X` or `--host=X`); every other flag is a switch. */
-const VALUED = new Set(["host", "org"]);
+const VALUED = new Set([
+    "host", "org",
+    // the session form (cubes import)
+    "title", "repo", "group", "cube", "input", "agent", "model", "runner", "cli-args", "package",
+    "mcp-config", "hooks",
+    // cubes export
+    "dir",
+]);
 export function parseArgs(argv) {
     const pos = [];
     const flags = new Map();
+    const lists = new Map();
+    const valued = (name, v) => {
+        flags.set(name, v);
+        lists.set(name, [...(lists.get(name) ?? []), v]);
+    };
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         if (a === "-h") {
@@ -19,12 +31,12 @@ export function parseArgs(argv) {
             const eq = a.indexOf("=");
             const name = eq > 0 ? a.slice(2, eq) : a.slice(2);
             if (eq > 0)
-                flags.set(name, a.slice(eq + 1));
+                valued(name, a.slice(eq + 1));
             else if (VALUED.has(name)) {
                 const v = argv[i + 1];
                 if (v === undefined || v.startsWith("--"))
-                    throw new CliError(`--${name} needs a value`);
-                flags.set(name, v);
+                    throw new CliError(`--${name} needs a value${name === "cli-args" ? ` (use --${name}="--flag ...")` : ""}`);
+                valued(name, v);
                 i++;
             }
             else
@@ -33,5 +45,5 @@ export function parseArgs(argv) {
         }
         pos.push(a);
     }
-    return { cmd: pos.shift(), pos, flags };
+    return { cmd: pos.shift(), pos, flags, lists };
 }

package/dist/attach.js

@@ -46,7 +46,7 @@ export function wsUrlFor(host, id) {
 }
 export function attach(deps, session, opts = {}) {
     const { api, stdin, stdout, stderr } = deps;
-    const filter = new InputFilter({ pasteImage: !opts.view });
+    const filter = new InputFilter({ pasteImage: !opts.view, detach: opts.detachKey !== false });
     const enc = new TextEncoder();
     return new Promise((resolve) => {
         let ws = null;
@@ -218,10 +218,6 @@ export function attach(deps, session, opts = {}) {
         function onData(chunk) {
             for (const a of filter.feed(chunk)) {
                 if (a.kind === "detach") {
-                    if (opts.onDetachKey) {
-                        opts.onDetachKey();
-                        continue;
-                    }
                     finish(0, "detached", "detached");
                     return;
                 }

package/dist/cli.js

@@ -4,6 +4,8 @@
 //   cubes login --host https://your-cubes   sign in (device code, approved in the browser)
 //   cubes ls                                 list sessions
 //   cubes attach [session]                   attach this terminal to a session (Ctrl-] detaches)
+//   cubes import [conversation]              continue a Claude Code conversation from here in Cubes
+//   cubes export [session]                   bring a session's conversation here, for claude --resume
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { createInterface } from "node:readline/promises";
@@ -20,9 +22,11 @@ import { clearLogin, configPath, loadLogin, saveLogin } from "./config.js";
 import { parseArgs } from "./args.js";
 import { formatSections, isUuid, listSessions, LIVE, resolveSession, sectionize, stateOf } from "./sessions.js";
 import { upgrade } from "./upgrade.js";
+import { exportCommand, importCommand } from "./conversationCmds.js";
+import { defaultsPrompter, terminalPrompter } from "./prompt.js";
 const PKG = createRequire(import.meta.url)("../package.json");
 const VERSION = PKG.version;
-const HELP = `cubes ${VERSION} - attach to your Cubes sessions from your own terminal
+const HELP = `cubes ${VERSION} - your Cubes sessions in your own terminal, and Claude Code conversations between here and Cubes
 
 Usage:
   cubes                                                   the split view: your sessions on the left, one open
@@ -35,6 +39,11 @@ Usage:
                                                           --live: running now, --all: include spawned ones)
   cubes attach [SESSION] [--view] [--no-resume] [--no-status]
                                                           attach to a session
+  cubes import [CONVERSATION] [--yes] [--no-attach] [form flags]
+                                                          start a Cubes session that continues a Claude Code
+                                                          conversation from this computer
+  cubes export [SESSION] [--dir DIR] [--force]            copy a session's conversation here, so
+                                                          \`claude --resume <id>\` continues it in DIR
   cubes upgrade [--check]                                 install the newest cubes (--check only reports)
 
 SESSION is an id, the start of one (4+ characters), or part of its title. Left out, you pick from
@@ -49,8 +58,21 @@ selecting). Claude Code's own copy, like the c on its login URL, lands there too
 
 If the connection drops, nothing reconnects on its own: you are told why, and r reconnects.
 
-In the split view: ⏎ or a click opens a session, Ctrl-] in a session jumps back to the list, l / m
-show only live / your sessions, / finds, ←→ fold a session's children, q quits (sessions keep running).
+Import asks which org, then everything the New session dialog asks (title, group, repositories,
+cube, agents, model, runner, Remote Control, extra CLI args), uploads the conversation and starts
+the session continuing it. CONVERSATION is its id, the start of it, or the path to its .jsonl; left
+out, you pick from your recent ones (this directory's first). Any question can be answered up front:
+  --title T  --group G  --repo R (repeatable)  --cube C  --input name=value (repeatable)
+  --agent A (repeatable)  --model M|default  --runner R  --rc | --no-rc  --cli-args="..."
+  --package ID  --mcp-config FILE  --hooks FILE
+--yes takes the default for everything not given. Only the conversation travels: the session checks
+its repositories out fresh. Export writes the conversation under ~/.claude/projects (or
+$CLAUDE_CONFIG_DIR) for DIR (default: here); it never replaces a copy you have continued locally
+unless --force. A stopped session on a cluster runner is resumed first, if you say so.
+
+In the split view: ⏎ or a click shows a session on the right and leaves you in the list, so you can
+keep browsing; F1 switches between the list and the session (a second ⏎ goes in too). l / m show
+only live / your sessions, / finds, ←→ fold a session's children, q quits (sessions keep running).
 
 Attaching takes the keyboard from any browser tab on the same session (it becomes read-only) and
 fits the session to this window. --view watches without taking it.
@@ -256,6 +278,19 @@ async function cmdAttach(a) {
         row = await api.get(`/sessions/${encodeURIComponent(row.id)}`);
     }
 }
+/** What import and export need from this process: who answers questions, and how to attach. */
+function conversationDeps(a) {
+    const interactive = isTTY() && !a.flags.has("yes");
+    return {
+        ask: interactive ? terminalPrompter() : defaultsPrompter(),
+        interactive,
+        err: process.stderr,
+        out: process.stdout,
+        attach: (id, org) => cmdAttach({
+            cmd: "attach", pos: [id], flags: new Map(org ? [["org", org]] : []), lists: new Map(),
+        }),
+    };
+}
 /** What the session copies goes to this machine's clipboard, when it has a way to write one. */
 export function copier() {
     const cmd = clipboardWriter();
@@ -288,7 +323,7 @@ async function main(argv) {
     }
     // No command at all, in a terminal: the split view. Piped or scripted, still the help.
     if (!a.cmd && !a.flags.has("help") && isTTY())
-        return launchTui({ org: str(a.flags, "org") });
+        return launchTui({ org: str(a.flags, "org"), version: VERSION });
     if (!a.cmd || a.cmd === "help" || a.flags.has("help")) {
         process.stdout.write(HELP);
         return a.cmd || a.flags.has("help") ? 0 : 1;
@@ -313,6 +348,8 @@ async function main(argv) {
             return 0;
         case "attach":
         case "a": return cmdAttach(a);
+        case "import": return importCommand(a, conversationDeps(a));
+        case "export": return exportCommand(a, conversationDeps(a));
         // The split view's two panes (src/tui), started by tmux - not for typing by hand.
         case "_list": return runList();
         case "_pane": return runPane(a.pos[0]);

package/dist/conversationCmds.js

@@ -0,0 +1,273 @@
+// `cubes import` and `cubes export` - a Claude Code conversation from this computer into a new Cubes
+// session, and a Cubes session's conversation onto this computer.
+//
+//   cubes import [CONVERSATION] [form flags] [--yes] [--attach | --no-attach]
+//   cubes export [SESSION] [--dir DIR] [--force]
+//
+// An import is the New session dialog with a conversation attached: which org, then every question the
+// dialog asks (src/form.ts), then the conversation is uploaded and the session is created through the
+// same route the dialog uses, continuing that conversation. An export files the session's
+// conversation where `claude --resume <id>` finds it when run in DIR (default: here).
+//
+// What travels is the CONVERSATION - the dialogue `--resume` reads. Not the working tree: an import
+// checks the session's repositories out fresh on its runner, and an export leaves the session's files
+// where they are (push them, or pull them from the session's branch).
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import { ApiError, makeApi } from "./api.js";
+import { CliError, currentSession, orgsOf } from "./auth.js";
+import { sessionForm } from "./form.js";
+import { claudeConfigDir, exportTarget, placeExport, recentConversations, resolveConversation, } from "./local.js";
+import { ensureRunning } from "./resume.js";
+import { age, isUuid, listSessions, LIVE, resolveSession, stateOf } from "./sessions.js";
+import { downloadConversation, uploadConversation } from "./transfer.js";
+export function fmtBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    if (n < 1024 * 1024 * 1024)
+        return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+/** A one-line progress readout on a terminal; a line at the start and the end otherwise. */
+export function progressLine(err, label) {
+    const tty = !!err.isTTY;
+    let last = -1;
+    let started = false;
+    return {
+        update(done, total) {
+            if (!tty) {
+                if (!started) {
+                    err.write(`${label}...\n`);
+                    started = true;
+                }
+                return;
+            }
+            const pct = total > 0 ? Math.floor((done / total) * 100) : 0;
+            if (pct === last)
+                return;
+            last = pct;
+            const width = 24;
+            const fill = Math.round((pct / 100) * width);
+            err.write(`\r\x1b[2K${label}  [${"#".repeat(fill)}${"-".repeat(width - fill)}] ${pct}%  ${fmtBytes(done)} of ${fmtBytes(total)}`);
+        },
+        done(final) {
+            err.write(tty ? `\r\x1b[2K${final}\n` : `${final}\n`);
+        },
+    };
+}
+/** "owner/name" for the checkout a conversation ran in, from its git origin - so its repository is
+ *  pre-selected. Nothing when the directory is not on this computer or is not a git checkout. */
+export async function gitOriginOf(cwd) {
+    if (!cwd || !existsSync(cwd))
+        return [];
+    try {
+        const { stdout } = await promisify(execFile)("git", ["-C", cwd, "remote", "get-url", "origin"], { timeout: 3000 });
+        const m = /[:/]([^/:\s]+\/[^/\s]+?)(?:\.git)?\/?\s*$/.exec(stdout.trim());
+        return m ? [m[1]] : [];
+    }
+    catch {
+        return [];
+    }
+}
+function readJsonFlag(path, flag) {
+    let v;
+    try {
+        v = JSON.parse(readFileSync(resolve(path), "utf8"));
+    }
+    catch (e) {
+        throw new CliError(`--${flag}: cannot read ${path} as JSON (${e.message})`);
+    }
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        throw new CliError(`--${flag}: ${path} must hold a JSON object`);
+    return v;
+}
+/** The form's answers that came on the command line. */
+export function formFlagsOf(a) {
+    const str = (n) => { const v = a.flags.get(n); return typeof v === "string" ? v : undefined; };
+    const inputs = {};
+    for (const kv of a.lists.get("input") ?? []) {
+        const eq = kv.indexOf("=");
+        if (eq < 1)
+            throw new CliError(`--input takes name=value (got "${kv}")`);
+        inputs[kv.slice(0, eq)] = kv.slice(eq + 1);
+    }
+    if (a.flags.has("rc") && a.flags.has("no-rc"))
+        throw new CliError("--rc and --no-rc together");
+    let hooks;
+    const hooksPath = str("hooks");
+    if (hooksPath) {
+        const h = readJsonFlag(hooksPath, "hooks");
+        // A settings.json pasted whole: take its `hooks`.
+        hooks = Object.keys(h).length === 1 && h.hooks && typeof h.hooks === "object" ? h.hooks : h;
+    }
+    const mcpPath = str("mcp-config");
+    return {
+        title: str("title"),
+        repos: (a.lists.get("repo") ?? []).flatMap((r) => r.split(",")).map((r) => r.trim()).filter(Boolean),
+        group: str("group"),
+        cube: str("cube"),
+        inputs: Object.keys(inputs).length ? inputs : undefined,
+        agents: (a.lists.get("agent") ?? []).flatMap((r) => r.split(",")).map((r) => r.trim()).filter(Boolean),
+        model: str("model"),
+        runner: str("runner"),
+        rc: a.flags.has("rc") ? true : a.flags.has("no-rc") ? false : undefined,
+        cliArgs: str("cli-args"),
+        packageId: str("package"),
+        mcpServers: mcpPath ? readJsonFlag(mcpPath, "mcp-config") : undefined,
+        hooks,
+    };
+}
+const orgFlag = (a) => { const v = a.flags.get("org"); return typeof v === "string" ? v : undefined; };
+/** Which org: the flag, the only one, or - asked for - a choice among the person's orgs. */
+async function chooseOrg(a, deps) {
+    const flagged = orgFlag(a);
+    const base = (deps.session ?? ((org) => currentSession({ org })))(flagged);
+    if (flagged)
+        return flagged;
+    const orgs = orgsOf(await base.token());
+    if (orgs.length <= 1 || !deps.interactive)
+        return base.org ?? orgs[0];
+    const def = Math.max(0, orgs.indexOf(base.org ?? ""));
+    return deps.ask.select("Which org should the session be in?", orgs.map((o) => ({
+        label: o, value: o, hint: o === base.org ? "your default" : undefined,
+    })), def);
+}
+function conversationLabel(c) {
+    const name = (c.title ?? c.firstPrompt ?? "(no prompt yet)").slice(0, 60);
+    return {
+        label: `${c.id.slice(0, 8)}  ${age(new Date(c.mtime).toISOString()).padStart(3)}  ${name}`,
+        hint: [c.cwd ?? "", fmtBytes(c.bytes)].filter(Boolean).join("  "),
+    };
+}
+export async function importCommand(a, deps) {
+    const env = deps.env ?? process.env;
+    const configDir = claudeConfigDir(env);
+    const query = a.pos.join(" ").trim();
+    let conv;
+    if (query)
+        conv = await resolveConversation(configDir, query);
+    else {
+        if (!deps.interactive)
+            throw new CliError("which conversation? `cubes import <id, start of the id, or path to its .jsonl>`");
+        const recent = await recentConversations(configDir, { cwd: deps.cwd ?? process.cwd(), limit: 15 });
+        if (!recent.length)
+            throw new CliError(`no Claude Code conversations in ${configDir}/projects`);
+        conv = await deps.ask.select("Import which conversation? (this directory's first)", recent.map((c) => ({ ...conversationLabel(c), value: c })), 0);
+    }
+    deps.ask.note(`Conversation ${conv.id} (${fmtBytes(conv.bytes)}${conv.cwd ? `, from ${conv.cwd}` : ""})`);
+    const org = await chooseOrg(a, deps);
+    const s = (deps.session ?? ((o) => currentSession({ org: o })))(org);
+    const api = makeApi(s);
+    const { spec, summary } = await sessionForm(api, deps.ask, formFlagsOf(a), {
+        suggestedTitle: conv.title ?? conv.firstPrompt ?? undefined,
+        repoHints: await gitOriginOf(conv.cwd),
+    });
+    deps.err.write(`\nA new session in ${org ?? "your org"}, continuing that conversation:\n${summary.join("\n")}\n\n`);
+    if (deps.interactive && !(await deps.ask.confirm("Start it?", true))) {
+        deps.err.write("Nothing was started.\n");
+        return 1;
+    }
+    const bar = progressLine(deps.err, "Uploading the conversation");
+    let importId;
+    try {
+        ({ importId } = await uploadConversation(api, conv, (d, t) => bar.update(d, t)));
+    }
+    catch (e) {
+        bar.done("Upload failed.");
+        throw e;
+    }
+    bar.done(`Uploaded ${fmtBytes(conv.bytes)}.`);
+    const created = await createImported(api, spec, importId);
+    const still = !created.provisioning ? "" : spec.repoIds?.length ? " - its repositories are still being checked out" : " - it is still starting";
+    deps.err.write(`Started "${spec.title}" (${created.id.slice(0, 8)})${still}.\n`);
+    deps.err.write(`Open it in the browser: ${s.host}/sessions/${created.id}\n`);
+    deps.out.write(`${created.id}\n`);
+    const wantAttach = a.flags.has("attach") || (!a.flags.has("no-attach") && deps.interactive
+        && await deps.ask.confirm("Attach to it now?", true));
+    if (wantAttach && deps.attach)
+        return deps.attach(created.id, org);
+    if (!wantAttach)
+        deps.err.write(`Attach any time with: cubes attach ${created.id.slice(0, 8)}${org ? ` --org ${org}` : ""}\n`);
+    return 0;
+}
+async function createImported(api, spec, importId) {
+    try {
+        return await api.post("/sessions", { ...spec, importId });
+    }
+    catch (e) {
+        // The upload is the server's to keep until it expires; a refused create would otherwise leave it
+        // counting against the person's open imports for hours.
+        await api.del(`/session-imports/${encodeURIComponent(importId)}`).catch(() => undefined);
+        throw e;
+    }
+}
+export async function exportCommand(a, deps) {
+    const env = deps.env ?? process.env;
+    const org = orgFlag(a);
+    const s = (deps.session ?? ((o) => currentSession({ org: o })))(org);
+    const api = makeApi(s);
+    const query = a.pos.join(" ").trim();
+    let row;
+    if (query && isUuid(query))
+        row = await api.get(`/sessions/${encodeURIComponent(query)}`);
+    else if (query)
+        row = resolveSession(await listSessions(api, { all: true }), query);
+    else {
+        if (!deps.interactive)
+            throw new CliError("which session? `cubes export <id or title>`");
+        const rows = (await listSessions(api)).slice(0, 20);
+        if (!rows.length)
+            throw new CliError("no sessions to export");
+        row = await deps.ask.select("Export which session?", rows.map((r) => ({
+            label: `${r.id.slice(0, 8)}  ${stateOf(r).padEnd(8)} ${r.title ?? "(untitled)"}`, value: r,
+        })), 0);
+    }
+    const dirFlag = a.flags.get("dir");
+    const dir = resolve(typeof dirFlag === "string" ? dirFlag : deps.cwd ?? process.cwd());
+    const configDir = claudeConfigDir(env);
+    const name = `"${row.title ?? row.id.slice(0, 8)}"`;
+    const fetchIt = async () => {
+        const bar = progressLine(deps.err, `Downloading ${name}`);
+        try {
+            const d = await downloadConversation(api, row.id, (cid) => exportTarget(configDir, dir, cid), (x, t) => bar.update(x, t));
+            bar.done(`Downloaded ${fmtBytes(d.bytes)}.`);
+            return d;
+        }
+        catch (e) {
+            bar.done("Download failed.");
+            throw e;
+        }
+    };
+    let got;
+    try {
+        got = await fetchIt();
+    }
+    catch (e) {
+        if (e instanceof ApiError && e.code === "no_conversation")
+            throw new CliError(`nothing has been said in ${name} yet, so there is no conversation to export`);
+        // A stopped session on a cluster runner keeps its conversation on its own volume; only a running
+        // box can read it. Offer to bring it back rather than just refusing.
+        if (!(e instanceof ApiError && e.code === "conversation_not_running"))
+            throw e;
+        if (!deps.interactive || !(await deps.ask.confirm(`${name} is not running, and its conversation is on its machine. Resume it to export?`, true))) {
+            throw new CliError(`${name} is not running - resume it first (\`cubes attach ${row.id.slice(0, 8)}\`, then detach), or answer yes here`);
+        }
+        row = await ensureRunning(api, row, true);
+        got = await fetchIt();
+    }
+    const target = exportTarget(configDir, dir, got.conversationId);
+    const how = await placeExport(got.file, target, a.flags.has("force"));
+    deps.err.write(how === "unchanged"
+        ? `Already up to date: ${target}\n`
+        : `${how === "created" ? "Exported" : "Updated"} ${name} to ${target}\n`);
+    deps.err.write(`Continue it here with:\n\n  cd ${JSON.stringify(dir)} && claude --resume ${got.conversationId}\n\n`);
+    if (LIVE.has(row.status)) {
+        deps.err.write("The session is still running in Cubes; what it says from now on stays there unless you export again.\n");
+    }
+    deps.out.write(`${target}\n`);
+    return 0;
+}