directionallylocal 0.0.0-stage → 0.1.2

package/dist/laptop/git.js

@@ -0,0 +1,77 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, copyFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** Matches the server's limit on an uploaded patch. */
+export const MAX_PATCH_CHARS = 3 * 1024 * 1024;
+/** owner/name of the GitHub repository behind a git remote URL, or undefined for other hosts. */
+export function parseGitHubRemote(url) {
+    const match = url.trim().match(/^(?:https:\/\/(?:[^@/]+@)?github\.com\/|ssh:\/\/git@github\.com(?::\d+)?\/|git@github\.com:)([A-Za-z0-9-]{1,39})\/([A-Za-z0-9._-]{1,100}?)(?:\.git)?\/?$/);
+    return match ? `${match[1]}/${match[2]}` : undefined;
+}
+export async function detectGitHubRepository(cwd, remote = "origin") {
+    let url;
+    try {
+        url = await git(cwd, ["remote", "get-url", remote]);
+    }
+    catch {
+        throw new Error(`This directory has no "${remote}" git remote; pass --repo owner/name`);
+    }
+    const repository = parseGitHubRemote(url);
+    if (!repository)
+        throw new Error(`The "${remote}" remote is not a GitHub repository (${url}); pass --repo owner/name`);
+    return repository;
+}
+/**
+ * The local work a remote run should start from. The base is the merge-base of HEAD
+ * with its upstream (or origin's default branch), so it exists on GitHub; the patch
+ * carries everything newer, built in a throwaway index so the user's index is untouched.
+ */
+export async function snapshotWorkingTree(cwd) {
+    const root = await git(cwd, ["rev-parse", "--show-toplevel"]).catch(() => {
+        throw new Error("Not inside a git repository");
+    });
+    await git(root, ["rev-parse", "--verify", "HEAD"]).catch(() => {
+        throw new Error("This repository has no commits yet; push a first commit before running remotely");
+    });
+    const baseRef = await upstreamRef(root);
+    const baseCommit = await git(root, ["merge-base", "HEAD", baseRef]).catch(() => {
+        throw new Error(`HEAD shares no history with ${baseRef}`);
+    });
+    const scratch = await mkdtemp(join(tmpdir(), "autopilot-snapshot-"));
+    try {
+        const index = join(scratch, "index");
+        const realIndex = resolve(root, await git(root, ["rev-parse", "--git-path", "index"]));
+        await copyFile(realIndex, index).catch(() => { });
+        const env = { ...process.env, GIT_INDEX_FILE: index };
+        await git(root, ["add", "--all"], env);
+        const patch = await git(root, ["diff", "--cached", "--binary", "--no-color", "--no-ext-diff", baseCommit], env, false);
+        if (patch.length > MAX_PATCH_CHARS) {
+            throw new Error(`Local changes are ${(patch.length / 1024 / 1024).toFixed(1)} MiB, over the 3 MiB limit; commit and push some of them first`);
+        }
+        const files = (await git(root, ["diff", "--cached", "--name-only", "--no-renames", baseCommit], env)).split("\n").filter(Boolean);
+        return { baseCommit, patch, baseRef, files };
+    }
+    finally {
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+async function upstreamRef(root) {
+    const upstream = await git(root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]).catch(() => "");
+    if (upstream.startsWith("origin/"))
+        return upstream;
+    const originHead = await git(root, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]).catch(() => "");
+    if (originHead)
+        return originHead;
+    for (const candidate of ["origin/main", "origin/master"]) {
+        if (await git(root, ["rev-parse", "--verify", "--quiet", candidate]).then(() => true, () => false))
+            return candidate;
+    }
+    throw new Error("Can't find this branch on origin; run `git fetch origin` (or push the branch) first");
+}
+async function git(cwd, args, env, trim = true) {
+    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], { env: env ?? process.env, maxBuffer: 64 * 1024 * 1024 });
+    return trim ? stdout.trim() : stdout;
+}

