directionallylocal 0.3.0 → 0.4.0

package/dist/cli.js

@@ -2,9 +2,11 @@ import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { parseArgs } from "node:util";
 import { doctor, formatChecks } from "./doctor.js";
+import { serverKeysCommand } from "./keys.js";
 import { briefStatus, connectLaptop, laptopsCommand, logsCommand, pairLaptop, serverHome, serverRunsCommand } from "./home.js";
-import { cancel, connect, describeError, laptopHome, pull, run, runs, servers, watch } from "./laptop/commands.js";
+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 { setup } from "./laptop/setup.js";
 import { localCommand } from "./local/cli.js";
 import { setUpOnThisComputer } from "./local/setup.js";
@@ -14,21 +16,23 @@ import { DryRunSystem, RealSystem } from "./system.js";
 import { uninstall } from "./uninstall.js";
 import { JsonUi, PlainUi, TerminalUi, palette } from "./ui.js";
 import { needs, parseAccessMode, parseProvidedAnswers, up } from "./up.js";
-const HELP = `Directionally Local: background coding agents on your own server.
-Send a task from your laptop; it runs in its own sandbox and comes back as a pull request.
+const HELP = `Directionally Local: coding agents that run on this computer or on your own server.
+Send a task; it runs in its own sandbox and comes back as a pull request.
 (dl is short for directionallylocal; both work.)
 
 On your laptop:
-  dl                      set up where agents run (the first time; afterwards, an overview)
-  dl setup                set up, or repair, a server over SSH (safe to re-run)
+  dl                      set up the first time; afterwards, an overview
+  dl setup                set up or repair where your agents run (safe to re-run)
   dl connect URL          connect to a server someone else set up (approve the code it shows)
-  dl run "TASK"           run a task on the server, from inside a GitHub repository
+  dl run "TASK"           run a task, from inside a GitHub repository
                           (your uncommitted changes go along; Ctrl-C stops watching, not the task)
   dl runs                 your tasks and their pull requests
   dl watch ID             follow a task      dl cancel ID   stop one
   dl pull ID              check out a task's branch here
-  dl servers              connected servers (dl servers remove NAME)
-  run options: --server NAME, -m MODEL, --repo OWNER/NAME, --detach
+  dl servers              where agents run (dl servers remove NAME · dl servers rename OLD NEW)
+  dl use [NAME]           where tasks go without --server (no NAME: show it)
+  dl keys [openrouter|github]   which keys are set, or replace one (--server NAME)
+  run options: --server NAME, -m/--model MODEL, --repo OWNER/NAME, --detach
   dl local status         agents running on this computer: running?, where, how many fit
   dl local uninstall [--purge]   stop and remove them (--purge also deletes keys and data)
 
@@ -41,6 +45,7 @@ On the server:
   dl runs                 tasks running or done, with their pull requests
   dl logs [hotcell|autopilot] [-f]   the services' logs
   dl doctor               check every part, with a fix for each problem
+  dl keys [set openrouter|github]   which keys are set, or replace one (hidden input)
   dl uninstall [--purge]  remove everything (--purge also removes config and data)
 
 up options:
@@ -62,6 +67,7 @@ Used by the laptop's setup (over SSH, as root):
                               install with the keys as one JSON object on stdin; progress as JSON lines
   dl up --needs [--access ssh]   which keys dl up would still need, as JSON; changes nothing
   dl pair --name NAME --json     a credential for that laptop, as JSON
