directionallylocal 0.0.0-stage → 0.1.2

package/dist/system.js

@@ -0,0 +1,177 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, mkdirSync, openSync } from "node:fs";
+import { chmod, chown, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export class CommandError extends Error {
+    command;
+    result;
+    constructor(command, result) {
+        super(`${command} failed (exit ${result.code})${result.stderr.trim() ? `: ${result.stderr.trim().split("\n").slice(-3).join(" ")}` : ""}`);
+        this.command = command;
+        this.result = result;
+        this.name = "CommandError";
+    }
+}
+export class RealSystem {
+    output;
+    dryRun = false;
+    logFd;
+    /**
+     * With `outputLog`, every command and its output goes to that file instead of the screen,
+     * including long installs that would otherwise stream (`inherit`), so the terminal UI owns
+     * the screen. Without it, those installs stream as before (plain mode, logs, CI).
+     */
+    constructor(output = (line) => process.stdout.write(`${line}\n`), options = {}) {
+        this.output = output;
+        if (options.outputLog) {
+            mkdirSync(dirname(options.outputLog), { recursive: true, mode: 0o700 });
+            this.logFd = openSync(options.outputLog, "w", 0o600);
+            appendFileSync(this.logFd, `# directionallylocal ${new Date().toISOString()}\n`);
+        }
+    }
+    run(command, args, options = {}) {
+        return this.spawn(command, args, options, true);
+    }
+    spawn(command, args, options, logged) {
+        const log = logged ? this.logFd : undefined;
+        const stream = options.inherit && this.logFd === undefined;
+        if (log !== undefined)
+            appendFileSync(log, `\n$ ${options.describe ?? [command, ...args].join(" ")}\n`);
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd: options.cwd,
+                env: { ...process.env, ...options.env },
+                stdio: [options.input === undefined ? "ignore" : "pipe", stream ? "inherit" : "pipe", stream ? "inherit" : "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout?.on("data", (chunk) => {
+                stdout += chunk.toString();
+                if (log !== undefined && !options.secretOutput)
+                    appendFileSync(log, chunk);
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString();
+                if (log !== undefined)
+                    appendFileSync(log, chunk);
+            });
+            child.on("error", (error) => {
+                const result = { code: 127, stdout, stderr: stderr || error.message };
+                if (options.allowFailure)
+                    resolve(result);
+                else
+                    reject(new CommandError(options.describe ?? command, result));
+            });
+            child.on("close", (code) => {
+                const result = { code: code ?? 1, stdout, stderr };
+                if (log !== undefined && result.code !== 0)
+                    appendFileSync(log, `(exit ${result.code})\n`);
+                if (result.code !== 0 && !options.allowFailure)
+                    reject(new CommandError(options.describe ?? [command, ...args].join(" "), result));
+                else
+                    resolve(result);
+            });
+            if (options.input !== undefined)
+                child.stdin?.end(options.input);
+        });
+    }
+    /** Detection probes are frequent and read-only; they stay out of the install log. */
+    probe(command, args, options = {}) {
+        return this.spawn(command, args, { ...options, allowFailure: true }, false);
+    }
+    async readFile(path) {
+        try {
+            return await readFile(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    async writeFile(path, content, options = {}) {
+        await mkdir(dirname(path), { recursive: true });
+        const mode = options.mode ?? 0o644;
+        // Create with the final mode so a secret is never briefly world-readable.
+        await writeFile(path, content, { mode });
+        await chmod(path, mode);
+        if (options.owner)
+            await this.chown(path, options.owner);
+    }
+    /**
+     * Every directory this creates gets the mode and owner, not just the last one: Node's
+     * recursive mkdir applies the mode to new parents too, so a root-owned 0700 parent would
+     * lock the owner out of its own directory.
+     */
+    async mkdir(path, options = {}) {
+        const created = [];
+        for (let dir = resolve(path); !(await this.exists(dir)); dir = dirname(dir))
+            created.unshift(dir);
+        await mkdir(path, { recursive: true, ...(options.mode !== undefined ? { mode: options.mode } : {}) });
+        for (const dir of created.length > 0 ? created : [resolve(path)]) {
+            if (options.mode !== undefined)
+                await chmod(dir, options.mode);
+            if (options.owner)
+                await this.chown(dir, options.owner);
+        }
+    }
+    async remove(path) {
+        await rm(path, { recursive: true, force: true });
+    }
+    async exists(path) {
+        return stat(path).then(() => true, () => false);
+    }
+    log(line) {
+        this.output(line);
+    }
+    async chown(path, owner) {
+        const [user, group = user] = owner.split(":");
+        const uid = Number((await this.run("id", ["-u", user])).stdout.trim());
+        const gid = Number((await this.run("getent", ["group", group])).stdout.split(":")[2]);
+        await chown(path, uid, gid);
+    }
+}
+/**
+ * Prints what `up` would change and changes nothing. Reads still hit the real machine,
+ * so the plan reflects what is already installed.
+ */
+export class DryRunSystem {
+    output;
+    dryRun = true;
+    real;
+    constructor(output = (line) => process.stdout.write(`${line}\n`)) {
+        this.output = output;
+        this.real = new RealSystem(output);
+    }
+    async run(command, args, options = {}) {
+        this.output(`  would run: ${options.describe ?? [command, ...args].join(" ")}`);
+        return { code: 0, stdout: "", stderr: "" };
+    }
+    probe(command, args, options = {}) {
+        return this.real.probe(command, args, options);
+    }
+    readFile(path) {
+        return this.real.readFile(path);
+    }
+    async writeFile(path, content, options = {}) {
+        const mode = (options.mode ?? 0o644).toString(8).padStart(4, "0");
+        this.output(`  would write: ${path} (${mode}${options.owner ? ` ${options.owner}` : ""})`);
+        if (!options.secret)
+            for (const line of content.trimEnd().split("\n"))
+                this.output(`      ${line}`);
+    }
+    async mkdir(path, options = {}) {
+        if (!(await this.real.exists(path)))
+            this.output(`  would create: ${path}/${options.owner ? ` (${options.owner})` : ""}`);
+    }
+    async remove(path) {
+        if (await this.real.exists(path))
+            this.output(`  would remove: ${path}`);
+    }
+    exists(path) {
+        return this.real.exists(path);
+    }
+    log(line) {
+        this.output(line);
+    }
+}

package/dist/ui.js

@@ -0,0 +1,223 @@
+/**
+ * What people see while the installer works. On a terminal: a live checklist in
+ * Camouflage's visual language (✓ done, ✗ failed, ○ pending, a spinner and timer on the
+ * active step), redrawn in place in normal scrollback so the final link and command stay
+ * on screen to copy. Without a terminal (CI, logs, unattended installs): one plain line
+ * per event. Other tools' output never reaches the screen; it goes to the install log.
+ */
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const GLYPH = { pending: "○", active: "", done: "✓", failed: "✗", info: "·" };
+const LABEL_WIDTH = 33;
+/** ANSI styles, or none under NO_COLOR / TERM=dumb. */
+export function palette(enabled) {
+    const wrap = (open, close) => (text) => enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text;
+    return {
+        bold: wrap("1", "22"),
+        dim: wrap("2", "22"),
+        green: wrap("32", "39"),
+        red: wrap("31", "39"),
+        yellow: wrap("33", "39"),
+        cyan: wrap("36", "39"),
+    };
+}
+export class TerminalUi {
+    write;
+    columns;
+    interactive = true;
+    steps = [];
+    rendered = 0;
+    frame = 0;
+    timer;
+    warnings = [];
+    c;
+    constructor(write = (text) => process.stdout.write(text), columns = () => process.stdout.columns || 80, color = !process.env.NO_COLOR && process.env.TERM !== "dumb") {
+        this.write = write;
+        this.columns = columns;
+        this.c = palette(color);
+    }
+    title(text) {
+        this.write(`\n  ${this.c.bold(text)}\n\n`);
+    }
+    line(status, label, detail) {
+        this.write(`${this.fit(this.row(status, label, detail))}\n`);
+    }
+    plan(steps) {
+        this.steps = steps.map((step) => ({ ...step, status: "pending" }));
+        this.render();
+    }
+    start(id, detail) {
+        const step = this.step(id);
+        step.status = "active";
+        step.startedAt = Date.now();
+        if (detail !== undefined)
+            step.detail = detail;
+        // Animate only while something is running; unref so a finished run exits.
+        this.timer ??= setInterval(() => { this.frame++; this.render(); }, 80);
+        this.timer.unref?.();
+        this.render();
+    }
+    done(id, detail) {
+        const step = this.step(id);
+        step.status = "done";
+        step.detail = detail;
+        this.settle();
+    }
+    fail(id, message) {
+        const step = this.step(id);
+        step.status = "failed";
+        step.detail = message.split("\n")[0];
+        this.settle();
+    }
+    questions(intro) {
+        this.write(`\n  ${this.c.dim(intro)}\n\n`);
+    }
+    prompt(label, hint) {
+        return `  ${this.c.bold(label)}${hint ? `  ${this.c.dim(hint)}` : ""}\n  ${this.c.cyan("›")} `;
+    }
+    answered(label, detail) {
+        // Replace the two prompt lines with a confirmation.
+        this.write(`\x1b[2F\x1b[J${this.fit(this.row("done", label, detail))}\n`);
+    }
+    rejected(message) {
+        this.write(`\x1b[2F\x1b[J  ${this.c.yellow("!")} ${message}\n`);
+    }
+    ready(headline, items, extra = {}) {
+        this.stop();
+        this.write(`\n  ${this.c.green("✓")} ${this.c.bold(headline)}\n`);
+        if (extra.about)
+            this.write(`\n${extra.about.map((line) => `  ${line}`).join("\n")}\n`);
+        items.forEach((item, index) => {
+            // Values are never truncated: they're meant to be copied. Each line is its own command.
+            const value = item.value.split("\n").map((line) => `     ${this.c.bold(line)}`).join("\n");
+            this.write(`\n  ${this.c.cyan(String(index + 1))}  ${item.label}\n${value}\n`);
+        });
+        if (extra.footer)
+            this.write(`\n  ${this.c.dim(extra.footer)}\n`);
+        this.write("\n");
+        this.flushWarnings();
+    }
+    warn(text) {
+        this.warnings.push(text);
+    }
+    finish() {
+        this.stop();
+        this.flushWarnings();
+    }
+    settle() {
+        if (!this.steps.some((step) => step.status === "active"))
+            this.stop();
+        this.render();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    flushWarnings() {
+        for (const text of this.warnings.splice(0))
+            this.write(`  ${this.c.yellow("!")} ${text}\n`);
+    }
+    render() {
+        const lines = this.steps.map((step) => this.fit(this.row(step.status, step.label, this.detailFor(step))));
+        // Back to the top of the checklist and redraw it; lines never wrap, so the count holds.
+        const rewind = this.rendered > 0 ? `\x1b[${this.rendered}F` : "";
+        this.write(`${rewind}${lines.map((line) => `\x1b[2K${line}\n`).join("")}`);
+        this.rendered = lines.length;
+    }
+    detailFor(step) {
+        if (step.status !== "active")
+            return step.detail;
+        const seconds = Math.floor((Date.now() - (step.startedAt ?? Date.now())) / 1000);
+        const elapsed = `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+        return step.detail ? `${step.detail} · ${elapsed}` : elapsed;
+    }
+    row(status, label, detail) {
+        const glyph = status === "active" ? this.c.cyan(SPINNER[this.frame % SPINNER.length]) :
+            status === "done" ? this.c.green(GLYPH.done) :
+                status === "failed" ? this.c.red(GLYPH.failed) :
+                    this.c.dim(GLYPH[status]);
+        const text = status === "pending" ? this.c.dim(label) : status === "failed" ? this.c.red(label) : label;
+        const segments = [{ plain: "  ", styled: "  " }, { plain: "x", styled: glyph }, { plain: " ", styled: " " }, { plain: label, styled: text }];
+        if (detail) {
+            const pad = " ".repeat(Math.max(2, LABEL_WIDTH - label.length));
+            segments.push({ plain: pad, styled: pad }, { plain: detail, styled: status === "failed" ? this.c.red(detail) : this.c.dim(detail) });
+        }
+        return segments;
+    }
+    /** Joins styled segments, truncated by their visible width so a line never wraps. */
+    fit(segments) {
+        let room = Math.max(10, this.columns() - 1);
+        let out = "";
+        for (const segment of segments) {
+            if (room <= 0)
+                break;
+            if (segment.plain.length <= room) {
+                out += segment.styled;
+                room -= segment.plain.length;
+            }
+            else {
+                out += this.c.dim(`${segment.plain.slice(0, Math.max(0, room - 1))}…`);
+                room = 0;
+            }
+        }
+        return out;
+    }
+    step(id) {
+        const step = this.steps.find((entry) => entry.id === id);
+        if (!step)
+            throw new Error(`unknown step ${id}`);
+        return step;
+    }
+}
+/** Logs, CI, and unattended installs: one plain line per event, no escape codes. */
+export class PlainUi {
+    write;
+    interactive = false;
+    labels = new Map();
+    constructor(write = (text) => process.stdout.write(text)) {
+        this.write = write;
+    }
+    title(text) { this.write(`${text}\n`); }
+    line(status, label, detail) {
+        this.write(`${status === "done" ? "ok" : status === "failed" ? "FAILED" : "--"} ${label}${detail ? `: ${detail}` : ""}\n`);
+    }
+    plan(steps) { this.labels = new Map(steps.map((step) => [step.id, step.label])); }
+    start(id, detail) { this.write(`.. ${this.labels.get(id) ?? id}${detail ? `: ${detail}` : ""}\n`); }
+    done(id, detail) { this.write(`ok ${this.labels.get(id) ?? id}${detail ? `: ${detail}` : ""}\n`); }
+    fail(id, message) { this.write(`FAILED ${this.labels.get(id) ?? id}: ${message}\n`); }
+    questions(intro) { this.write(`${intro}\n`); }
+    prompt(label, hint) { return `${label}${hint ? ` (${hint})` : ""}: `; }
+    answered(label, detail) { this.write(`ok ${label}${detail ? `: ${detail}` : ""}\n`); }
+    rejected(message) { this.write(`!! ${message}\n`); }
+    ready(headline, items, extra = {}) {
+        this.write(`\n${headline}\n`);
+        if (extra.about)
+            this.write(`${extra.about.join(" ")}\n`);
+        for (const item of items)
+            this.write(`  ${item.label}: ${item.value.split("\n").join(" ; ")}\n`);
+        if (extra.footer)
+            this.write(`${extra.footer}\n`);
+    }
+    warn(text) { this.write(`!! ${text}\n`); }
+    finish() { }
+}
+/** Records events for tests. */
+export class RecordingUi {
+    interactive = false;
+    events = [];
+    title(text) { this.events.push(`title ${text}`); }
+    line(status, label, detail) { this.events.push(`line ${status} ${label}${detail ? ` | ${detail}` : ""}`); }
+    plan(steps) { this.events.push(`plan ${steps.map((step) => step.id).join(",")}`); }
+    start(id) { this.events.push(`start ${id}`); }
+    done(id, detail) { this.events.push(`done ${id}${detail ? ` | ${detail}` : ""}`); }
+    fail(id, message) { this.events.push(`fail ${id} | ${message}`); }
+    questions(intro) { this.events.push(`questions ${intro}`); }
+    prompt(label) { return label; }
+    answered(label, detail) { this.events.push(`answered ${label}${detail ? ` | ${detail}` : ""}`); }
+    rejected(message) { this.events.push(`rejected ${message}`); }
+    ready(headline, items, extra = {}) {
+        this.events.push(`ready ${headline}`, ...(extra.about ?? []).map((line) => `about ${line}`), ...items.map((item) => `item ${item.label} | ${item.value}`), ...(extra.footer ? [`footer ${extra.footer}`] : []));
+    }
+    warn(text) { this.events.push(`warn ${text}`); }
+    finish() { }
+}

package/dist/uninstall.js

@@ -0,0 +1,48 @@
+import { AUTOPILOT_PORT, MOTD_SCRIPT, NODE_AUTO_UPDATES, PATHS, SERVICES, USERS } from "./layout.js";
+import { readState } from "./state.js";
+/**
+ * `directionallylocal uninstall`: stops and removes every service and the installed
+ * software. Data and secrets stay unless --purge, so a later `up` picks up where it was.
+ * Docker and Tailscale stay installed; Tailscale only stops serving Autopilot.
+ */
+export async function uninstall(system, options = {}) {
+    const say = (line) => system.log(line);
+    const state = await readState(system);
+    say("== Services");
+    for (const service of [SERVICES.autopilot, SERVICES.hotcell, SERVICES.metadataBlock]) {
+        await system.run("systemctl", ["disable", "--now", service], { allowFailure: true });
+        await system.remove(`${PATHS.units}/${service}`);
+    }
+    await system.run("systemctl", ["daemon-reload"]);
+    await system.run("systemctl", ["reset-failed"], { allowFailure: true });
+    if (state?.access.mode === "tailscale" || (await system.probe("tailscale", ["version"])).code === 0) {
+        say("== Tailscale");
+        await system.run("tailscale", ["serve", "--https=443", `http://127.0.0.1:${AUTOPILOT_PORT}`, "off"], { allowFailure: true });
+    }
+    say("== Sandboxes and software");
+    // Hotcell's sandboxes are labeled; remove any left running so nothing keeps the box busy.
+    const containers = (await system.probe("docker", ["ps", "-aq", "--filter", "label=sbx.managed=true"])).stdout.split("\n").filter(Boolean);
+    if (containers.length > 0)
+        await system.run("docker", ["rm", "-f", ...containers], { allowFailure: true });
+    await system.remove(PATHS.root);
+    // Node.js stays installed, and so do Ubuntu's own automatic updates; only our addition goes.
+    await system.remove(NODE_AUTO_UPDATES);
+    await system.remove(MOTD_SCRIPT);
+    if (!options.purge) {
+        say(`Removed the services and software. Kept configuration and data (${PATHS.stateDir}, ${PATHS.autopilotEtc}, ${PATHS.hotcellEtc}, /var/lib/{autopilot,hotcell}); --purge deletes them.`);
+        return;
+    }
+    say("== Configuration, data, and accounts (--purge)");
+    if (state?.image)
+        await system.run("docker", ["image", "rm", state.image], { allowFailure: true });
+    const volumes = (await system.probe("docker", ["volume", "ls", "-q", "--filter", "label=sbx.managed=true"])).stdout.split("\n").filter(Boolean);
+    if (volumes.length > 0)
+        await system.run("docker", ["volume", "rm", ...volumes], { allowFailure: true });
+    for (const path of [PATHS.stateDir, PATHS.autopilotEtc, PATHS.hotcellEtc, PATHS.autopilotHome, PATHS.hotcellHome])
+        await system.remove(path);
+    for (const user of [USERS.autopilot, USERS.hotcell]) {
+        if ((await system.probe("id", ["-u", user])).code === 0)
+            await system.run("userdel", [user], { allowFailure: true });
+    }
+    say("Removed everything directionallylocal installed. Docker and Tailscale are still installed.");
+}