arelos 0.1.0

package/dist/services.js

@@ -0,0 +1,56 @@
+/**
+ * Ties together plist rendering + writing + launchd bootstrap (spec §1 Step 11,
+ * §3.1 Repair). Also used by `--no-service` dry runs, which stop before the
+ * launchctl calls (see install.ts).
+ */
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { bootstrapService, kickstartService } from "./launchd.js";
+import { VAULT_LABEL, WEB_LABEL, launchAgentsDir, plistPath } from "./paths.js";
+import { renderPlistTemplate } from "./plist.js";
+export function renderServicePlists(installDir) {
+    const specs = [
+        { label: WEB_LABEL, templateFile: "com.arelos.web.plist.tmpl" },
+        { label: VAULT_LABEL, templateFile: "com.arelos.vault.plist.tmpl" },
+    ];
+    return specs.map(({ label, templateFile }) => {
+        const templatePath = join(installDir, "scripts", "service", templateFile);
+        if (!existsSync(templatePath)) {
+            throw new Error(`Missing plist template: ${templatePath}`);
+        }
+        const template = readFileSync(templatePath, "utf8");
+        const xml = renderPlistTemplate(template, installDir);
+        return { label, templatePath, targetPath: plistPath(label), xml };
+    });
+}
+/** Write rendered plists to ~/Library/LaunchAgents and chmod the run scripts. */
+export function installServiceFiles(installDir) {
+    mkdirSync(launchAgentsDir(), { recursive: true });
+    const rendered = renderServicePlists(installDir);
+    for (const svc of rendered) {
+        writeFileSync(svc.targetPath, svc.xml);
+    }
+    for (const script of ["run-web.sh", "run-vault.sh"]) {
+        const p = join(installDir, "scripts", "service", script);
+        if (existsSync(p))
+            chmodSync(p, 0o755);
+    }
+    return rendered;
+}
+/** Bootstrap + kickstart both services (idempotent bootout-then-bootstrap). */
+export async function bootstrapAndStart() {
+    const errors = [];
+    const webRes = await bootstrapService(WEB_LABEL);
+    if (!webRes.ok)
+        errors.push(`web bootstrap: ${webRes.stderr.trim()}`);
+    const vaultRes = await bootstrapService(VAULT_LABEL);
+    if (!vaultRes.ok)
+        errors.push(`vault bootstrap: ${vaultRes.stderr.trim()}`);
+    const webKick = await kickstartService(WEB_LABEL);
+    if (!webKick.ok)
+        errors.push(`web kickstart: ${webKick.stderr.trim()}`);
+    const vaultKick = await kickstartService(VAULT_LABEL);
+    if (!vaultKick.ok)
+        errors.push(`vault kickstart: ${vaultKick.stderr.trim()}`);
+    return { web: webRes.ok && webKick.ok, vault: vaultRes.ok && vaultKick.ok, errors };
+}

package/dist/status.js