+  dl keys set openrouter|github --stdin --json   replace a key read from stdin
 `;
 export async function main(argv, io = {
     out: (text) => process.stdout.write(text),
@@ -92,6 +98,8 @@ export async function main(argv, io = {
                 "answers-stdin": { type: "boolean" },
                 events: { type: "string" },
                 needs: { type: "boolean" },
+                identity: { type: "string" },
+                stdin: { type: "boolean" },
             },
         });
     }
@@ -220,7 +228,7 @@ export async function main(argv, io = {
                 return 0;
             }
             case "setup":
-                return await setup({ io: laptopIO, terminal, localSetup: (input) => setUpOnThisComputer(input) });
+                return await setup({ io: laptopIO, terminal, localSetup: (input) => setUpOnThisComputer(input), ...(values.identity ? { identityFile: values.identity } : {}) });
             case "connect": {
                 const url = parsed.positionals[1];
                 if (!url) {
@@ -265,6 +273,8 @@ export async function main(argv, io = {
             }
             case "servers":
                 return await servers(parsed.positionals.slice(1), laptopIO);
+            case "use":
+                return await use(parsed.positionals.slice(1), laptopIO);
             case "runs":
                 // On a server, its runs; on a laptop, the tasks it sent.
                 if (!(await readState(system))) {
@@ -293,6 +303,18 @@ export async function main(argv, io = {
                     return await serverRunsCommand(system, io.out, colors);
                 return await logsCommand(system, [...rest, ...(values.follow ? ["-f"] : [])]);
             }
+            case "keys": {
+                // On a server, its own keys (as root); on a laptop, the keys where its agents run.
+                if (!(await readState(system)))
+                    return await keys(parsed.positionals.slice(1), { ...(values.server ? { server: values.server } : {}), io: laptopIO, terminal });
+                if (!isRoot()) {
+                    io.err(`  Run it as root: sudo dl ${parsed.positionals.join(" ")}\n`);
+                    return 1;
+                }
+                return await serverKeysCommand(system, parsed.positionals.slice(1), { json: Boolean(values.json), stdin: Boolean(values.stdin) }, {
+                    out: io.out, err: io.err, colors, stdin: options.stdin ?? process.stdin, prompter: new TtyPrompter(),
+                });
+            }
             case "local":
                 return await localCommand(parsed.positionals.slice(1), { purge: Boolean(values.purge) }, io, colors, ui);
             case "uninstall":
@@ -321,10 +343,10 @@ export async function main(argv, io = {
 const NOT_A_SERVER = (c) => `
   ${c.bold("Directionally Local")}  ${c.dim("isn't set up on this machine.")}
 
-  Background coding agents on your own server: send a task from your laptop,
+  Coding agents that run on this computer or on your own server: send a task,
   get a pull request back.
 
-  ${c.dim("Set it up from your laptop (asks a few questions):")}
+  ${c.dim("Set it up here, or on a server over SSH (asks a few questions):")}
      dl setup
 
   ${c.dim("Or on a server (as root, on Ubuntu or Debian):")}

package/dist/keys.js

