arelos 0.1.0

package/dist/bun-setup.js

@@ -0,0 +1,66 @@
+/**
+ * Bun install/detection (spec §1 Step 7). npx only guarantees Node — Bun is
+ * installed during setup if missing, via the official installer script.
+ */
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { commandExists, runCapture, runStreaming } from "./exec.js";
+const MIN_BUN_MAJOR = 1;
+const MIN_BUN_MINOR = 1;
+export function resolvedBunPath() {
+    return join(homedir(), ".bun", "bin", "bun");
+}
+export function findBun() {
+    if (commandExists("bun"))
+        return "bun";
+    const resolved = resolvedBunPath();
+    if (existsSync(resolved))
+        return resolved;
+    return null;
+}
+export function parseBunVersion(versionOutput) {
+    const match = versionOutput.trim().match(/^(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return { major: Number(match[1]), minor: Number(match[2]) };
+}
+export function meetsMinimumVersion(version) {
+    if (!version)
+        return false;
+    if (version.major !== MIN_BUN_MAJOR)
+        return version.major > MIN_BUN_MAJOR;
+    return version.minor >= MIN_BUN_MINOR;
+}
+export async function bunVersion(bunBin) {
+    const res = await runCapture(bunBin, ["--version"]);
+    if (res.code !== 0)
+        return null;
+    return parseBunVersion(res.stdout);
+}
+export const MANUAL_BUN_INSTALL_HINT = "curl -fsSL https://bun.sh/install | bash";
+/** Install Bun via the official installer script. Returns the resolved bun binary path, or null on failure. */
+export async function installBun() {
+    const res = await runStreaming("bash", ["-c", "curl -fsSL https://bun.sh/install | bash"]);
+    if (res.code !== 0)
+        return null;
+    const resolved = resolvedBunPath();
+    return existsSync(resolved) ? resolved : null;
+}
+/** Ensure a usable Bun is present, installing it if missing. Returns the bun binary to invoke. */
+export async function ensureBun() {
+    let bunBin = findBun();
+    if (!bunBin) {
+        bunBin = await installBun();
+        if (!bunBin) {
+            return { error: `Bun install failed. Install manually: ${MANUAL_BUN_INSTALL_HINT}` };
+        }
+    }
+    const version = await bunVersion(bunBin);
+    if (!meetsMinimumVersion(version)) {
+        return {
+            error: `Bun ${version ? `${version.major}.${version.minor}` : "(unknown)"} found, but >= ${MIN_BUN_MAJOR}.${MIN_BUN_MINOR} is required. Reinstall: ${MANUAL_BUN_INSTALL_HINT}`,
+        };
+    }
+    return { bunBin };
+}

package/dist/cli-args.js

@@ -0,0 +1,62 @@
+export function parseInstallFlags(argv) {
+    const flags = {
+        yes: false,
+        noService: false,
+        localRepo: null,
+        displayName: null,
+        installDir: null,
+        vaultPath: null,
+        webPort: null,
+        vaultPort: null,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--yes":
+            case "--defaults":
+                flags.yes = true;
+                break;
+            case "--no-service":
+                flags.noService = true;
+                break;
+            case "--local-repo":
+                flags.localRepo = argv[++i] ?? null;
+                break;
+            case "--display-name":
+                flags.displayName = argv[++i] ?? null;
+                break;
+            case "--install-dir":
+                flags.installDir = argv[++i] ?? null;
+                break;
+            case "--vault-path":
+                flags.vaultPath = argv[++i] ?? null;
+                break;
+            case "--web-port":
+                flags.webPort = Number(argv[++i]);
+                break;
+            case "--vault-port":
+                flags.vaultPort = Number(argv[++i]);
+                break;
+            default:
+                break;
+        }
+    }
+    return flags;
+}
+export function parseLogsFlags(argv) {
+    let which = "both";
+    let follow = false;
+    let lines = 100;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "web" || arg === "vault")
+            which = arg;
+        else if (arg === "-f" || arg === "--follow")
+            follow = true;
+        else if (arg === "-n")
+            lines = Number(argv[++i]) || 100;
+        else if (arg.startsWith("-n="))
+            lines = Number(arg.slice(3)) || 100;
+    }
+    return { which, follow, lines };
+}

