directionallylocal 0.1.2 → 0.3.0

package/dist/local/test-support/fake-computer.js

@@ -0,0 +1,263 @@
+import { HTTP_STATUS_SCRIPT, PORT_FREE_SCRIPT } from "../probes.js";
+/**
+ * A simulated Mac (or Linux desktop) with Docker Desktop, for "on this computer" tests.
+ * launchctl/systemctl load and unload services, which then answer on the ports in their
+ * env files; npm installs packages; Autopilot's CLI issues credentials. So setup can run
+ * twice to prove it repairs without reinstalling.
+ */
+export class FakeComputer {
+    home;
+    dryRun = false;
+    files = new Map();
+    dirs = new Map();
+    commands = [];
+    probes = [];
+    logs = [];
+    images = new Set();
+    containers = [];
+    /** launchd labels or systemd units that are running. */
+    running = new Set();
+    /** Ports something else on this computer listens on. */
+    busy = new Set();
+    credentials = [];
+    hotcellKeys = new Map();
+    docker = true;
+    /** Docker Desktop is installed as an app (it may be stopped). */
+    dockerApp = true;
+    dockerDenied = false;
+    /** Containers reach host.docker.internal. */
+    reachHost = true;
+    git = true;
+    uid = "501";
+    diskFreeKb = 120 * 1024 * 1024;
+    /** Docker Desktop's VM: 8 GB, 8 CPUs. */
+    dockerMemBytes = 8 * 1024 * 1024 * 1024;
+    systemdUser = true;
+    bridgeIp = undefined;
+    constructor(home = "/Users/ada") {
+        this.home = home;
+        this.files.set(`${home}/.docker/run/docker.sock`, { content: "", mode: 0o755 });
+        this.files.set("/opt/homebrew/opt/node/bin/node", { content: "", mode: 0o755 });
+        this.files.set("/Applications/Docker.app/Contents/Info.plist", { content: "", mode: 0o644 });
+        this.files.set("/etc/os-release", { content: 'ID=ubuntu\nPRETTY_NAME="Ubuntu 24.04.1 LTS"\n', mode: 0o644 });
+    }
+    get ran() {
+        return this.commands.map(({ command, args }) => [command, ...args].join(" "));
+    }
+    async run(command, args, options = {}) {
+        this.commands.push({ command, args, ...(options.input !== undefined ? { input: options.input } : {}), ...(options.env ? { env: options.env } : {}) });
+        const result = this.respond(command, args, options);
+        if (result.code !== 0 && !options.allowFailure)
+            throw new Error(`${command} ${args.join(" ")} failed: ${result.stderr}`);
+        return result;
+    }
+    async probe(command, args, options = {}) {
+        this.probes.push({ command, args, ...(options.input !== undefined ? { input: options.input } : {}), ...(options.env ? { env: options.env } : {}) });
+        return this.respond(command, args, options);
+    }
+    async readFile(path) {
+        return this.files.get(path)?.content;
+    }
+    async writeFile(path, content, options = {}) {
+        this.files.set(path, { content, mode: options.mode ?? 0o644 });
+    }
+    async mkdir(path, options = {}) {
+        this.dirs.set(path, options.mode);
+    }
+    async remove(path) {
+        for (const file of [...this.files.keys()])
+            if (file === path || file.startsWith(`${path}/`))
+                this.files.delete(file);
+        for (const dir of [...this.dirs.keys()])
+            if (dir === path || dir.startsWith(`${path}/`))
+                this.dirs.delete(dir);
+    }
+    async exists(path) {
+        if (path === "/Applications/Docker.app")
+            return this.dockerApp;
+        return this.files.has(path) || this.dirs.has(path) || [...this.files.keys(), ...this.dirs.keys()].some((entry) => entry.startsWith(`${path}/`));
+    }
+    log(line) {
+        this.logs.push(line);
+    }
+    /** The ports a running service of ours listens on, from its env file. */
+    ourPorts() {
+        const ports = new Map();
+        const env = (name) => Object.fromEntries((this.files.get(`${this.home}/.directionallylocal/config/${name}`)?.content ?? "")
+            .split("\n").flatMap((line) => line.match(/^([A-Z_]+)=(.*)$/) ? [[line.split("=")[0], line.slice(line.indexOf("=") + 1)]] : []));
+        if ([...this.running].some((name) => name.includes("hotcell"))) {
+            const hotcell = env("hotcell.env");
+            for (const key of ["HOTCELL_PORT", "HOTCELL_PROXY_PORT", "HOTCELL_EGRESS_PORT"])
+                if (hotcell[key])
+                    ports.set(Number(hotcell[key]), "hotcell");
+        }
+        if ([...this.running].some((name) => name.includes("autopilot"))) {
+            const autopilot = env("autopilot.env");
+            if (autopilot.AUTOPILOT_PUBLIC_URL)
+                ports.set(Number(autopilot.AUTOPILOT_PUBLIC_URL.split(":").at(-1)), "autopilot");
+            if (autopilot.AUTOPILOT_ASTER_GITHUB_PROXY_LISTEN)
+                ports.set(Number(autopilot.AUTOPILOT_ASTER_GITHUB_PROXY_LISTEN.split(":").at(-1)), "autopilot");
+        }
+        return ports;
+    }
+    respond(command, args, options) {
+        const ok = (stdout = "") => ({ code: 0, stdout, stderr: "" });
+        const fail = (stderr = "failed") => ({ code: 1, stdout: "", stderr });
+        const line = args.join(" ");
+        if (command.endsWith("/node") && args[0] === "-e") {
+            if (args[1] === PORT_FREE_SCRIPT) {
+                const port = Number(args[3]);
+                return this.busy.has(port) || this.ourPorts().has(port) ? fail() : ok();
+            }
+            if (args[1] === HTTP_STATUS_SCRIPT) {
+                const url = new URL(args[2]);
+                const owner = this.ourPorts().get(Number(url.port));
+                if (owner === "hotcell")
+                    return ok("401\n");
+                if (owner === "autopilot" && url.pathname === "/api/v1/health") {
+                    const token = (options.input ?? "").trim();
+                    return ok(token && this.credentials.some((entry) => entry.token === token && entry.status === "active") ? "200\n" : "401\n");
+                }
+                return ok("0\n");
+            }
+        }
+        if (command.endsWith("/node") && args[0]?.endsWith("hotcell/dist/index.js")) {
+            if (args[1] === "keys" && args[2] === "add") {
+                this.hotcellKeys.set(args[3], options.input ?? "");
+                const home = options.env?.HOTCELL_HOME ?? "";
+                this.files.set(`${home}/keys.json`, { content: "{}", mode: 0o600 });
+                return ok("stored\n");
+            }
+            if (args[1] === "keys" && args[2] === "ls")
+                return !this.files.has(`${options.env?.HOTCELL_HOME ?? ""}/keys.json`) ? ok("") : ok([...this.hotcellKeys.keys()].map((key) => `  ${key}  file\n`).join(""));
+            return ok();
+        }
+        if (command.endsWith("/node") && args[0]?.endsWith("autopilot-ai/bin/autopilot.mjs")) {
+            const sub = args.slice(1, 4).join(" ");
+            if (sub.startsWith("aster token create")) {
+                const id = `cred_${this.credentials.length + 1}`;
+                const token = `aster_${"t".repeat(30)}${this.credentials.length + 1}`;
+                const expiresAt = Date.parse("2027-10-28T10:00:00Z");
+                this.credentials.push({ id, name: args[args.indexOf("--name") + 1], status: "active", token, expiresAt });
+                return ok(`${JSON.stringify({ credentialId: id, workspaceIds: ["default"], scopes: [], createdAt: 0, expiresAt, token })}\n`);
+            }
+            if (sub.startsWith("aster token list")) {
+                return ok(`${JSON.stringify(this.credentials.map(({ token: _token, ...entry }) => ({ ...entry, scopes: [] })))}\n`);
+            }
+            if (sub.startsWith("aster token revoke")) {
+                const entry = this.credentials.find((credential) => credential.id === args.at(-1));
+                if (entry)
+                    entry.status = "revoked";
+                return ok();
+            }
+            return ok();
+        }
+        switch (command) {
+            case "id": return ok(`${this.uid}\n`);
+            case "sw_vers": return ok("15.1\n");
+            case "df": return ok(`Filesystem 1024-blocks Used Available Capacity Mounted on\n/dev/disk3s5 971350180 1000 ${this.diskFreeKb} 10% /System/Volumes/Data\n`);
+            case "git":
+                if (!this.git)
+                    return { code: 127, stdout: "", stderr: "not found" };
+                if (args[0] === "--version")
+                    return ok("git version 2.50.1\n");
+                if (args.includes("init"))
+                    this.dirs.set(`${args[1]}/.git`, undefined);
+                return ok();
+            case "sh":
+                if (line === "-c command -v docker")
+                    return ok("/usr/local/bin/docker\n");
+                return ok();
+            case "ip": return this.bridgeIp ? ok(`4: docker0    inet ${this.bridgeIp}/16 brd 172.17.255.255 scope global docker0\n`) : fail("no docker0");
+            case "systemctl":
+                if (args[1] === "is-system-running")
+                    return this.systemdUser ? ok("running\n") : fail("Failed to connect to bus");
+                if (args[1] === "restart")
+                    this.running.add(args[2]);
+                if (args[1] === "disable" && args[2] === "--now")
+                    this.running.delete(args[3]);
+                if (args[1] === "is-active")
+                    return ok(this.running.has(args[2]) ? "active\n" : "inactive\n");
+                return ok();
+            case "launchctl": {
+                if (args[0] === "bootstrap") {
+                    const plist = this.files.get(args[2])?.content ?? "";
+                    const label = plist.match(/<key>Label<\/key>\s*<string>([^<]+)<\/string>/)?.[1];
+                    if (!label)
+                        return fail("Bootstrap failed: 5: Input/output error");
+                    this.running.add(label);
+                    return ok();
+                }
+                if (args[0] === "bootout") {
+                    const label = args[1].split("/").at(-1);
+                    return this.running.delete(label) ? ok() : fail("Boot-out failed: 3: No such process");
+                }
+                if (args[0] === "print") {
+                    const label = args[1].split("/").at(-1);
+                    return this.running.has(label) ? ok(`${args[1]} = {\n\tstate = running\n\tpid = 4242\n}\n`) : fail("Could not find service");
+                }
+                return ok();
+            }
+            case "open":
+                if (this.dockerApp)
+                    this.docker = true;
+                return ok();
+            case "npm":
+                if (args[0] === "view")
+                    return ok(args[1] === "hotcell" ? "0.1.30\n" : "2.6.1\n");
+                if (args[0] === "install" && args[1] === "--prefix") {
+                    for (const pkg of ["autopilot-ai", "hotcell"])
+                        this.files.set(`${args[2]}/node_modules/${pkg}/package.json`, { content: "{}", mode: 0o644 });
+                    this.files.set(`${args[2]}/node_modules/hotcell/dist/index.js`, { content: "", mode: 0o755 });
+                    this.dirs.set(args[2], 0o700);
+                }
+                return ok();
+            case "ln":
+                for (const [path, file] of [...this.files])
+                    if (path.startsWith(`${args[1]}/`))
+                        this.files.set(path.replace(args[1], args[2]), file);
+                return ok();
+            case "ls":
+                return ok([...this.dirs.keys()].filter((dir) => dir.startsWith(`${args[1]}/`) && !dir.slice(args[1].length + 1).includes("/")).map((dir) => dir.split("/").at(-1)).join("\n"));
+            case "mktemp": return ok("/tmp/tmp.build\n");
+            case "wc": return ok("0\n");
+            case "/usr/local/bin/docker": {
+                if (args[0] === "context")
+                    return ok(`unix://${this.home}/.docker/run/docker.sock\n`);
+                if (args[0] === "info") {
+                    if (this.dockerDenied)
+                        return { code: 1, stdout: "", stderr: "permission denied while trying to connect to the Docker daemon socket" };
+                    if (!this.docker)
+                        return fail("Cannot connect to the Docker daemon");
+                    return args[2].startsWith("{{.ServerVersion}}") ? ok(`29.5.2|Docker Desktop|${this.dockerMemBytes}|8\n`) : ok(`${this.dockerMemBytes}|8\n`);
+                }
+                if (!this.docker)
+                    return fail("Cannot connect to the Docker daemon");
+                if (args[0] === "image" && args[1] === "inspect")
+                    return this.images.has(args[2]) ? ok("[]") : fail("no such image");
+                if (args[0] === "image" && args[1] === "rm") {
+                    this.images.delete(args[2]);
+                    return ok();
+                }
+                if (args[0] === "build") {
+                    this.images.add(args[args.indexOf("-t") + 1]);
+                    return ok();
+                }
+                if (args[0] === "run")
+                    return ok(this.reachHost && this.ourPorts().size > 0 ? "404\n" : "0\n");
+                if (args[0] === "ps") {
+                    const filters = args.flatMap((arg, index) => args[index - 1] === "--filter" ? [arg.replace(/^label=/, "")] : []);
+                    return ok(this.containers.filter((entry) => filters.every((filter) => entry.labels.includes(filter))).map((entry) => entry.id).join("\n"));
+                }
+                if (args[0] === "rm") {
+                    for (const id of args.slice(2))
+                        this.containers.splice(this.containers.findIndex((entry) => entry.id === id), 1);
+                    return ok();
+                }
+                return ok();
+            }
+            default:
+                return ok();
+        }
+    }
+}

