directionallylocal 0.1.2 → 0.3.0

package/dist/local/layout.js

@@ -0,0 +1,227 @@
+/**
+ * "On this computer": where everything lives in the user's home, and the files written
+ * there. Nothing here needs root. Secrets sit in 0600 env files that `node --env-file`
+ * reads, so they never appear in a launchd plist, a systemd unit, or any command line.
+ */
+import { join } from "node:path";
+export function localPaths(home, platform) {
+    const root = join(home, ".directionallylocal");
+    const config = join(root, "config");
+    const autopilotHome = join(root, "autopilot");
+    return {
+        home,
+        root,
+        releases: join(root, "releases"),
+        current: join(root, "current"),
+        logs: join(root, "logs"),
+        state: join(root, "state.json"),
+        config,
+        hotcellEnv: join(config, "hotcell.env"),
+        autopilotEnv: join(config, "autopilot.env"),
+        githubEnv: join(config, "github.env"),
+        asterConfig: join(config, "aster.json"),
+        hotcellHome: join(root, "hotcell"),
+        autopilotHome,
+        workspace: join(autopilotHome, "workspaces", "default"),
+        services: platform === "darwin" ? join(home, "Library", "LaunchAgents") : join(home, ".config", "systemd", "user"),
+    };
+}
+/** launchd labels and systemd user units, prefixed so they never clash with a user's own Hotcell. */
+export const LOCAL_SERVICES = {
+    hotcell: { label: "com.directionallylocal.hotcell", unit: "directionallylocal-hotcell.service", log: "hotcell.log" },
+    autopilot: { label: "com.directionallylocal.autopilot", unit: "directionallylocal-autopilot.service", log: "autopilot.log" },
+};
+export function serviceFile(paths, platform, service) {
+    const entry = LOCAL_SERVICES[service];
+    return join(paths.services, platform === "darwin" ? `${entry.label}.plist` : entry.unit);
+}
+/** Preferred ports; each moves up to the next free one when something else has it. */
+export const PREFERRED_PORTS = {
+    autopilot: 4096,
+    hotcell: 4750,
+    hotcellProxy: 4751,
+    hotcellEgress: 4752,
+    githubProxy: 4760,
+};
+export const LOCAL_CELL_MEMORY_MB = 1024;
+export const LOCAL_MIN_DISK_GB = 10;
+export const PAIRED_NAME = "this-computer";
+export function localHotcellBin(paths) {
+    return join(paths.current, "node_modules", "hotcell", "dist", "index.js");
+}
+export function localAutopilotBin(paths) {
+    return join(paths.current, "node_modules", "autopilot-ai", "bin", "autopilot.mjs");
+}
+/**
+ * KEY=value lines for `node --env-file`. Values with spaces or `#` (a home like
+ * "/Users/Jane Doe") are double-quoted, which Node's parser understands.
+ */
+export function localEnvFile(header, values) {
+    const lines = Object.entries(values).map(([key, value]) => {
+        if (!/^[A-Z][A-Z0-9_]*$/.test(key) || /[\n\r"]/.test(value))
+            throw new Error(`invalid env entry ${key}`);
+        return `${key}=${/[\s#'`$\\]/.test(value) ? `"${value}"` : value}`;
+    });
+    return `# ${header}\n# Written by directionallylocal; re-running setup keeps your values.\n${lines.join("\n")}\n`;
+}
+export function parseLocalEnvFile(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].replace(/^"(.*)"$/, "$1");
+    }
+    return values;
+}
+export function localHotcellEnv(input) {
+    const { paths, ports } = input;
+    return localEnvFile("Hotcell daemon (sandboxes + credential gateway), on this computer", {
+        HOTCELL_HOME: paths.hotcellHome,
+        // A 0600 file, not the login keychain: see setup.ts for why.
+        HOTCELL_KEYSTORE: "file",
+        HOTCELL_DB: join(paths.hotcellHome, "state.db"),
+        HOTCELL_BACKUP_DIR: join(paths.hotcellHome, "backups"),
+        HOTCELL_HOST: "127.0.0.1",
+        HOTCELL_PORT: String(ports.hotcell),
+        HOTCELL_PROXY_PORT: String(ports.hotcellProxy),
+        HOTCELL_API_KEY: input.apiKey,
+        HOTCELL_DRIVER: "container",
+        HOTCELL_EGRESS_HOST: input.net.listenHost,
+        HOTCELL_EGRESS_PORT: String(ports.hotcellEgress),
+        HOTCELL_EGRESS_ADVERTISE_HOST: "host.docker.internal",
+    });
+}
+export function localAutopilotEnv(input) {
+    const { paths, ports } = input;
+    return localEnvFile("Autopilot server (Aster API), on this computer", {
+        AUTOPILOT_ASTER_CONFIG: paths.asterConfig,
+        AUTOPILOT_ASTER_DB: join(paths.autopilotHome, "aster.db"),
+        AUTOPILOT_RUNS_DB: join(paths.autopilotHome, "runs.db"),
+        AUTOPILOT_PUBLIC_URL: `http://127.0.0.1:${ports.autopilot}`,
+        // The model key lives only in Hotcell; no model calls from this computer itself.
+        AUTOPILOT_ASTER_MEMORY: "off",
+        AUTOPILOT_HOTCELL_ENDPOINT: `http://127.0.0.1:${ports.hotcell}`,
+        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(LOCAL_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),
+        // Cells clone and push through Autopilot's repository-scoped proxy; the token stays here.
+        AUTOPILOT_ASTER_GITHUB_PROXY_LISTEN: `${input.net.listenHost}:${ports.githubProxy}`,
+        AUTOPILOT_ASTER_GITHUB_PROXY_URL: `http://host.docker.internal:${ports.githubProxy}`,
+    });
+}
+export function localGithubEnv(token) {
+    return localEnvFile("GitHub credential for cloning, pushing, and opening PRs (never sent to sandboxes)", { GITHUB_TOKEN: token });
+}
+export function localAsterConfig(paths) {
+    return `${JSON.stringify({
+        models: "openrouter",
+        workspaces: [{ id: "default", displayName: "Default workspace", rootPath: paths.workspace }],
+    }, null, 2)}\n`;
+}
+export function serviceSpecs(input) {
+    const { paths } = input;
+    const docker = input.dockerHost ? { DOCKER_HOST: input.dockerHost } : {};
+    return {
+        hotcell: {
+            service: "hotcell",
+            description: "Hotcell sandbox daemon (Directionally Local)",
+            node: input.node,
+            envFiles: [paths.hotcellEnv],
+            args: [localHotcellBin(paths), "start", "--foreground", "--defaults"],
+            // Its own HOME, so nothing falls back to a user's own ~/.hotcell.
+            env: { HOME: paths.hotcellHome, PATH: input.path, ...docker },
+            workingDirectory: paths.hotcellHome,
+            log: join(paths.logs, LOCAL_SERVICES.hotcell.log),
+        },
+        autopilot: {
+            service: "autopilot",
+            description: "Autopilot server (Directionally Local)",
+            node: input.node,
+            envFiles: [paths.autopilotEnv, paths.githubEnv],
+            args: [localAutopilotBin(paths), "serve", "--hostname", "127.0.0.1", "--port", String(input.ports.autopilot)],
+            // Its own HOME and XDG dirs: a user's own Autopilot config and keys are never picked up.
+            env: { HOME: paths.autopilotHome, PATH: input.path, ...autopilotXdg(paths), ...docker },
+            workingDirectory: paths.autopilotHome,
+            log: join(paths.logs, LOCAL_SERVICES.autopilot.log),
+        },
+    };
+}
+export function autopilotXdg(paths) {
+    return {
+        XDG_CONFIG_HOME: join(paths.autopilotHome, ".config"),
+        XDG_STATE_HOME: join(paths.autopilotHome, ".local", "state"),
+        XDG_DATA_HOME: join(paths.autopilotHome, ".local", "share"),
+        XDG_CACHE_HOME: join(paths.autopilotHome, ".cache"),
+    };
+}
+function xml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** A LaunchAgent: starts at login, restarted if it exits, logs under ~/.directionallylocal/logs. */
+export function launchAgentPlist(spec) {
+    const program = [spec.node, ...spec.envFiles.map((file) => `--env-file=${file}`), ...spec.args];
+    const env = Object.entries(spec.env).map(([key, value]) => `    <key>${xml(key)}</key>\n    <string>${xml(value)}</string>`).join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!-- ${xml(spec.description)}. Written by directionallylocal; remove with: dl local uninstall -->
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LOCAL_SERVICES[spec.service].label}</string>
+  <key>ProgramArguments</key>
+  <array>
+${program.map((arg) => `    <string>${xml(arg)}</string>`).join("\n")}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${env}
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${xml(spec.workingDirectory)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Standard</string>
+  <key>StandardOutPath</key>
+  <string>${xml(spec.log)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(spec.log)}</string>
+</dict>
+</plist>
+`;
+}
+function systemdQuote(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%")}"`;
+}
+/** A systemd user unit: starts with the user's session (default.target), restarted on exit. */
+export function systemdUserUnit(spec, after) {
+    const program = [spec.node, ...spec.envFiles.map((file) => `--env-file=${file}`), ...spec.args];
+    return `[Unit]
+Description=${spec.description}
+${after ? `After=${after}\nWants=${after}\n` : ""}
+[Service]
+Type=simple
+${Object.entries(spec.env).map(([key, value]) => `Environment=${systemdQuote(`${key}=${value}`)}`).join("\n")}
+WorkingDirectory=${spec.workingDirectory}
+ExecStart=${program.map(systemdQuote).join(" ")}
+Restart=always
+RestartSec=5
+StandardOutput=append:${spec.log}
+StandardError=append:${spec.log}
+
+[Install]
+WantedBy=default.target
+`;
+}

