arelos 0.1.0 → 0.1.2

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",
@@ -19,6 +19,26 @@ export function normalizeDisplayName(input) {
     const trimmed = input.trim();
     return trimmed.length > 0 ? trimmed : DEFAULTS.displayName;
 }
+/**
+ * Slugify a chosen display name into a safe directory-name fragment:
+ * lowercase, spaces/unsafe chars -> dashes, collapsed and trimmed. Falls back
+ * to the fixed default install dir's basename when the slug would be empty
+ * (e.g. a name made entirely of emoji/punctuation).
+ */
+export function slugifyName(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/** Default install dir derived from the chosen display name, e.g. "My Brain" -> "~/my-brain". */
+export function defaultInstallDirFor(displayName) {
+    const slug = slugifyName(displayName);
+    if (!slug)
+        return DEFAULTS.installDir;
+    return `~/${slug}`;
+}
 export function checkInstallDir(rawPath) {
     const path = expandHome(rawPath);
     const parent = dirname(path);
@@ -55,12 +75,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

@@ -9,12 +9,13 @@ import { ensureBun } from "./bun-setup.js";
 import { readConfig, writeConfig } from "./config.js";
 import { runStreaming } from "./exec.js";
 import { waitForHealthy } from "./health.js";
-import { checkInstallDir, defaultVaultPath, DEFAULTS, normalizeDisplayName, resolvePort, toArelConfig, } from "./install-plan.js";
+import { checkInstallDir, defaultInstallDirFor, defaultVaultPath, DEFAULTS, normalizeDisplayName, resolvePort, slugifyName, toArelConfig, } from "./install-plan.js";
 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)
@@ -159,7 +173,7 @@ export async function runInstall(argv, flags) {
         }
     }
     p.outro([
-        pc.green(`Arel OS is running at ${url}`),
+        pc.green(`${answers.displayName} is running at ${url}`),
         "Runs 24/7 in the background.",
         "Next: arelos status · arelos logs · arelos update · arelos uninstall",
     ].join("\n"));