package/dist/server-api.js

@@ -42,6 +42,28 @@ export async function ownerLink(system, url) {
     const link = result.stdout.trim().split("\n").at(-1);
     return result.code === 0 && link?.startsWith("http") ? link : undefined;
 }
+/** How long a laptop's credential lasts; re-running the laptop's setup pairs it again. */
+export const LAPTOP_CREDENTIAL_DAYS = 90;
+/**
+ * Creates a credential for a laptop that set this server up over SSH, so it never has to
+ * show a code and wait for approval: being root here already proves it's the owner's.
+ * The token comes back in the command's output, so that output stays out of the log.
+ */
+export async function createLaptopCredential(system, name, url) {
+    const result = await autopilotServer(system, [
+        "aster", "token", "create", "--name", name, "--workspace", "default", "--expires-in-days", String(LAPTOP_CREDENTIAL_DAYS), "--json",
+    ], { secretOutput: true });
+    if (result.code !== 0) {
+        throw new Error(`Couldn't create a credential for the laptop${result.stderr.trim() ? `: ${result.stderr.trim().split("\n").slice(-3).join(" ")}` : ""}; run dl up to update this server.`);
+    }
+    const created = parseJson(result);
+    const { credentialId, expiresAt, token } = created ?? {};
+    // Never echo the output when it doesn't parse: it may hold the token.
+    if (typeof token !== "string" || !token || typeof credentialId !== "string" || typeof expiresAt !== "number" || !Number.isFinite(expiresAt)) {
+        throw new Error("Autopilot created a credential but its answer wasn't what dl expects; run dl up to update this server.");
+    }
+    return { token, credentialId, name, expiresAt: new Date(expiresAt).toISOString(), url };
+}
 function parseJson(result) {
     if (result.code !== 0)
         return undefined;

package/dist/state.js

@@ -1,4 +1,9 @@
 import { PATHS } from "./layout.js";
+export const ACCESS_MODES = ["tailscale", "loopback", "ssh"];
+/** How people reach this server, in words (the address alone means little for a tunnel). */
+export function describeAccess(access) {
+    return access.mode === "ssh" ? "over SSH from your laptop" : access.url;
+}
 export async function readState(system) {
     const raw = await system.readFile(PATHS.state);
     if (!raw)

package/dist/ui.js

@@ -201,6 +201,39 @@ export class PlainUi {
     warn(text) { this.write(`!! ${text}\n`); }
     finish() { }
 }
+/**
+ * For the laptop that runs `dl up` over SSH and draws the progress itself: one JSON object
+ * per line (NDJSON) on stdout, nothing else there. Nothing is asked in this mode, so a
+ * rejected answer is only a warning, and a prompt is never shown.
+ */
+export class JsonUi {
+    write;
+    interactive = false;
+    constructor(write = (text) => process.stdout.write(text)) {
+        this.write = write;
+    }
+    title(text) { this.emit({ event: "title", text }); }
+    line(status, label, detail) { this.emit({ event: "line", status, label, detail }); }
+    plan(steps) { this.emit({ event: "plan", steps: steps.map(({ id, label }) => ({ id, label })) }); }
+    start(id, detail) { this.emit({ event: "start", id, detail }); }
+    done(id, detail) { this.emit({ event: "done", id, detail }); }
+    fail(id, message) { this.emit({ event: "fail", id, message }); }
+    questions(intro) { this.emit({ event: "questions", text: intro }); }
+    prompt(label) { return label; }
+    answered(label, detail) { this.emit({ event: "answered", label, detail }); }
+    rejected(message) { this.emit({ event: "warn", text: message }); }
+    ready(headline, items, extra = {}) {
+        this.emit({ event: "ready", headline, items: items.map(({ label, value }) => ({ label, value })), about: extra.about, footer: extra.footer });
+    }
+    warn(text) { this.emit({ event: "warn", text }); }
+    /** The last event of a failed run (not part of Ui: the CLI reports failures, not `up`). */
+    error(message) { this.emit({ event: "error", message }); }
+    finish() { }
+    emit(event) {
+        // JSON.stringify drops undefined fields and escapes newlines, so each event is one line.
+        this.write(`${JSON.stringify(event)}\n`);
+    }
+}
 /** Records events for tests. */
 export class RecordingUi {
     interactive = false;

package/dist/up.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { hostname } from "node:os";
 import { agentCapacity, detectHost, preflightProblems } from "./detect.js";
 import { AUTOPILOT_PORT, CELL_MEMORY_MB, GITHUB_PROXY_PORT, HOTCELL_EGRESS_PORT, HOTCELL_PORT, PATHS, SERVICES, USERS, AUTO_UPGRADES, NODE_AUTO_UPDATES, asterConfig, autoUpgrades, autopilotBin, autopilotEnv, autopilotUnit, MOTD_SCRIPT, cellDockerfile, cellImage, githubEnv, hotcellBin, hotcellEnv, hotcellUnit, metadataBlockUnit, motdScript, nodeAutoUpdates, parseEnvFile, } from "./layout.js";
-import { readState, writeState } from "./state.js";
+import { ACCESS_MODES, readState, writeState } from "./state.js";
 import { PlainUi } from "./ui.js";
 import { ownerLink } from "./server-api.js";
 const DRY_RUN_BRIDGE_IP = "172.17.0.1";
@@ -26,9 +26,9 @@ export async function up(system, options) {
     ui.line("done", "Checked this machine", `${facts.os.prettyName.replace(/ LTS$/, "")} · ${facts.cpus} CPU · ${(facts.memoryMb / 1024).toFixed(1)} GB · ${facts.diskFreeGb} GB free`);
     // Every question comes first, so the long part runs unattended.
     const previous = await readState(system);
-    const access = accessMode(env, previous);
+    const access = accessMode(options.access, env, previous);
     const check = env.DL_SKIP_CREDENTIAL_CHECK === "1" ? undefined : fetchImpl;
-    const answers = await collectAnswers(system, ui, options.prompter, env, check, facts, access);
+    const answers = await collectAnswers(system, ui, options.prompter, given(env, options.answers), check, facts, access);
     ui.plan([
         ...(access === "tailscale" ? [{ id: "tailnet", label: "Joining your tailnet" }] : []),
         { id: "docker", label: "Setting up Docker" },
@@ -121,6 +121,10 @@ export async function up(system, options) {
         return { value: apiKey, detail: "sandboxes and keys ready" };
     });
     const url = await step("access", async () => {
+        // Moving off Tailscale: stop publishing on the tailnet, so the only way in is the new one.
+        if (access !== "tailscale" && previous?.access.mode === "tailscale") {
+            await system.run("tailscale", ["serve", "--https=443", `http://127.0.0.1:${AUTOPILOT_PORT}`, "off"], { allowFailure: true });
+        }
         const address = access === "tailscale" ? await serveOverTailscale(system) : `http://127.0.0.1:${AUTOPILOT_PORT}`;
         await system.writeFile(PATHS.autopilotEnv, autopilotEnv({ hotcellApiKey, image, bridgeIp, publicUrl: address }), { mode: 0o640, owner: `root:${USERS.autopilot}`, secret: true });
         await system.run("systemctl", ["enable", SERVICES.autopilot]);
@@ -141,8 +145,15 @@ export async function up(system, options) {
         access: { mode: access, url },
     };
     await writeState(system, state);
-    const link = await ownerLink(system, url);
     const capacity = agentCapacity(facts, CELL_MEMORY_MB);
+    if (access === "ssh") {
+        // The laptop set this up, pairs itself (`dl pair`), and prints its own summary, so there's
+        // no browser link to make: a one-time owner link would only be a secret in its output.
+        await installLoginStatus(system);
+        ui.ready("Ready", [{ label: "On your laptop, from inside a GitHub repository", value: 'dl run "fix the flaky checkout test"' }]);
+        return { url, ownerLink: undefined, capacity, state };
+    }
+    const link = await ownerLink(system, url);
     await installLoginStatus(system);
     ui.ready("Ready", nextSteps({ url, ownerLink: link, access }), {
         about: [
@@ -171,46 +182,116 @@ async function installLoginStatus(system) {
         return;
     await system.writeFile(MOTD_SCRIPT, motdScript(), { mode: 0o755 });
 }
-function accessMode(env, previous) {
+/** Checks an access mode named by `--access` or DL_ACCESS. */
+export function parseAccessMode(value, source = "--access") {
+    const mode = ACCESS_MODES.find((entry) => entry === value);
+    if (mode)
+        return mode;
+    throw new Error(`${source} must be ${ACCESS_MODES.join(", ").replace(/, ([^,]+)$/, " or $1")} (got "${value}"); an own domain and the instant address are coming.`);
+}
+/** The flag wins, then DL_ACCESS, then what the last `up` chose; Tailscale on a fresh machine. */
+function accessMode(flag, env, previous) {
+    if (flag)
+        return flag;
     const requested = env.DL_ACCESS?.trim();
     if (requested === undefined || requested === "")
         return previous?.access.mode ?? "tailscale";
-    if (requested === "tailscale" || requested === "loopback")
-        return requested;
-    throw new Error(`DL_ACCESS must be tailscale or loopback (got "${requested}"); an own domain and the instant address are coming.`);
+    return parseAccessMode(requested, "DL_ACCESS");
 }
-async function collectAnswers(system, ui, prompter, env, fetchImpl, facts, access) {
+/**
+ * `dl up --needs`: the answers a real `up` would require on this machine, without asking for
+ * or changing anything (it only reads files and runs read-only probes). The laptop asks for
+ * exactly these before it starts the install. Answers in DL_* variables don't count: the
+ * laptop's `up` takes its answers from stdin.
+ */
+export async function needs(system, options = {}) {
+    const access = accessMode(options.access, options.env ?? process.env, await readState(system));
+    const missing = await missingAnswers(system, await detectHost(system), access);
+    return ["tailscale", "openrouter", "github"].filter((need) => missing[need]);
+}
+/**
+ * Which answers this machine still lacks: the model key unless Hotcell has one, a GitHub
+ * token unless its env file has one, a Tailscale key only for Tailscale access off a tailnet.
+ */
+async function missingAnswers(system, facts, access) {
     const tailscaleRunning = access !== "tailscale" || (facts.tailscale && await tailscaleIsUp(system));
-    const hasModelKey = await hotcellHasKey(system, "openrouter");
-    const hasGitHub = Boolean(parseEnvFile(await system.readFile(PATHS.githubEnv)).GITHUB_TOKEN);
+    return {
+        tailscale: !tailscaleRunning,
+        openrouter: !(await hotcellHasKey(system, "openrouter")),
+        github: !parseEnvFile(await system.readFile(PATHS.githubEnv)).GITHUB_TOKEN,
+    };
+}
+function given(env, provided) {
+    if (provided) {
+        return { tailscaleAuthKey: provided.tailscaleAuthKey, openRouterKey: provided.openrouterKey, githubToken: provided.githubToken, source: "from your laptop", final: true };
+    }
+    return { tailscaleAuthKey: env.DL_TAILSCALE_AUTH_KEY, openRouterKey: env.DL_OPENROUTER_API_KEY, githubToken: env.DL_GITHUB_TOKEN, source: "from the environment", final: false };
+}
+/**
+ * The answers from `--answers-stdin`. Parse errors never quote the input: it holds keys.
+ * Unknown fields are ignored, so a newer laptop can send more than this server knows.
+ */
+export function parseProvidedAnswers(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error("The answers on stdin aren't valid JSON; expected one object like {\"openrouterKey\": \"sk-or-…\"}.");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        throw new Error("The answers on stdin must be one JSON object.");
+    const record = parsed;
+    const answers = {};
+    for (const key of ["openrouterKey", "githubToken", "tailscaleAuthKey"]) {
+        const value = record[key];
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value !== "string")
+            throw new Error(`The answer "${key}" on stdin must be a string.`);
+        answers[key] = value;
+    }
+    return answers;
+}
+async function collectAnswers(system, ui, prompter, provided, fetchImpl, facts, access) {
+    const missing = await missingAnswers(system, facts, access);
     if (system.dryRun) {
         return {
-            tailscaleAuthKey: tailscaleRunning ? undefined : "<asked>",
-            openRouterKey: hasModelKey ? undefined : "<asked>",
-            githubToken: hasGitHub ? undefined : "<asked>",
+            tailscaleAuthKey: missing.tailscale ? "<asked>" : undefined,
+            openRouterKey: missing.openrouter ? "<asked>" : undefined,
+            githubToken: missing.github ? "<asked>" : undefined,
         };
     }
-    const typed = [
-        !tailscaleRunning && !env.DL_TAILSCALE_AUTH_KEY,
-        !hasModelKey && !env.DL_OPENROUTER_API_KEY,
-        !hasGitHub && !env.DL_GITHUB_TOKEN,
+    const typed = provided.final ? 0 : [
+        missing.tailscale && !provided.tailscaleAuthKey,
+        missing.openrouter && !provided.openRouterKey,
+        missing.github && !provided.githubToken,
     ].filter(Boolean).length;
     if (typed > 0)
         ui.questions(`${typed === 1 ? "One key" : `${typed} keys`}, then it runs on its own. Typing is hidden.`);
-    const tailscaleAuthKey = tailscaleRunning ? undefined : await askValidated(ui, env.DL_TAILSCALE_AUTH_KEY, "Tailscale auth key", () => prompter.secret(ui.prompt("Tailscale auth key", "login.tailscale.com/admin/settings/keys")), async (value) => /^tskey-[A-Za-z0-9-]+$/.test(value) ? {} : { problem: "That doesn't look like a Tailscale auth key (tskey-…)." });
-    const openRouterKey = hasModelKey ? undefined : await askValidated(ui, env.DL_OPENROUTER_API_KEY, "OpenRouter API key", () => prompter.secret(ui.prompt("OpenRouter API key", "stays in Hotcell; sandboxes and laptops never see it")), async (value) => ({ ...await validateOpenRouterKey(value, fetchImpl).then((problem) => problem ? { problem } : { detail: "kept in Hotcell" }) }));
-    const githubToken = hasGitHub ? undefined : await askValidated(ui, env.DL_GITHUB_TOKEN, "GitHub token", () => prompter.secret(ui.prompt("GitHub token", "fine-grained · Contents + Pull requests read/write")), (value) => validateGitHubToken(value, fetchImpl));
+    // With final answers there's no one to ask: a missing one fails before anything changes.
+    const asking = (ask) => provided.final ? undefined : ask;
+    const tailscaleAuthKey = !missing.tailscale ? undefined : await askValidated(ui, provided.tailscaleAuthKey, provided.source, "Tailscale auth key", asking(() => prompter.secret(ui.prompt("Tailscale auth key", "login.tailscale.com/admin/settings/keys"))), async (value) => /^tskey-[A-Za-z0-9-]+$/.test(value) ? {} : { problem: "That doesn't look like a Tailscale auth key (tskey-…)." });
+    const openRouterKey = !missing.openrouter ? undefined : await askValidated(ui, provided.openRouterKey, provided.source, "OpenRouter API key", asking(() => prompter.secret(ui.prompt("OpenRouter API key", "stays in Hotcell; sandboxes and laptops never see it"))), async (value) => ({ ...await validateOpenRouterKey(value, fetchImpl).then((problem) => problem ? { problem } : { detail: "kept in Hotcell" }) }));
+    const githubToken = !missing.github ? undefined : await askValidated(ui, provided.githubToken, provided.source, "GitHub token", asking(() => prompter.secret(ui.prompt("GitHub token", "fine-grained · Contents + Pull requests read/write"))), (value) => validateGitHubToken(value, fetchImpl));
     return { tailscaleAuthKey, openRouterKey, githubToken };
 }
-/** Takes an env answer as-is (failing fast if invalid) or asks up to three times. */
-async function askValidated(ui, fromEnv, label, ask, validate) {
+/**
+ * Takes a given answer as-is (failing fast if invalid) or asks up to three times. Without a
+ * way to ask (answers from the laptop), a missing answer is a failure.
+ */
+async function askValidated(ui, fromEnv, source, label, ask, validate) {
     if (fromEnv) {
         const { problem, detail } = await validate(fromEnv.trim());
         if (problem)
             throw new Error(problem);
-        ui.line("done", label, detail ? `${detail} · from the environment` : "from the environment");
+        ui.line("done", label, detail ? `${detail} · ${source}` : source);
         return fromEnv.trim();
     }
+    if (!ask) {
+        ui.line("failed", label, "not given");
+        throw new Error(`This server needs ${/^[AEIOU]/.test(label) ? "an" : "a"} ${label} and none was given ${source.replace(/^from/, "by")}.`);
+    }
     for (let attempt = 1;; attempt++) {
         const value = (await ask()).trim();
         const { problem, detail } = value ? await validate(value) : { problem: "An answer is required.", detail: undefined };

package/install.sh

@@ -8,6 +8,7 @@
 # key, and sets up Hotcell + Autopilot as services. Safe to run again.
 #
 # Unattended: export DL_TAILSCALE_AUTH_KEY, DL_OPENROUTER_API_KEY and DL_GITHUB_TOKEN first.
+# Install only (the laptop's setup, which then runs `dl up` itself over SSH): DL_INSTALL_ONLY=1.
 # Pin a version: DL_VERSION=0.1.0. Install from a local tarball: DL_PACKAGE=/path/to.tgz.
 set -eu
 
@@ -27,7 +28,7 @@ step() {
   if [ -n "$FANCY" ]; then printf '  \033[36m⠋\033[0m %s' "$1"; else say ".. $1"; fi
 }
 step_done() {
-  if [ -n "$FANCY" ]; then printf '\r\033[2K  \033[32m✓\033[0m %-33s\033[2m%s\033[0m\n' "$1" "${2:-}"; else say "ok $1${2:+: $2}"; fi
+  if [ -n "$FANCY" ]; then printf '\r\033[2K  \033[32m✓\033[0m %-33s\033[2m%s\033[0m\n' "$1" "${2:-}"; else say "ok ${STEP:-$1}${2:+: $2}"; fi
 }
 
 # Quiet steps: output goes to a log that's shown only if the step fails.
@@ -136,6 +137,12 @@ main() {
   quietly "installing $package" as_root npm install -g --no-audit --no-fund --loglevel=error "$package"
   step_done "Got the installer" "dl $(dl --version 2>/dev/null || echo "")"
 
+  # The laptop's setup stops here: it asks for the keys itself and runs `dl up` next,
+  # with its own progress display.
+  if [ "${DL_INSTALL_ONLY:-}" = "1" ]; then
+    return 0
+  fi
+
   # Prompts read the terminal, not this piped script. Test by opening it: the device
   # node exists even when there's no controlling terminal.
   # dl up continues the same screen, so it skips its own title.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directionallylocal",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Directionally Local: background coding agents on your own server. One-line server install, and the dl command for your server and laptop.",
   "homepage": "https://directionallylocal.com",
   "repository": {