package/dist/local/probes.js

@@ -0,0 +1,22 @@
+/**
+ * Exit 0 when HOST:PORT is free. Connecting first catches a listener on 0.0.0.0, which
+ * macOS would still let us bind 127.0.0.1 next to.
+ */
+export const PORT_FREE_SCRIPT = [
+    "const net=require('net');const [h,p]=[process.argv[1],Number(process.argv[2])];",
+    "const c=net.connect(p,h);c.once('connect',()=>{c.destroy();process.exit(1)});",
+    "c.once('error',()=>{const s=net.createServer();s.once('error',()=>process.exit(1));s.listen(p,h,()=>s.close(()=>process.exit(0)))});",
+].join("");
+/** Prints the HTTP status of GET URL (0 if nothing answers); a bearer token, if any, comes on stdin. */
+export const HTTP_STATUS_SCRIPT = [
+    "let t='';process.stdin.on('data',d=>t+=d).on('end',async()=>{",
+    "try{const r=await fetch(process.argv[1],{headers:t.trim()?{authorization:'Bearer '+t.trim()}:{},signal:AbortSignal.timeout(5000)});",
+    "console.log(r.status)}catch{console.log(0)}});",
+].join("");
+export async function portFree(system, node, host, port) {
+    return (await system.probe(node, ["-e", PORT_FREE_SCRIPT, host, String(port)])).code === 0;
+}
+export async function httpStatus(system, node, url, token = "") {
+    const result = await system.probe(node, ["-e", HTTP_STATUS_SCRIPT, url], { input: token });
+    return Number(result.stdout.trim()) || 0;
+}

