directionallylocal 0.3.0 → 0.4.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -71,3 +71,7 @@ npm test          # node:test through tsx; a simulated server exercises up, doct
 npm run typecheck
 npm run build
 ```
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE).

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/doctor.js

@@ -1,10 +1,11 @@
 import { detectHost, MIN_DISK_GB } from "./detect.js";
 import { nodeAdvisory } from "./node-advisory.js";
 import { AUTOPILOT_PORT, AUTO_UPGRADES, HOTCELL_PORT, NODE_AUTO_UPDATES, PATHS, SERVICES, parseEnvFile } from "./layout.js";
+import { fileMtime, modelPricesHealth } from "./model-prices.js";
 import { describeAccess, readState } from "./state.js";
 import { palette } from "./ui.js";
 /** `directionallylocal doctor`: every moving part, with a fix for each failure. */
-export async function doctor(system) {
+export async function doctor(system, now = new Date()) {
     const checks = [];
     const add = (check) => checks.push(check);
     const state = await readState(system);
@@ -45,6 +46,8 @@ export async function doctor(system) {
     const keys = await system.probe("runuser", ["-u", "hotcell", "--", "env", `HOTCELL_HOME=${PATHS.hotcellHome}`, "HOTCELL_KEYSTORE=file", "/usr/bin/node", `${PATHS.current}/node_modules/hotcell/dist/index.js`, "keys", "ls"]);
     const hasModelKey = keys.code === 0 && /^\s*openrouter\b/m.test(keys.stdout);
     add({ name: "model key", ok: hasModelKey, detail: hasModelKey ? "OpenRouter key in Hotcell" : "no OpenRouter key in Hotcell", fix: "sudo dl up (asks for it)" });
+    const prices = modelPricesHealth(await system.readFile(PATHS.modelPrices), await fileMtime(system, PATHS.modelPrices), now, "dl up");
+    add({ name: "model prices", ok: prices.ok, ...(prices.warn ? { warn: true } : {}), detail: prices.detail, fix: "sudo dl up (downloads them from openrouter.ai)" });
     const github = Boolean(parseEnvFile(await system.readFile(PATHS.githubEnv)).GITHUB_TOKEN);
     add({ name: "github", ok: github, detail: github ? "token configured" : "no token; runs can't push or open PRs", fix: "sudo dl up (asks for it)" });
     const autopilot = (await system.probe("curl", ["-s", "-o", "/dev/null", "-w", "%{http_code}", `http://127.0.0.1:${AUTOPILOT_PORT}/api/v1/health`])).stdout.trim();
@@ -63,9 +66,9 @@ export function formatChecks(checks, color = false) {
     const c = palette(color);
     const width = Math.max(...checks.map((check) => check.name.length)) + 2;
     const rows = checks.map((check) => {
-        const glyph = check.ok ? c.green("✓") : c.red("✗");
+        const glyph = !check.ok ? c.red("✗") : check.warn ? c.yellow("!") : c.green("✓");
         const fix = !check.ok && check.fix ? `\n     ${c.dim(`fix: ${check.fix}`)}` : "";
-        return `  ${glyph} ${check.name.padEnd(width)}${check.ok ? c.dim(check.detail) : c.red(check.detail)}${fix}`;
+        return `  ${glyph} ${check.name.padEnd(width)}${!check.ok ? c.red(check.detail) : check.warn ? c.yellow(check.detail) : c.dim(check.detail)}${fix}`;
     });
     const failed = checks.filter((check) => !check.ok).length;
     const verdict = failed === 0 ? `${c.green("✓")} ${c.bold("All good")}` : `${c.red("✗")} ${c.bold(`${failed} to fix`)}`;

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";
+}