@@ -0,0 +1,42 @@
+/**
+ * `rlo status` (spec §2). Config summary + service state + port probes +
+ * git revision / behind-origin check.
+ */
+import pc from "picocolors";
+import { readConfig } from "./config.js";
+import { checkVaultHealth, checkWebHealth } from "./health.js";
+import { getServiceStatus } from "./launchd.js";
+import { currentRevision, isBehindOrigin } from "./repo.js";
+import { VAULT_LABEL, WEB_LABEL } from "./paths.js";
+export async function statusCommand() {
+    const config = readConfig();
+    if (!config) {
+        console.error("No Arel OS install found. Run `npx arelos` to install.");
+        return 1;
+    }
+    console.log(pc.bold(config.displayName));
+    console.log(`  Install dir: ${config.installDir}`);
+    console.log(`  Vault path:  ${config.vaultPath}`);
+    console.log(`  Web port:    ${config.webPort}`);
+    console.log(`  Vault port:  ${config.vaultPort}`);
+    console.log("");
+    const [webSvc, vaultSvc, webHealth, vaultHealth, rev, behind] = await Promise.all([
+        getServiceStatus(WEB_LABEL),
+        getServiceStatus(VAULT_LABEL),
+        checkWebHealth(config.webPort),
+        checkVaultHealth(config.vaultPort),
+        currentRevision(config.installDir),
+        isBehindOrigin(config.installDir),
+    ]);
+    printService("web", webSvc, webHealth.up, webHealth.status ? `HTTP ${webHealth.status}` : webHealth.error);
+    printService("vault", vaultSvc, vaultHealth.up, vaultHealth.up ? `displayName=${vaultHealth.displayName}` : vaultHealth.error);
+    console.log("");
+    console.log(`  Revision: ${rev ?? "unknown"}${behind === true ? pc.yellow(" (behind origin — run arelos update)") : behind === false ? " (up to date)" : ""}`);
+    return 0;
+}
+function printService(name, svc, up, detail) {
+    const stateLabel = up ? pc.green("up") : pc.red("down");
+    const loadedLabel = svc.loaded ? "loaded" : "not loaded";
+    const pidLabel = svc.pid ? `pid ${svc.pid}` : "no pid";
+    console.log(`  ${name.padEnd(6)} ${stateLabel}  (${loadedLabel}, ${pidLabel})  ${detail ?? ""}`);
+}

package/dist/uninstall.js

@@ -0,0 +1,84 @@
+/**
+ * `rlo uninstall` (spec §2). Vault deletion is gated behind confirm + a
+ * literal typed "DELETE" — a single yes can never destroy notes (spec §3.2,
+ * acceptance criterion 5). This module separates the pure decision logic
+ * (shouldDeleteVault) from the destructive I/O (performUninstall) so the
+ * gate can be unit tested without touching a filesystem.
+ */
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { existsSync, rmSync, unlinkSync } from "node:fs";
+import { readConfig } from "./config.js";
+import { bootoutService } from "./launchd.js";
+import { VAULT_LABEL, WEB_LABEL, plistPath, configPath } from "./paths.js";
+/**
+ * Pure gate: vault is deleted iff confirmed AND the typed word is exactly
+ * "DELETE". Any other input (including case variants, whitespace, empty)
+ * preserves the vault. This is the load-bearing safety rule from the spec —
+ * kept as an isolated pure function so it's trivially unit-testable.
+ */
+export function shouldDeleteVault(confirmed, typedWord) {
+    return confirmed === true && typedWord === "DELETE";
+}
+export async function uninstallCommand() {
+    const config = readConfig();
+    if (!config) {
+        console.error("No Arel OS install found. Nothing to uninstall.");
+        return 1;
+    }
+    p.intro(pc.bold("Uninstall Arel OS"));
+    await bootoutService(WEB_LABEL);
+    await bootoutService(VAULT_LABEL);
+    for (const label of [WEB_LABEL, VAULT_LABEL]) {
+        const path = plistPath(label);
+        if (existsSync(path))
+            unlinkSync(path);
+    }
+    p.log.success("Services stopped and unregistered.");
+    const removeInstallDir = await p.confirm({
+        message: `Remove the install directory ${config.installDir}?`,
+        initialValue: false,
+    });
+    if (p.isCancel(removeInstallDir)) {
+        p.cancel("Uninstall stopped after removing services.");
+        return 1;
+    }
+    let deleteVault = false;
+    const vaultConfirm = await p.confirm({
+        message: `Also delete your vault at ${config.vaultPath}? This erases all your notes.`,
+        initialValue: false,
+    });
+    if (!p.isCancel(vaultConfirm) && vaultConfirm) {
+        const typed = await p.text({
+            message: 'Type DELETE (all caps) to confirm permanent vault deletion, or anything else to cancel:',
+        });
+        const typedWord = p.isCancel(typed) ? "" : String(typed);
+        deleteVault = shouldDeleteVault(true, typedWord);
+        if (!deleteVault) {
+            p.log.message("Vault deletion cancelled — vault preserved.");
+        }
+    }
+    const removeConfig = await p.confirm({
+        message: "Remove the saved config (~/.arelos/config.json)? Keeping it lets a reinstall remember your settings.",
+        initialValue: false,
+    });
+    performUninstall(config.installDir, config.vaultPath, {
+        removeInstallDir: !p.isCancel(removeInstallDir) && removeInstallDir,
+        deleteVault,
+        removeConfig: !p.isCancel(removeConfig) && removeConfig,
+    });
+    p.outro(pc.green("Arel OS uninstalled." + (deleteVault ? "" : " Your vault was preserved.")));
+    return 0;
+}
+/** Destructive I/O, isolated from prompt flow for testability via direct calls with explicit choices. */
+export function performUninstall(installDir, vaultPath, choices) {
+    if (choices.deleteVault && existsSync(vaultPath)) {
+        rmSync(vaultPath, { recursive: true, force: true });
+    }
+    if (choices.removeInstallDir && existsSync(installDir)) {
+        rmSync(installDir, { recursive: true, force: true });
+    }
+    if (choices.removeConfig && existsSync(configPath())) {
+        unlinkSync(configPath());
+    }
+}