package/dist/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * arelos — the Arel OS installer/service manager. `npx arelos` with no subcommand
+ * runs the interactive install flow (rlo-cli-spec.md §1).
+ */
+if (process.platform !== "darwin") {
+    console.error("Arel OS currently supports macOS only.");
+    process.exit(1);
+}
+import { parseInstallFlags, parseLogsFlags } from "./cli-args.js";
+import { runInstall } from "./install.js";
+import { logsCommand } from "./logs.js";
+import { statusCommand } from "./status.js";
+import { uninstallCommand } from "./uninstall.js";
+import { updateCommand } from "./update.js";
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
+        printHelp();
+        return 0;
+    }
+    // No subcommand given, or the first token is a flag (e.g. `arelos --yes ...`)
+    // rather than a subcommand name — both mean "install". Anything else in
+    // the known set consumes its name as the subcommand; everything after it
+    // is passed through as that subcommand's own args.
+    const knownSubcommands = new Set(["install", "status", "update", "uninstall", "logs"]);
+    const firstIsFlag = argv.length === 0 || argv[0].startsWith("-");
+    const firstIsKnown = argv.length > 0 && knownSubcommands.has(argv[0]);
+    if (!firstIsFlag && !firstIsKnown) {
+        console.error(`Unknown command: ${argv[0]}\n`);
+        printHelp();
+        return 1;
+    }
+    const hasExplicitSubcommand = firstIsKnown;
+    const subcommand = hasExplicitSubcommand ? argv[0] : "install";
+    const rest = hasExplicitSubcommand ? argv.slice(1) : argv;
+    switch (subcommand) {
+        case "install":
+            return runInstall(rest, parseInstallFlags(rest));
+        case "status":
+            return statusCommand();
+        case "update":
+            return updateCommand();
+        case "uninstall":
+            return uninstallCommand();
+        case "logs":
+            return logsCommand(parseLogsFlags(rest));
+        default:
+            console.error(`Unknown command: ${subcommand}\n`);
+            printHelp();
+            return 1;
+    }
+}
+function printHelp() {
+    console.log(`arelos — install and manage a self-hosted Arel OS
+
+Usage:
+  npx arelos              Install (interactive)
+  arelos status            Show install + service status
+  arelos update             git pull + rebuild + restart
+  arelos uninstall          Stop services, optionally remove install dir / vault
+  arelos logs [web|vault]   Tail service logs (-f to follow, -n <N> for line count)
+
+Install flags (non-interactive):
+  --yes, --defaults        Skip prompts, use defaults/flags below
+  --display-name <name>
+  --install-dir <path>
+  --vault-path <path>
+  --web-port <port>
+  --vault-port <port>
+  --no-service              Skip launchd bootstrap (for dry runs / development)
+  --local-repo <path>       Use a local path instead of cloning from GitHub
+`);
+}
+main()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    console.error(err instanceof Error ? err.stack ?? err.message : err);
+    process.exit(1);
+});

package/dist/config.js

