arelos 0.1.1 → 0.1.2

package/dist/install-plan.js

@@ -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);

package/dist/install.js

@@ -9,7 +9,7 @@ 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";
@@ -173,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"));
@@ -189,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;
@@ -211,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;
@@ -253,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/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/package.json

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