directionallylocal 0.3.0 → 0.4.1

package/dist/laptop/commands.js

@@ -1,23 +1,30 @@
 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 { isModelNotPriced } from "../model-prices.js";
 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 +67,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 +81,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 +92,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 +107,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 +184,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 +202,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 +278,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;
@@ -258,7 +324,11 @@ async function follow(client, remote, conversationId, cursor, signal, io, replay
         io.err("\n");
         return 0;
     }
-    io.err(`\n  ${c.red("✗")} ${id} ${outcome}\n\n`);
+    io.err(`\n  ${c.red("✗")} ${id} ${outcome}\n`);
+    if (renderer.unpriced || isModelNotPriced(JSON.stringify(final))) {
+        io.err(`  This model isn't in your server's price list yet. Run ${c.bold("dl setup")} to refresh it, or pick another model with -m.\n`);
+    }
+    io.err("\n");
     return 1;
 }
 /** Writes the agent's text as it streams and one line per tool call. */
@@ -266,12 +336,16 @@ class EventRenderer {
     io;
     c;
     midLine = false;
+    /** Hotcell refused the model for lack of a price (a stale price list on the server). */
+    unpriced = false;
     constructor(io, c) {
         this.io = io;
         this.c = c;
     }
     render(event) {
         const data = event.data;
+        if (event.type !== "assistant.delta" && !this.unpriced && isModelNotPriced(JSON.stringify(data)))
+            this.unpriced = true;
         if (event.type === "assistant.delta") {
             const text = typeof data.text === "string" ? data.text : typeof data.delta === "string" ? data.delta : "";
             if (!text)
@@ -326,22 +400,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";

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);
 }

package/dist/laptop/credentials.js

@@ -52,7 +52,7 @@ export async function gatherKeys(needs, input) {
         answers.openrouterKey = await openrouterKey(input);
     return answers;
 }
-async function githubToken({ ui, prompter, sources }) {
+export async function githubToken({ ui, prompter, sources }) {
     const fromCli = (await sources.gh().catch(() => undefined))?.trim();
     if (fromCli) {
         const checked = await validateGitHubToken(fromCli, sources.fetch);
@@ -73,7 +73,7 @@ async function githubToken({ ui, prompter, sources }) {
         return { value: token, ...(checked.problem ? { problem: checked.problem } : {}), ...(checked.login ? { detail: `signed in as ${checked.login}` } : {}) };
     });
 }
-async function openrouterKey({ ui, prompter, sources }) {
+export async function openrouterKey({ ui, prompter, sources }) {
     const candidates = [];
     const fromEnv = sources.env.OPENROUTER_API_KEY?.trim();
     if (fromEnv)

package/dist/laptop/keys.js

@@ -0,0 +1,133 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+import { KEY_LABELS, formatKeyListing, parseKeyName } from "../keys.js";
+import { listLocalKeys, setLocalKey } from "../local/keys.js";
+import { PAIRED_NAME } from "../local/layout.js";
+import { TtyPrompter } from "../prompt.js";
+import { palette, PlainUi, TerminalUi } from "../ui.js";
+import { resolveRemote } from "./config.js";
+import { githubToken, openrouterKey } from "./credentials.js";
+import { checkServer, realSshExec } from "./ssh.js";
+export const LAPTOP_KEYS_USAGE = "  Usage: dl keys [openrouter|github] [--server NAME]\n"
+    + "         dl keys              which keys are set where your agents run\n"
+    + "         dl keys openrouter   replace the OpenRouter key     dl keys github   replace the GitHub token\n";
+export async function laptopKeys(args, options, deps) {
+    const [first, ...rest] = args;
+    const which = first === undefined || first === "ls" || first === "list" ? undefined : parseKeyName(first);
+    if ((first !== undefined && first !== "ls" && first !== "list" && !which) || rest.length > 0) {
+        deps.write(LAPTOP_KEYS_USAGE);
+        return 2;
+    }
+    const target = await resolveTarget(options.server, deps.remotesFile);
+    const again = (key) => `dl keys ${key}${options.server ? ` --server ${target.remote.name}` : ""}`;
+    if (!which) {
+        const listing = target.kind === "local" ? await deps.local.list() : await listOverSsh(target, deps.ssh);
+        deps.write(formatKeyListing(listing, palette(deps.color), `on ${target.kind === "local" ? "this computer" : target.remote.name}`, again));
+        return 0;
+    }
+    // Reach the server before asking for anything, so a dead connection doesn't waste a key.
+    const root = target.kind === "ssh" ? (await checkServer(target.access, deps.ssh, target.remote.name)).root : true;
+    const where = target.kind === "local" ? "this computer" : target.remote.name;
+    const label = `${KEY_LABELS[which]} ${which === "github" ? "token" : "key"}`;
+    const askUi = deps.newUi();
+    askUi.questions(`A new ${label} for ${where}; it replaces the one there. Typing is hidden.`);
+    const value = which === "github"
+        ? await githubToken({ ui: askUi, prompter: deps.prompter, sources: deps.sources })
+        : await openrouterKey({ ui: askUi, prompter: deps.prompter, sources: deps.sources });
+    askUi.finish();
+    const ui = deps.newUi();
+    ui.plan([{ id: "apply", label: `Replacing the ${label} on ${where}` }]);
+    ui.start("apply");
+    try {
+        const result = target.kind === "local" ? await deps.local.set(which, value) : await setOverSsh(target, root, which, value, deps.ssh);
+        ui.done("apply", result.detail);
+    }
+    catch (error) {
+        ui.fail("apply", error instanceof Error ? error.message.split("\n")[0] : String(error));
+        ui.finish();
+        throw error;
+    }
+    ui.finish();
+    return 0;
+}
+/** The server in use: `--server NAME`, or the only (or default) one. */
+async function resolveTarget(server, remotesFile) {
+    const remote = remotesFile ? await resolveRemote(server, remotesFile) : await resolveRemote(server);
+    if (remote.ssh)
+        return { kind: "ssh", remote, access: remote.ssh };
+    if (remote.name === PAIRED_NAME)
+        return { kind: "local", remote };
+    throw new Error(`${remote.name} was connected with dl connect, so this laptop can't reach its keys. On that server, run: sudo dl keys`);
+}
+function sudo(root) {
+    return root ? "" : "sudo -n ";
+}
+async function setOverSsh(target, root, which, value, ssh) {
+    // The key travels on stdin only; the command line names which key, never its value.
+    const result = await ssh(target.access, `${sudo(root)}dl keys set ${which} --stdin --json`, { input: `${value}\n` });
+    const parsed = lastJson(result.stdout);
+    if (parsed?.ok === true)
+        return { ok: true, key: which, detail: typeof parsed.detail === "string" ? parsed.detail : "replaced" };
+    if (typeof parsed?.error === "string")
+        throw new Error(`${target.remote.name}: ${parsed.error}`);
+    throw serverFailure(target.remote.name, result);
+}
+async function listOverSsh(target, ssh) {
+    const { root } = await checkServer(target.access, ssh, target.remote.name);
+    const result = await ssh(target.access, `${sudo(root)}dl keys --json`);
+    const parsed = lastJson(result.stdout);
+    if (result.code !== 0 || !parsed || !Array.isArray(parsed.keys))
+        throw serverFailure(target.remote.name, result);
+    return parsed.keys.filter(isListing);
+}
+function serverFailure(name, result) {
+    if (/Unknown command "keys"|Unknown option '--(stdin|json)'/.test(result.stderr)) {
+        return new Error(`The dl on ${name} is too old for dl keys; update it with dl setup (it keeps your keys), then try again.`);
+    }
+    return new Error(`Couldn't change the keys on ${name}: ${lastLine(result.stderr) || lastLine(result.stdout) || `exit ${result.code}`}`);
+}
+function isListing(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const entry = value;
+    return (entry.key === "openrouter" || entry.key === "github") && typeof entry.set === "boolean"
+        && (entry.detail === undefined || typeof entry.detail === "string") && (entry.problem === undefined || typeof entry.problem === "string");
+}
+function lastJson(stdout) {
+    for (const line of stdout.trim().split("\n").reverse()) {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            // not JSON; keep looking
+        }
+    }
+    return undefined;
+}
+function lastLine(text) {
+    return text.trim().split("\n").filter((line) => line.trim() && !/Permanently added/i.test(line)).at(-1)?.trim() ?? "";
+}
+/** `dl keys` on a laptop with the real terminal, ssh, gh, and filesystem. */
+export async function keys(args, options) {
+    const { io, terminal } = options;
+    const color = io.color === true;
+    const execFileAsync = promisify(execFile);
+    return laptopKeys(args, options.server ? { server: options.server } : {}, {
+        newUi: () => terminal ? new TerminalUi(io.out, undefined, color) : new PlainUi(io.out),
+        prompter: new TtyPrompter(),
+        write: io.out,
+        color,
+        ssh: realSshExec,
+        sources: {
+            env: process.env,
+            home: homedir(),
+            readFile: (path) => readFile(path, "utf8").catch(() => undefined),
+            gh: () => execFileAsync("gh", ["auth", "token"], { timeout: 5000 }).then(({ stdout }) => stdout.trim() || undefined, () => undefined),
+            fetch: globalThis.fetch,
+        },
+        // Checked online here already; this computer re-checks only the format.
+        local: { set: (which, value) => setLocalKey(which, value), list: () => listLocalKeys({ fetchImpl: globalThis.fetch }) },
+    });
+}