@@ -0,0 +1,30 @@
+/**
+ * rlo's own config read/write helpers — mirrors the shape read by
+ * server/config.ts (portability-contract.md §1.1/§1.2). rlo is the writer,
+ * the app is the reader; this is the one contract between them.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { configPath } from "./paths.js";
+export function readConfig() {
+    const p = configPath();
+    if (!existsSync(p))
+        return null;
+    const raw = JSON.parse(readFileSync(p, "utf8"));
+    if (typeof raw !== "object" || raw === null || raw.version !== 1) {
+        throw new Error(`Invalid or unsupported config at ${p}: expected { version: 1, ... }`);
+    }
+    return raw;
+}
+/**
+ * Write config atomically: write to a .tmp sibling then rename over the
+ * target. Guarantees a reader never observes a partially written file
+ * (spec §3.2 "Config write is last-writer-wins; never partially written").
+ */
+export function writeConfig(config) {
+    const p = configPath();
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = `${p}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    renameSync(tmp, p);
+}

package/dist/exec.js

@@ -0,0 +1,45 @@
+/**
+ * Thin wrappers over node:child_process so the rest of the CLI never calls
+ * execFileSync/spawn directly — keeps side effects easy to find and stub.
+ */
+import { execFileSync, spawn } from "node:child_process";
+/** Run a command to completion, streaming its stdout/stderr to ours. */
+export function runStreaming(cmd, args, opts = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"], ...opts });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (d) => {
+            stdout += d.toString();
+            process.stdout.write(d);
+        });
+        child.stderr?.on("data", (d) => {
+            stderr += d.toString();
+            process.stderr.write(d);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    });
+}
+/** Run a command silently, capturing output, never throwing on nonzero exit. */
+export function runCapture(cmd, args, opts = {}) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"], ...opts });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (d) => (stdout += d.toString()));
+        child.stderr?.on("data", (d) => (stderr += d.toString()));
+        child.on("error", (err) => resolve({ code: 1, stdout, stderr: String(err) }));
+        child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    });
+}
+/** True if `cmd` exists on PATH and runs without error (e.g. `git --version`). */
+export function commandExists(cmd, versionArgs = ["--version"]) {
+    try {
+        execFileSync(cmd, versionArgs, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/health.js

@@ -0,0 +1,58 @@
+/**
+ * HTTP health probes for the vault (`/config`) and web (`/`) services
+ * (spec §1 Step 12, §2 rlo status). Pure fetch-based, no deps.
+ */
+async function fetchWithTimeout(url, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function checkVaultHealth(vaultPort, timeoutMs = 3000) {
+    try {
+        const res = await fetchWithTimeout(`http://localhost:${vaultPort}/config`, timeoutMs);
+        if (!res.ok)
+            return { up: false, error: `HTTP ${res.status}` };
+        const body = (await res.json());
+        return { up: true, displayName: body.displayName, vaultPort: body.vaultPort };
+    }
+    catch (err) {
+        return { up: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export async function checkWebHealth(webPort, timeoutMs = 3000) {
+    try {
+        const res = await fetchWithTimeout(`http://localhost:${webPort}/`, timeoutMs);
+        return { up: res.ok, status: res.status };
+    }
+    catch (err) {
+        return { up: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Poll both services until healthy or timeout. Used post-install/update
+ * (spec §1 Step 12): vault must serve /config with the right port, web must
+ * return 200/HTML. The web service runs a full build on first start, so the
+ * default timeout is generous.
+ */
+export async function waitForHealthy(webPort, vaultPort, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 60_000;
+    const intervalMs = opts.intervalMs ?? 1500;
+    const start = Date.now();
+    let vault = { up: false };
+    let web = { up: false };
+    while (Date.now() - start < timeoutMs) {
+        vault = await checkVaultHealth(vaultPort);
+        web = await checkWebHealth(webPort);
+        opts.onTick?.(Date.now() - start);
+        if (vault.up && vault.vaultPort === vaultPort && web.up) {
+            return { healthy: true, vault, web };
+        }
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    return { healthy: false, vault, web };
+}

package/dist/install-plan.js

@@ -0,0 +1,66 @@
+/**
+ * Pure planning/validation logic for the install flow, factored out of the
+ * interactive prompt wiring in install.ts so it can be unit tested without
+ * a TTY. Each function here validates one prompt's answer per rlo-cli-spec §1.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { accessSync, constants } from "node:fs";
+import { dirname } from "node:path";
+import { expandHome } from "./paths.js";
+import { findFreePort, isValidPort } from "./ports.js";
+export const DEFAULTS = {
+    displayName: "Arel OS",
+    installDir: "~/ArelOS",
+    vaultPathSuffix: "vault",
+    webPort: 1347,
+    vaultPort: 5274,
+};
+export function normalizeDisplayName(input) {
+    const trimmed = input.trim();
+    return trimmed.length > 0 ? trimmed : DEFAULTS.displayName;
+}
+export function checkInstallDir(rawPath) {
+    const path = expandHome(rawPath);
+    const parent = dirname(path);
+    let parentWritable = true;
+    try {
+        accessSync(existsSync(parent) ? parent : dirname(parent), constants.W_OK);
+    }
+    catch {
+        parentWritable = false;
+    }
+    const exists = existsSync(path);
+    let nonEmpty = false;
+    let isPriorArelosInstall = false;
+    if (exists && statSync(path).isDirectory()) {
+        const entries = readdirSync(path);
+        nonEmpty = entries.length > 0;
+        isPriorArelosInstall = entries.includes(".git") && entries.includes("package.json");
+    }
+    return { path, parentWritable, exists, nonEmpty, isPriorArelosInstall };
+}
+export function defaultVaultPath(installDir) {
+    return `${expandHome(installDir)}/${DEFAULTS.vaultPathSuffix}`;
+}
+/** Validate a chosen port and, if it's taken, propose the next free one. */
+export async function resolvePort(requested) {
+    if (!isValidPort(requested)) {
+        throw new Error(`Port ${requested} is invalid — must be an integer between 1024 and 65535.`);
+    }
+    const { isPortFree } = await import("./ports.js");
+    const free = await isPortFree(requested);
+    if (free)
+        return { requested, resolved: requested, wasFree: true };
+    const suggestion = await findFreePort(requested + 1);
+    return { requested, resolved: suggestion, wasFree: false };
+}
+export function toArelConfig(answers) {
+    return {
+        version: 1,
+        displayName: answers.displayName,
+        installDir: expandHome(answers.installDir),
+        vaultPath: expandHome(answers.vaultPath),
+        webPort: answers.webPort,
+        vaultPort: answers.vaultPort,
+    };
+}