directionallylocal 0.4.0 → 0.5.0

package/dist/laptop/session.js

@@ -0,0 +1,279 @@
+import { execFile, spawn } from "node:child_process";
+import { constants, existsSync, readFileSync } from "node:fs";
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, delimiter, dirname, join, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { palette } from "../ui.js";
+import { RemoteApiError } from "./client.js";
+import { describeError, pickModel, readAutopilotModel } from "./commands.js";
+import { recordLastUsed, resolveTarget } from "./config.js";
+import { detectGitHubRepository, snapshotWorkingTree } from "./git.js";
+import { findSession, forgetSession, rememberSession, sessionsPath } from "./session-store.js";
+import { openRemoteForSession, withConnections } from "./tunnel.js";
+/**
+ * `dl` inside a project: Autopilot's own interactive screen, attached to this repository's
+ * conversation on the place agents run (`autopilot attach-remote`). The first time it starts
+ * one from this checkout (base commit + uncommitted changes, as `dl run` sends them); after
+ * that it reopens the same one. dl only finds the conversation, holds the SSH tunnel open,
+ * and gets out of the way: Autopilot owns the terminal until the user detaches.
+ */
+const execFileAsync = promisify(execFile);
+const realSpawn = (command, args, env) => spawn(command, args, { stdio: "inherit", env });
+const FORWARDED = ["SIGINT", "SIGTERM", "SIGHUP"];
+const UPDATE = "npm install -g directionallylocal";
+class Interrupted extends Error {
+}
+/**
+ * Opens the session, or returns undefined when this isn't a project dl can open one for
+ * (not a Git repository, origin not on GitHub, nothing pushed yet, or no place to pick),
+ * after a one-line note for the last three, so the caller shows the overview instead.
+ */
+export async function projectSession(input, io) {
+    const c = palette(io.color === true);
+    const note = (text) => io.err(`  ${c.yellow("!")} ${text}\n`);
+    const root = await gitRoot(input.cwd);
+    if (!root)
+        return undefined;
+    let repository;
+    try {
+        repository = await detectGitHubRepository(root);
+    }
+    catch {
+        note(`${basename(root)}'s origin isn't on GitHub, so there's no agent conversation to open here.`);
+        return undefined;
+    }
+    let target;
+    try {
+        target = await resolveTarget(input.server);
+    }
+    catch (error) {
+        if (input.server !== undefined)
+            throw error;
+        note(describeError(error));
+        return undefined;
+    }
+    const { remote } = target;
+    const key = { place: remote.name, repository, root };
+    const file = input.sessionsFile ?? sessionsPath();
+    const autopilot = await (input.autopilot ?? findAutopilot)();
+    // Asked while the tunnel opens; it only matters right before launching.
+    const ready = autopilot ? (input.probe ?? supportsAttachRemote)(autopilot).catch(() => false) : Promise.resolve(false);
+    const missing = () => {
+        io.err(`  ${c.red("✗")} The Autopilot that comes with dl ${autopilot ? "is too old to open a session" : "isn't installed"}. Update: ${c.bold(UPDATE)}\n`);
+        return 1;
+    };
+    // Ctrl-C (or a hang-up) before Autopilot starts stops dl, closing the tunnel on the way out;
+    // once it runs, Autopilot handles Ctrl-C itself and dl only passes on SIGTERM/SIGHUP.
+    const signals = input.signals ?? process;
+    let child;
+    let interrupt = () => { };
+    const interrupted = new Promise((_, reject) => { interrupt = () => reject(new Interrupted()); });
+    interrupted.catch(() => { });
+    const handlers = FORWARDED.map((name) => {
+        const handler = () => {
+            if (!child)
+                interrupt();
+            else if (name !== "SIGINT")
+                child.kill(name);
+        };
+        signals.on(name, handler);
+        return [name, handler];
+    });
+    const step = (work) => Promise.race([work, interrupted]);
+    try {
+        return await withConnections(input.open ?? openRemoteForSession, async (connections) => {
+            const client = await step(connections.client(remote));
+            let remembered = input.fresh ? undefined : await findSession(key, file);
+            if (remembered) {
+                const alive = await step(client.getConversation(remembered.conversationId).then((conversation) => conversation.status !== "destroyed", (error) => {
+                    if (error instanceof RemoteApiError && (error.status === 404 || error.status === 410))
+                        return false;
+                    throw error;
+                }));
+                if (!alive) {
+                    await forgetSession(key, file);
+                    note(`The last conversation for ${repository} on ${remote.name} is gone; starting a new one.`);
+                    remembered = undefined;
+                }
+            }
+            const scratch = await mkdtemp(join(tmpdir(), "dl-session-"));
+            try {
+                const stateFile = join(scratch, "state.json");
+                const args = ["attach-remote", "--state-file", stateFile, "--title", `${remote.name} · ${repository}`];
+                let detail;
+                if (remembered) {
+                    args.push("--conversation", remembered.conversationId);
+                    detail = remembered.conversationId.slice(0, 8);
+                }
+                else {
+                    let snapshot;
+                    try {
+                        snapshot = await step(snapshotWorkingTree(root));
+                    }
+                    catch (error) {
+                        if (error instanceof Interrupted)
+                            throw error;
+                        note(`${describeError(error)}.`.replace(/\.\.$/, "."));
+                        return undefined;
+                    }
+                    const [workspaces, models, preferred] = await step(Promise.all([
+                        client.workspaces(),
+                        client.models(),
+                        input.model ? Promise.resolve(undefined) : (input.autopilotModel ?? (() => readAutopilotModel()))(),
+                    ]));
+                    const workspace = workspaces[0];
+                    if (!workspace)
+                        throw new Error(`${remote.name} has no workspace this laptop can use`);
+                    const model = pickModel(models, input.model, preferred);
+                    args.push("--workspace", workspace.id, "--repo", repository, "--model", model, "--base-commit", snapshot.baseCommit);
+                    if (snapshot.patch) {
+                        const patchFile = join(scratch, "changes.patch");
+                        await writeFile(patchFile, snapshot.patch, { mode: 0o600 });
+                        args.push("--patch-file", patchFile);
+                    }
+                    const changes = snapshot.files.length ? ` + ${snapshot.files.length} local change${snapshot.files.length === 1 ? "" : "s"}` : "";
+                    detail = `new conversation from ${snapshot.baseCommit.slice(0, 7)}${changes}, ${model}`;
+                }
+                if (!autopilot || !(await step(ready)))
+                    return missing();
+                // `dl new`: the old conversation keeps running on the place (dl runs lists it).
+                if (input.fresh)
+                    await forgetSession(key, file);
+                io.err(`\n  ${c.cyan("·")} Connecting to ${c.bold(remote.name)} · ${repository} …  ${c.dim(`(${detail})`)}\n`);
+                // The token goes in the environment only: argv is visible to every user on the machine.
+                const env = { ...process.env, AUTOPILOT_REMOTE_URL: client.baseUrl, AUTOPILOT_REMOTE_TOKEN: remote.token };
+                let saved = remembered?.conversationId;
+                const save = async () => {
+                    const state = await readState(stateFile);
+                    if (!state || state.conversationId === saved)
+                        return;
+                    saved = state.conversationId;
+                    await rememberSession({ ...key, conversationId: state.conversationId, ...(state.branch ? { branch: state.branch } : {}) }, file);
+                };
+                // Remember it as soon as it exists, so a closed terminal doesn't lose it.
+                const poll = setInterval(() => { void save().catch(() => { }); }, 500);
+                poll.unref?.();
+                const outcome = await new Promise((resolve) => {
+                    const started = (input.spawn ?? realSpawn)(autopilot.command, [...autopilot.args, ...args], env);
+                    child = started;
+                    started.on("exit", (code) => resolve({ code }));
+                    started.on("error", (error) => resolve(error));
+                }).finally(() => clearInterval(poll));
+                await save().catch(() => { });
+                if (outcome instanceof Error)
+                    return missing();
+                if (outcome.code === 2)
+                    return missing();
+                if (outcome.code !== 0)
+                    return 1;
+                await recordLastUsed(remote.name).catch(() => undefined);
+                io.err(`\n  It keeps running on ${c.bold(remote.name)}. Type ${c.bold("dl")} here to come back, or ${c.bold("dl runs")}.\n\n`);
+                return 0;
+            }
+            finally {
+                await rm(scratch, { recursive: true, force: true });
+            }
+        });
+    }
+    catch (error) {
+        if (!(error instanceof Interrupted))
+            throw error;
+        io.err("\n");
+        return 130;
+    }
+    finally {
+        for (const [name, handler] of handlers)
+            signals.off(name, handler);
+    }
+}
+/** What `attach-remote --state-file` wrote, once the conversation exists. */
+async function readState(path) {
+    const raw = await readFile(path, "utf8").catch(() => undefined);
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.conversationId !== "string" || !parsed.conversationId)
+            return undefined;
+        return { conversationId: parsed.conversationId, ...(typeof parsed.branch === "string" && parsed.branch ? { branch: parsed.branch } : {}) };
+    }
+    catch {
+        return undefined; // still being written
+    }
+}
+async function gitRoot(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The Autopilot installed with dl (run with this Node), else an `autopilot` on PATH. */
+export async function findAutopilot() {
+    const bundled = bundledAutopilot();
+    if (bundled)
+        return { command: process.execPath, args: [bundled] };
+    const onPath = await autopilotOnPath();
+    return onPath ? { command: onPath, args: [] } : undefined;
+}
+/**
+ * autopilot-ai's bin script, found from where Node resolves the package for dl. Its exports
+ * don't include package.json, so the entry point is resolved and its package root found above it.
+ */
+export function bundledAutopilot(resolve = (specifier) => import.meta.resolve(specifier)) {
+    for (const specifier of ["autopilot-ai/package.json", "autopilot-ai"]) {
+        let dir;
+        try {
+            dir = dirname(fileURLToPath(resolve(specifier)));
+        }
+        catch {
+            continue;
+        }
+        for (;;) {
+            const manifest = join(dir, "package.json");
+            if (existsSync(manifest)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+                    if (pkg.name === "autopilot-ai") {
+                        const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.autopilot;
+                        const path = typeof bin === "string" ? resolvePath(dir, bin) : undefined;
+                        return path && existsSync(path) ? path : undefined;
+                    }
+                }
+                catch {
+                    // not a readable manifest; keep looking up
+                }
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return undefined;
+}
+export async function autopilotOnPath(env = process.env) {
+    for (const dir of (env.PATH ?? "").split(delimiter).filter(Boolean)) {
+        const candidate = join(dir, "autopilot");
+        if (await access(candidate, constants.X_OK).then(() => true, () => false))
+            return candidate;
+    }
+    return undefined;
+}
+/** An Autopilot that knows `attach-remote` lists its options (an older one prints its general help). */
+export async function supportsAttachRemote(autopilot) {
+    try {
+        const { stdout, stderr } = await execFileAsync(autopilot.command, [...autopilot.args, "attach-remote", "--help"], {
+            timeout: 30_000,
+            env: { ...process.env, NO_COLOR: "1" },
+        });
+        return `${stdout}${stderr}`.includes("--state-file");
+    }
+    catch {
+        return false;
+    }
+}

package/dist/laptop/setup.js

@@ -3,21 +3,23 @@ import { access as fileAccess, readdir, readFile } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
 import { join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { TtyPrompter } from "../prompt.js";
+import { PromptCancelled, TtyPrompter } from "../prompt.js";
 import { palette, PlainUi, TerminalUi } from "../ui.js";
-import { loadRemotes, normalizeServerUrl, REMOTE_NAME_RE, remotesPath, saveRemote } from "./config.js";
+import { loadRemotes, loadRemotesFile, normalizeServerUrl, REMOTE_NAME_RE, remotesPath, saveRemote, setDefaultRemote } from "./config.js";
 import { confirm, gatherKeys } from "./credentials.js";
 import { bootstrap, INSTALL_URL, installOnServer, pairLaptop, serverNeeds } from "./remote-install.js";
 import { checkServer, describeHost, discoverKeys, hostOf, parseSshConfig, parseTarget, realSshExec, SshAuthError } from "./ssh.js";
 import { openRemote, withConnections } from "./tunnel.js";
 const RUN_EXAMPLE = 'dl run "fix the flaky checkout test"';
+const PLACES = [
+    { value: "local", label: "On this computer", detail: "start now · nothing to rent · pauses when this computer sleeps" },
+    { value: "server", label: "On my own server", detail: "keeps going when your laptop is closed · needs SSH access" },
+];
 export async function setupWizard(deps) {
     const c = palette(deps.color);
     deps.write(`\n  ${c.bold("Directionally Local")}\n  Background coding agents. Where should they run?\n\n`);
-    deps.write(`  ${c.cyan("1")}  ${"On this computer".padEnd(22)} ${c.dim("start now · nothing to rent · pauses when this computer sleeps")}\n`);
-    deps.write(`  ${c.cyan("2")}  ${"On my own server".padEnd(22)} ${c.dim("keeps going when your laptop is closed · needs SSH access")}\n\n`);
     const ui = deps.newUi();
-    let where = await pick(ui, deps.prompter, "Where", "1 or 2 · Enter for 1", { "1": "local", "2": "server" });
+    let where = (await deps.prompter.select(ui.prompt("Where"), PLACES, 0)).value;
     ui.answered("Where", where === "local" ? "On this computer" : "On my own server");
     if (where === "local" && !deps.localSetup) {
         ui.line("info", "On this computer", "coming soon");
@@ -30,11 +32,15 @@ export async function setupWizard(deps) {
     }
     if (where === "local") {
         const keysUi = deps.newUi();
-        const answers = await gatherKeys(["github", "openrouter"], { ui: keysUi, prompter: deps.prompter, sources: deps.sources });
+        const answers = await gatherKeys(["github", "openrouter"], { ui: keysUi, prompter: deps.prompter, sources: deps.sources, place: "this computer" });
         keysUi.finish();
-        const remote = await deps.localSetup({ ui: deps.newUi(), prompter: deps.prompter, answers: { openrouterKey: answers.openrouterKey, githubToken: answers.githubToken } });
-        await saveRemote(remote, deps.remotesFile ?? remotesPath());
-        finishScreen(deps.newUi(), undefined);
+        const { remote, capacity } = await deps.localSetup({ ui: deps.newUi(), prompter: deps.prompter, answers: { openrouterKey: answers.openrouterKey, githubToken: answers.githubToken } });
+        const remotesFile = deps.remotesFile ?? remotesPath();
+        const isNew = !(await loadRemotes(remotesFile)).some((entry) => entry.name === remote.name);
+        await saveRemote(remote, remotesFile);
+        if (isNew)
+            await chooseDefault(deps, remote, remotesFile);
+        finishScreen(deps.newUi(), capacity);
         return remote;
     }
     return setUpServer(deps);
@@ -61,7 +67,8 @@ async function setUpServer(deps) {
     // 4. A credential for this laptop, checked through the tunnel every command will use. Each
     // `dl pair` makes a new credential on the server, so a re-run keeps the saved one if it works.
     const remotesFile = deps.remotesFile ?? remotesPath();
-    const saved = (await loadRemotes(remotesFile)).find((entry) => sameServer(entry, access));
+    const known = await loadRemotes(remotesFile);
+    const saved = known.find((entry) => sameServer(entry, access));
     let remote;
     if (saved && await stillWorks({ ...saved, ssh: access }, deps.open))
         remote = { ...saved, ssh: access };
@@ -91,25 +98,25 @@ async function setUpServer(deps) {
     await saveRemote(remote, remotesFile);
     connectedUi.line("done", "This laptop", `connected as ${remote.name}`);
     connectedUi.finish();
+    if (!known.some((entry) => entry.name === paired.name))
+        await chooseDefault(deps, remote, remotesFile);
     finishScreen(deps.newUi(), capacity);
     return remote;
 }
 async function chooseServer(deps, hosts) {
-    const c = palette(deps.color);
     const ui = deps.newUi();
-    if (hosts.length > 0) {
-        deps.write(`\n  ${c.dim("Your servers in ~/.ssh/config:")}\n`);
-        hosts.forEach((host, index) => deps.write(`  ${c.cyan(String(index + 1))}  ${host.alias.padEnd(22)} ${c.dim(describeHost(host))}\n`));
-        deps.write(`  ${c.cyan(String(hosts.length + 1))}  Another server\n\n`);
-    }
-    else {
-        deps.write("\n");
-    }
-    const hint = hosts.length > 0 ? `1-${hosts.length + 1}, or user@host[:port]` : "user@host[:port], e.g. root@203.0.113.10";
+    deps.write("\n");
+    const example = "user@host[:port], e.g. root@203.0.113.10";
+    const options = [
+        ...hosts.map((host, index) => ({ value: String(index), label: host.alias, detail: describeHost(host) })),
+        { value: "another", label: "Another server", input: { prompt: ui.prompt("Server address", example), placeholder: example } },
+    ];
     for (let attempt = 1;; attempt++) {
-        let answer = (await deps.prompter.text(ui.prompt("Server", hint))).trim();
-        const index = /^\d+$/.test(answer) ? Number(answer) - 1 : -1;
-        const host = hosts[index];
+        // Without saved hosts, a one-item list would only be in the way: just ask for the address.
+        const picked = hosts.length > 0
+            ? await deps.prompter.select(ui.prompt("Server"), options, 0)
+            : { value: "another", text: (await deps.prompter.text(ui.prompt("Server", example))).trim() };
+        const host = picked.value === "another" ? undefined : hosts[Number(picked.value)];
         if (host) {
             ui.answered("SSH", host.alias);
             return {
@@ -118,12 +125,8 @@ async function chooseServer(deps, hosts) {
                 display: `${host.user ? `${host.user}@` : ""}${host.hostName ?? host.alias}${host.port && host.port !== 22 ? `:${host.port}` : ""}`,
             };
         }
-        if (index === hosts.length && hosts.length > 0) {
-            ui.answered("SSH", "another server");
-            answer = (await deps.prompter.text(ui.prompt("Server address", "user@host[:port], e.g. root@203.0.113.10"))).trim();
-        }
         try {
-            const access = parseTarget(answer);
+            const access = parseTarget(picked.text ?? "");
             ui.answered("SSH", access.target);
             return { access, display: `${access.target}${access.port ? `:${access.port}` : ""}` };
         }
@@ -134,6 +137,35 @@ async function chooseServer(deps, hosts) {
         }
     }
 }
+/**
+ * With two or more places set up, where `dl run` sends tasks unless told otherwise. Asked
+ * only when setup adds a place, with the new one preselected; the first place becomes the
+ * default by itself (saveRemote).
+ */
+async function chooseDefault(deps, added, remotesFile) {
+    const { remotes } = await loadRemotesFile(remotesFile);
+    if (remotes.length < 2)
+        return;
+    const ui = deps.newUi();
+    deps.write("\n");
+    const options = remotes.map((remote) => ({ value: remote.name, label: remote.name, detail: describePlace(remote) }));
+    const initial = Math.max(0, remotes.findIndex((remote) => remote.name === added.name));
+    const { value } = await deps.prompter.select(ui.prompt("Where should tasks go by default?"), options, initial);
+    await setDefaultRemote(value, remotesFile);
+    ui.answered("Default", value);
+    ui.finish();
+}
+function describePlace(remote) {
+    if (remote.ssh)
+        return `server · ${remote.ssh.target}${remote.ssh.port ? `:${remote.ssh.port}` : ""}`;
+    try {
+        const host = new URL(remote.url).hostname;
+        return host === "127.0.0.1" || host === "localhost" ? "this computer" : `server · ${host}`;
+    }
+    catch {
+        return remote.url;
+    }
+}
 /**
  * Connects and checks the server. If it refuses the default keys (ssh's own: the agent and
  * ~/.ssh/id_*), each key pair in ~/.ssh is tried in turn with -i, without asking: auth
@@ -246,25 +278,13 @@ export function serverLabel(text) {
 }
 function finishScreen(ui, capacity) {
     ui.ready(capacity ? `Ready · fits ~${capacity} agents at once (estimate)` : "Ready", [
-        { label: "From any GitHub repository", value: RUN_EXAMPLE },
-        { label: "See progress, then check out the result", value: "dl runs\ndl pull ID" },
-    ]);
+        { label: "Start a session: cd into a GitHub repository, then type", value: "dl" },
+        { label: "Or hand off a one-off task", value: RUN_EXAMPLE },
+    ], { footer: "dl status shows where agents run and what they're doing." });
 }
 function laptopName(name) {
     return name.replace(/\.local$/, "").replace(/[^\p{L}\p{N} ._'()@-]/gu, "-").slice(0, 40) || "laptop";
 }
-async function pick(ui, prompter, label, hint, choices) {
-    const values = Object.values(choices);
-    for (let attempt = 1;; attempt++) {
-        const answer = (await prompter.text(ui.prompt(label, hint))).trim();
-        const choice = answer === "" ? values[0] : choices[answer];
-        if (choice)
-            return choice;
-        if (attempt >= 3)
-            throw new Error(`Pick one of ${Object.keys(choices).join(", ")}`);
-        ui.rejected(`Type ${Object.keys(choices).join(" or ")}.`);
-    }
-}
 /** `dl setup` with the real terminal, ssh, gh, and filesystem. */
 export async function setup(options) {
     const { io, terminal } = options;
@@ -277,25 +297,34 @@ export async function setup(options) {
         identityFile = resolve(options.identityFile.replace(/^~(?=$|\/)/, home).replace(/\.pub$/, ""));
         await fileAccess(identityFile).catch(() => { throw new Error(`No SSH key at ${options.identityFile} (--identity takes the private key, e.g. ~/.ssh/id_ed25519)`); });
     }
-    await setupWizard({
-        newUi: () => terminal ? new TerminalUi(io.out, undefined, color) : new PlainUi(io.out),
-        prompter: new TtyPrompter(),
-        write: io.out,
-        color,
-        ssh: realSshExec,
-        open: openRemote,
-        sources: {
-            env: process.env,
-            home,
-            readFile: (path) => readFile(path, "utf8").catch(() => undefined),
-            listDir: (path) => readdir(path).catch(() => []),
-            gh: () => execFileAsync("gh", ["auth", "token"], { timeout: 5000 }).then(({ stdout }) => stdout.trim() || undefined, () => undefined),
-            fetch: globalThis.fetch,
-        },
-        hostname: hostname(),
-        installUrl: process.env.DL_INSTALL_URL || INSTALL_URL,
-        ...(options.localSetup ? { localSetup: options.localSetup } : {}),
-        ...(identityFile ? { identityFile } : {}),
-    });
+    try {
+        await setupWizard({
+            newUi: () => terminal ? new TerminalUi(io.out, undefined, color) : new PlainUi(io.out),
+            prompter: new TtyPrompter({ color }),
+            write: io.out,
+            color,
+            ssh: realSshExec,
+            open: openRemote,
+            sources: {
+                env: process.env,
+                home,
+                readFile: (path) => readFile(path, "utf8").catch(() => undefined),
+                listDir: (path) => readdir(path).catch(() => []),
+                gh: () => execFileAsync("gh", ["auth", "token"], { timeout: 5000 }).then(({ stdout }) => stdout.trim() || undefined, () => undefined),
+                fetch: globalThis.fetch,
+            },
+            hostname: hostname(),
+            installUrl: process.env.DL_INSTALL_URL || INSTALL_URL,
+            ...(options.localSetup ? { localSetup: options.localSetup } : {}),
+            ...(identityFile ? { identityFile } : {}),
+        });
+    }
+    catch (error) {
+        if (!(error instanceof PromptCancelled))
+            throw error;
+        // Esc / Ctrl-C at a question: the terminal is restored; say so quietly and stop.
+        io.out(`  ${palette(color).dim("Cancelled. Run")} dl setup ${palette(color).dim("when you're ready.")}\n\n`);
+        return 130;
+    }
     return 0;
 }

package/dist/laptop/tunnel.js

@@ -57,6 +57,14 @@ export function createOpener(options = {}) {
     };
 }
 export const openRemote = createOpener();
+/**
+ * For an interactive session: ssh in its own process group, so Ctrl-C typed into the agent's
+ * screen (which the terminal sends to its whole foreground group) doesn't drop the tunnel.
+ * The session closes it itself when the agent exits, or when dl is told to stop.
+ */
+export const openRemoteForSession = createOpener({
+    spawn: (args) => spawn("ssh", args, { stdio: ["ignore", "ignore", "pipe"], detached: true }),
+});
 /**
  * The endpoints one command uses: at most one tunnel per server, reused across its
  * requests, all closed when the command ends (commands close it in `finally`, which also

package/dist/layout.js

@@ -8,6 +8,8 @@ export const PATHS = {
     hotcellEnv: "/etc/hotcell/hotcell.env",
     hotcellEtc: "/etc/hotcell",
     hotcellHome: "/var/lib/hotcell",
+    /** OpenRouter's prices, so Hotcell's spend-capped gateway forwards current models. */
+    modelPrices: "/var/lib/hotcell/model-prices.json",
     autopilotEtc: "/etc/autopilot",
     autopilotEnv: "/etc/autopilot/autopilot.env",
     githubEnv: "/etc/autopilot/github.env",
@@ -70,6 +72,8 @@ export function hotcellEnv(input) {
         HOTCELL_EGRESS_HOST: input.bridgeIp,
         HOTCELL_EGRESS_PORT: String(HOTCELL_EGRESS_PORT),
         HOTCELL_EGRESS_ADVERTISE_HOST: "host.docker.internal",
+        // Under a spend cap the gateway refuses models it can't price; `dl up` refreshes this list.
+        HOTCELL_MODEL_PRICES: PATHS.modelPrices,
     });
 }
 export function autopilotEnv(input) {

package/dist/local/cli.js

@@ -28,12 +28,15 @@ export function formatLocalStatus(status, c, home) {
     const mark = (ok) => (ok ? c.green("✓") : c.red("✗"));
     const line = (ok, label, detail) => `  ${mark(ok)} ${label.padEnd(12)}${c.dim(detail)}\n`;
     const describe = (entry) => entry.running ? `running${entry.pid ? ` (pid ${entry.pid})` : ""}` : entry.installed ? "stopped" : "not installed";
-    const healthy = services.hotcell.running && services.autopilot.running && status.answering && status.dockerRunning;
+    const healthy = services.hotcell.running && services.autopilot.running && status.answering && status.dockerRunning && status.modelPrices.ok;
     return [
         `\n  ${c.bold("Directionally Local")}  ${c.dim("on this computer")}  ${healthy ? c.green("running") : c.red("needs attention")}\n\n`,
         line(status.dockerRunning, "Docker", status.dockerRunning ? state.dockerRuntime : `${state.dockerRuntime} isn't running; start it`),
         line(services.hotcell.running, "Hotcell", `${describe(services.hotcell)} · 127.0.0.1:${state.ports.hotcell} · ${state.hotcellVersion}`),
         line(services.autopilot.running && status.answering, "Autopilot", `${describe(services.autopilot)}${status.answering ? "" : ", not answering"} · ${state.url} · ${state.autopilotVersion}`),
+        status.modelPrices.warn
+            ? `  ${c.yellow("!")} ${"Prices".padEnd(12)}${c.dim(status.modelPrices.detail)}\n`
+            : line(status.modelPrices.ok, "Prices", status.modelPrices.detail),
         `\n  ${c.dim("Fits")}        ${status.capacity !== undefined ? `~${status.capacity} agents at once (estimate, from Docker's memory)` : "unknown while Docker is stopped"}\n`,
         `  ${c.dim("Installed")}   ${short(status.paths.current)}\n`,
         `  ${c.dim("Logs")}        ${short(status.paths.logs)}\n`,

package/dist/local/layout.js

@@ -21,6 +21,7 @@ export function localPaths(home, platform) {
         githubEnv: join(config, "github.env"),
         asterConfig: join(config, "aster.json"),
         hotcellHome: join(root, "hotcell"),
+        modelPrices: join(root, "hotcell", "model-prices.json"),
         autopilotHome,
         workspace: join(autopilotHome, "workspaces", "default"),
         services: platform === "darwin" ? join(home, "Library", "LaunchAgents") : join(home, ".config", "systemd", "user"),
@@ -89,6 +90,8 @@ export function localHotcellEnv(input) {
         HOTCELL_EGRESS_HOST: input.net.listenHost,
         HOTCELL_EGRESS_PORT: String(ports.hotcellEgress),
         HOTCELL_EGRESS_ADVERTISE_HOST: "host.docker.internal",
+        // Under a spend cap the gateway refuses models it can't price; setup refreshes this list.
+        HOTCELL_MODEL_PRICES: paths.modelPrices,
     });
 }
 export function localAutopilotEnv(input) {

package/dist/local/setup.js

@@ -28,6 +28,7 @@ import { removeRemote } from "../laptop/config.js";
 import { RealSystem } from "../system.js";
 import { checkComputer, computerProblems, localCapacity, servicePath, supportedPlatform } from "./check.js";
 import { LOCAL_SERVICES, PAIRED_NAME, PREFERRED_PORTS, autopilotXdg, localAsterConfig, localAutopilotBin, localAutopilotEnv, localGithubEnv, localHotcellBin, localHotcellEnv, localPaths, parseLocalEnvFile, serviceSpecs, } from "./layout.js";
+import { fileMtime, modelPricesHealth, refreshModelPrices } from "../model-prices.js";
 import { httpStatus, portFree } from "./probes.js";
 import { installService, removeServices, serviceState, stopService, userId } from "./services.js";
 import { readLocalState, writeLocalState } from "./state.js";
@@ -153,6 +154,14 @@ export async function setUpOnThisComputer(input) {
         const previousAutopilot = parseLocalEnvFile(await system.readFile(paths.autopilotEnv));
         const ports = await choosePorts(ctx, node, net, previousPorts(previous, previousAutopilot));
         const apiKey = previous.HOTCELL_API_KEY || randomBytes(24).toString("hex");
+        // Hotcell reads it once at start, so it's in place before the service starts below.
+        const prices = await refreshModelPrices(system, {
+            path: paths.modelPrices,
+            write: { mode: 0o644 },
+            fetchImpl: input.fetchImpl ?? fetch,
+            warn: (text) => ui.warn(text),
+            retry: "dl setup",
+        });
         await system.writeFile(paths.hotcellEnv, localHotcellEnv({ paths, apiKey, ports, net }), { mode: 0o600, secret: true });
         if (!(await system.readFile(paths.asterConfig)))
             await system.writeFile(paths.asterConfig, localAsterConfig(paths), { mode: 0o600 });
@@ -168,7 +177,7 @@ export async function setUpOnThisComputer(input) {
         // Without a token the Aster API answers 401: up, and refusing strangers.
         await waitUntil(ctx, "Autopilot", join(paths.logs, LOCAL_SERVICES.autopilot.log), async () => await httpStatus(system, node, `http://127.0.0.1:${ports.autopilot}/api/v1/health`) === 401);
         await pruneReleases(system, paths, release);
-        return { value: ports, detail: `start at login · logs in ${tilde(paths.logs, ctx.home)}` };
+        return { value: ports, detail: `start at login · logs in ${tilde(paths.logs, ctx.home)}${prices ? ` · ${prices}` : ""}` };
     });
     const url = `http://127.0.0.1:${ports.autopilot}`;
     return await step("connect", async () => {
@@ -212,10 +221,8 @@ export async function setUpOnThisComputer(input) {
             expiresAt: new Date(credential.expiresAt).toISOString(),
             addedAt: at,
         };
-        return {
-            value: remote,
-            detail: `${url.replace(/^http:\/\//, "")} · fits ~${localCapacity(docker)} at once · tasks pause while this computer sleeps`,
-        };
+        // The address is an implementation detail here; how many fit goes on the wizard's Ready line.
+        return { value: { remote, capacity: localCapacity(docker) }, detail: "this computer · tasks pause while it sleeps" };
     });
 }
 /**
@@ -296,7 +303,8 @@ export async function localStatus(options = {}) {
             capacity = localCapacity({ memoryMb: Math.round(Number(mem) / 1024 / 1024), cpus: Number(cpus) || 0 });
         }
     }
-    return { installed: Boolean(state), state, services: { hotcell, autopilot }, answering, capacity, dockerRunning, paths, platform: ctx.rawPlatform };
+    const modelPrices = modelPricesHealth(await system.readFile(paths.modelPrices), await fileMtime(system, paths.modelPrices, platform), (options.now ?? (() => new Date()))(), "dl setup");
+    return { installed: Boolean(state), state, services: { hotcell, autopilot }, answering, capacity, dockerRunning, modelPrices, paths, platform: ctx.rawPlatform };
 }
 function checkOptions(ctx, options) {
     return {