@@ -175,7 +189,7 @@ async function checkGit() {
 async function collectAnswers(flags) {
     if (flags.yes) {
         const displayName = normalizeDisplayName(flags.displayName ?? DEFAULTS.displayName);
-        const installDir = flags.installDir ?? DEFAULTS.installDir;
+        const installDir = flags.installDir ?? defaultInstallDirFor(displayName);
         const vaultPath = flags.vaultPath ?? defaultVaultPath(installDir);
         const webPortReq = flags.webPort ?? DEFAULTS.webPort;
         const vaultPortReq = flags.vaultPort ?? DEFAULTS.vaultPort;
@@ -197,28 +211,45 @@ async function collectAnswers(flags) {
     });
     if (p.isCancel(displayNameRaw))
         return null;
+    const displayName = normalizeDisplayName(String(displayNameRaw));
+    const installDirDefault = defaultInstallDirFor(displayName);
     // Step 3 — Install location.
     let installDir = "";
     for (;;) {
         const raw = await p.text({
-            message: "Where should Arel OS be installed?",
-            placeholder: DEFAULTS.installDir,
-            defaultValue: DEFAULTS.installDir,
+            message: `Where should ${displayName} be installed?`,
+            placeholder: installDirDefault,
+            defaultValue: installDirDefault,
         });
         if (p.isCancel(raw))
             return null;
-        const check = checkInstallDir(String(raw || DEFAULTS.installDir));
+        const check = checkInstallDir(String(raw || installDirDefault));
         if (!check.parentWritable) {
             p.log.error(`Cannot write to ${check.path} — choose another location.`);
             continue;
         }
         if (check.nonEmpty && !check.isPriorArelosInstall) {
-            const proceed = await p.confirm({
-                message: `${check.path} exists and is not empty. Use it anyway?`,
-                initialValue: false,
+            const subfolder = `${check.path}/${slugifyName(displayName) || "arelos"}`;
+            const choice = await p.select({
+                message: `${check.path} already has files in it, so installing there would fail.`,
+                options: [
+                    { value: "subfolder", label: `Install into ${subfolder} instead`, hint: "recommended" },
+                    { value: "different", label: "Choose a different location" },
+                    { value: "cancel", label: "Cancel install" },
+                ],
+                initialValue: "subfolder",
             });
-            if (p.isCancel(proceed) || !proceed)
+            if (p.isCancel(choice) || choice === "cancel")
+                return null;
+            if (choice === "different")
+                continue;
+            const subCheck = checkInstallDir(subfolder);
+            if (subCheck.nonEmpty && !subCheck.isPriorArelosInstall) {
+                p.log.error(`${subCheck.path} also already has files in it — choose another location.`);
                 continue;
+            }
+            installDir = subCheck.path;
+            break;
         }
         installDir = check.path;
         break;
@@ -239,7 +270,7 @@ async function collectAnswers(flags) {
     if (vaultPort === null)
         return null;
     return {
-        displayName: normalizeDisplayName(String(displayNameRaw)),
+        displayName,
         installDir,
         vaultPath: String(vaultRaw || defaultVaultPath(installDir)),
         webPort,

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/ports.js

@@ -1,28 +1,46 @@
 /**
  * Zero-dependency free-port detection via node:net (spec §1 Step 5).
+ *
+ * A port must be probed on BOTH loopback families: a server listening only on
+ * [::1] (IPv6) leaves 127.0.0.1 bindable, so an IPv4-only probe reports the
+ * port "free" while browsers (which resolve localhost to ::1 first) hit the
+ * other process. Field-tested: a Node dev server on [::1]:1347 made the
+ * installer pre-fill an occupied port. A port counts as free only if every
+ * loopback family available on this machine can bind it.
  */
 import { createServer } from "node:net";
-/** Resolve true if `port` is free to bind on 127.0.0.1, false if taken. */
-export function isPortFree(port) {
+/** Error codes meaning "this address family isn't available on this machine". */
+const FAMILY_UNAVAILABLE = new Set(["EADDRNOTAVAIL", "EAFNOSUPPORT", "EINVAL"]);
+/** Try to bind `port` on one loopback host and report what happened. */
+function probeBind(port, host) {
     return new Promise((resolve) => {
         const server = createServer();
         server.once("error", (err) => {
             server.close();
-            if (err.code === "EADDRINUSE" || err.code === "EACCES") {
-                resolve(false);
+            if (err.code && FAMILY_UNAVAILABLE.has(err.code)) {
+                // No IPv6 (or IPv4) loopback on this machine — nothing to conflict with.
+                resolve("family-unavailable");
             }
             else {
-                // Unexpected error probing the port — treat conservatively as taken
-                // so we never suggest a port we can't actually validate.
-                resolve(false);
+                // EADDRINUSE/EACCES, or anything unexpected — treat conservatively as
+                // taken so we never suggest a port we can't actually validate.
+                resolve("taken");
             }
         });
         server.once("listening", () => {
-            server.close(() => resolve(true));
+            server.close(() => resolve("free"));
         });
-        server.listen(port, "127.0.0.1");
+        server.listen(port, host);
     });
 }
+/**
+ * Resolve true if `port` is free to bind on ALL applicable loopback families
+ * (127.0.0.1 and ::1), false if any listener holds it on either family.
+ */
+export async function isPortFree(port) {
+    const [v4, v6] = await Promise.all([probeBind(port, "127.0.0.1"), probeBind(port, "::1")]);
+    return v4 !== "taken" && v6 !== "taken";
+}
 /**
  * Find the first free port at or above `start`, scanning upward. Stops at
  * `start + maxScan` to avoid an unbounded loop.

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.2",
   "description": "Installer and service manager for a self-hosted Arel OS on macOS.",
   "type": "module",
   "bin": {