arelos 0.1.0 → 0.1.1

package/dist/config.js

@@ -5,7 +5,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { configPath } from "./paths.js";
+import { configPath, LEGACY_VAULT_LABEL, LEGACY_WEB_LABEL } from "./paths.js";
 export function readConfig() {
     const p = configPath();
     if (!existsSync(p))
@@ -28,3 +28,11 @@ export function writeConfig(config) {
     writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
     renameSync(tmp, p);
 }
+/**
+ * The labels to actually operate on for an existing install: config.serviceLabels
+ * when present (installs made after this fix), else the legacy fixed labels
+ * (installs made before it — backward compat per spec).
+ */
+export function resolveServiceLabels(config) {
+    return config.serviceLabels ?? { web: LEGACY_WEB_LABEL, vault: LEGACY_VAULT_LABEL };
+}

package/dist/install-plan.js

@@ -6,7 +6,7 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { accessSync, constants } from "node:fs";
 import { dirname } from "node:path";
-import { expandHome } from "./paths.js";
+import { deriveServiceLabels, expandHome } from "./paths.js";
 import { findFreePort, isValidPort } from "./ports.js";
 export const DEFAULTS = {
     displayName: "Arel OS",
@@ -55,12 +55,14 @@ export async function resolvePort(requested) {
     return { requested, resolved: suggestion, wasFree: false };
 }
 export function toArelConfig(answers) {
+    const installDir = expandHome(answers.installDir);
     return {
         version: 1,
         displayName: answers.displayName,
-        installDir: expandHome(answers.installDir),
+        installDir,
         vaultPath: expandHome(answers.vaultPath),
         webPort: answers.webPort,
         vaultPort: answers.vaultPort,
+        serviceLabels: deriveServiceLabels(installDir),
     };
 }

package/dist/install.js

@@ -14,7 +14,8 @@ import { bootstrapAndStart, installServiceFiles } from "./services.js";
 import { cloneRepo, isGitCheckout } from "./repo.js";
 import { ensureEnvFile, ensureLogsDir, scaffoldVault, TemplateVaultMissingError } from "./scaffold.js";
 import { runRepairMenu } from "./repair.js";
-import { configPath } from "./paths.js";
+import { configPath, deriveServiceLabels } from "./paths.js";
+import { listLoadedArelosLabels } from "./launchd.js";
 export async function runInstall(argv, flags) {
     // Step 0 — Preflight & existing-install detection.
     if (process.platform !== "darwin") {
@@ -125,11 +126,24 @@ export async function runInstall(argv, flags) {
         p.outro(pc.green("Dry-run install complete (no services started)."));
         return 0;
     }
+    // Step 10.5 — Preflight: check for a same-slug reinstall vs. an unrelated
+    // Arel OS install already holding other com.arelos.* labels.
+    const labels = config.serviceLabels ?? deriveServiceLabels(installDir);
+    const loadedLabels = await listLoadedArelosLabels();
+    const oursAlreadyLoaded = loadedLabels.filter((l) => l === labels.web || l === labels.vault);
+    const othersLoaded = loadedLabels.filter((l) => l !== labels.web && l !== labels.vault);
+    if (oursAlreadyLoaded.length > 0) {
+        log(flags.yes, `Services for this install dir are already loaded (${oursAlreadyLoaded.join(", ")}) — will bootout and re-bootstrap.`);
+    }
+    if (othersLoaded.length > 0) {
+        console.error(pc.yellow(`Another Arel OS install is already running with its own services (${othersLoaded.join(", ")}). ` +
+            "This install uses its own unique labels, so it will not disturb that install."));
+    }
     // Step 11 — Generate + bootstrap launchd services.
     const svcSpin = spinner(flags.yes);
     svcSpin.start("Registering background services…");
-    installServiceFiles(installDir);
-    const bootstrapResult = await bootstrapAndStart();
+    installServiceFiles(installDir, labels);
+    const bootstrapResult = await bootstrapAndStart(labels);
     if (bootstrapResult.errors.length > 0) {
         svcSpin.stop("Service registration had errors.");
         for (const e of bootstrapResult.errors)

package/dist/launchd.js

@@ -2,6 +2,29 @@
  * launchctl wrapper (modern per-GUI-domain bootstrap/bootout/kickstart API).
  * Every op is idempotent per spec §3.2: bootout-then-bootstrap never errors
  * on "already loaded"; a --no-service dry run skips all of this.
+ *
+ * Field report conclusion — "Bootstrap failed: 5: Input/output error":
+ * launchd's errno 5 (EIO) here is a catch-all it surfaces for several distinct
+ * setup failures, not just "job already loaded". Two concrete causes were
+ * found and fixed in this codebase:
+ *   1. Label collision (the actual reported bug) — a second install on the
+ *      same Mac reused the fixed labels com.arelos.web/.vault. Bootstrapping
+ *      a plist under a label already claimed by a *different* plist path
+ *      (the first install's) is exactly the kind of state launchd reports as
+ *      an I/O error rather than a clean "already exists". Fixed by deriving a
+ *      per-installDir label (paths.ts deriveServiceLabels) so two installs
+ *      never share a label.
+ *   2. Missing log directory — the plists' StandardOutPath/StandardErrorPath
+ *      point at <installDir>/logs/service/*.log. If that directory doesn't
+ *      exist yet, launchd can fail to set up the job's stdio redirection at
+ *      bootstrap/first-spawn time. install.ts already called ensureLogsDir
+ *      before registering services, but repair.ts/update.ts funneled straight
+ *      into installServiceFiles without it — a real gap for any repair/update
+ *      run where logs/service/ had been deleted or never existed. Fixed by
+ *      making installServiceFiles itself create the directory unconditionally
+ *      (see services.ts), so all three callers get it for free.
+ * The domain string ("gui/<uid>") and the bootout-before-bootstrap idempotency
+ * pattern were checked and are correct as written — not a contributor here.
  */
 import { userInfo } from "node:os";
 import { runCapture } from "./exec.js";
@@ -44,3 +67,15 @@ export async function getServiceStatus(label) {
 export function guiDomainForTest() {
     return guiDomain();
 }
+/**
+ * All currently-loaded launchd labels starting with "com.arelos." — used by
+ * install preflight to detect a same-slug reinstall vs. an unrelated,
+ * still-running Arel OS install that grabbed different labels first.
+ */
+export async function listLoadedArelosLabels() {
+    const res = await runCapture("launchctl", ["list"]);
+    return res.stdout
+        .split("\n")
+        .map((l) => l.trim().split(/\s+/).pop())
+        .filter((label) => !!label && label.startsWith("com.arelos."));
+}

package/dist/paths.js

@@ -3,6 +3,7 @@
  * Everything here honors ARELOS_CONFIG_PATH so tests/dry-runs never touch
  * the real ~/.arelos.
  */
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 export function configPath() {
@@ -14,8 +15,30 @@ export function configDir() {
 export function launchAgentsDir() {
     return join(homedir(), "Library", "LaunchAgents");
 }
-export const WEB_LABEL = "com.arelos.web";
-export const VAULT_LABEL = "com.arelos.vault";
+/**
+ * Pre-per-install-label launchd labels. A second install on the same Mac used
+ * to collide on these fixed labels — see serviceLabels below for the fix.
+ * Kept as the fallback for configs written before this fix (spec: legacy
+ * compat) and as the thing preflight checks for "another install exists".
+ */
+export const LEGACY_WEB_LABEL = "com.arelos.web";
+export const LEGACY_VAULT_LABEL = "com.arelos.vault";
+/**
+ * Short stable hash of the resolved installDir: same dir -> same slug across
+ * reinstalls/repairs, different dirs -> different slugs, so two installs on
+ * one Mac never fight over the same launchd label.
+ */
+export function installSlug(installDir) {
+    return createHash("sha256").update(installDir).digest("hex").slice(0, 8);
+}
+/** Derive the unique per-install label pair from the resolved installDir. */
+export function deriveServiceLabels(installDir) {
+    const slug = installSlug(installDir);
+    return {
+        web: `com.arelos.${slug}.web`,
+        vault: `com.arelos.${slug}.vault`,
+    };
+}
 export function plistPath(label) {
     return join(launchAgentsDir(), `${label}.plist`);
 }

package/dist/plist.js

@@ -1,11 +1,12 @@
 /**
  * Plist template rendering (portability-contract.md §3.1). Templates ship at
- * `scripts/service/com.arelos.{web,vault}.plist.tmpl` in the app repo and
- * take a single {{INSTALL_DIR}} token — ports/vaultPath are read from config
- * at process start by the run-*.sh scripts / server, never baked into the plist.
+ * `scripts/service/{web,vault}.plist.tmpl` in the app repo and take two
+ * tokens — {{INSTALL_DIR}} and {{LABEL}} (the per-install launchd label from
+ * paths.ts deriveServiceLabels). Ports/vaultPath are read from config at
+ * process start by the run-*.sh scripts / server, never baked into the plist.
  */
-export function renderPlistTemplate(template, installDir) {
-    return template.split("{{INSTALL_DIR}}").join(installDir);
+export function renderPlistTemplate(template, installDir, label) {
+    return template.split("{{INSTALL_DIR}}").join(installDir).split("{{LABEL}}").join(label);
 }
 /** Basic structural sanity check without shelling out to `plutil` (used in unit tests; `plutil -lint` is used in the dry-run for the real macOS check). */
 export function looksLikeValidPlist(xml) {

package/dist/repair.js

@@ -5,6 +5,7 @@
  */
 import * as p from "@clack/prompts";
 import pc from "picocolors";
+import { resolveServiceLabels } from "./config.js";
 import { runUpdate } from "./update.js";
 import { waitForHealthy } from "./health.js";
 import { bootstrapAndStart, installServiceFiles } from "./services.js";
@@ -67,8 +68,9 @@ async function runRepair(existing) {
     }
     s.stop("Rebuilt.");
     s.start("Re-rendering and re-bootstrapping services…");
-    installServiceFiles(existing.installDir);
-    const bootstrap = await bootstrapAndStart();
+    const labels = resolveServiceLabels(existing);
+    installServiceFiles(existing.installDir, labels);
+    const bootstrap = await bootstrapAndStart(labels);
     s.stop(bootstrap.errors.length ? "Services re-registered with warnings." : "Services re-registered.");
     for (const e of bootstrap.errors)
         console.error(pc.yellow(e));

package/dist/services.js

@@ -6,12 +6,12 @@
 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 { deriveServiceLabels, launchAgentsDir, plistPath } from "./paths.js";
 import { renderPlistTemplate } from "./plist.js";
-export function renderServicePlists(installDir) {
+export function renderServicePlists(installDir, labels = deriveServiceLabels(installDir)) {
     const specs = [
-        { label: WEB_LABEL, templateFile: "com.arelos.web.plist.tmpl" },
-        { label: VAULT_LABEL, templateFile: "com.arelos.vault.plist.tmpl" },
+        { label: labels.web, templateFile: "web.plist.tmpl" },
+        { label: labels.vault, templateFile: "vault.plist.tmpl" },
     ];
     return specs.map(({ label, templateFile }) => {
         const templatePath = join(installDir, "scripts", "service", templateFile);
@@ -19,14 +19,22 @@ export function renderServicePlists(installDir) {
             throw new Error(`Missing plist template: ${templatePath}`);
         }
         const template = readFileSync(templatePath, "utf8");
-        const xml = renderPlistTemplate(template, installDir);
+        const xml = renderPlistTemplate(template, installDir, label);
         return { label, templatePath, targetPath: plistPath(label), xml };
     });
 }
 /** Write rendered plists to ~/Library/LaunchAgents and chmod the run scripts. */
-export function installServiceFiles(installDir) {
+export function installServiceFiles(installDir, labels = deriveServiceLabels(installDir)) {
     mkdirSync(launchAgentsDir(), { recursive: true });
-    const rendered = renderServicePlists(installDir);
+    // The plists' StandardOutPath/StandardErrorPath point at <installDir>/logs/service/*.log;
+    // launchd needs that directory to exist before it can bootstrap the job (a
+    // missing log dir is one confirmed cause of the "Bootstrap failed: 5:
+    // Input/output error" field report — see launchd.ts docstring). install.ts
+    // already calls ensureLogsDir before this, but repair/update funnel through
+    // here too, so guarantee it unconditionally rather than relying on callers
+    // to remember.
+    mkdirSync(join(installDir, "logs", "service"), { recursive: true });
+    const rendered = renderServicePlists(installDir, labels);
     for (const svc of rendered) {
         writeFileSync(svc.targetPath, svc.xml);
     }
@@ -38,18 +46,18 @@ export function installServiceFiles(installDir) {
     return rendered;
 }
 /** Bootstrap + kickstart both services (idempotent bootout-then-bootstrap). */
-export async function bootstrapAndStart() {
+export async function bootstrapAndStart(labels) {
     const errors = [];
-    const webRes = await bootstrapService(WEB_LABEL);
+    const webRes = await bootstrapService(labels.web);
     if (!webRes.ok)
         errors.push(`web bootstrap: ${webRes.stderr.trim()}`);
-    const vaultRes = await bootstrapService(VAULT_LABEL);
+    const vaultRes = await bootstrapService(labels.vault);
     if (!vaultRes.ok)
         errors.push(`vault bootstrap: ${vaultRes.stderr.trim()}`);
-    const webKick = await kickstartService(WEB_LABEL);
+    const webKick = await kickstartService(labels.web);
     if (!webKick.ok)
         errors.push(`web kickstart: ${webKick.stderr.trim()}`);
-    const vaultKick = await kickstartService(VAULT_LABEL);
+    const vaultKick = await kickstartService(labels.vault);
     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

@@ -3,11 +3,10 @@
  * git revision / behind-origin check.
  */
 import pc from "picocolors";
-import { readConfig } from "./config.js";
+import { readConfig, resolveServiceLabels } 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) {
@@ -20,9 +19,10 @@ export async function statusCommand() {
     console.log(`  Web port:    ${config.webPort}`);
     console.log(`  Vault port:  ${config.vaultPort}`);
     console.log("");
+    const labels = resolveServiceLabels(config);
     const [webSvc, vaultSvc, webHealth, vaultHealth, rev, behind] = await Promise.all([
-        getServiceStatus(WEB_LABEL),
-        getServiceStatus(VAULT_LABEL),
+        getServiceStatus(labels.web),
+        getServiceStatus(labels.vault),
         checkWebHealth(config.webPort),
         checkVaultHealth(config.vaultPort),
         currentRevision(config.installDir),

package/dist/uninstall.js

@@ -8,9 +8,9 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { existsSync, rmSync, unlinkSync } from "node:fs";
-import { readConfig } from "./config.js";
+import { readConfig, resolveServiceLabels } from "./config.js";
 import { bootoutService } from "./launchd.js";
-import { VAULT_LABEL, WEB_LABEL, plistPath, configPath } from "./paths.js";
+import { 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)
@@ -27,9 +27,10 @@ export async function uninstallCommand() {
         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 labels = resolveServiceLabels(config);
+    await bootoutService(labels.web);
+    await bootoutService(labels.vault);
+    for (const label of [labels.web, labels.vault]) {
         const path = plistPath(label);
         if (existsSync(path))
             unlinkSync(path);

package/dist/update.js

@@ -4,7 +4,7 @@
  */
 import pc from "picocolors";
 import { ensureBun } from "./bun-setup.js";
-import { readConfig } from "./config.js";
+import { readConfig, resolveServiceLabels } from "./config.js";
 import { runStreaming } from "./exec.js";
 import { waitForHealthy } from "./health.js";
 import { pullLatest } from "./repo.js";
@@ -44,8 +44,9 @@ export async function runUpdate(config) {
     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();
+    const labels = resolveServiceLabels(config);
+    installServiceFiles(config.installDir, labels);
+    const bootstrap = await bootstrapAndStart(labels);
     for (const e of bootstrap.errors)
         console.error(pc.yellow(e));
     console.log("Restarting services and re-checking health…");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arelos",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Installer and service manager for a self-hosted Arel OS on macOS.",
   "type": "module",
   "bin": {