directionallylocal 0.2.0 → 0.4.0

package/dist/laptop/commands.js

@@ -1,19 +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),
@@ -56,9 +66,12 @@ 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, 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, reason, input, io) {
     const c = palette(io.color === true);
-    const remote = await resolveRemote(input.server);
-    const client = new RemoteClient(remote.url, remote.token);
     const repository = input.repository ?? await detectGitHubRepository(input.cwd);
     const snapshot = await snapshotWorkingTree(input.cwd);
     const [workspaces, models] = await Promise.all([client.workspaces(), client.models()]);
@@ -67,7 +80,8 @@ export async function run(input, io = processIO) {
         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,
@@ -77,6 +91,8 @@ export async function run(input, io = processIO) {
         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) {
@@ -88,14 +104,17 @@ export async function run(input, io = processIO) {
 }
 /** `dl runs`: tasks on every connected server, newest first. */
 export async function runs(input, io = processIO) {
-    const c = palette(io.color === true);
     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) {
+    const c = palette(io.color === true);
     const rows = [];
     for (const remote of remotes) {
         try {
-            const list = await new RemoteClient(remote.url, remote.token).listConversations();
+            const list = await (await connections.client(remote)).listConversations();
             rows.push(...list.filter((entry) => entry.kind === "code").map((entry) => ({ ...entry, server: remote.name })));
         }
         catch (error) {
@@ -103,7 +122,7 @@ export async function runs(input, io = processIO) {
         }
     }
     rows.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    if (input.json) {
+    if (json) {
         io.out(`${JSON.stringify(rows, null, 2)}\n`);
         return;
     }
@@ -122,21 +141,26 @@ export async function runs(input, io = processIO) {
 }
 /** `dl watch <id>`: replay and follow a task's output. */
 export async function watch(input, io = processIO) {
-    const { remote, run: found } = await findRun(input.id, input.server);
-    const client = new RemoteClient(remote.url, remote.token);
-    const finished = TERMINAL_STATUSES.has(found.status) && !found.activeRunId;
-    return follow(client, remote, found.conversationId, 0, input.signal, io, finished ? found.lastEventId : undefined);
+    return withConnections(input.open, async (connections) => {
+        const { remote, run: found } = await findRun(input.id, input.server, connections);
+        const client = await connections.client(remote);
+        const finished = TERMINAL_STATUSES.has(found.status) && !found.activeRunId;
+        return follow(client, remote, found.conversationId, 0, input.signal, io, finished ? found.lastEventId : undefined);
+    });
 }
 export async function cancel(input, io = processIO) {
     const c = palette(io.color === true);
-    const { remote, run: found } = await findRun(input.id, input.server);
-    await new RemoteClient(remote.url, remote.token).cancel(found.conversationId);
-    io.out(`  ${c.green("✓")} Stopped ${found.conversationId.slice(0, 8)}\n`);
+    await withConnections(input.open, async (connections) => {
+        const { remote, run: found } = await findRun(input.id, input.server, connections);
+        await (await connections.client(remote)).cancel(found.conversationId);
+        io.out(`  ${c.green("✓")} Stopped ${found.conversationId.slice(0, 8)}\n`);
+    });
 }
 /** `dl pull <id>`: check out a task's branch here. */
 export async function pull(input, io = processIO) {
     const c = palette(io.color === true);
-    const { run: found } = await findRun(input.id, input.server);
+    // The server is only asked for the branch name; the code itself comes from GitHub.
+    const { run: found } = await withConnections(input.open, (connections) => findRun(input.id, input.server, connections));
     const branch = found.branch;
     if (!branch)
         throw new Error("That task has no branch");
@@ -159,45 +183,104 @@ 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] ?? "";
-        if (!(await removeRemote(name))) {
+        const removed = (await loadRemotes()).find((remote) => remote.name === name);
+        if (!removed || !(await removeRemote(name))) {
             io.err(`  ${c.red("✗")} Not connected to "${name}".\n`);
             return 1;
         }
-        io.out(`  ${c.green("✓")} Forgot ${name}. To disconnect it on the server too: sudo dl laptops remove "${clientName()}"\n`);
+        const onServer = `sudo dl laptops remove "${clientName()}"`;
+        io.out(`  ${c.green("✓")} Forgot ${name}. To disconnect it on the server too: ${removed.ssh ? `${sshCommandLine(removed.ssh)} '${onServer}'` : onServer}\n`);
         return 0;
     }
     const remotes = await loadRemotes();
     if (remotes.length === 0) {
-        io.out(`\n  Not connected to a server yet.  ${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)} ${remote.url}  ${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. */
-export async function laptopHome(io = processIO) {
+export async function laptopHome(io = processIO, open) {
     const c = palette(io.color === true);
     const remotes = await loadRemotes();
     if (remotes.length === 0)
         return false;
     let running = 0;
     let total = 0;
-    for (const remote of remotes) {
-        const list = await new RemoteClient(remote.url, remote.token).listConversations().catch(() => undefined);
-        running += list?.filter((entry) => entry.activeRunId !== null).length ?? 0;
-        total += list?.length ?? 0;
-    }
+    await withConnections(open, async (connections) => {
+        for (const remote of remotes) {
+            const list = await connections.client(remote).then((client) => client.listConversations()).catch(() => undefined);
+            running += list?.filter((entry) => entry.activeRunId !== null).length ?? 0;
+            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(remote.url)}`).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;
@@ -285,36 +368,76 @@ class EventRenderer {
         this.io.out(`${text}\n`);
     }
 }
-async function findRun(id, server) {
+async function findRun(id, server, connections) {
     const needle = id.trim().toLowerCase();
     if (!/^[0-9a-f-]{4,36}$/.test(needle))
         throw new Error("Task IDs are the short hex IDs dl runs shows");
     const remotes = server ? [await resolveRemote(server)] : await loadRemotes();
     const matches = [];
+    const unreachable = [];
     for (const remote of remotes) {
-        const list = await new RemoteClient(remote.url, remote.token).listConversations(200).catch(() => []);
+        const list = await connections.client(remote).then((client) => client.listConversations(200)).catch((error) => {
+            unreachable.push(`${remote.name}: ${describeError(error)}`);
+            return [];
+        });
         for (const entry of list)
             if (entry.conversationId.startsWith(needle))
                 matches.push({ remote, run: entry });
     }
+    // Say why when a server couldn't be asked (e.g. its SSH tunnel failed), rather than "no task".
     if (matches.length === 0)
-        throw new Error(`No task ${id} on ${server ?? "any connected server"}`);
+        throw new Error(`No task ${id} on ${server ?? "any connected server"}${unreachable.length ? `\n${unreachable.join("\n")}` : ""}`);
     if (matches.length > 1)
         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 place is, as people know it: this computer, its URL, or the SSH destination its tunnel goes to. */
+function where(remote) {
+    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";

package/dist/laptop/config.js

@@ -9,47 +9,127 @@ export function remotesPath(env = process.env) {
     return join(configHome, "autopilot", "remotes.json");
 }
 export async function loadRemotes(path = remotesPath()) {
+    return (await loadRemotesFile(path)).remotes;
+}
+/**
+ * The remotes with the default and last-used names. A name that no longer matches a
+ * remote (it was removed, or renamed by something that didn't know) is dropped.
+ */
+export async function loadRemotesFile(path = remotesPath()) {
     let raw;
     try {
         raw = await readFile(path, "utf8");
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return [];
+            return { remotes: [] };
         throw error;
     }
     const parsed = JSON.parse(raw);
-    return Array.isArray(parsed.remotes) ? parsed.remotes.filter(isRemote) : [];
+    const remotes = Array.isArray(parsed.remotes) ? parsed.remotes.filter(isRemote) : [];
+    const known = (name) => typeof name === "string" && remotes.some((entry) => entry.name === name);
+    return {
+        remotes,
+        ...(known(parsed.default) ? { default: parsed.default } : {}),
+        ...(known(parsed.lastUsed) ? { lastUsed: parsed.lastUsed } : {}),
+    };
 }
-/** Adds or replaces a remote by name. The file holds bearer tokens, so it is 0600 in a 0700 directory. */
+/**
+ * Adds or replaces a remote by name. The file holds bearer tokens, so it is 0600 in a 0700
+ * directory. When no default is set yet, the first place saved becomes it (an older file's
+ * first entry, if it had any), so the first setup needs no `dl use`.
+ */
 export async function saveRemote(remote, path = remotesPath()) {
-    const remotes = (await loadRemotes(path)).filter((entry) => entry.name !== remote.name);
+    const file = await loadRemotesFile(path);
+    const remotes = file.remotes.filter((entry) => entry.name !== remote.name);
     remotes.push(remote);
-    await writeRemotes(remotes, path);
+    await writeRemotes({ ...file, remotes, default: file.default ?? file.remotes[0]?.name ?? remote.name }, path);
 }
 export async function removeRemote(name, path = remotesPath()) {
-    const remotes = await loadRemotes(path);
-    const kept = remotes.filter((entry) => entry.name !== name);
-    if (kept.length === remotes.length)
+    const file = await loadRemotesFile(path);
+    const kept = file.remotes.filter((entry) => entry.name !== name);
+    if (kept.length === file.remotes.length)
         return false;
-    await writeRemotes(kept, path);
+    // Forgetting the default leaves none; with one place left, that one is used anyway.
+    await writeRemotes({
+        remotes: kept,
+        ...(file.default && file.default !== name ? { default: file.default } : {}),
+        ...(file.lastUsed && file.lastUsed !== name ? { lastUsed: file.lastUsed } : {}),
+    }, path);
     return true;
 }
-/** The named remote, or the only one when no name is given. */
-export async function resolveRemote(name, path = remotesPath()) {
-    const remotes = await loadRemotes(path);
-    if (remotes.length === 0)
-        throw new Error("No servers paired yet. Run: autopilot remote add https://your-server");
-    if (name === undefined) {
-        if (remotes.length === 1)
-            return remotes[0];
-        throw new Error(`Several servers are paired; pick one with --on (${remotes.map((entry) => entry.name).join(", ")})`);
+/**
+ * `dl servers rename OLD NEW`: renames a place in this laptop's list (the server itself doesn't
+ * change). The `default` and `lastUsed` pointers follow the entry to its new name.
+ */
+export async function renameRemote(from, to, path = remotesPath()) {
+    if (!REMOTE_NAME_RE.test(to))
+        throw new Error(`"${to}" can't be a server name: use lowercase letters, digits, and dashes (up to 40), starting with a letter or digit`);
+    const file = await loadRemotesFile(path);
+    if (!file.remotes.some((entry) => entry.name === from)) {
+        throw new Error(`No server named "${from}". Connected: ${file.remotes.map((entry) => entry.name).join(", ") || "none"}`);
     }
-    const remote = remotes.find((entry) => entry.name === name);
+    if (from === to)
+        return;
+    if (file.remotes.some((entry) => entry.name === to))
+        throw new Error(`There's already a server named "${to}"`);
+    const follow = (name) => (name === from ? to : name);
+    const defaultName = follow(file.default);
+    const lastUsed = follow(file.lastUsed);
+    await writeRemotes({
+        remotes: file.remotes.map((entry) => (entry.name === from ? { ...entry, name: to } : entry)),
+        ...(defaultName ? { default: defaultName } : {}),
+        ...(lastUsed ? { lastUsed } : {}),
+    }, path);
+}
+/** `dl use NAME`: where commands go when none is named. */
+export async function setDefaultRemote(name, path = remotesPath()) {
+    const file = await loadRemotesFile(path);
+    const remote = file.remotes.find((entry) => entry.name === name);
     if (!remote)
-        throw new Error(`No server named "${name}". Paired: ${remotes.map((entry) => entry.name).join(", ")}`);
+        throw new Error(unknownName(name, file.remotes));
+    await writeRemotes({ ...file, default: name }, path);
     return remote;
 }
+/** Remembers where the last task went (the fallback when there's no default). */
+export async function recordLastUsed(name, path = remotesPath()) {
+    const file = await loadRemotesFile(path);
+    if (file.lastUsed === name || !file.remotes.some((entry) => entry.name === name))
+        return;
+    await writeRemotes({ ...file, lastUsed: name }, path);
+}
+/** The named remote, else the default, else the only one, else the last one used. */
+export async function resolveRemote(name, path = remotesPath()) {
+    return (await resolveTarget(name, path)).remote;
+}
+/** resolveRemote, and why that one (for the command's first line). */
+export async function resolveTarget(name, path = remotesPath()) {
+    const file = await loadRemotesFile(path);
+    const { remotes } = file;
+    if (remotes.length === 0)
+        throw new Error("Nothing is set up yet. Run: dl setup");
+    const named = (wanted) => remotes.find((entry) => entry.name === wanted);
+    if (name !== undefined) {
+        const remote = named(name);
+        if (!remote)
+            throw new Error(unknownName(name, remotes));
+        return { remote, reason: "named" };
+    }
+    if (remotes.length === 1)
+        return { remote: remotes[0], reason: "only" };
+    const chosen = file.default ? named(file.default) : undefined;
+    if (chosen)
+        return { remote: chosen, reason: "default" };
+    const last = file.lastUsed ? named(file.lastUsed) : undefined;
+    if (last)
+        return { remote: last, reason: "last used" };
+    throw new Error(`Several places are set up (${remotes.map((entry) => entry.name).join(", ")}). Pick one with --server NAME, or set a default: dl use NAME`);
+}
+function unknownName(name, remotes) {
+    return remotes.length
+        ? `Nothing named "${name}" is set up. Set up: ${remotes.map((entry) => entry.name).join(", ")}`
+        : `Nothing named "${name}" is set up; nothing is yet. Run: dl setup`;
+}
 /** A short default name from the URL's host: https://acme.example.com -> acme. */
 export function defaultRemoteName(url) {
     const host = new URL(url).hostname.toLowerCase();
@@ -74,10 +154,16 @@ export function normalizeServerUrl(input) {
         throw new Error("The server URL must not include credentials, a query, or a fragment");
     return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
 }
-async function writeRemotes(remotes, path) {
+async function writeRemotes(file, path) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const temp = `${path}.${process.pid}.tmp`;
-    await writeFile(temp, `${JSON.stringify({ version: 1, remotes }, null, 2)}\n`, { mode: 0o600 });
+    const body = {
+        version: 1,
+        remotes: file.remotes,
+        ...(file.default ? { default: file.default } : {}),
+        ...(file.lastUsed ? { lastUsed: file.lastUsed } : {}),
+    };
+    await writeFile(temp, `${JSON.stringify(body, null, 2)}\n`, { mode: 0o600 });
     await chmod(temp, 0o600);
     await rename(temp, path);
 }
@@ -85,5 +171,15 @@ function isRemote(value) {
     if (!value || typeof value !== "object")
         return false;
     const entry = value;
-    return ["name", "url", "token", "credentialId", "expiresAt", "addedAt"].every((key) => typeof entry[key] === "string");
+    if (!["name", "url", "token", "credentialId", "expiresAt", "addedAt"].every((key) => typeof entry[key] === "string"))
+        return false;
+    return entry.ssh === undefined || isSshAccess(entry.ssh);
+}
+function isSshAccess(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const ssh = value;
+    return typeof ssh.target === "string" && ssh.target.length > 0 && !ssh.target.startsWith("-") &&
+        (ssh.port === undefined || (typeof ssh.port === "number" && Number.isInteger(ssh.port) && ssh.port > 0 && ssh.port < 65536)) &&
+        (ssh.identityFile === undefined || typeof ssh.identityFile === "string");
 }

package/dist/laptop/credentials.js

@@ -0,0 +1,129 @@
+import { join } from "node:path";
+/** Autopilot's config, where `autopilot` keeps the user's OpenRouter key. */
+export function autopilotConfigPath(env, home) {
+    return join(env.XDG_CONFIG_HOME?.trim() || join(home, ".config"), "kimiflare", "config.json");
+}
+export async function validateOpenRouterKey(key, fetchImpl) {
+    if (!/^sk-or-[A-Za-z0-9_-]{10,}$/.test(key))
+        return "That doesn't look like an OpenRouter key (sk-or-…).";
+    if (!fetchImpl)
+        return undefined;
+    try {
+        const response = await fetchImpl("https://openrouter.ai/api/v1/key", { headers: { Authorization: `Bearer ${key}` } });
+        if (response.status === 401 || response.status === 403)
+            return "OpenRouter rejected that key.";
+    }
+    catch {
+        // Offline: the format is right, and the server checks it again.
+    }
+    return undefined;
+}
+export async function validateGitHubToken(token, fetchImpl) {
+    if (!/^(github_pat_|ghp_|gho_|ghu_)[A-Za-z0-9_]{20,}$/.test(token))
+        return { problem: "That doesn't look like a GitHub token (github_pat_… or ghp_…)." };
+    if (!fetchImpl)
+        return {};
+    try {
+        const response = await fetchImpl("https://api.github.com/user", { headers: { Authorization: `Bearer ${token}`, "User-Agent": "directionallylocal" } });
+        if (response.status === 401)
+            return { problem: "GitHub rejected that token." };
+        if (response.ok) {
+            const user = await response.json();
+            if (typeof user.login === "string")
+                return { login: user.login };
+        }
+    }
+    catch {
+        // Offline isn't fatal.
+    }
+    return {};
+}
+/** Finds, confirms, or asks for exactly the keys in `needs`. */
+export async function gatherKeys(needs, input) {
+    const { ui } = input;
+    const answers = {};
+    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.`);
+    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 }) {
+    const fromCli = (await sources.gh().catch(() => undefined))?.trim();
+    if (fromCli) {
+        const checked = await validateGitHubToken(fromCli, sources.fetch);
+        if (checked.problem) {
+            ui.warn(`Your GitHub CLI login didn't work (${checked.problem}); asking for a token instead.`);
+        }
+        else {
+            const who = checked.login ? ` (${checked.login})` : "";
+            if (await confirm(ui, prompter, `Use your GitHub CLI login${who}? It stays on your server.`)) {
+                ui.answered("GitHub", `${checked.login ? `signed in as ${checked.login} · ` : ""}from the GitHub CLI`);
+                return fromCli;
+            }
+        }
+    }
+    return askUntilValid(ui, "GitHub", async () => {
+        const token = await prompter.secret(ui.prompt("GitHub token", "fine-grained: github.com/settings/personal-access-tokens/new"));
+        const checked = await validateGitHubToken(token, sources.fetch);
+        return { value: token, ...(checked.problem ? { problem: checked.problem } : {}), ...(checked.login ? { detail: `signed in as ${checked.login}` } : {}) };
+    });
+}
+export async function openrouterKey({ ui, prompter, sources }) {
+    const candidates = [];
+    const fromEnv = sources.env.OPENROUTER_API_KEY?.trim();
+    if (fromEnv)
+        candidates.push({ key: fromEnv, question: "Use the OpenRouter key in OPENROUTER_API_KEY?", from: "from OPENROUTER_API_KEY" });
+    const config = await sources.readFile(autopilotConfigPath(sources.env, sources.home));
+    const fromAutopilot = config ? readAutopilotKey(config) : undefined;
+    if (fromAutopilot && fromAutopilot !== fromEnv)
+        candidates.push({ key: fromAutopilot, question: "Use the OpenRouter key from Autopilot?", from: "from Autopilot" });
+    for (const candidate of candidates) {
+        const problem = await validateOpenRouterKey(candidate.key, sources.fetch);
+        if (problem) {
+            ui.warn(`The OpenRouter key ${candidate.from} didn't work (${problem})`);
+            continue;
+        }
+        if (await confirm(ui, prompter, `${candidate.question} It stays on your server.`)) {
+            ui.answered("OpenRouter", candidate.from);
+            return candidate.key;
+        }
+    }
+    return askUntilValid(ui, "OpenRouter", async () => {
+        const key = await prompter.secret(ui.prompt("OpenRouter key", "openrouter.ai/keys"));
+        const problem = await validateOpenRouterKey(key, sources.fetch);
+        return { value: key, ...(problem ? { problem } : {}) };
+    });
+}
+function readAutopilotKey(text) {
+    try {
+        const value = JSON.parse(text).openrouterApiKey;
+        return typeof value === "string" && value.trim() ? value.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A Y/n question; Enter means yes. */
+export async function confirm(ui, prompter, question) {
+    const answer = (await prompter.text(ui.prompt(question, "Y/n"))).trim().toLowerCase();
+    return answer === "" || answer === "y" || answer === "yes";
+}
+async function askUntilValid(ui, label, ask) {
+    for (let attempt = 1;; attempt++) {
+        const { value, problem, detail } = await ask();
+        if (!problem) {
+            ui.answered(label, detail);
+            return value.trim();
+        }
+        if (attempt >= 3) {
+            ui.rejected(problem);
+            throw new Error(problem);
+        }
+        ui.rejected(`${problem} Try again.`);
+    }
+}