directionallylocal 0.0.0-stage → 0.1.2

package/dist/up.js

@@ -0,0 +1,426 @@
+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 { PlainUi } from "./ui.js";
+import { ownerLink } from "./server-api.js";
+const DRY_RUN_BRIDGE_IP = "172.17.0.1";
+const DRY_RUN_URL = "https://<this-machine>.<tailnet>.ts.net";
+/** `dl up`: install or repair Hotcell + Autopilot as services. Safe to re-run. */
+export async function up(system, options) {
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const ui = options.ui ?? new PlainUi((text) => { for (const line of text.replace(/\n$/, "").split("\n"))
+        system.log(line); });
+    // install.sh already showed the title on this screen.
+    if (env.DL_TITLE_SHOWN !== "1")
+        ui.title("Directionally Local");
+    let facts = await detectHost(system);
+    const problems = preflightProblems(facts);
+    if (problems.length > 0) {
+        ui.line("failed", "This machine can't run it yet");
+        throw new Error(`Can't install here:\n  - ${problems.join("\n  - ")}`);
+    }
+    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 check = env.DL_SKIP_CREDENTIAL_CHECK === "1" ? undefined : fetchImpl;
+    const answers = await collectAnswers(system, ui, options.prompter, env, check, facts, access);
+    ui.plan([
+        ...(access === "tailscale" ? [{ id: "tailnet", label: "Joining your tailnet" }] : []),
+        { id: "docker", label: "Setting up Docker" },
+        { id: "software", label: "Installing Hotcell + Autopilot" },
+        { id: "image", label: "Building the sandbox image" },
+        { id: "services", label: "Starting services" },
+        { id: "access", label: access === "tailscale" ? "Opening private access" : "Starting the API" },
+    ]);
+    const step = async (id, work) => {
+        ui.start(id);
+        try {
+            const { value, detail } = await work();
+            ui.done(id, detail);
+            return value;
+        }
+        catch (error) {
+            ui.fail(id, error.message);
+            throw error;
+        }
+    };
+    if (access === "tailscale") {
+        await step("tailnet", async () => ({ value: undefined, detail: await joinTailnet(system, answers.tailscaleAuthKey) }));
+    }
+    const bridgeIp = await step("docker", async () => {
+        let detail = "already running";
+        if (!facts.docker) {
+            // An installed Docker (Ubuntu's docker.io or Docker's docker-ce) is started, never
+            // replaced: get.docker.com swapping packages under a running install is how the socket
+            // and service fall out of step.
+            if (facts.dockerInstalled) {
+                detail = "was installed; started it";
+            }
+            else {
+                await system.run("sh", ["-c", "curl -fsSL https://get.docker.com | sh"], { inherit: true, describe: "install Docker (get.docker.com)" });
+                detail = "installed";
+            }
+            await startDocker(system, sleep);
+            facts = await detectHost(system);
+        }
+        const ip = facts.dockerBridgeIp ?? (system.dryRun ? DRY_RUN_BRIDGE_IP : undefined);
+        if (!ip)
+            throw new Error("Docker is running but its docker0 bridge has no IPv4 address; sandboxes couldn't reach the gateway.");
+        return { value: ip, detail };
+    });
+    const { autopilotVersion, hotcellVersion, release } = await step("software", async () => {
+        await ensureAutomaticUpdates(system, ui);
+        await ensureUser(system, USERS.hotcell, PATHS.hotcellHome, ["docker"]);
+        await ensureUser(system, USERS.autopilot, PATHS.autopilotHome, []);
+        const autopilot = options.autopilotVersion ?? await latestVersion(system, "autopilot-ai");
+        const hotcell = options.hotcellVersion ?? await latestVersion(system, "hotcell");
+        const name = `autopilot-${autopilot}_hotcell-${hotcell}`;
+        const releaseDir = `${PATHS.releases}/${name}`;
+        if (!(await system.exists(`${releaseDir}/node_modules/autopilot-ai/package.json`) && await system.exists(`${releaseDir}/node_modules/hotcell/package.json`))) {
+            await system.mkdir(releaseDir, { mode: 0o755 });
+            await system.run("npm", ["install", "--prefix", releaseDir, "--no-audit", "--no-fund", "--omit=dev", `autopilot-ai@${autopilot}`, `hotcell@${hotcell}`], { inherit: true });
+        }
+        await system.run("ln", ["-sfn", releaseDir, PATHS.current]);
+        // Store the keys as soon as their homes exist, so a later failure never asks again.
+        if (answers.openRouterKey) {
+            // Into Hotcell's keystore over stdin: never in argv, env files, or Autopilot's config.
+            await asHotcell(system, ["keys", "add", "openrouter", "--stdin"], { input: answers.openRouterKey, describe: "hotcell keys add openrouter --stdin (as hotcell)" });
+        }
+        await system.mkdir(PATHS.autopilotEtc, { mode: 0o750, owner: `root:${USERS.autopilot}` });
+        if (answers.githubToken) {
+            await system.writeFile(PATHS.githubEnv, githubEnv(answers.githubToken), { mode: 0o640, owner: `root:${USERS.autopilot}`, secret: true });
+        }
+        return { value: { autopilotVersion: autopilot, hotcellVersion: hotcell, release: name }, detail: `Autopilot ${autopilot} · Hotcell ${hotcell}` };
+    });
+    const image = cellImage(autopilotVersion);
+    await step("image", async () => ({ value: undefined, detail: await ensureCellImage(system, image, autopilotVersion) ? "already built" : `Node 24 · Autopilot ${autopilotVersion}` }));
+    const hotcellApiKey = await step("services", async () => {
+        const hotcellValues = parseEnvFile(await system.readFile(PATHS.hotcellEnv));
+        const apiKey = hotcellValues.HOTCELL_API_KEY || randomBytes(24).toString("hex");
+        await system.mkdir(PATHS.hotcellEtc, { mode: 0o750, owner: `root:${USERS.hotcell}` });
+        await system.writeFile(PATHS.hotcellEnv, hotcellEnv({ apiKey, bridgeIp }), { mode: 0o640, owner: `root:${USERS.hotcell}`, secret: true });
+        if (!(await system.readFile(PATHS.asterConfig))) {
+            await system.writeFile(PATHS.asterConfig, asterConfig(), { mode: 0o640, owner: `root:${USERS.autopilot}` });
+        }
+        await ensureWorkspace(system);
+        await allowBridgePorts(system, bridgeIp);
+        await system.writeFile(`${PATHS.units}/${SERVICES.metadataBlock}`, metadataBlockUnit());
+        await system.writeFile(`${PATHS.units}/${SERVICES.hotcell}`, hotcellUnit());
+        await system.writeFile(`${PATHS.units}/${SERVICES.autopilot}`, autopilotUnit());
+        await system.run("systemctl", ["daemon-reload"]);
+        await system.run("systemctl", ["enable", "--now", SERVICES.metadataBlock]);
+        await system.run("systemctl", ["enable", SERVICES.hotcell]);
+        await system.run("systemctl", ["restart", SERVICES.hotcell]);
+        await waitUntil(system, sleep, "Hotcell", async () => (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);
+        return { value: apiKey, detail: "sandboxes and keys ready" };
+    });
+    const url = await step("access", async () => {
+        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]);
+        await system.run("systemctl", ["restart", SERVICES.autopilot]);
+        // Without a token the Aster API answers 401: the server is up and refusing strangers.
+        await waitUntil(system, sleep, "Autopilot", async () => (await system.probe("curl", ["-s", "-o", "/dev/null", "-w", "%{http_code}", `http://127.0.0.1:${AUTOPILOT_PORT}/api/v1/health`])).stdout.trim() === "401");
+        return { value: address, detail: address.replace(/^https?:\/\//, "") };
+    });
+    const now = (options.now ?? (() => new Date()))().toISOString();
+    const state = {
+        version: 1,
+        installedAt: previous?.installedAt ?? now,
+        updatedAt: now,
+        release,
+        autopilotVersion,
+        hotcellVersion,
+        image,
+        access: { mode: access, url },
+    };
+    await writeState(system, state);
+    const link = await ownerLink(system, url);
+    const capacity = agentCapacity(facts, CELL_MEMORY_MB);
+    await installLoginStatus(system);
+    ui.ready("Ready", nextSteps({ url, ownerLink: link, access }), {
+        about: [
+            "This server now runs coding agents for you. Send it a task from your laptop:",
+            "it works in its own sandbox, opens a pull request, and keeps going while",
+            `your laptop is closed. It fits ~${capacity} at once (estimate).`,
+        ],
+        footer: "Forgot any of this? Type  dl  on this server.",
+    });
+    return { url, ownerLink: link, capacity, state };
+}
+/** What to do next, shown at the end of `dl up` and by `dl connect-laptop`. */
+export function nextSteps(input) {
+    const reach = input.access === "tailscale"
+        ? "On your laptop (signed in to the same tailnet)"
+        : `On your laptop, after: ssh -N -L ${AUTOPILOT_PORT}:127.0.0.1:${AUTOPILOT_PORT} root@<this-server>`;
+    return [
+        ...(input.ownerLink ? [{ label: "Open this once in your laptop's browser, so it can approve laptops", value: input.ownerLink }] : []),
+        { label: `${reach}, connect it`, value: `npm install -g directionallylocal\ndl connect ${input.url}` },
+        { label: "Send it a task, from inside a GitHub repository", value: `dl run "fix the flaky checkout test"\ndl runs                 see progress and pull requests` },
+    ];
+}
+/** A short status line when someone logs in, so a server visited weeks later explains itself. */
+async function installLoginStatus(system) {
+    if (!(await system.exists("/etc/update-motd.d")))
+        return;
+    await system.writeFile(MOTD_SCRIPT, motdScript(), { mode: 0o755 });
+}
+function accessMode(env, previous) {
+    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.`);
+}
+async function collectAnswers(system, ui, prompter, env, fetchImpl, 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);
+    if (system.dryRun) {
+        return {
+            tailscaleAuthKey: tailscaleRunning ? undefined : "<asked>",
+            openRouterKey: hasModelKey ? undefined : "<asked>",
+            githubToken: hasGitHub ? undefined : "<asked>",
+        };
+    }
+    const typed = [
+        !tailscaleRunning && !env.DL_TAILSCALE_AUTH_KEY,
+        !hasModelKey && !env.DL_OPENROUTER_API_KEY,
+        !hasGitHub && !env.DL_GITHUB_TOKEN,
+    ].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));
+    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) {
+    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");
+        return fromEnv.trim();
+    }
+    for (let attempt = 1;; attempt++) {
+        const value = (await ask()).trim();
+        const { problem, detail } = value ? await validate(value) : { problem: "An answer is required.", detail: undefined };
+        if (!problem) {
+            ui.answered(label, detail);
+            return value;
+        }
+        if (attempt >= 3) {
+            ui.rejected(problem);
+            throw new Error(problem);
+        }
+        ui.rejected(`${problem} Try again.`);
+    }
+}
+export async function validateOpenRouterKey(key, fetchImpl) {
+    if (!/^sk-or-[A-Za-z0-9_-]{10,}$/.test(key))
+        return "That doesn't look like an OpenRouter key (sk-or-…).";
+    if (!fetchImpl)
+        return undefined;
+    try {
+        const response = await fetchImpl("https://openrouter.ai/api/v1/key", { headers: { Authorization: `Bearer ${key}` } });
+        if (response.status === 401 || response.status === 403)
+            return "OpenRouter rejected that key.";
+        return undefined;
+    }
+    catch {
+        // Offline validation isn't fatal: the format is right, and doctor checks it later.
+        return undefined;
+    }
+}
+export async function validateGitHubToken(token, fetchImpl) {
+    if (!/^(github_pat_|ghp_|gho_)[A-Za-z0-9_]{20,}$/.test(token))
+        return { problem: "That doesn't look like a GitHub token (github_pat_… or ghp_…)." };
+    if (!fetchImpl)
+        return {};
+    try {
+        const response = await fetchImpl("https://api.github.com/user", { headers: { Authorization: `Bearer ${token}`, "User-Agent": "directionallylocal" } });
+        if (response.status === 401)
+            return { problem: "GitHub rejected that token." };
+        if (response.ok) {
+            const user = await response.json();
+            if (user.login)
+                return { detail: `signed in as ${user.login}` };
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Ubuntu's unattended-upgrades only patches Ubuntu's own packages, so Node.js from
+ * NodeSource would never pick up a security release by itself. Docker's repo is left out
+ * on purpose: it ships major upgrades, and restarting dockerd can stop running sandboxes.
+ */
+async function ensureAutomaticUpdates(system, ui) {
+    const installed = await system.probe("dpkg-query", ["-W", "-f=${Status}", "unattended-upgrades"]);
+    if (!installed.stdout.includes("install ok installed")) {
+        await system.run("apt-get", ["install", "-y", "-qq", "unattended-upgrades"], { env: { DEBIAN_FRONTEND: "noninteractive" } });
+    }
+    // Keep an operator's own schedule; only turn the daily run on where it's missing.
+    if (!(await system.readFile(AUTO_UPGRADES)))
+        await system.writeFile(AUTO_UPGRADES, autoUpgrades());
+    if ((await system.probe("apt-cache", ["policy", "nodejs"])).stdout.includes("deb.nodesource.com")) {
+        await system.writeFile(NODE_AUTO_UPDATES, nodeAutoUpdates());
+    }
+    else {
+        ui.warn("Node.js isn't from NodeSource here, so it won't update itself; keep it at 22.23.4+, 24.22.1+ or 26.12.1+.");
+    }
+}
+/**
+ * Starts Docker so it actually answers. docker.service is socket-activated on Ubuntu: if it
+ * starts while docker.socket is down, dockerd exits ("no sockets found via socket
+ * activation") and systemd soon stops retrying. So: clear that failed state, bring up the
+ * socket first, then the service, and wait for the daemon to respond.
+ */
+async function startDocker(system, sleep) {
+    await system.run("systemctl", ["reset-failed", "docker.service", "docker.socket"], { allowFailure: true });
+    await system.run("systemctl", ["enable", "--now", "docker.socket"], { allowFailure: true });
+    await system.run("systemctl", ["enable", "docker.service"]);
+    await system.run("systemctl", ["restart", "docker.service"]);
+    await waitUntil(system, sleep, "Docker", async () => (await system.probe("docker", ["version", "--format", "{{.Server.Version}}"])).stdout.trim() !== "", "docker");
+}
+async function ensureUser(system, name, home, groups) {
+    if ((await system.probe("id", ["-u", name])).code !== 0) {
+        await system.run("useradd", ["--system", "--user-group", "--home-dir", home, "--shell", "/usr/sbin/nologin", name]);
+    }
+    for (const group of groups)
+        await system.run("usermod", ["-aG", group, name]);
+    await system.mkdir(home, { mode: 0o750, owner: `${name}:${name}` });
+}
+async function latestVersion(system, pkg) {
+    const result = await system.probe("npm", ["view", pkg, "version"]);
+    const version = result.stdout.trim();
+    if (result.code !== 0 || !/^\d+\.\d+\.\d+/.test(version))
+        throw new Error(`Couldn't look up the latest ${pkg} on npm${result.stderr ? `: ${result.stderr.trim()}` : ""}`);
+    return version;
+}
+function asHotcell(system, args, options = {}) {
+    return system.run("runuser", [
+        "-u", USERS.hotcell, "--", "env", `HOTCELL_HOME=${PATHS.hotcellHome}`, "HOTCELL_KEYSTORE=file",
+        "/usr/bin/node", hotcellBin(), ...args,
+    ], options);
+}
+async function hotcellHasKey(system, provider) {
+    if (!(await system.exists(hotcellBin())))
+        return false;
+    const result = await system.probe("runuser", [
+        "-u", USERS.hotcell, "--", "env", `HOTCELL_HOME=${PATHS.hotcellHome}`, "HOTCELL_KEYSTORE=file", "/usr/bin/node", hotcellBin(), "keys", "ls",
+    ]);
+    return result.code === 0 && new RegExp(`^\\s*${provider}\\b`, "m").test(result.stdout);
+}
+/** The default workspace: an empty Git repository Aster requires as a root. */
+async function ensureWorkspace(system) {
+    if (await system.exists(`${PATHS.workspace}/.git`))
+        return;
+    await system.mkdir(PATHS.workspace, { mode: 0o700, owner: `${USERS.autopilot}:${USERS.autopilot}` });
+    const git = (args) => system.run("runuser", ["-u", USERS.autopilot, "--", "git", "-C", PATHS.workspace, ...args]);
+    await git(["init", "--quiet", "--initial-branch=main"]);
+    await system.run("runuser", ["-u", USERS.autopilot, "--", "sh", "-c", `printf '# Default workspace\\n' > ${PATHS.workspace}/README.md`]);
+    await git(["add", "README.md"]);
+    await git(["-c", "user.name=Autopilot", "-c", "user.email=autopilot@localhost", "commit", "--quiet", "-m", "Initialize workspace"]);
+}
+/** Builds the sandbox image unless it exists; returns whether it already did. */
+async function ensureCellImage(system, image, autopilotVersion) {
+    if ((await system.probe("docker", ["image", "inspect", image])).code === 0)
+        return true;
+    const dir = system.dryRun ? "/tmp/directionallylocal-image" : (await system.run("mktemp", ["-d"])).stdout.trim();
+    try {
+        await system.run("npm", ["pack", `autopilot-ai@${autopilotVersion}`, "--pack-destination", dir, "--silent"]);
+        await system.run("sh", ["-c", `mv ${dir}/autopilot-ai-*.tgz ${dir}/autopilot.tgz`]);
+        await system.writeFile(`${dir}/Dockerfile`, cellDockerfile());
+        await system.run("docker", ["build", "--pull", "-q", "-t", image, dir], { inherit: true });
+    }
+    finally {
+        await system.remove(dir);
+    }
+    return false;
+}
+/** With UFW on, sandboxes still need the gateway and GitHub proxy on the bridge address. */
+async function allowBridgePorts(system, bridgeIp) {
+    const status = await system.probe("ufw", ["status"]);
+    if (status.code !== 0 || !/Status: active/.test(status.stdout))
+        return;
+    for (const port of [HOTCELL_EGRESS_PORT, GITHUB_PROXY_PORT]) {
+        await system.run("ufw", ["allow", "in", "on", "docker0", "to", bridgeIp, "port", String(port), "proto", "tcp", "comment", "directionallylocal sandboxes"]);
+    }
+}
+async function tailscaleIsUp(system) {
+    const status = await system.probe("tailscale", ["status", "--json"]);
+    if (status.code !== 0)
+        return false;
+    try {
+        return JSON.parse(status.stdout).BackendState === "Running";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Joins the tailnet right after the questions, before the long steps: the auth key is
+ * used at once, so a later failure never has to ask for it again (it's never kept on disk).
+ */
+async function joinTailnet(system, authKey) {
+    if ((await system.probe("tailscale", ["version"])).code !== 0) {
+        await system.run("sh", ["-c", "curl -fsSL https://tailscale.com/install.sh | sh"], { inherit: true, describe: "install Tailscale (tailscale.com/install.sh)" });
+    }
+    if (authKey) {
+        // The key goes through a 0600 file, never argv.
+        const keyFile = `${PATHS.stateDir}/tailscale-auth-key`;
+        await system.mkdir(PATHS.stateDir, { mode: 0o700 });
+        await system.writeFile(keyFile, authKey, { mode: 0o600, secret: true });
+        try {
+            await system.run("tailscale", ["up", `--auth-key=file:${keyFile}`, `--hostname=${machineName()}`]);
+        }
+        finally {
+            await system.remove(keyFile);
+        }
+    }
+    if (system.dryRun)
+        return "on your tailnet";
+    const status = await system.probe("tailscale", ["status", "--json"]);
+    const name = JSON.parse(status.stdout || "{}").Self?.DNSName?.replace(/\.$/, "");
+    return name ? `${authKey ? "joined as" : "already on it as"} ${name.split(".")[0]}` : "joined";
+}
+/** Serves Autopilot on the machine's HTTPS ts.net name; returns that URL. */
+async function serveOverTailscale(system) {
+    const served = await system.run("tailscale", ["serve", "--bg", "--https=443", `http://127.0.0.1:${AUTOPILOT_PORT}`], { allowFailure: true });
+    if (served.code !== 0) {
+        throw new Error(`Tailscale couldn't serve HTTPS: ${served.stderr.trim() || served.stdout.trim()}\n`
+            + "  Turn on MagicDNS and HTTPS certificates at https://login.tailscale.com/admin/dns, then run `dl up` again.");
+    }
+    if (system.dryRun)
+        return DRY_RUN_URL;
+    const status = await system.probe("tailscale", ["status", "--json"]);
+    const dnsName = JSON.parse(status.stdout || "{}").Self?.DNSName?.replace(/\.$/, "");
+    if (!dnsName)
+        throw new Error("Tailscale is up but reported no DNS name for this machine; is MagicDNS on?");
+    return `https://${dnsName}`;
+}
+async function waitUntil(system, sleep, what, ready, unit = what.toLowerCase()) {
+    if (system.dryRun)
+        return;
+    for (let attempt = 0; attempt < 60; attempt++) {
+        if (await ready())
+            return;
+        await sleep(1_000);
+    }
+    throw new Error(`${what} didn't come up; check: journalctl -u ${unit} -n 50`);
+}
+function machineName() {
+    return hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").slice(0, 63) || "directionallylocal";
+}

package/install.sh

@@ -0,0 +1,150 @@
+#!/bin/sh
+# Directionally Local: one-line server install.
+#
+#   curl -fsSL https://directionallylocal.run | sh
+#
+# Installs Node.js 24 if needed and the directionallylocal CLI (also `dl`), then runs
+# `dl up`, which asks how to reach this server and for the model
+# 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.
+# Pin a version: DL_VERSION=0.1.0. Install from a local tarball: DL_PACKAGE=/path/to.tgz.
+set -eu
+
+say() { printf '%s\n' "$*"; }
+fail() { printf '\n  directionallylocal: %s\n' "$*" >&2; exit 1; }
+
+# The same look as `dl up`: a running step has a spinner and a timer, and becomes "✓"
+# when done. Without a terminal (or with NO_COLOR) it's plain lines.
+if [ -t 1 ] && [ -z "${NO_COLOR:-}" ] && [ "${TERM:-}" != "dumb" ]; then
+  FANCY=1
+else
+  FANCY=""
+fi
+STEP=""
+step() {
+  STEP=$1
+  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
+}
+
+# Quiet steps: output goes to a log that's shown only if the step fails.
+LOG=$(mktemp)
+trap 'rm -f "$LOG"' EXIT
+# Runs a command as root, through sudo when needed (keeping DL_* answers in the environment).
+as_root() {
+  if [ "$(id -u)" -eq 0 ]; then
+    "$@"
+  else
+    sudo -E "$@"
+  fi
+}
+
+# The spinner frame for tick $1 (POSIX sh has no arrays, and multibyte cut isn't portable).
+frame() {
+  case $(($1 % 10)) in
+    0) printf '⠋' ;; 1) printf '⠙' ;; 2) printf '⠹' ;; 3) printf '⠸' ;; 4) printf '⠼' ;;
+    5) printf '⠴' ;; 6) printf '⠦' ;; 7) printf '⠧' ;; 8) printf '⠇' ;; *) printf '⠏' ;;
+  esac
+}
+
+# On failure, show only this step's own output, not the earlier steps' in the same log.
+show_step_log() {
+  tail -n "+$(($1 + 1))" "$LOG" | tail -n 15 | while IFS= read -r line; do
+    if [ -n "$FANCY" ]; then printf '    \033[2m%s\033[0m\n' "$line" >&2; else printf '    %s\n' "$line" >&2; fi
+  done
+}
+
+quietly() {
+  what=$1
+  shift
+  from=$(wc -l <"$LOG")
+  if [ -z "$FANCY" ]; then
+    "$@" >>"$LOG" 2>&1 || { show_step_log "$from"; fail "$what failed"; }
+    return 0
+  fi
+  # Run in the background and animate the current step until it finishes.
+  "$@" >>"$LOG" 2>&1 &
+  pid=$!
+  started=$(date +%s)
+  tick=0
+  while kill -0 "$pid" 2>/dev/null; do
+    elapsed=$(($(date +%s) - started))
+    printf '\r\033[2K  \033[36m%s\033[0m %-33s\033[2m%d:%02d\033[0m' "$(frame "$tick")" "$STEP" $((elapsed / 60)) $((elapsed % 60))
+    tick=$((tick + 1))
+    sleep 0.1
+  done
+  if ! wait "$pid"; then
+    printf '\r\033[2K  \033[31m✗\033[0m %s\n\n' "$STEP"
+    show_step_log "$from"
+    fail "$what failed"
+  fi
+}
+
+node_major() {
+  node -p 'process.versions.node.split(".")[0]' 2>/dev/null || echo 0
+}
+
+node_is_patched() {
+  command -v node >/dev/null 2>&1 || return 1
+  node -e '
+    const [major, minor, patch] = process.versions.node.split(".").map(Number);
+    const fixed = { 22: [23, 4], 24: [22, 1], 26: [12, 1] }[major];
+    const ok = major > 26 || (fixed && (minor > fixed[0] || (minor === fixed[0] && patch >= fixed[1])));
+    process.exit(ok ? 0 : 1);
+  ' 2>/dev/null
+}
+
+# Wrapped in a function so a truncated download never runs half a script.
+main() {
+  if [ -n "$FANCY" ]; then printf '\n  \033[1mDirectionally Local\033[0m\n\n'; else say "Directionally Local"; fi
+  if [ "$(id -u)" -ne 0 ] && ! command -v sudo >/dev/null 2>&1; then
+    fail "run as root (or install sudo)"
+  fi
+
+  [ "$(uname -s)" = "Linux" ] || fail "only Linux servers are supported (found $(uname -s))"
+  [ -r /etc/os-release ] || fail "can't identify this Linux distribution (/etc/os-release missing)"
+  # shellcheck disable=SC1091
+  . /etc/os-release
+  case "${ID:-}" in
+    ubuntu|debian) ;;
+    *) fail "${PRETTY_NAME:-this distribution} isn't supported yet; use Ubuntu 24.04 or 22.04, or Debian 12" ;;
+  esac
+  export DEBIAN_FRONTEND=noninteractive
+  if ! command -v curl >/dev/null 2>&1; then
+    quietly "apt-get update" as_root apt-get update -qq
+    quietly "installing curl" as_root apt-get install -y -qq curl ca-certificates
+  fi
+
+  # Node must have the fix for CVE-2026-111497 (Brotli RCE via fetch): 22.23.4+, 24.22.1+ or
+  # 26.12.1+, the same rule as Hotcell's engines. A missing or unsupported Node gets 24 LTS
+  # (security fixes until April 2028); an unpatched 22, 24 or 26 is upgraded on its own line.
+  if ! node_is_patched; then
+    line=24
+    case "$(node_major)" in 24|26) line=$(node_major) ;; esac
+    step "Installing Node.js ${line}"
+    quietly "adding the Node.js ${line} repository" as_root sh -c "curl -fsSL https://deb.nodesource.com/setup_${line}.x | bash -"
+    quietly "installing Node.js ${line}" as_root apt-get install -y -qq nodejs
+    node_is_patched || fail "Node.js $(node -v 2>/dev/null || echo '?') is still missing the CVE-2026-111497 fix; install 22.23.4+, 24.22.1+ or 26.12.1+ and re-run"
+    step_done "Installed Node.js" "$(node -v)"
+  fi
+
+  package="${DL_PACKAGE:-directionallylocal@${DL_VERSION:-latest}}"
+  step "Getting the installer"
+  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 "")"
+
+  # 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.
+  export DL_TITLE_SHOWN=1
+  if (exec </dev/tty) 2>/dev/null; then
+    as_root directionallylocal up </dev/tty
+  else
+    as_root directionallylocal up
+  fi
+}
+
+main "$@"

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "directionallylocal",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "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": {
+    "type": "git",
+    "url": "git+https://github.com/directionally-local/installer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/directionally-local/installer/issues"
+  },
+  "type": "module",
+  "bin": {
+    "directionallylocal": "bin/directionallylocal.mjs",
+    "dl": "bin/directionallylocal.mjs"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "install.sh",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit && tsc -p site/tsconfig.json",
+    "test": "tsx --test \"src/**/*.test.ts\" \"site/**/*.test.ts\"",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}