directionallylocal 0.2.0 → 0.3.0

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

package/dist/laptop/setup.js

@@ -0,0 +1,253 @@
+import { execFile } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { TtyPrompter } from "../prompt.js";
+import { palette, PlainUi, TerminalUi } from "../ui.js";
+import { loadRemotes, normalizeServerUrl, REMOTE_NAME_RE, remotesPath, saveRemote } from "./config.js";
+import { confirm, gatherKeys } from "./credentials.js";
+import { bootstrap, INSTALL_URL, installOnServer, pairLaptop, serverNeeds } from "./remote-install.js";
+import { checkServer, describeHost, discoverKeys, hostOf, parseSshConfig, parseTarget, realSshExec, SshAuthError } from "./ssh.js";
+import { openRemote, withConnections } from "./tunnel.js";
+const RUN_EXAMPLE = 'dl run "fix the flaky checkout test"';
+export async function setupWizard(deps) {
+    const c = palette(deps.color);
+    deps.write(`\n  ${c.bold("Directionally Local")}\n  Background coding agents. Where should they run?\n\n`);
+    deps.write(`  ${c.cyan("1")}  ${"On this computer".padEnd(22)} ${c.dim("start now · nothing to rent · pauses when this computer sleeps")}\n`);
+    deps.write(`  ${c.cyan("2")}  ${"On my own server".padEnd(22)} ${c.dim("keeps going when your laptop is closed · needs SSH access")}\n\n`);
+    const ui = deps.newUi();
+    let where = await pick(ui, deps.prompter, "Where", "1 or 2 · Enter for 1", { "1": "local", "2": "server" });
+    ui.answered("Where", where === "local" ? "On this computer" : "On my own server");
+    if (where === "local" && !deps.localSetup) {
+        ui.line("info", "On this computer", "coming soon");
+        if (!(await confirm(ui, deps.prompter, "Set up on your own server instead?"))) {
+            deps.write(`\n  ${c.dim("Nothing changed. Run")} dl setup ${c.dim("when you're ready.")}\n\n`);
+            return undefined;
+        }
+        ui.answered("Where", "On my own server");
+        where = "server";
+    }
+    if (where === "local") {
+        const keysUi = deps.newUi();
+        const answers = await gatherKeys(["github", "openrouter"], { ui: keysUi, prompter: deps.prompter, sources: deps.sources });
+        keysUi.finish();
+        const remote = await deps.localSetup({ ui: deps.newUi(), prompter: deps.prompter, answers: { openrouterKey: answers.openrouterKey, githubToken: answers.githubToken } });
+        await saveRemote(remote, deps.remotesFile ?? remotesPath());
+        finishScreen(deps.newUi(), undefined);
+        return remote;
+    }
+    return setUpServer(deps);
+}
+async function setUpServer(deps) {
+    const c = palette(deps.color);
+    const home = deps.sources.home;
+    const sshDir = join(home, ".ssh");
+    const hosts = parseSshConfig(await deps.sources.readFile(join(sshDir, "config")) ?? "", home);
+    // 1. Which server, and can we get in?
+    let { access, display } = await chooseServer(deps, hosts);
+    let facts;
+    for (let attempt = 0; !facts; attempt++) {
+        const ui = deps.newUi();
+        ui.plan([{ id: "ssh", label: "Server" }]);
+        ui.start("ssh", display);
+        try {
+            facts = await checkServer(access, deps.ssh, display);
+        }
+        catch (error) {
+            ui.fail("ssh", error instanceof SshAuthError ? "SSH key not accepted" : "can't set up here");
+            ui.finish();
+            if (!(error instanceof SshAuthError) || attempt >= 2)
+                throw explainAuth(error, access);
+            access = { ...access, identityFile: await chooseKey(deps, sshDir, access) };
+            continue;
+        }
+        display = `${facts.user}@${display.replace(/^[^@]*@/, "")}`;
+        ui.done("ssh", `${display}  ${facts.os} · ${facts.arch}`);
+        ui.finish();
+        if (facts.newHostKey)
+            deps.newUi().line("info", "New server", "first connection: trusted its host key (accept-new)");
+    }
+    // 2. Install dl there, then ask only for the keys it still lacks.
+    await bootstrap(access, facts, deps.ssh, deps.newUi(), deps.installUrl);
+    const needs = await serverNeeds(access, facts, deps.ssh);
+    if (needs.includes("tailscale"))
+        throw new Error("The server asked for Tailscale, but this setup reaches it over SSH; update dl on the server and run dl setup again.");
+    const keysUi = deps.newUi();
+    const answers = await gatherKeys(needs, { ui: keysUi, prompter: deps.prompter, sources: deps.sources });
+    if (needs.length === 0)
+        keysUi.line("done", "Keys", "already on the server");
+    keysUi.finish();
+    // 3. The install itself, its checklist replayed here.
+    const { capacity } = await installOnServer(access, facts, deps.ssh, answers, deps.newUi);
+    // 4. A credential for this laptop, checked through the tunnel every command will use. Each
+    // `dl pair` makes a new credential on the server, so a re-run keeps the saved one if it works.
+    const remotesFile = deps.remotesFile ?? remotesPath();
+    const saved = (await loadRemotes(remotesFile)).find((entry) => sameServer(entry, access));
+    let remote;
+    if (saved && await stillWorks({ ...saved, ssh: access }, deps.open))
+        remote = { ...saved, ssh: access };
+    if (!remote) {
+        const pairing = await pairLaptop(access, facts, deps.ssh, `${laptopName(deps.hostname)} (dl)`);
+        remote = {
+            name: saved?.name ?? await remoteName(access, remotesFile),
+            url: normalizeServerUrl(pairing.url),
+            token: pairing.token,
+            credentialId: pairing.credentialId,
+            expiresAt: pairing.expiresAt,
+            addedAt: (deps.now?.() ?? new Date()).toISOString(),
+            ssh: access,
+        };
+    }
+    const connectedUi = deps.newUi();
+    const paired = remote;
+    await withConnections(deps.open, async (connections) => {
+        try {
+            await (await connections.client(paired)).health();
+        }
+        catch (error) {
+            connectedUi.line("failed", "This laptop", "couldn't reach the server's API through SSH");
+            throw new Error(`The server is set up, but this laptop couldn't reach it through an SSH tunnel: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    await saveRemote(remote, remotesFile);
+    connectedUi.line("done", "This laptop", `connected as ${remote.name}`);
+    connectedUi.finish();
+    finishScreen(deps.newUi(), capacity);
+    return remote;
+}
+async function chooseServer(deps, hosts) {
+    const c = palette(deps.color);
+    const ui = deps.newUi();
+    if (hosts.length > 0) {
+        deps.write(`\n  ${c.dim("Your servers in ~/.ssh/config:")}\n`);
+        hosts.forEach((host, index) => deps.write(`  ${c.cyan(String(index + 1))}  ${host.alias.padEnd(22)} ${c.dim(describeHost(host))}\n`));
+        deps.write(`  ${c.cyan(String(hosts.length + 1))}  Another server\n\n`);
+    }
+    else {
+        deps.write("\n");
+    }
+    const hint = hosts.length > 0 ? `1-${hosts.length + 1}, or user@host[:port]` : "user@host[:port], e.g. root@203.0.113.10";
+    for (let attempt = 1;; attempt++) {
+        let answer = (await deps.prompter.text(ui.prompt("Server", hint))).trim();
+        const index = /^\d+$/.test(answer) ? Number(answer) - 1 : -1;
+        const host = hosts[index];
+        if (host) {
+            ui.answered("SSH", host.alias);
+            return {
+                access: { target: host.alias },
+                display: `${host.user ? `${host.user}@` : ""}${host.hostName ?? host.alias}${host.port && host.port !== 22 ? `:${host.port}` : ""}`,
+            };
+        }
+        if (index === hosts.length && hosts.length > 0) {
+            ui.answered("SSH", "another server");
+            answer = (await deps.prompter.text(ui.prompt("Server address", "user@host[:port], e.g. root@203.0.113.10"))).trim();
+        }
+        try {
+            const access = parseTarget(answer);
+            ui.answered("SSH", access.target);
+            return { access, display: `${access.target}${access.port ? `:${access.port}` : ""}` };
+        }
+        catch (error) {
+            if (attempt >= 3)
+                throw error;
+            ui.rejected(`${error.message}. Try again.`);
+        }
+    }
+}
+/** The server refused the default keys: offer the ones in ~/.ssh and retry with -i. */
+async function chooseKey(deps, sshDir, access) {
+    const c = palette(deps.color);
+    const keys = discoverKeys(sshDir, await deps.sources.listDir(sshDir)).filter((key) => key !== access.identityFile);
+    if (keys.length === 0)
+        throw explainAuth(new SshAuthError(access, "no other keys in ~/.ssh"), access);
+    deps.write(`\n  ${c.dim("Which key does this server accept?")}\n`);
+    keys.forEach((key, index) => deps.write(`  ${c.cyan(String(index + 1))}  ${key.replace(deps.sources.home, "~")}\n`));
+    deps.write("\n");
+    const ui = deps.newUi();
+    const answer = (await deps.prompter.text(ui.prompt("SSH key", `1-${keys.length}`))).trim();
+    const key = keys[(Number(answer) || 1) - 1] ?? keys[0];
+    ui.answered("SSH key", key.replace(deps.sources.home, "~"));
+    return key;
+}
+function explainAuth(error, access) {
+    if (!(error instanceof SshAuthError))
+        return error instanceof Error ? error : new Error(String(error));
+    return new Error([
+        error.message,
+        "  Add this computer's public key to the server (it asks for the password once):",
+        `     ssh-copy-id ${access.port ? `-p ${access.port} ` : ""}${access.target}`,
+        "  If your key has a passphrase, load it first with: ssh-add",
+    ].join("\n"));
+}
+function sameServer(remote, access) {
+    return remote.ssh?.target === access.target && remote.ssh.port === access.port;
+}
+async function stillWorks(remote, open) {
+    return withConnections(open, async (connections) => {
+        await (await connections.client(remote)).health();
+        return true;
+    }).catch(() => false);
+}
+/** box (from an ssh alias) or 203-0-113-10, unique unless it's this same server again. */
+async function remoteName(access, remotesFile) {
+    const host = hostOf(access.target).toLowerCase();
+    const label = /^\d+(\.\d+){3}$/.test(host) || host.includes(":") ? host.replace(/[.:]/g, "-") : host.split(".")[0] ?? "server";
+    const base = label.replace(/[^a-z0-9-]/g, "-").replace(/^-+/, "").slice(0, 36) || "server";
+    const name = REMOTE_NAME_RE.test(base) ? base : "server";
+    const remotes = await loadRemotes(remotesFile);
+    for (let n = 1;; n++) {
+        const candidate = n === 1 ? name : `${name}-${n}`;
+        const existing = remotes.find((remote) => remote.name === candidate);
+        if (!existing || sameServer(existing, access))
+            return candidate;
+    }
+}
+function finishScreen(ui, capacity) {
+    ui.ready(capacity ? `Ready · fits ~${capacity} agents at once (estimate)` : "Ready", [
+        { label: "From any GitHub repository", value: RUN_EXAMPLE },
+        { label: "See progress, then check out the result", value: "dl runs\ndl pull ID" },
+    ]);
+}
+function laptopName(name) {
+    return name.replace(/\.local$/, "").replace(/[^\p{L}\p{N} ._'()@-]/gu, "-").slice(0, 40) || "laptop";
+}
+async function pick(ui, prompter, label, hint, choices) {
+    const values = Object.values(choices);
+    for (let attempt = 1;; attempt++) {
+        const answer = (await prompter.text(ui.prompt(label, hint))).trim();
+        const choice = answer === "" ? values[0] : choices[answer];
+        if (choice)
+            return choice;
+        if (attempt >= 3)
+            throw new Error(`Pick one of ${Object.keys(choices).join(", ")}`);
+        ui.rejected(`Type ${Object.keys(choices).join(" or ")}.`);
+    }
+}
+/** `dl setup` with the real terminal, ssh, gh, and filesystem. */
+export async function setup(options) {
+    const { io, terminal } = options;
+    const color = io.color === true;
+    const execFileAsync = promisify(execFile);
+    const home = homedir();
+    await setupWizard({
+        newUi: () => terminal ? new TerminalUi(io.out, undefined, color) : new PlainUi(io.out),
+        prompter: new TtyPrompter(),
+        write: io.out,
+        color,
+        ssh: realSshExec,
+        open: openRemote,
+        sources: {
+            env: process.env,
+            home,
+            readFile: (path) => readFile(path, "utf8").catch(() => undefined),
+            listDir: (path) => readdir(path).catch(() => []),
+            gh: () => execFileAsync("gh", ["auth", "token"], { timeout: 5000 }).then(({ stdout }) => stdout.trim() || undefined, () => undefined),
+            fetch: globalThis.fetch,
+        },
+        hostname: hostname(),
+        installUrl: process.env.DL_INSTALL_URL || INSTALL_URL,
+        ...(options.localSetup ? { localSetup: options.localSetup } : {}),
+    });
+    return 0;
+}