package/dist/update.js

@@ -0,0 +1,59 @@
+/**
+ * `rlo update` (spec §2). git pull --ff-only + bun install/build + restart +
+ * re-health-check. Config file untouched.
+ */
+import pc from "picocolors";
+import { ensureBun } from "./bun-setup.js";
+import { readConfig } from "./config.js";
+import { runStreaming } from "./exec.js";
+import { waitForHealthy } from "./health.js";
+import { pullLatest } from "./repo.js";
+import { bootstrapAndStart, installServiceFiles } from "./services.js";
+export async function updateCommand() {
+    const config = readConfig();
+    if (!config) {
+        console.error("No Arel OS install found. Run `npx arelos` to install.");
+        return 1;
+    }
+    return runUpdate(config);
+}
+export async function runUpdate(config) {
+    console.log(`Updating ${config.installDir}…`);
+    const pull = await pullLatest(config.installDir);
+    if (pull.dirty) {
+        console.error(pc.red("Working tree has uncommitted changes — refusing to pull. Run `git -C " +
+            `${config.installDir} stash` +
+            "` first."));
+        return 1;
+    }
+    if (pull.code !== 0) {
+        console.error(pc.red(`git pull failed: ${pull.stderr}`));
+        return 1;
+    }
+    const bunResult = await ensureBun();
+    if ("error" in bunResult) {
+        console.error(pc.red(bunResult.error));
+        return 1;
+    }
+    const installRes = await runStreaming(bunResult.bunBin, ["install"], { cwd: config.installDir });
+    if (installRes.code !== 0) {
+        console.error(pc.red("bun install failed."));
+        return 1;
+    }
+    const buildRes = await runStreaming(bunResult.bunBin, ["run", "build"], { cwd: config.installDir });
+    if (buildRes.code !== 0) {
+        console.warn(pc.yellow("bun run build failed — keeping old dist/. The web service will keep serving it."));
+    }
+    installServiceFiles(config.installDir);
+    const bootstrap = await bootstrapAndStart();
+    for (const e of bootstrap.errors)
+        console.error(pc.yellow(e));
+    console.log("Restarting services and re-checking health…");
+    const health = await waitForHealthy(config.webPort, config.vaultPort);
+    if (!health.healthy) {
+        console.error(pc.red("Health check timed out after update. Run `arelos logs`."));
+        return 1;
+    }
+    console.log(pc.green("Update complete. Arel OS is healthy."));
+    return 0;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "arelos",
+  "version": "0.1.0",
+  "description": "Installer and service manager for a self-hosted Arel OS on macOS.",
+  "type": "module",
+  "bin": {
+    "arelos": "dist/cli.js",
+    "rlo": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "pretest": "tsc -p tsconfig.test.json",
+    "test": "node --test dist-test/test/*.test.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.7.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vishmathpati/arel-os.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/vishmathpati/arel-os#readme",
+  "bugs": {
+    "url": "https://github.com/vishmathpati/arel-os/issues"
+  }
+}