package/dist/laptop/open-browser.js

@@ -0,0 +1,22 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+/**
+ * Opens a URL in the laptop's browser. Returns false when that's turned off
+ * (DL_NO_BROWSER=1 or BROWSER=none) or impossible, so the caller shows the link instead.
+ */
+export function openBrowser(url) {
+    if (process.env.DL_NO_BROWSER === "1" || process.env.BROWSER === "none")
+        return false;
+    try {
+        const os = platform();
+        // start is a cmd.exe builtin; the empty string is its window-title argument.
+        const [cmd, args] = os === "darwin" ? ["open", [url]] : os === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+        const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+        child.on("error", () => undefined);
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/layout.js

@@ -0,0 +1,216 @@
+/** Where everything lives on the server, and the files the installer writes there. */
+export const PATHS = {
+    root: "/opt/directionallylocal",
+    releases: "/opt/directionallylocal/releases",
+    current: "/opt/directionallylocal/current",
+    state: "/etc/directionallylocal/state.json",
+    stateDir: "/etc/directionallylocal",
+    hotcellEnv: "/etc/hotcell/hotcell.env",
+    hotcellEtc: "/etc/hotcell",
+    hotcellHome: "/var/lib/hotcell",
+    autopilotEtc: "/etc/autopilot",
+    autopilotEnv: "/etc/autopilot/autopilot.env",
+    githubEnv: "/etc/autopilot/github.env",
+    asterConfig: "/etc/autopilot/aster.json",
+    autopilotHome: "/var/lib/autopilot",
+    workspace: "/var/lib/autopilot/workspaces/default",
+    units: "/etc/systemd/system",
+};
+/** Lets Ubuntu's unattended-upgrades install Node.js fixes from NodeSource, like its own packages. */
+export const NODE_AUTO_UPDATES = "/etc/apt/apt.conf.d/52directionallylocal-nodejs";
+export const AUTO_UPGRADES = "/etc/apt/apt.conf.d/20auto-upgrades";
+export const SERVICES = {
+    hotcell: "hotcell.service",
+    autopilot: "autopilot.service",
+    metadataBlock: "directionallylocal-metadata-block.service",
+};
+export const USERS = { hotcell: "hotcell", autopilot: "autopilot" };
+export const AUTOPILOT_PORT = 4096;
+export const HOTCELL_PORT = 4750;
+export const HOTCELL_EGRESS_PORT = 4752;
+export const GITHUB_PROXY_PORT = 4760;
+/** Per-sandbox memory cap; the "fits ~N agents" estimate divides by it. */
+export const CELL_MEMORY_MB = 1024;
+export function hotcellBin() {
+    return `${PATHS.current}/node_modules/hotcell/dist/index.js`;
+}
+export function autopilotBin() {
+    return `${PATHS.current}/node_modules/autopilot-ai/bin/autopilot.mjs`;
+}
+export function cellImage(autopilotVersion) {
+    return `directionallylocal-cell:${autopilotVersion}`;
+}
+/** Renders KEY=value lines; values never contain newlines, so they need no quoting for systemd. */
+export function envFile(header, values) {
+    for (const [key, value] of Object.entries(values)) {
+        if (!/^[A-Z][A-Z0-9_]*$/.test(key) || /[\n\r]/.test(value))
+            throw new Error(`invalid env entry ${key}`);
+    }
+    return `# ${header}\n# Written by directionallylocal; edit with care, \`directionallylocal up\` keeps your values.\n${Object.entries(values).map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
+}
+/** Parses an env file back, so re-running `up` keeps generated secrets. */
+export function parseEnvFile(text) {
+    const values = {};
+    for (const line of (text ?? "").split("\n")) {
+        const match = line.match(/^([A-Z][A-Z0-9_]*)=(.*)$/);
+        if (match)
+            values[match[1]] = match[2];
+    }
+    return values;
+}
+export function hotcellEnv(input) {
+    return envFile("Hotcell daemon (sandboxes + credential gateway)", {
+        HOTCELL_HOME: PATHS.hotcellHome,
+        HOTCELL_KEYSTORE: "file",
+        HOTCELL_HOST: "127.0.0.1",
+        HOTCELL_PORT: String(HOTCELL_PORT),
+        HOTCELL_API_KEY: input.apiKey,
+        HOTCELL_DRIVER: "container",
+        // Sandboxes reach the gateway over the Docker bridge; loopback isn't reachable from them.
+        HOTCELL_EGRESS_HOST: input.bridgeIp,
+        HOTCELL_EGRESS_PORT: String(HOTCELL_EGRESS_PORT),
+        HOTCELL_EGRESS_ADVERTISE_HOST: "host.docker.internal",
+    });
+}
+export function autopilotEnv(input) {
+    return envFile("Autopilot server (Aster API)", {
+        HOME: PATHS.autopilotHome,
+        AUTOPILOT_ASTER_CONFIG: PATHS.asterConfig,
+        AUTOPILOT_ASTER_DB: `${PATHS.autopilotHome}/aster.db`,
+        AUTOPILOT_RUNS_DB: `${PATHS.autopilotHome}/runs.db`,
+        AUTOPILOT_PUBLIC_URL: input.publicUrl,
+        // The model key lives only in Hotcell; no server-side model calls.
+        AUTOPILOT_ASTER_MEMORY: "off",
+        AUTOPILOT_HOTCELL_ENDPOINT: `http://127.0.0.1:${HOTCELL_PORT}`,
+        AUTOPILOT_HOTCELL_API_KEY: input.hotcellApiKey,
+        AUTOPILOT_HOTCELL_DRIVER: "container",
+        AUTOPILOT_HOTCELL_IMAGE: input.image,
+        AUTOPILOT_HOTCELL_NETWORKED: "true",
+        AUTOPILOT_HOTCELL_ANY_MODEL: "true",
+        AUTOPILOT_HOTCELL_SLEEP_AFTER_MS: "900000",
+        AUTOPILOT_HOTCELL_MEMORY_MB: String(CELL_MEMORY_MB),
+        AUTOPILOT_HOTCELL_CPUS: "1",
+        AUTOPILOT_HOTCELL_PIDS: "512",
+        AUTOPILOT_HOTCELL_SPEND_CAP_USD: "10",
+        AUTOPILOT_HOTCELL_TOKEN_TTL_MS: String(30 * 24 * 60 * 60 * 1000),
+        // Code cells clone and push through Autopilot's repository-scoped proxy on the bridge.
+        AUTOPILOT_ASTER_GITHUB_PROXY_LISTEN: `${input.bridgeIp}:${GITHUB_PROXY_PORT}`,
+        AUTOPILOT_ASTER_GITHUB_PROXY_URL: `http://host.docker.internal:${GITHUB_PROXY_PORT}`,
+    });
+}
+export function githubEnv(token) {
+    return envFile("GitHub credential for cloning, pushing, and opening PRs (never sent to sandboxes)", { GITHUB_TOKEN: token });
+}
+export function asterConfig() {
+    return `${JSON.stringify({
+        models: "openrouter",
+        workspaces: [{ id: "default", displayName: "Default workspace", rootPath: PATHS.workspace }],
+    }, null, 2)}\n`;
+}
+export function hotcellUnit() {
+    return `[Unit]
+Description=Hotcell sandbox daemon (Directionally Local)
+After=docker.service network-online.target ${SERVICES.metadataBlock}
+Requires=docker.service
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=${USERS.hotcell}
+Group=${USERS.hotcell}
+SupplementaryGroups=docker
+EnvironmentFile=${PATHS.hotcellEnv}
+WorkingDirectory=${PATHS.hotcellHome}
+ExecStart=/usr/bin/node ${hotcellBin()} start --foreground --defaults
+Restart=on-failure
+RestartSec=5
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=${PATHS.hotcellHome}
+PrivateTmp=true
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+export function autopilotUnit() {
+    return `[Unit]
+Description=Autopilot server (Directionally Local)
+After=${SERVICES.hotcell} network-online.target
+Wants=${SERVICES.hotcell} network-online.target
+
+[Service]
+Type=simple
+User=${USERS.autopilot}
+Group=${USERS.autopilot}
+EnvironmentFile=${PATHS.autopilotEnv}
+EnvironmentFile=${PATHS.githubEnv}
+WorkingDirectory=${PATHS.autopilotHome}
+ExecStart=/usr/bin/node ${autopilotBin()} serve --hostname 127.0.0.1 --port ${AUTOPILOT_PORT}
+Restart=on-failure
+RestartSec=5
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=${PATHS.autopilotHome}
+PrivateTmp=true
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+export function nodeAutoUpdates() {
+    return `// Written by directionallylocal: install Node.js security fixes from NodeSource
+// automatically, the way Ubuntu's own packages are. Delete this file to opt out.
+// Matched by site: NodeSource's Release file has no meaningful Origin or Label.
+Unattended-Upgrade::Origins-Pattern {
+        "site=deb.nodesource.com";
+};
+`;
+}
+/** Prints `dl`'s one-line status at login (Ubuntu's update-motd); silent if dl is gone. */
+export const MOTD_SCRIPT = "/etc/update-motd.d/60-directionallylocal";
+export function motdScript() {
+    return `#!/bin/sh
+# Written by directionallylocal: a one-line status at login. Delete this file to opt out.
+command -v dl >/dev/null 2>&1 && dl status --brief 2>/dev/null || true
+`;
+}
+/** Ubuntu's default: refresh package lists and run unattended-upgrades daily. */
+export function autoUpgrades() {
+    return `APT::Periodic::Update-Package-Lists "1";
+APT::Periodic::Unattended-Upgrade "1";
+`;
+}
+/** Keeps sandboxes away from the cloud metadata endpoint (instance credentials). */
+export function metadataBlockUnit() {
+    const rule = "DOCKER-USER -d 169.254.169.254/32 -j DROP";
+    return `[Unit]
+Description=Block cloud metadata from Docker sandboxes (Directionally Local)
+After=docker.service
+Requires=docker.service
+Before=${SERVICES.hotcell}
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/bin/sh -c 'iptables -C ${rule} 2>/dev/null || iptables -I ${rule}'
+ExecStop=/bin/sh -c 'iptables -D ${rule} 2>/dev/null || true'
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+/** The sandbox image: Node, git, common build tools, and the Autopilot runtime baked in. */
+export function cellDockerfile() {
+    return `FROM node:24-bookworm
+RUN apt-get update && apt-get install -y --no-install-recommends git ca-certificates python3 python3-pip \\
+    && rm -rf /var/lib/apt/lists/*
+COPY autopilot.tgz /tmp/autopilot.tgz
+RUN mkdir -p /opt/autopilot \\
+    && npm install --prefix /opt/autopilot --no-audit --no-fund /tmp/autopilot.tgz \\
+    && rm /tmp/autopilot.tgz
+WORKDIR /workspace
+`;
+}

package/dist/node-advisory.js

@@ -0,0 +1,26 @@
+/**
+ * Whether a Node.js version is safe to run the stack on. CVE-2026-111497 ("Node2Shell")
+ * is a critical out-of-bounds write in Node's bundled Brotli decoder, reachable through
+ * fetch(); it's fixed in 22.23.4, 24.22.1 and 26.12.1. Odd lines get no fix. Mirrors
+ * Hotcell's `engines` (^22.23.4 || ^24.22.1 || >=26.12.1) and its startup advisory.
+ */
+const FIXED = { 22: [23, 4], 24: [22, 1], 26: [12, 1] };
+/** End of security support for each LTS line (nodejs/Release schedule). */
+export const NODE_END_OF_LIFE = { 22: "2027-04-30", 24: "2028-04-30", 26: "2029-04-30" };
+export function nodeAdvisory(version, today = new Date()) {
+    const match = version.trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return { ok: false, message: `Couldn't read the Node.js version (${version || "none"}).` };
+    const [major, minor, patch] = [Number(match[1]), Number(match[2]), Number(match[3])];
+    const fixed = FIXED[major];
+    const patched = major > 26 || (fixed !== undefined && (minor > fixed[0] || (minor === fixed[0] && patch >= fixed[1])));
+    if (!patched) {
+        const reason = major < 22 || major % 2 === 1 ? `Node.js ${major} is unsupported and gets no fix` : `Node.js ${version.replace(/^v/, "")} is vulnerable`;
+        return { ok: false, message: `${reason} for CVE-2026-111497 (remote code execution via fetch). Use 22.23.4+, 24.22.1+ or 26.12.1+.` };
+    }
+    const end = NODE_END_OF_LIFE[major];
+    if (end && Date.parse(end) - today.getTime() < 90 * 24 * 60 * 60 * 1000) {
+        return { ok: true, message: `Node.js ${major} stops getting security fixes on ${end}; move to a newer LTS line.` };
+    }
+    return { ok: true, message: undefined };
+}

package/dist/prompt.js

@@ -0,0 +1,87 @@
+import { openSync, closeSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { ReadStream, WriteStream } from "node:tty";
+/**
+ * Reads from /dev/tty, so prompts work under `curl … | sh` where stdin is the script.
+ * Without a terminal every question fails with the env var that answers it.
+ */
+export class TtyPrompter {
+    async choose(question, options, fallback) {
+        const lines = options.map((option, index) => `  ${index + 1}. ${option.label}`).join("\n");
+        const answer = (await this.ask(`${question}\n${lines}\nChoice [1]: `, false)).trim();
+        if (!answer)
+            return options[0]?.value ?? fallback;
+        const index = Number(answer) - 1;
+        return options[index]?.value ?? options.find((option) => option.value === answer)?.value ?? fallback;
+    }
+    secret(question) {
+        return this.ask(question, true);
+    }
+    text(question) {
+        return this.ask(question, false);
+    }
+    ask(question, hidden) {
+        let fd;
+        try {
+            fd = openSync("/dev/tty", "r+");
+        }
+        catch {
+            throw new Error("No terminal to ask on; pass the answers as environment variables (see `dl --help`).");
+        }
+        const input = new ReadStream(fd);
+        const output = new WriteStream(fd);
+        // A styled prompt is "label line\n› ": print the label line ourselves and give readline
+        // only the last line, so its redraws (and the hidden-input filter) stay on one line.
+        const split = question.lastIndexOf("\n");
+        const head = split >= 0 ? question.slice(0, split + 1) : "";
+        const line = split >= 0 ? question.slice(split + 1) : question;
+        if (head)
+            output.write(head);
+        return new Promise((resolve) => {
+            const rl = createInterface({ input, output, terminal: true });
+            if (hidden) {
+                // Echo nothing while the secret is typed.
+                rl._writeToOutput = (text) => {
+                    if (text.includes(line))
+                        output.write(text);
+                };
+            }
+            rl.question(line, (answer) => {
+                if (hidden)
+                    output.write("\n");
+                rl.close();
+                input.destroy();
+                output.destroy();
+                try {
+                    closeSync(fd);
+                }
+                catch { /* already closed with the streams */ }
+                resolve(answer.trim());
+            });
+        });
+    }
+}
+/** Answers from a map (tests); a missing answer is a test bug, so it throws. */
+export class ScriptedPrompter {
+    answers;
+    asked = [];
+    constructor(answers) {
+        this.answers = answers;
+    }
+    async choose(question) {
+        return this.answer(question);
+    }
+    async secret(question) {
+        return this.answer(question);
+    }
+    async text(question) {
+        return this.answer(question);
+    }
+    answer(question) {
+        this.asked.push(question);
+        const key = Object.keys(this.answers).find((fragment) => question.includes(fragment));
+        if (key === undefined)
+            throw new Error(`unexpected question: ${question}`);
+        return this.answers[key];
+    }
+}

package/dist/server-api.js

@@ -0,0 +1,54 @@
+import { PATHS, USERS, autopilotBin } from "./layout.js";
+/**
+ * Autopilot's server-side commands, run as the autopilot account against the same
+ * config and database as the service. `dl` reads laptops and runs through these, never
+ * through Autopilot's database directly.
+ */
+export function autopilotServer(system, args, options = {}) {
+    return system.run("runuser", [
+        "-u", USERS.autopilot, "--", "env", `HOME=${PATHS.autopilotHome}`, `AUTOPILOT_ASTER_CONFIG=${PATHS.asterConfig}`,
+        `AUTOPILOT_ASTER_DB=${PATHS.autopilotHome}/aster.db`, "/usr/bin/node", autopilotBin(), ...args,
+    ], { allowFailure: true, describe: options.describe ?? `autopilot ${args.join(" ")} (as autopilot)`, ...(options.secretOutput ? { secretOutput: true } : {}) });
+}
+/** Paired laptops and apps: active credentials that aren't owner browsers. Undefined if Autopilot can't say. */
+export async function listLaptops(system) {
+    const result = await autopilotServer(system, ["aster", "token", "list", "--json"]);
+    const parsed = parseJson(result);
+    return parsed?.filter((entry) => entry.status === "active" && !entry.scopes.includes("pairing:approve"));
+}
+export async function listServerRuns(system, limit = 200) {
+    return parseJson(await autopilotServer(system, ["aster", "runs", "--json", "--limit", String(limit)]));
+}
+/** Pairing codes waiting for approval, e.g. "BCDF-GHJK  MacBook (autopilot)". */
+export async function pendingPairings(system) {
+    const result = await autopilotServer(system, ["aster", "pair", "list"]);
+    if (result.code !== 0)
+        return [];
+    return result.stdout.split("\n").flatMap((line) => {
+        const match = line.match(/^([A-Z]{4}-[A-Z]{4})\s+(.+?)\s+expires\s/);
+        return match ? [{ code: match[1], name: match[2] }] : [];
+    });
+}
+export async function approvePairing(system, code) {
+    const result = await autopilotServer(system, ["aster", "pair", "approve", code]);
+    return { ok: result.code === 0, message: (result.code === 0 ? result.stdout : result.stderr || result.stdout).trim() };
+}
+export async function revokeLaptop(system, id) {
+    return (await autopilotServer(system, ["aster", "token", "revoke", id])).code === 0;
+}
+/** A fresh one-time link that makes the browser opening it able to approve laptops. */
+export async function ownerLink(system, url) {
+    const result = await autopilotServer(system, ["aster", "owner", "link", "--url", url], { secretOutput: true, describe: "autopilot aster owner link (as autopilot)" });
+    const link = result.stdout.trim().split("\n").at(-1);
+    return result.code === 0 && link?.startsWith("http") ? link : undefined;
+}
+function parseJson(result) {
+    if (result.code !== 0)
+        return undefined;
+    try {
+        return JSON.parse(result.stdout.trim().split("\n").at(-1) ?? "");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/state.js

@@ -0,0 +1,19 @@
+import { PATHS } from "./layout.js";
+export async function readState(system) {
+    const raw = await system.readFile(PATHS.state);
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed.version === 1 ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function writeState(system, state) {
+    // Readable by everyone: versions and the address aren't secret, and any login can see the
+    // status. Secrets in this directory (a Tailscale key, briefly) are written 0600.
+    await system.mkdir(PATHS.stateDir, { mode: 0o755 });
+    await system.writeFile(PATHS.state, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o644 });
+}