directionallylocal 0.4.1 → 0.5.0

package/dist/cli.js

@@ -7,6 +7,7 @@ import { briefStatus, connectLaptop, laptopsCommand, logsCommand, pairLaptop, se
 import { cancel, connect, describeError, laptopHome, pull, run, runs, servers, use, watch } from "./laptop/commands.js";
 import { loadRemotes } from "./laptop/config.js";
 import { keys } from "./laptop/keys.js";
+import { projectSession } from "./laptop/session.js";
 import { setup } from "./laptop/setup.js";
 import { localCommand } from "./local/cli.js";
 import { setUpOnThisComputer } from "./local/setup.js";
@@ -23,6 +24,9 @@ Send a task; it runs in its own sandbox and comes back as a pull request.
 On your laptop:
   dl                      set up the first time; afterwards, an overview
   dl setup                set up or repair where your agents run (safe to re-run)
+  dl  (in a GitHub repo)  talk to the repository's agent; it keeps running when you leave
+  dl new                  in a GitHub repo: start a fresh conversation for it
+  dl status               where your agents run and what they're doing (works anywhere)
   dl connect URL          connect to a server someone else set up (approve the code it shows)
   dl run "TASK"           run a task, from inside a GitHub repository
                           (your uncommitted changes go along; Ctrl-C stops watching, not the task)
@@ -206,8 +210,15 @@ export async function main(argv, io = {
                 if (!state) {
                     if (values.brief)
                         return 0;
-                    // A laptop connected to servers gets its own home; otherwise, what this is and how to start.
-                    if (!command && await laptopHome(laptopIO))
+                    // Inside a GitHub repository, that repository's conversation; elsewhere, the laptop's home.
+                    if (!command && terminal && (await loadRemotes()).length > 0) {
+                        const code = await projectSession({ cwd: process.cwd(), ...(values.server ? { server: values.server } : {}), ...(values.model ? { model: values.model } : {}) }, laptopIO);
+                        if (code !== undefined)
+                            return code;
+                    }
+                    // A laptop connected to servers gets its own home (`dl status` shows it from anywhere);
+                    // otherwise, what this is and how to start.
+                    if ((!command || command === "status") && await laptopHome(laptopIO))
                         return 0;
                     // A laptop with nothing set up yet: the wizard (it needs someone to answer it).
                     if (!command && terminal && !isRoot() && (await loadRemotes()).length === 0)
@@ -271,6 +282,13 @@ export async function main(argv, io = {
                     await pull({ id, cwd: process.cwd(), ...server }, laptopIO);
                 return 0;
             }
+            case "new": {
+                const code = await projectSession({ cwd: process.cwd(), fresh: true, ...(values.server ? { server: values.server } : {}), ...(values.model ? { model: values.model } : {}) }, laptopIO);
+                if (code !== undefined)
+                    return code;
+                io.err(`  dl new starts a fresh conversation from inside a GitHub repository (with something set up: dl setup).\n`);
+                return 1;
+            }
             case "servers":
                 return await servers(parsed.positionals.slice(1), laptopIO);
             case "use":

package/dist/laptop/commands.js

@@ -283,7 +283,8 @@ export async function laptopHome(io = processIO, open) {
     io.out("  Coding agents that run on this computer or your own server: send a task, get a pull request back.\n\n");
     io.out(`  ${c.dim("Runs on".padEnd(11))}${remotes.map((remote) => `${mark(remote, current, c)} ${remote.name} ${c.dim(where(remote))}`).join(", ")}   ${c.dim(remotes.length > 1 ? "dl servers · dl use NAME" : "dl servers")}\n`);
     io.out(`  ${c.dim("Tasks".padEnd(11))}${running} running · ${total} in all   ${c.dim("dl runs")}\n\n`);
-    io.out(`  ${c.dim("Send a task, from inside a GitHub repository:")}\n     ${c.bold('dl run "fix the flaky checkout test"')}\n\n`);
+    io.out(`  ${c.dim("Start a session: cd into a GitHub repository, then type")}  ${c.bold("dl")}\n`);
+    io.out(`  ${c.dim("Or hand off a one-off task:")}  ${c.bold('dl run "fix the flaky checkout test"')}\n\n`);
     return true;
 }
 async function follow(client, remote, conversationId, cursor, signal, io, replayUntil) {

package/dist/laptop/credentials.js

@@ -45,14 +45,14 @@ export async function gatherKeys(needs, input) {
     const wanted = needs.filter((need) => need === "github" || need === "openrouter");
     if (wanted.length === 0)
         return answers;
-    ui.questions(`${wanted.length === 1 ? "1 key" : "2 keys"}, kept on your server only; then it sets itself up.`);
+    ui.questions(`${wanted.length === 1 ? "1 key" : "2 keys"}, kept on ${input.place ?? "your server"} only; then it sets itself up.`);
     if (wanted.includes("github"))
         answers.githubToken = await githubToken(input);
     if (wanted.includes("openrouter"))
         answers.openrouterKey = await openrouterKey(input);
     return answers;
 }
-export async function githubToken({ ui, prompter, sources }) {
+export async function githubToken({ ui, prompter, sources, place = "your server" }) {
     const fromCli = (await sources.gh().catch(() => undefined))?.trim();
     if (fromCli) {
         const checked = await validateGitHubToken(fromCli, sources.fetch);
@@ -61,7 +61,7 @@ export async function githubToken({ ui, prompter, sources }) {
         }
         else {
             const who = checked.login ? ` (${checked.login})` : "";
-            if (await confirm(ui, prompter, `Use your GitHub CLI login${who}? It stays on your server.`)) {
+            if (await confirm(ui, prompter, `Use your GitHub CLI login${who}? It stays on ${place}.`)) {
                 ui.answered("GitHub", `${checked.login ? `signed in as ${checked.login} · ` : ""}from the GitHub CLI`);
                 return fromCli;
             }
@@ -73,7 +73,7 @@ export async function githubToken({ ui, prompter, sources }) {
         return { value: token, ...(checked.problem ? { problem: checked.problem } : {}), ...(checked.login ? { detail: `signed in as ${checked.login}` } : {}) };
     });
 }
-export async function openrouterKey({ ui, prompter, sources }) {
+export async function openrouterKey({ ui, prompter, sources, place = "your server" }) {
     const candidates = [];
     const fromEnv = sources.env.OPENROUTER_API_KEY?.trim();
     if (fromEnv)
@@ -88,7 +88,7 @@ export async function openrouterKey({ ui, prompter, sources }) {
             ui.warn(`The OpenRouter key ${candidate.from} didn't work (${problem})`);
             continue;
         }
-        if (await confirm(ui, prompter, `${candidate.question} It stays on your server.`)) {
+        if (await confirm(ui, prompter, `${candidate.question} It stays on ${place}.`)) {
             ui.answered("OpenRouter", candidate.from);
             return candidate.key;
         }

package/dist/laptop/session-store.js

@@ -0,0 +1,62 @@
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function sessionsPath(env = process.env) {
+    const configHome = env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    return join(configHome, "directionallylocal", "sessions.json");
+}
+export async function loadSessions(path = sessionsPath()) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.sessions) ? parsed.sessions.filter(isEntry) : [];
+    }
+    catch {
+        // A damaged file only costs a new conversation; it gets rewritten on the next save.
+        return [];
+    }
+}
+export async function findSession(key, path = sessionsPath()) {
+    return (await loadSessions(path)).find((entry) => sameKey(entry, key));
+}
+/** Remembers (or replaces) the conversation for this place + repository + checkout. */
+export async function rememberSession(entry, path = sessionsPath()) {
+    const kept = (await loadSessions(path)).filter((existing) => !sameKey(existing, entry));
+    kept.push({ ...entry, updatedAt: new Date().toISOString() });
+    await writeSessions(kept, path);
+}
+/** Forgets this key's conversation (it keeps running on the place); true when there was one. */
+export async function forgetSession(key, path = sessionsPath()) {
+    const sessions = await loadSessions(path);
+    const kept = sessions.filter((entry) => !sameKey(entry, key));
+    if (kept.length === sessions.length)
+        return false;
+    await writeSessions(kept, path);
+    return true;
+}
+function sameKey(a, b) {
+    return a.place === b.place && a.repository === b.repository && a.root === b.root;
+}
+async function writeSessions(sessions, path) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temp = `${path}.${process.pid}.tmp`;
+    const body = { version: 1, sessions };
+    await writeFile(temp, `${JSON.stringify(body, null, 2)}\n`, { mode: 0o600 });
+    await chmod(temp, 0o600);
+    await rename(temp, path);
+}
+function isEntry(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const entry = value;
+    return ["place", "repository", "root", "conversationId", "updatedAt"].every((key) => typeof entry[key] === "string") &&
+        (entry.branch === undefined || typeof entry.branch === "string");
+}

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/local/setup.js

@@ -221,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" };
     });
 }
 /**

package/dist/prompt.js

@@ -1,11 +1,52 @@
 import { openSync, closeSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { ReadStream, WriteStream } from "node:tty";
+import { palette } from "./ui.js";
+/** Thrown when someone presses Esc or Ctrl-C at a question; the terminal is already restored. */
+export class PromptCancelled extends Error {
+    constructor() {
+        super("Cancelled.");
+        this.name = "PromptCancelled";
+    }
+}
+function openDevTty() {
+    let fd;
+    try {
+        fd = openSync("/dev/tty", "r+");
+    }
+    catch {
+        throw new Error("No terminal to ask on; pass the answers as environment variables (see `dl --help`).");
+    }
+    const input = new ReadStream(fd);
+    const output = new WriteStream(fd);
+    return {
+        input,
+        output,
+        close: () => {
+            input.destroy();
+            output.destroy();
+            try {
+                closeSync(fd);
+            }
+            catch { /* already closed with the streams */ }
+        },
+    };
+}
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
 /**
  * Reads from /dev/tty, so prompts work under `curl … | sh` where stdin is the script.
  * Without a terminal every question fails with the env var that answers it.
  */
 export class TtyPrompter {
+    open;
+    color;
+    env;
+    constructor(options = {}) {
+        this.open = options.open ?? openDevTty;
+        this.env = options.env ?? process.env;
+        this.color = options.color ?? (!this.env.NO_COLOR && this.env.TERM !== "dumb");
+    }
     async choose(question, options, fallback) {
         const lines = options.map((option, index) => `  ${index + 1}. ${option.label}`).join("\n");
         const answer = (await this.ask(`${question}\n${lines}\nChoice [1]: `, false)).trim();
@@ -14,22 +55,50 @@ export class TtyPrompter {
         const index = Number(answer) - 1;
         return options[index]?.value ?? options.find((option) => option.value === answer)?.value ?? fallback;
     }
+    async select(question, options, initial = 0) {
+        if (options.length === 0)
+            throw new Error("select() needs at least one option");
+        const start = Math.min(Math.max(0, initial), options.length - 1);
+        const terminal = this.open();
+        const raw = typeof terminal.input.setRawMode === "function" && terminal.input.isTTY === true && this.env.TERM !== "dumb";
+        if (!raw) {
+            terminal.close();
+            return this.numbered(question, options, start);
+        }
+        return new ArrowSelect(terminal, question, options, start, this.color).run();
+    }
     secret(question) {
         return this.ask(question, true);
     }
     text(question) {
         return this.ask(question, false);
     }
-    ask(question, hidden) {
-        let fd;
-        try {
-            fd = openSync("/dev/tty", "r+");
-        }
-        catch {
-            throw new Error("No terminal to ask on; pass the answers as environment variables (see `dl --help`).");
+    /** The plain fallback: a numbered list, then a typed choice (Enter for the preselected one). */
+    async numbered(question, options, start) {
+        const c = palette(this.color);
+        const width = Math.max(...options.map((option) => option.label.length)) + 2;
+        const list = options.map((option, index) => `  ${c.cyan(String(index + 1))}  ${option.detail ? `${option.label.padEnd(width)} ${c.dim(option.detail)}` : option.label}`).join("\n");
+        const typed = options.find((option) => option.input);
+        const range = options.length === 2 ? "1 or 2" : `1-${options.length}`;
+        const hint = `${range}${typed ? `, or ${typed.input.placeholder.split(",")[0]}` : ""} · Enter for ${start + 1}`;
+        const split = question.lastIndexOf("\n");
+        const styled = split >= 0 ? `${question.slice(0, split)}  ${c.dim(hint)}${question.slice(split)}` : question;
+        for (let attempt = 1;; attempt++) {
+            const answer = (await this.ask(`${attempt === 1 ? `${list}\n\n` : ""}${styled}`, false)).trim();
+            const index = answer === "" ? start : /^\d+$/.test(answer) ? Number(answer) - 1 : -1;
+            const option = options[index];
+            if (option?.input)
+                return { value: option.value, text: (await this.ask(option.input.prompt, false)).trim() };
+            if (option)
+                return { value: option.value };
+            if (typed && answer)
+                return { value: typed.value, text: answer };
+            if (attempt >= 3)
+                throw new Error(`Pick one of ${range}`);
         }
-        const input = new ReadStream(fd);
-        const output = new WriteStream(fd);
+    }
+    ask(question, hidden) {
+        const { input, output, close } = this.open();
         // A styled prompt is "label line\n› ": print the label line ourselves and give readline
         // only the last line, so its redraws (and the hidden-input filter) stay on one line.
         const split = question.lastIndexOf("\n");
@@ -38,7 +107,7 @@ export class TtyPrompter {
         if (head)
             output.write(head);
         return new Promise((resolve) => {
-            const rl = createInterface({ input, output, terminal: true });
+            const rl = createInterface({ input, output, terminal: input.isTTY === true });
             if (hidden) {
                 // Echo nothing while the secret is typed.
                 rl._writeToOutput = (text) => {
@@ -50,17 +119,248 @@ export class TtyPrompter {
                 if (hidden)
                     output.write("\n");
                 rl.close();
-                input.destroy();
-                output.destroy();
-                try {
-                    closeSync(fd);
-                }
-                catch { /* already closed with the streams */ }
+                close();
                 resolve(answer.trim());
             });
         });
     }
 }
+/** Splits a chunk of terminal input into keys (one chunk can hold several, e.g. a paste). */
+export function parseKeys(chunk) {
+    const keys = [];
+    let text = "";
+    const push = (key) => {
+        if (text)
+            keys.push({ text });
+        text = "";
+        keys.push(key);
+    };
+    for (let i = 0; i < chunk.length; i++) {
+        const ch = chunk[i];
+        if (ch === "\x1b") {
+            const next = chunk[i + 1];
+            if (next === "[" || next === "O") {
+                // CSI / SS3: skip the parameters up to the final byte.
+                let end = i + 2;
+                while (end < chunk.length && !/[A-Za-z~]/.test(chunk[end]))
+                    end++;
+                const final = chunk[end];
+                if (final === "A")
+                    push("up");
+                else if (final === "B")
+                    push("down");
+                i = end;
+            }
+            else {
+                push("escape");
+            }
+        }
+        else if (ch === "\r" || ch === "\n") {
+            push("enter");
+        }
+        else if (ch === "\x03" || ch === "\x04") {
+            push("cancel");
+        }
+        else if (ch === "\x7f" || ch === "\b") {
+            push("backspace");
+        }
+        else if (ch === "\x15") {
+            push("clear");
+        }
+        else if (ch >= " ") {
+            text += ch;
+        }
+    }
+    if (text)
+        keys.push({ text });
+    return keys;
+}
+/**
+ * The arrow-key list, drawn inline under the question in normal scrollback: ↑/↓ or j/k move
+ * the `›` cursor, a digit jumps, Enter picks, Esc or Ctrl-C cancels. It redraws only its own
+ * lines and hides the cursor meanwhile; raw mode and the cursor come back on every way out,
+ * including a crash or a SIGINT/SIGTERM from elsewhere.
+ */
+class ArrowSelect {
+    terminal;
+    options;
+    cursor;
+    typing = false;
+    text = "";
+    digits = "";
+    drawn = 0;
+    head;
+    marker;
+    caret;
+    c;
+    constructor(terminal, question, options, start, color) {
+        this.terminal = terminal;
+        this.options = options;
+        this.c = palette(color);
+        this.cursor = start;
+        this.caret = color ? "\x1b[7m \x1b[27m" : "▏";
+        const split = question.lastIndexOf("\n");
+        this.head = split >= 0 ? question.slice(0, split) : question.trimEnd();
+        this.marker = split >= 0 ? question.slice(split + 1) : `${this.c.cyan("›")} `;
+    }
+    run() {
+        const { input, output } = this.terminal;
+        return new Promise((resolve, reject) => {
+            let finished = false;
+            const restore = () => {
+                input.setRawMode?.(false);
+                output.write(SHOW_CURSOR);
+            };
+            const onExit = () => restore();
+            const onSignal = () => { restore(); process.exit(130); };
+            const end = (outcome) => {
+                if (finished)
+                    return;
+                finished = true;
+                input.off("data", onData);
+                process.off("exit", onExit);
+                process.off("SIGINT", onSignal);
+                process.off("SIGTERM", onSignal);
+                restore();
+                this.terminal.close();
+                outcome();
+            };
+            const onData = (chunk) => {
+                try {
+                    for (const key of parseKeys(typeof chunk === "string" ? chunk : chunk.toString("utf8"))) {
+                        const result = this.handle(key);
+                        if (result === "cancel") {
+                            this.erase(true);
+                            end(() => reject(new PromptCancelled()));
+                            return;
+                        }
+                        if (result) {
+                            // Leave what an answered text prompt leaves: the question and `› choice`.
+                            this.erase(false);
+                            output.write(`${this.marker}${result.text ?? this.options.find((option) => option.value === result.value).label}\n`);
+                            end(() => resolve(result));
+                            return;
+                        }
+                    }
+                    this.draw();
+                }
+                catch (error) {
+                    end(() => reject(error));
+                }
+            };
+            process.once("exit", onExit);
+            process.on("SIGINT", onSignal);
+            process.on("SIGTERM", onSignal);
+            input.setRawMode(true);
+            input.on("data", onData);
+            input.resume();
+            output.write(`${HIDE_CURSOR}${this.fit(this.head, this.c.dim("  ↑/↓ to move · Enter to pick"))}\n`);
+            this.draw();
+        });
+    }
+    /** Applies a key: a result when something was picked, "cancel" to stop, else nothing (redraw). */
+    handle(key) {
+        if (key === "cancel")
+            return "cancel";
+        if (this.typing) {
+            if (key === "escape") {
+                this.typing = false;
+                this.text = "";
+            }
+            else if (key === "enter")
+                return this.text.trim() ? { value: this.options[this.cursor].value, text: this.text.trim() } : undefined;
+            else if (key === "backspace")
+                this.text = this.text.slice(0, -1);
+            else if (key === "clear")
+                this.text = "";
+            else if (typeof key === "object")
+                this.text += key.text;
+            return undefined;
+        }
+        if (key === "escape")
+            return "cancel";
+        if (key === "up")
+            this.move(-1);
+        else if (key === "down")
+            this.move(1);
+        else if (key === "enter") {
+            const option = this.options[this.cursor];
+            if (!option.input)
+                return { value: option.value };
+            this.typing = true;
+        }
+        else if (typeof key === "object") {
+            for (const ch of key.text) {
+                if (ch === "k")
+                    this.move(-1);
+                else if (ch === "j")
+                    this.move(1);
+                else if (/\d/.test(ch))
+                    this.jump(ch);
+            }
+        }
+        return undefined;
+    }
+    move(by) {
+        this.digits = "";
+        this.cursor = (this.cursor + by + this.options.length) % this.options.length;
+    }
+    /** A digit jumps to that option; with 10 or more, a second digit right after makes 10+. */
+    jump(digit) {
+        const combined = Number(this.digits + digit) - 1;
+        if (this.digits && combined < this.options.length) {
+            this.cursor = combined;
+            this.digits = "";
+            return;
+        }
+        const single = Number(digit) - 1;
+        if (single >= 0 && single < this.options.length)
+            this.cursor = single;
+        this.digits = this.options.length >= 10 && single >= 0 ? digit : "";
+    }
+    lines() {
+        if (this.typing) {
+            const option = this.options[this.cursor];
+            const placeholder = this.text ? "" : this.c.dim(option.input.placeholder);
+            // The real cursor stays hidden (it sits below the list); draw one where typing goes.
+            return [this.c.dim(`  ${option.label} · Esc to go back`), `${this.marker}${this.text}${this.caret}${placeholder}`];
+        }
+        const width = Math.max(...this.options.map((option) => option.label.length)) + 2;
+        return this.options.map((option, index) => {
+            const selected = index === this.cursor;
+            const label = option.detail ? option.label.padEnd(width) : option.label;
+            const line = `  ${selected ? this.c.cyan("›") : " "} ${selected ? this.c.bold(label) : label}`;
+            return this.fit(line, option.detail ? this.c.dim(option.detail) : "");
+        });
+    }
+    /** Redraws the lines under the question in place; lines never wrap, so the count holds. */
+    draw() {
+        const lines = this.lines();
+        const rewind = this.drawn > 0 ? `\x1b[${this.drawn}F` : "";
+        // When there are fewer lines than last time (typing mode), clear what's left below.
+        const stale = this.drawn > lines.length ? "\x1b[J" : "";
+        this.terminal.output.write(`${rewind}${lines.map((line) => `\x1b[2K${line}\n`).join("")}${stale}`);
+        this.drawn = lines.length;
+    }
+    /** Erases the list (and, when cancelling, the question too). */
+    erase(all) {
+        const up = this.drawn + (all ? 1 : 0);
+        this.terminal.output.write(`${up > 0 ? `\x1b[${up}F` : ""}\x1b[J`);
+        this.drawn = 0;
+    }
+    /** `styled` plus a dim tail, the tail cut so the line fits the terminal's width. */
+    fit(styled, tail) {
+        const columns = this.terminal.output.columns || 80;
+        const visible = (text) => text.replace(/\x1b\[[0-9;]*m/g, "");
+        const room = columns - 1 - visible(styled).length;
+        const plainTail = visible(tail);
+        if (plainTail.length <= room)
+            return `${styled}${tail}`;
+        if (room <= 1)
+            return styled;
+        return `${styled}${this.c.dim(`${plainTail.slice(0, room - 1)}…`)}`;
+    }
+}
 /** Answers from a map (tests); a missing answer is a test bug, so it throws. */
 export class ScriptedPrompter {
     answers;
@@ -71,6 +371,23 @@ export class ScriptedPrompter {
     async choose(question) {
         return this.answer(question);
     }
+    /**
+     * An answer is a number (1-based), an option's value or label, or "" for the preselected
+     * one. Picking an option that takes input then asks its prompt; other text goes to it directly.
+     */
+    async select(question, options, initial = 0) {
+        const answer = this.answer(question).trim();
+        const index = answer === "" ? initial : /^\d+$/.test(answer) ? Number(answer) - 1 : options.findIndex((option) => option.value === answer || option.label === answer);
+        const option = options[index];
+        if (option?.input)
+            return { value: option.value, text: this.answer(option.input.prompt).trim() };
+        if (option)
+            return { value: option.value };
+        const typed = options.find((entry) => entry.input);
+        if (typed)
+            return { value: typed.value, text: answer };
+        throw new Error(`no option "${answer}" for: ${question}`);
+    }
     async secret(question) {
         return this.answer(question);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directionallylocal",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Directionally Local: background coding agents on your own server. One-line server install, and the dl command for your server and laptop.",
   "license": "Apache-2.0",
   "homepage": "https://directionallylocal.com",
@@ -35,5 +35,8 @@
     "@types/node": "^22.10.0",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "autopilot-ai": "^2.7.0"
   }
 }