package/dist/local/services.js

@@ -0,0 +1,68 @@
+import { LOCAL_SERVICES, launchAgentPlist, serviceFile, systemdUserUnit, } from "./layout.js";
+const ORDER = ["hotcell", "autopilot"];
+export async function userId(system) {
+    const uid = (await system.probe("id", ["-u"])).stdout.trim();
+    if (!/^\d+$/.test(uid))
+        throw new Error("Couldn't tell which user this is (id -u).");
+    if (uid === "0")
+        throw new Error("Run this as yourself, not as root or with sudo: the agents run as your user.");
+    return uid;
+}
+/** Writes the service definition, then starts (or restarts) it. */
+export async function installService(system, manager, spec) {
+    const { platform, paths } = manager;
+    const file = serviceFile(paths, platform, spec.service);
+    await system.mkdir(paths.services, { mode: platform === "darwin" ? 0o755 : 0o700 });
+    if (platform === "darwin") {
+        await system.writeFile(file, launchAgentPlist(spec), { mode: 0o644 });
+        await stopService(system, manager, spec.service);
+        const target = `gui/${manager.uid}/${LOCAL_SERVICES[spec.service].label}`;
+        // A service the user disabled stays disabled across bootstrap; setup means "on".
+        await system.run("launchctl", ["enable", target], { allowFailure: true });
+        // bootout returns before launchd has let go of the label; bootstrap can briefly fail with EIO.
+        for (let attempt = 1;; attempt++) {
+            const result = await system.run("launchctl", ["bootstrap", `gui/${manager.uid}`, file], { allowFailure: true });
+            if (result.code === 0)
+                break;
+            if (attempt >= 5)
+                throw new Error(`launchd wouldn't start ${spec.service}: ${(result.stderr || result.stdout).trim()}`);
+            await manager.sleep(1_000);
+        }
+        return;
+    }
+    const unit = LOCAL_SERVICES[spec.service].unit;
+    await system.writeFile(file, systemdUserUnit(spec, spec.service === "autopilot" ? LOCAL_SERVICES.hotcell.unit : undefined), { mode: 0o644 });
+    await system.run("systemctl", ["--user", "daemon-reload"]);
+    await system.run("systemctl", ["--user", "enable", unit]);
+    await system.run("systemctl", ["--user", "restart", unit]);
+}
+export async function stopService(system, manager, service) {
+    if (manager.platform === "darwin") {
+        await system.run("launchctl", ["bootout", `gui/${manager.uid}/${LOCAL_SERVICES[service].label}`], { allowFailure: true });
+    }
+    else {
+        await system.run("systemctl", ["--user", "disable", "--now", LOCAL_SERVICES[service].unit], { allowFailure: true });
+    }
+}
+/** Stops and deletes both service definitions. */
+export async function removeServices(system, manager) {
+    for (const service of [...ORDER].reverse()) {
+        await stopService(system, manager, service);
+        await system.remove(serviceFile(manager.paths, manager.platform, service));
+    }
+    if (manager.platform === "linux") {
+        await system.run("systemctl", ["--user", "daemon-reload"], { allowFailure: true });
+        await system.run("systemctl", ["--user", "reset-failed"], { allowFailure: true });
+    }
+}
+export async function serviceState(system, manager, service) {
+    const installed = await system.exists(serviceFile(manager.paths, manager.platform, service));
+    if (manager.platform === "darwin") {
+        const printed = await system.probe("launchctl", ["print", `gui/${manager.uid}/${LOCAL_SERVICES[service].label}`]);
+        const running = printed.code === 0 && /^\s*state = running\s*$/m.test(printed.stdout);
+        const pid = Number(printed.stdout.match(/^\s*pid = (\d+)\s*$/m)?.[1]);
+        return { installed, running, ...(pid ? { pid } : {}) };
+    }
+    const active = await system.probe("systemctl", ["--user", "is-active", LOCAL_SERVICES[service].unit]);
+    return { installed, running: active.stdout.trim() === "active" };
+}