directionallylocal 0.2.0 → 0.4.0

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

package/dist/laptop/remote-install.js

@@ -0,0 +1,280 @@
+import { agentCapacity } from "../detect.js";
+import { CELL_MEMORY_MB } from "../layout.js";
+import { shellQuote } from "./ssh.js";
+/**
+ * Installing on the user's server from the laptop, over SSH, through the server-side
+ * commands' machine-readable modes:
+ *   1. bootstrap   install.sh with DL_INSTALL_ONLY=1 (plain `.. step` / `ok step: detail` lines)
+ *   2. needs       `dl up --needs --access ssh` (one JSON line: which keys it still lacks)
+ *   3. install     `dl up --access ssh --answers-stdin --events json` (keys on stdin, NDJSON out)
+ *   4. pair        `dl pair --name … --json` (a credential for this laptop)
+ * The server's checklist is replayed into the laptop's own Ui, so it animates here.
+ */
+export const INSTALL_URL = "https://directionallylocal.run";
+/** Non-root users run the server commands with sudo; checkServer made sure it needs no password. */
+function sudo(facts) {
+    return facts.root ? "" : "sudo -n ";
+}
+export function bootstrapCommand(facts, installUrl = INSTALL_URL) {
+    const run = facts.root ? "DL_INSTALL_ONLY=1 sh /tmp/dl-install.sh" : "sudo -n env DL_INSTALL_ONLY=1 sh /tmp/dl-install.sh";
+    return `curl -fsSL ${shellQuote(installUrl)} -o /tmp/dl-install.sh && ${run}`;
+}
+/**
+ * Renders install.sh's plain lines as a checklist. Steps aren't known up front, so each new
+ * one re-plans the list on a terminal (and restores the finished steps' ticks).
+ */
+export class BootstrapRenderer {
+    ui;
+    steps = [];
+    active;
+    output = [];
+    failure;
+    constructor(ui) {
+        this.ui = ui;
+    }
+    stdout(line) {
+        const started = /^\.\. (.+)$/.exec(line);
+        if (started)
+            return this.start(started[1].trim());
+        const finished = /^ok ([^:]+?)(?:: (.*))?$/.exec(line);
+        if (finished)
+            return this.done(finished[1].trim(), finished[2]?.trim());
+        this.keep(line);
+    }
+    stderr(line) {
+        const failed = /^directionallylocal: (.+)$/.exec(line);
+        if (failed) {
+            this.failure = failed[1].trim();
+            return;
+        }
+        this.keep(line);
+    }
+    /** After install.sh exits: fails the running step and throws with its output when it failed. */
+    finish(code) {
+        if (code === 0) {
+            if (this.active)
+                this.done(this.active);
+            this.ui.finish();
+            return;
+        }
+        const what = this.failure ?? `the install script exited with ${code}`;
+        const id = this.active ?? this.steps.at(-1)?.id;
+        if (id)
+            this.ui.fail(id, what);
+        this.ui.finish();
+        const tail = this.output.slice(-15).map((line) => `    ${line}`).join("\n");
+        throw new Error(`Installing dl on the server failed: ${what}${tail ? `\n${tail}` : ""}`);
+    }
+    start(label) {
+        if (this.active && this.active !== label)
+            this.done(this.active);
+        let step = this.steps.find((entry) => entry.id === label);
+        if (!step) {
+            step = { id: label, label, done: false };
+            this.steps.push(step);
+            this.ui.plan(this.steps.map(({ id, label: text }) => ({ id, label: text })));
+            // plan() shows every step as pending again; on a terminal, put the finished ones back.
+            if (this.ui.interactive)
+                for (const entry of this.steps)
+                    if (entry.done)
+                        this.ui.done(entry.id, entry.detail);
+        }
+        this.active = label;
+        this.ui.start(label);
+    }
+    done(label, detail) {
+        if (!this.steps.some((entry) => entry.id === label))
+            this.start(label);
+        const step = this.steps.find((entry) => entry.id === label);
+        step.done = true;
+        if (detail !== undefined)
+            step.detail = detail;
+        if (this.active === label)
+            this.active = undefined;
+        this.ui.done(label, detail);
+    }
+    keep(line) {
+        if (!line.trim())
+            return;
+        this.output.push(line);
+        if (this.output.length > 200)
+            this.output.shift();
+    }
+}
+export async function bootstrap(access, facts, ssh, ui, installUrl) {
+    const renderer = new BootstrapRenderer(ui);
+    const result = await ssh(access, bootstrapCommand(facts, installUrl), {
+        onStdoutLine: (line) => renderer.stdout(line),
+        onStderrLine: (line) => renderer.stderr(line),
+    });
+    renderer.finish(result.code);
+}
+/** Which keys the server still lacks, so a configured server is asked nothing. */
+export async function serverNeeds(access, facts, ssh) {
+    const result = await ssh(access, `${sudo(facts)}dl up --needs --access ssh`);
+    const parsed = lastJson(result.stdout);
+    if (result.code !== 0 || !parsed || !Array.isArray(parsed.needs)) {
+        throw new Error(`Couldn't ask the server what it needs: ${lastLine(result.stderr) || lastLine(result.stdout) || `exit ${result.code}`}`);
+    }
+    return parsed.needs.filter((need) => need === "openrouter" || need === "github" || need === "tailscale");
+}
+/**
+ * Replays `dl up --events json` into Ui calls. The server's own title and ready screen are
+ * skipped (the laptop prints its own); "answered" becomes a plain ✓ line, since on a
+ * terminal answered() erases the prompt above it, and there is none here.
+ */
+export class EventReplayer {
+    newUi;
+    ui;
+    planned = false;
+    ids = new Set();
+    output = [];
+    error;
+    capacity;
+    constructor(newUi) {
+        this.newUi = newUi;
+        this.ui = newUi();
+    }
+    line(text) {
+        let event;
+        try {
+            const parsed = JSON.parse(text);
+            if (!parsed || typeof parsed !== "object" || typeof parsed.event !== "string")
+                throw new Error("not an event");
+            event = parsed;
+        }
+        catch {
+            if (text.trim())
+                this.output.push(text);
+            return;
+        }
+        const str = (key) => typeof event[key] === "string" ? event[key] : undefined;
+        switch (event.event) {
+            case "line":
+            case "answered": {
+                // A line after a checklist starts a new one below it, or the redraw would overwrite it.
+                this.fresh();
+                const status = event.event === "answered" ? "done" : str("status");
+                this.capacity ??= capacityFromMachine(str("label"), str("detail"));
+                this.ui.line(status === "done" || status === "failed" ? status : "info", str("label") ?? "", ...optional(str("detail")));
+                return;
+            }
+            case "plan": {
+                if (this.planned)
+                    this.fresh();
+                const steps = Array.isArray(event.steps) ? event.steps
+                    .filter((step) => typeof step.id === "string")
+                    .map((step) => ({ id: step.id, label: typeof step.label === "string" ? step.label : step.id })) : [];
+                for (const step of steps)
+                    this.ids.add(step.id);
+                this.ui.plan(steps);
+                this.planned = true;
+                return;
+            }
+            case "start":
+            case "done":
+            case "fail": {
+                const id = str("id");
+                if (!id || !this.ids.has(id))
+                    return;
+                if (event.event === "start")
+                    this.ui.start(id, ...optional(str("detail")));
+                else if (event.event === "done")
+                    this.ui.done(id, ...optional(str("detail")));
+                else
+                    this.ui.fail(id, str("message") ?? "failed");
+                return;
+            }
+            case "warn":
+                if (str("text"))
+                    this.ui.warn(str("text"));
+                return;
+            case "ready":
+                this.capacity = capacityFrom(event) ?? this.capacity;
+                return;
+            case "error":
+                this.error = str("message") ?? "the install failed";
+                return;
+            default:
+                // "title", and anything newer than this laptop knows about.
+                return;
+        }
+    }
+    /** Recent lines that weren't events (the server's own messages), for an error. */
+    tail() {
+        return this.output.slice(-15);
+    }
+    finish() {
+        this.ui.finish();
+    }
+    fresh() {
+        if (!this.planned)
+            return;
+        this.ui.finish();
+        this.ui = this.newUi();
+        this.planned = false;
+        this.ids.clear();
+    }
+}
+function optional(value) {
+    return value === undefined ? [] : [value];
+}
+/**
+ * In SSH mode the server's ready screen has no estimate, so it's worked out here the way
+ * `dl up` does, from its machine check ("Ubuntu 24.04 · 4 CPU · 7.5 GB · …").
+ */
+function capacityFromMachine(label, detail) {
+    if (label !== "Checked this machine" || !detail)
+        return undefined;
+    const cpus = /(\d+) CPU/.exec(detail);
+    const memory = /([\d.]+) GB(?! free)/.exec(detail);
+    if (!cpus || !memory)
+        return undefined;
+    return agentCapacity({ cpus: Number(cpus[1]), memoryMb: Math.round(Number(memory[1]) * 1024) }, CELL_MEMORY_MB);
+}
+/** "fits ~6 agents at once" anywhere in the server's ready screen (non-SSH servers print it). */
+function capacityFrom(event) {
+    const match = /fits ~(\d+)/.exec(JSON.stringify(event));
+    return match ? Number(match[1]) : undefined;
+}
+/** Runs the install, keys on stdin as one JSON object. Resolves with the capacity estimate, if given. */
+export async function installOnServer(access, facts, ssh, answers, newUi) {
+    const replay = new EventReplayer(newUi);
+    const stderr = [];
+    const result = await ssh(access, `${sudo(facts)}dl up --access ssh --answers-stdin --events json`, {
+        input: `${JSON.stringify(answers)}\n`,
+        onStdoutLine: (line) => replay.line(line),
+        onStderrLine: (line) => { if (line.trim())
+            stderr.push(line); },
+    });
+    replay.finish();
+    if (result.code !== 0 || replay.error) {
+        const tail = [...replay.tail(), ...stderr.slice(-15)].map((line) => `    ${line}`).join("\n");
+        throw new Error(`Setting up the server failed: ${replay.error ?? `dl up exited with ${result.code}`}${tail ? `\n${tail}` : ""}\n  Fix it and run dl setup again; it picks up where it stopped.`);
+    }
+    return replay.capacity === undefined ? {} : { capacity: replay.capacity };
+}
+/** A credential for this laptop, issued on the server (no browser approval needed: SSH already proved who we are). */
+export async function pairLaptop(access, facts, ssh, name) {
+    const result = await ssh(access, `${sudo(facts)}dl pair --name ${shellQuote(name)} --json`);
+    const parsed = lastJson(result.stdout);
+    const fields = ["token", "credentialId", "name", "expiresAt", "url"];
+    if (result.code !== 0 || !parsed || !fields.every((key) => typeof parsed[key] === "string")) {
+        throw new Error(`Couldn't connect this laptop to the server: ${lastLine(result.stderr) || `dl pair exited with ${result.code}`}`);
+    }
+    return parsed;
+}
+function lastJson(text) {
+    for (const line of text.trim().split("\n").reverse()) {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            // keep looking: a banner or warning may come before the JSON
+        }
+    }
+    return undefined;
+}
+function lastLine(text) {
+    return text.trim().split("\n").at(-1)?.trim() ?? "";
+}