@@ -0,0 +1,188 @@
+/**
+ * `dl keys` on a server: replace the OpenRouter key or the GitHub token where `dl up`
+ * stored them, restart the one service that reads it, and show which keys are set (never
+ * their values). Keys come in on stdin (or hidden input on the server's own terminal),
+ * never argv, so they stay out of `ps`, shell history, and logs.
+ *
+ *   OpenRouter  Hotcell's file keystore, as the hotcell user   → restart hotcell.service
+ *   GitHub      /etc/autopilot/github.env (0640 root:autopilot) → restart autopilot.service
+ *
+ * The laptop's `dl keys` runs `dl keys set <which> --stdin --json` here over SSH.
+ */
+import { AUTOPILOT_PORT, HOTCELL_PORT, PATHS, SERVICES, USERS, githubEnv, hotcellBin, parseEnvFile } from "./layout.js";
+import { asHotcell, validateGitHubToken, validateOpenRouterKey, waitUntil } from "./up.js";
+export const KEY_NAMES = ["openrouter", "github"];
+export const KEY_LABELS = { openrouter: "OpenRouter", github: "GitHub" };
+export function parseKeyName(value) {
+    return KEY_NAMES.find((name) => name === value?.trim().toLowerCase());
+}
+/** Format first, then (with `fetchImpl`) the service itself; offline isn't fatal. */
+export async function checkKey(which, value, fetchImpl) {
+    if (!value)
+        return { problem: "No key was given." };
+    if (which === "openrouter") {
+        const problem = await validateOpenRouterKey(value, fetchImpl);
+        return problem ? { problem } : {};
+    }
+    return validateGitHubToken(value, fetchImpl);
+}
+/** The key wasn't accepted; nothing was stored or restarted. */
+export class KeyRejectedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "KeyRejectedError";
+    }
+}
+/** Stores the key exactly where `dl up` does, then restarts the service that reads it and waits for it. */
+export async function setServerKey(system, which, value, options = {}) {
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const key = value.trim();
+    const checked = await checkKey(which, key, options.fetchImpl);
+    if (checked.problem)
+        throw new KeyRejectedError(checked.problem);
+    if (which === "openrouter") {
+        if (!(await system.exists(hotcellBin())))
+            throw new Error("Hotcell isn't installed here; run dl up first.");
+        // Over stdin into Hotcell's keystore: never in argv, env files, or Autopilot's config. It replaces the old one.
+        await asHotcell(system, ["keys", "add", "openrouter", "--stdin"], { input: key, describe: "hotcell keys add openrouter --stdin (as hotcell)" });
+        // Hotcell reads its keystore at startup.
+        await system.run("systemctl", ["restart", SERVICES.hotcell]);
+        await waitUntil(system, sleep, "Hotcell", () => hotcellAnswers(system));
+        return { ok: true, key: which, detail: "replaced in Hotcell; Hotcell restarted" };
+    }
+    await system.mkdir(PATHS.autopilotEtc, { mode: 0o750, owner: `root:${USERS.autopilot}` });
+    await system.writeFile(PATHS.githubEnv, githubEnv(key), { mode: 0o640, owner: `root:${USERS.autopilot}`, secret: true });
+    // Autopilot reads GITHUB_TOKEN from its env file at startup.
+    await system.run("systemctl", ["restart", SERVICES.autopilot]);
+    await waitUntil(system, sleep, "Autopilot", () => autopilotAnswers(system));
+    return { ok: true, key: which, detail: `${checked.detail ? `${checked.detail}; ` : ""}Autopilot restarted` };
+}
+/** Which keys this server has. Reads and probes only; the GitHub login is a quick, optional API call. */
+export async function listServerKeys(system, options = {}) {
+    let openrouter = { key: "openrouter", set: false };
+    if (await system.exists(hotcellBin())) {
+        const listed = await system.probe("runuser", [
+            "-u", USERS.hotcell, "--", "env", `HOTCELL_HOME=${PATHS.hotcellHome}`, "HOTCELL_KEYSTORE=file", "NO_COLOR=1", "/usr/bin/node", hotcellBin(), "keys", "ls",
+        ]);
+        if (listed.code === 0)
+            openrouter = { key: "openrouter", ...hotcellKeyListed(listed.stdout, "openrouter") };
+    }
+    const token = parseEnvFile(await system.readFile(PATHS.githubEnv)).GITHUB_TOKEN;
+    return [openrouter, await githubListing(token, options.fetchImpl)];
+}
+/**
+ * A provider's row in `hotcell keys ls` (`openrouter  sk-or…ab  file`), with Hotcell's
+ * mask. A column that's long enough to be a key isn't shown, in case the format changes.
+ */
+export function hotcellKeyListed(stdout, provider) {
+    const plain = stdout.replace(/\x1b\[[0-9;]*m/g, "");
+    const row = plain.split("\n").map((line) => line.trim().split(/\s+/)).find((cells) => cells[0] === provider);
+    if (!row)
+        return { set: false };
+    const mask = row[1];
+    return mask && mask.length <= 12 && (mask.includes("…") || /^•+$/.test(mask)) ? { set: true, detail: mask } : { set: true };
+}
+/** The GitHub row: set or not, and whose token it is when GitHub answers within a few seconds. */
+export async function githubListing(token, fetchImpl) {
+    if (!token)
+        return { key: "github", set: false };
+    if (!fetchImpl)
+        return { key: "github", set: true };
+    const quick = (input, init) => fetchImpl(input, { ...init, signal: AbortSignal.timeout(5_000) });
+    const checked = await validateGitHubToken(token, quick);
+    // A stored token in an unexpected format still counts as set; only GitHub's own refusal is a problem.
+    if (checked.problem && /rejected/.test(checked.problem))
+        return { key: "github", set: true, problem: checked.problem };
+    return { key: "github", set: true, ...(checked.detail ? { detail: checked.detail } : {}) };
+}
+/** `dl keys` as text: one line per key, values never shown. */
+export function formatKeyListing(listing, c, where, replaceWith) {
+    const rows = listing.map((entry) => {
+        const label = KEY_LABELS[entry.key].padEnd(12);
+        if (!entry.set)
+            return `  ${c.red("✗")} ${label}${c.dim("not set")}   ${replaceWith(entry.key)}\n`;
+        if (entry.problem)
+            return `  ${c.red("✗")} ${label}${entry.problem}   ${c.dim("replace it:")} ${replaceWith(entry.key)}\n`;
+        return `  ${c.green("✓")} ${label}${c.dim(entry.detail ?? "set")}\n`;
+    });
+    const hint = listing.every((entry) => entry.set && !entry.problem)
+        ? `\n  ${c.dim("Replace one:")} ${replaceWith("openrouter")}   ${c.dim("or")}   ${replaceWith("github")}\n`
+        : "";
+    return `\n  ${c.bold("Keys")} ${c.dim(where)}\n\n${rows.join("")}${hint}\n`;
+}
+/**
+ * One line from stdin: the key, up to the first newline or the end. Never echoed, and a
+ * parse error never quotes it.
+ */
+export async function readKeyLine(stdin) {
+    if (stdin.isTTY)
+        throw new Error("--stdin reads the key from a pipe, not a terminal; leave it off to type the key (hidden).");
+    let text = "";
+    for await (const chunk of stdin) {
+        text += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (text.includes("\n"))
+            break;
+        if (text.length > 4096)
+            throw new Error("The key on stdin is too long; expected one line.");
+    }
+    const line = text.split("\n")[0].trim();
+    if (line.length > 4096)
+        throw new Error("The key on stdin is too long; expected one line.");
+    return line;
+}
+const SERVER_USAGE = "  Usage: dl keys                          which keys are set\n"
+    + "         dl keys set openrouter|github    replace one (hidden input; --stdin reads it from a pipe)\n";
+/**
+ * `dl keys [ls]`, `dl keys set <openrouter|github> [--stdin] [--json]`, and `dl keys
+ * <openrouter|github>` (the same as `set`), as root on a server.
+ */
+export async function serverKeysCommand(system, args, flags, deps) {
+    const c = deps.colors;
+    const env = deps.env ?? process.env;
+    const fetchImpl = env.DL_SKIP_CREDENTIAL_CHECK === "1" ? undefined : deps.fetchImpl ?? fetch;
+    const [first, second] = args;
+    if (first === undefined || first === "ls" || first === "list") {
+        const listing = await listServerKeys(system, { fetchImpl });
+        if (flags.json)
+            deps.out(`${JSON.stringify({ keys: listing })}\n`);
+        else
+            deps.out(formatKeyListing(listing, c, "on this server", (key) => `sudo dl keys set ${key}`));
+        return 0;
+    }
+    const which = parseKeyName(first === "set" ? second : first);
+    if (!which || (first !== "set" && second !== undefined)) {
+        deps.err(SERVER_USAGE);
+        return 2;
+    }
+    try {
+        let value;
+        if (flags.stdin)
+            value = await readKeyLine(deps.stdin);
+        else if (!flags.json)
+            value = await deps.prompter.secret(`  ${KEY_LABELS[which]} ${which === "github" ? "token" : "key"} (hidden): `);
+        else
+            throw new Error("--json needs the key on stdin: dl keys set KEY --stdin --json");
+        const result = await setServerKey(system, which, value, { fetchImpl, ...(deps.sleep ? { sleep: deps.sleep } : {}) });
+        if (flags.json)
+            deps.out(`${JSON.stringify(result)}\n`);
+        else
+            deps.out(`  ${c.green("✓")} ${KEY_LABELS[which]} ${which === "github" ? "token" : "key"} replaced  ${c.dim(result.detail)}\n`);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (flags.json)
+            deps.out(`${JSON.stringify({ ok: false, key: which, error: message })}\n`);
+        else
+            deps.err(`  ${c.red("✗")} ${message}\n`);
+        return 1;
+    }
+}
+async function hotcellAnswers(system) {
+    return (await system.probe("curl", ["-fsS", "-o", "/dev/null", `http://127.0.0.1:${HOTCELL_PORT}/`])).code === 0
+        || (await system.probe("sh", ["-c", `ss -ltn | grep -q '127.0.0.1:${HOTCELL_PORT}'`])).code === 0;
+}
+/** Without a token the Aster API answers 401: up, and refusing strangers. */
+async function autopilotAnswers(system) {
+    return (await system.probe("curl", ["-s", "-o", "/dev/null", "-w", "%{http_code}", `http://127.0.0.1:${AUTOPILOT_PORT}/api/v1/health`])).stdout.trim() === "401";
+}

package/dist/laptop/commands.js

@@ -1,23 +1,29 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { hostname } from "node:os";
+import { readFile } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
 import { promisify } from "node:util";
 import { palette } from "../ui.js";
 import { RemoteApiError, RemoteClient, TERMINAL_STATUSES } from "./client.js";
-import { defaultRemoteName, loadRemotes, normalizeServerUrl, REMOTE_NAME_RE, removeRemote, resolveRemote, saveRemote } from "./config.js";
+import { defaultRemoteName, loadRemotes, loadRemotesFile, normalizeServerUrl, recordLastUsed, REMOTE_NAME_RE, removeRemote, renameRemote, resolveRemote, resolveTarget, saveRemote, setDefaultRemote, } from "./config.js";
+import { autopilotConfigPath } from "./credentials.js";
+import { PAIRED_NAME } from "../local/layout.js";
 import { detectGitHubRepository, snapshotWorkingTree } from "./git.js";
 import { sshCommandLine } from "./ssh.js";
 import { openBrowser } from "./open-browser.js";
 import { withConnections } from "./tunnel.js";
 /**
- * `dl` on a laptop: connect to a server, send it tasks, follow them, and check out the
- * pull requests. It talks to the server's API directly (the same one Autopilot's
- * `--on` uses, and shares its list of servers), so the laptop needs nothing else.
+ * `dl` on a laptop: send tasks to where agents run (this computer, or your own server),
+ * follow them, and check out the pull requests. It talks to the server's API directly (the
+ * same one Autopilot's `--on` uses, and shares its list of servers), so the laptop needs
+ * nothing else.
  * Servers set up with `dl setup` are reached through an SSH tunnel that each command
  * opens and closes (see tunnel.ts); `open` lets tests swap the tunnel out.
  */
 const execFileAsync = promisify(execFile);
 const RUN_END_EVENTS = new Set(["completed", "failed", "cancelled", "interrupted"]);
+/** The model a task gets when neither -m nor the laptop's Autopilot picks one the server offers. */
+export const DEFAULT_MODEL = "moonshotai/kimi-k2.6";
 const processIO = {
     out: (text) => process.stdout.write(text),
     err: (text) => process.stderr.write(text),
@@ -60,10 +66,11 @@ export async function connect(input, io = processIO) {
  * checkout (uncommitted changes go along). Follows it until it ends; Ctrl-C only detaches.
  */
 export async function run(input, io = processIO) {
-    const remote = await resolveRemote(input.server);
-    return withConnections(input.open, async (connections) => runOn(await connections.client(remote), remote, input, io));
+    const { remote, reason } = await resolveTarget(input.server);
+    const preferred = input.preferredModel ?? await (input.autopilotModel ?? (() => readAutopilotModel()))();
+    return withConnections(input.open, async (connections) => runOn(await connections.client(remote), remote, reason, { ...input, ...(preferred ? { preferredModel: preferred } : {}) }, io));
 }
-async function runOn(client, remote, input, io) {
+async function runOn(client, remote, reason, input, io) {
     const c = palette(io.color === true);
     const repository = input.repository ?? await detectGitHubRepository(input.cwd);
     const snapshot = await snapshotWorkingTree(input.cwd);
@@ -73,7 +80,8 @@ async function runOn(client, remote, input, io) {
         throw new Error(`${remote.name} has no workspace this laptop can use`);
     const model = pickModel(models, input.model, input.preferredModel);
     const changes = snapshot.files.length ? ` + ${snapshot.files.length} local change${snapshot.files.length === 1 ? "" : "s"}` : "";
-    io.err(`\n  ${c.cyan("·")} Sending to ${c.bold(remote.name)}: ${repository} at ${snapshot.baseCommit.slice(0, 7)}${changes}  ${c.dim(model)}\n`);
+    const why = reason === "default" || reason === "last used" ? ` ${c.dim(`(${reason})`)}` : "";
+    io.err(`\n  ${c.cyan("·")} Sending to ${c.bold(remote.name)}${why}: ${repository} at ${snapshot.baseCommit.slice(0, 7)}${changes}  ${c.dim(model)}\n`);
     const conversation = await client.createCodeConversation({
         workspaceId: workspace.id,
         model,
@@ -83,6 +91,8 @@ async function runOn(client, remote, input, io) {
         idempotencyKey: `dl-${randomUUID()}`,
     });
     await client.submitTurn(conversation.conversationId, input.task, `dl-${randomUUID()}`);
+    // Only a fallback (a default, or the only place, always wins), so failing to write it is harmless.
+    await recordLastUsed(remote.name).catch(() => undefined);
     const id = conversation.conversationId.slice(0, 8);
     io.err(`${rewrite(io)}  ${c.green("✓")} Started ${c.bold(id)} on ${remote.name}  ${c.dim(`branch ${conversation.branch ?? "?"}`)}\n`);
     if (input.detach) {
@@ -96,7 +106,7 @@ async function runOn(client, remote, input, io) {
 export async function runs(input, io = processIO) {
     const remotes = input.server ? [await resolveRemote(input.server)] : await loadRemotes();
     if (remotes.length === 0)
-        throw new Error("This laptop isn't connected to a server yet. Run: dl connect https://your-server");
+        throw new Error("Nothing is set up yet. Run: dl setup  (or, for a server someone else set up: dl connect https://your-server)");
     return withConnections(input.open, (connections) => listRuns(remotes, connections, input.json === true, io));
 }
 async function listRuns(remotes, connections, json, io) {
@@ -173,9 +183,11 @@ export async function pull(input, io = processIO) {
     }
     io.out(`  ${c.green("✓")} On ${c.bold(branch)}${found.pullRequestURL ? `  ${c.dim(found.pullRequestURL)}` : ""}\n`);
 }
-/** `dl servers [remove NAME]`: the servers this laptop is connected to. */
+/** `dl servers [remove NAME | rename OLD NEW]`: the servers this laptop is connected to. */
 export async function servers(args, io = processIO) {
     const c = palette(io.color === true);
+    if (args[0] === "rename")
+        return renameServer(args.slice(1), io);
     if (args[0] === "remove") {
         const name = args[1] ?? "";
         const removed = (await loadRemotes()).find((remote) => remote.name === name);
@@ -189,13 +201,65 @@ export async function servers(args, io = processIO) {
     }
     const remotes = await loadRemotes();
     if (remotes.length === 0) {
-        io.out(`\n  Not connected to a server yet.  ${c.bold("dl setup")}  ${c.dim("or, for a server someone else set up:")} ${c.bold("dl connect https://your-server")}\n\n`);
+        io.out(`\n  Nothing set up yet.  ${c.bold("dl setup")}  ${c.dim("or, for a server someone else set up:")} ${c.bold("dl connect https://your-server")}\n\n`);
         return 0;
     }
+    const current = await defaultName();
     io.out("\n");
     for (const remote of remotes)
-        io.out(`  ${c.green("●")} ${remote.name.padEnd(16)} ${where(remote)}  ${c.dim(`until ${remote.expiresAt.slice(0, 10)}`)}\n`);
-    io.out("\n");
+        io.out(`  ${mark(remote, current, c)} ${remote.name.padEnd(16)} ${where(remote)}  ${c.dim(`until ${remote.expiresAt.slice(0, 10)}`)}\n`);
+    io.out(remotes.length > 1 ? `\n  ${c.dim(`● is where tasks go without --server. Change it: dl use NAME`)}\n\n` : "\n");
+    return 0;
+}
+/** `dl use [NAME]`: set, or show, where commands go when no --server is given. */
+export async function use(args, io = processIO) {
+    const c = palette(io.color === true);
+    const name = args[0];
+    if (name === undefined) {
+        const file = await loadRemotesFile();
+        if (file.remotes.length === 0) {
+            io.out(`  Nothing set up yet.  ${c.bold("dl setup")}\n`);
+            return 0;
+        }
+        const current = await defaultName();
+        io.out(current
+            ? `  Tasks go to ${c.bold(current)} unless you pass --server NAME.${file.remotes.length > 1 ? `  ${c.dim(`Change it: dl use NAME (${file.remotes.map((entry) => entry.name).join(", ")})`)}` : ""}\n`
+            : `  No default yet. Pick one: dl use NAME  ${c.dim(`(${file.remotes.map((entry) => entry.name).join(", ")})`)}\n`);
+        return 0;
+    }
+    try {
+        const remote = await setDefaultRemote(name);
+        io.out(`  ${c.green("✓")} Tasks now go to ${c.bold(remote.name)} ${c.dim(where(remote))} unless you pass --server NAME.\n`);
+        return 0;
+    }
+    catch (error) {
+        io.err(`  ${c.red("✗")} ${describeError(error)}\n`);
+        return 1;
+    }
+}
+/** Where a command without --server goes, or undefined when that's ambiguous. */
+async function defaultName() {
+    return resolveTarget(undefined).then((target) => target.remote.name, () => undefined);
+}
+function mark(remote, current, c) {
+    return remote.name === current ? c.green("●") : c.dim("○");
+}
+/** `dl servers rename OLD NEW`: only this laptop's name for it; the server doesn't change. */
+export async function renameServer(args, io = processIO, path) {
+    const c = palette(io.color === true);
+    const [from, to] = args;
+    if (!from || !to || args.length > 2) {
+        io.err(`  Usage: dl servers rename OLD NEW   ${c.dim("(names: lowercase letters, digits, and dashes)")}\n`);
+        return 2;
+    }
+    try {
+        await renameRemote(from, to, path);
+    }
+    catch (error) {
+        io.err(`  ${c.red("✗")} ${error.message}.\n`.replace(/\.\.\n$/, ".\n"));
+        return 1;
+    }
+    io.out(`  ${c.green("✓")} Renamed ${from} to ${c.bold(to)}  ${c.dim(`dl run --server ${to} …`)}\n`);
     return 0;
 }
 /** `dl` on a laptop: what this is, which servers it's connected to, what to type next. */
@@ -213,9 +277,10 @@ export async function laptopHome(io = processIO, open) {
             total += list?.length ?? 0;
         }
     });
+    const current = await defaultName();
     io.out(`\n  ${c.bold("Directionally Local")}  ${c.dim("on this laptop")}\n\n`);
-    io.out("  Background coding agents on your own server: send a task, get a pull request back.\n\n");
-    io.out(`  ${c.dim("Servers".padEnd(11))}${remotes.map((remote) => `${remote.name} ${c.dim(where(remote))}`).join(", ")}   ${c.dim("dl servers")}\n`);
+    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`);
     return true;
@@ -326,22 +391,53 @@ async function findRun(id, server, connections) {
         throw new Error(`${id} matches several tasks; use more characters`);
     return matches[0];
 }
-function pickModel(models, requested, preferred) {
+/**
+ * The task's model: -m/--model; else the laptop's Autopilot default, if the server offers it;
+ * else DEFAULT_MODEL, if offered. Never just the first in the server's list (that's the
+ * whole OpenRouter catalog, in no useful order).
+ */
+export function pickModel(models, requested, preferred) {
+    const how = `Pick one: dl run -m <model> "task"  (model IDs: https://openrouter.ai/models)`;
     if (requested) {
         if (!models.includes(requested))
-            throw new Error(`The server doesn't offer ${requested}`);
+            throw new Error(`The server doesn't offer ${requested}. ${how}`);
         return requested;
     }
     if (preferred && models.includes(preferred))
         return preferred;
-    const first = models[0];
-    if (!first)
-        throw new Error("The server offers no models");
-    return first;
+    if (models.includes(DEFAULT_MODEL))
+        return DEFAULT_MODEL;
+    if (models.length === 0)
+        throw new Error("The server offers no models; check its OpenRouter key (on the server: dl doctor)");
+    const tried = preferred && preferred !== DEFAULT_MODEL ? `your Autopilot model (${preferred}) or ${DEFAULT_MODEL}` : DEFAULT_MODEL;
+    throw new Error(`The server doesn't offer ${tried}. ${how}`);
+}
+/**
+ * The laptop's Autopilot default model: KIMI_MODEL (Autopilot's own override) or the
+ * `model` in its config. undefined when neither is set or the config can't be read.
+ */
+export async function readAutopilotModel(sources = {}) {
+    const env = sources.env ?? process.env;
+    const fromEnv = env.KIMI_MODEL?.trim();
+    if (fromEnv)
+        return fromEnv;
+    const read = sources.readFile ?? ((path) => readFile(path, "utf8").catch(() => undefined));
+    const raw = await read(autopilotConfigPath(env, sources.home ?? homedir()));
+    if (!raw)
+        return undefined;
+    try {
+        const model = JSON.parse(raw).model;
+        return typeof model === "string" && model.trim() ? model.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
-/** Where a server is, as people know it: its URL, or the SSH destination its tunnel goes to. */
+/** Where a place is, as people know it: this computer, its URL, or the SSH destination its tunnel goes to. */
 function where(remote) {
-    return remote.ssh ? `ssh ${remote.ssh.target}${remote.ssh.port ? `:${remote.ssh.port}` : ""}` : remote.url;
+    if (remote.ssh)
+        return `ssh ${remote.ssh.target}${remote.ssh.port ? `:${remote.ssh.port}` : ""}`;
+    return remote.name === PAIRED_NAME ? "this computer" : remote.url;
 }
 function clientName() {
     const host = hostname().replace(/\.local$/, "").replace(/[^\p{L}\p{N} ._'()@-]/gu, "-").slice(0, 40) || "laptop";