baychat 0.28.0 → 0.29.1

package/dist/launch/claude-trust.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRUST_KEY = void 0;
+exports.claudeConfigPath = claudeConfigPath;
+exports.trustKeysFor = trustKeysFor;
+exports.isFolderTrusted = isFolderTrusted;
+exports.trustProblemText = trustProblemText;
+exports.trustFolder = trustFolder;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Claude Code's "Quick safety check" (workspace trust), read — and, only at the computer, written.
+ *
+ * A `claude` started unattended in a folder Claude Code has not trusted sits at
+ * "Is this a project you created or one you trust? ❯ No, exit / Yes, I trust this folder"
+ * forever, with nobody there to answer. Claude Code records the answer in `~/.claude.json`
+ * (or `$CLAUDE_CONFIG_DIR/.claude.json`) as `projects["<absolute path>"].hasTrustDialogAccepted`.
+ * (Key verified against the real file on Claude Code 2.1.289.)
+ *
+ * ── WHO MAY WRITE TRUST ───────────────────────────────────────────────────────────────
+ * Only a person at this computer, through `baychat launch add` answering y. The relay only READS
+ * (`isFolderTrusted`) and refuses with FOLDER_NOT_TRUSTED; nothing that arrives over the network
+ * ever calls `trustFolder`.
+ *
+ * The file holds the person's whole Claude Code state (and may hold secrets), so the write is
+ * as small as it can be: that one boolean on that one project key, everything else re-serialised
+ * unchanged, a `.bak` copy first, then a temp file renamed over the original with its mode.
+ * A missing or unparsable file is never written: we report and let the person run `claude`.
+ */
+exports.TRUST_KEY = "hasTrustDialogAccepted";
+/** `$CLAUDE_CONFIG_DIR/.claude.json` when set (as Claude Code does), else `~/.claude.json`. */
+function claudeConfigPath(env = process.env, home = os.homedir()) {
+    const dir = env.CLAUDE_CONFIG_DIR?.trim();
+    return dir ? path.join(dir, ".claude.json") : path.join(home, ".claude.json");
+}
+/**
+ * The keys Claude Code may have recorded for `folder`: the path as given, its realpath, and on
+ * macOS the same path with and without `/private` (/tmp, /var and /etc are symlinks there).
+ */
+function trustKeysFor(folder, platform = process.platform) {
+    const keys = new Set([folder]);
+    try {
+        keys.add(fs.realpathSync(folder));
+    }
+    catch {
+        // A folder that does not resolve is checked by the name given only.
+    }
+    if (platform === "darwin") {
+        for (const k of [...keys]) {
+            const m = /^\/private(\/(?:tmp|var|etc)(?:\/.*)?)$/.exec(k);
+            if (m)
+                keys.add(m[1]);
+            else if (/^\/(?:tmp|var|etc)(?:\/|$)/.test(k))
+                keys.add(`/private${k}`);
+        }
+    }
+    return [...keys];
+}
+function readConfig(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        return { ok: false, reason: err.code === "ENOENT" ? "CONFIG_MISSING" : "CONFIG_UNREADABLE" };
+    }
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, reason: "CONFIG_UNPARSABLE" };
+    }
+    if (!json || typeof json !== "object" || Array.isArray(json))
+        return { ok: false, reason: "CONFIG_UNPARSABLE" };
+    const projects = json.projects;
+    if (projects !== undefined && (!projects || typeof projects !== "object" || Array.isArray(projects))) {
+        return { ok: false, reason: "CONFIG_UNPARSABLE" };
+    }
+    return { ok: true, raw, json: json };
+}
+/** Read-only: has Claude Code's trust dialog been accepted for `folder` (under any of its names)? */
+function isFolderTrusted(folder, file = claudeConfigPath()) {
+    const parsed = readConfig(file);
+    if (!parsed.ok)
+        return false;
+    const projects = (parsed.json.projects ?? {});
+    return trustKeysFor(folder).some((key) => {
+        const entry = Object.prototype.hasOwnProperty.call(projects, key) ? projects[key] : undefined;
+        return !!entry && typeof entry === "object" && entry[exports.TRUST_KEY] === true;
+    });
+}
+/** A sentence for each problem, for the person at the terminal. */
+function trustProblemText(reason, file) {
+    switch (reason) {
+        case "CONFIG_MISSING":
+            return `${file} does not exist yet (Claude Code has not run on this computer).`;
+        case "CONFIG_UNREADABLE":
+            return `${file} could not be read.`;
+        case "CONFIG_UNPARSABLE":
+            return `${file} is not the JSON BayChat expects, so it was left alone.`;
+        case "CONFIG_UNSAFE":
+            return `${file} holds numbers BayChat could not rewrite exactly, so it was left alone.`;
+        case "CONFIG_CHANGING":
+            return `${file} kept changing while BayChat tried to write it (is Claude Code busy?).`;
+        case "WRITE_FAILED":
+            return `${file} could not be written.`;
+    }
+}
+/**
+ * Set `projects[folder].hasTrustDialogAccepted = true` and nothing else. `folder` should be the
+ * realpath (the spot's stored path). Called ONLY from `baychat launch add` after a person said y.
+ */
+function trustFolder(folder, file = claudeConfigPath()) {
+    // Write through a symlinked ~/.claude.json (dotfile managers) instead of replacing the link.
+    let target = file;
+    try {
+        target = fs.realpathSync(file);
+    }
+    catch {
+        // Missing: readConfig reports it below.
+    }
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const parsed = readConfig(target);
+        if (!parsed.ok)
+            return parsed;
+        if (hasLossyNumbers(parsed.raw))
+            return { ok: false, reason: "CONFIG_UNSAFE" };
+        const projects = (parsed.json.projects ?? {});
+        const current = Object.prototype.hasOwnProperty.call(projects, folder) ? projects[folder] : undefined;
+        if (current !== undefined && (!current || typeof current !== "object" || Array.isArray(current))) {
+            return { ok: false, reason: "CONFIG_UNPARSABLE" };
+        }
+        if (current?.[exports.TRUST_KEY] === true)
+            return { ok: true, changed: false };
+        const next = {
+            ...parsed.json,
+            projects: { ...projects, [folder]: { ...(current ?? {}), [exports.TRUST_KEY]: true } },
+        };
+        const text = serialiseLike(parsed.raw, next);
+        let mode;
+        try {
+            mode = fs.statSync(target).mode & 0o777;
+            const bak = `${target}.bak`;
+            fs.copyFileSync(target, bak);
+            fs.chmodSync(bak, mode);
+        }
+        catch {
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+        const tmp = path.join(path.dirname(target), `.${path.basename(target)}.baychat-${process.pid}-${Date.now()}.tmp`);
+        try {
+            fs.writeFileSync(tmp, text, { mode });
+            fs.chmodSync(tmp, mode); // writeFile's mode is masked by the umask
+            // Claude Code rewrites this file often. If it changed since we read it, start over
+            // rather than rename our older copy over its newer one.
+            if (fs.readFileSync(target, "utf8") !== parsed.raw) {
+                fs.rmSync(tmp, { force: true });
+                continue;
+            }
+            fs.renameSync(tmp, target);
+            return { ok: true, changed: true };
+        }
+        catch {
+            fs.rmSync(tmp, { force: true });
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+    }
+    return { ok: false, reason: "CONFIG_CHANGING" };
+}
+/** JSON.stringify in the file's own style: its indent, and its trailing newline or lack of one. */
+function serialiseLike(raw, value) {
+    const indent = /^\{\r?\n(\t| +)"/.exec(raw)?.[1] ?? (raw.trimStart().startsWith("{\n") ? 2 : 0);
+    const body = JSON.stringify(value, null, indent);
+    return raw.endsWith("\n") ? `${body}\n` : body;
+}
+/**
+ * A number JSON.parse cannot hold exactly (more than 15 significant digits) would be silently
+ * changed by the rewrite. Strings are blanked first so ids and tokens inside quotes don't count.
+ */
+function hasLossyNumbers(raw) {
+    const outsideStrings = raw.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+    return (outsideStrings.match(/-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g) ?? []).some((n) => {
+        const digits = n.replace(/^-/, "").split(/[eE]/)[0].replace(".", "").replace(/^0+/, "");
+        return digits.length > 15;
+    });
+}

package/dist/launch/command.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trustByHand = exports.APPROVALS_NOTICE = exports.LAUNCH_USAGE = void 0;
+exports.cmdLaunch = cmdLaunch;
+const path = __importStar(require("path"));
+const args_1 = require("../args");
+const multiplexer_launch_1 = require("../multiplexer-launch");
+const policy_1 = require("../relay/acp/policy");
+const claude_trust_1 = require("./claude-trust");
+const policy_2 = require("./policy");
+exports.LAUNCH_USAGE = `Usage: baychat launch add <folder> [--label <label>] [--runtime claude,codex] [--max <n>]
+                                  Let BayChat start sessions in <folder> from the app
+       baychat launch list         The folders BayChat may start sessions in
+       baychat launch remove <id>  Stop offering one of them`;
+/** Printed by every `add`: the one thing a person must know before saying yes. */
+exports.APPROVALS_NOTICE = "Sessions started here from BayChat ask for approvals in BayChat.";
+const realDeps = () => {
+    const file = (0, claude_trust_1.claudeConfigPath)();
+    return {
+        print: (line) => console.log(line),
+        policyFile: (0, policy_2.launchPolicyPath)(),
+        trust: { isTrusted: (folder) => (0, claude_trust_1.isFolderTrusted)(folder, file), trust: (folder) => (0, claude_trust_1.trustFolder)(folder, file), file },
+        interactive: !!process.stdin.isTTY && !!process.stdout.isTTY,
+        ask: multiplexer_launch_1.askLine,
+    };
+};
+/**
+ * `baychat launch add|list|remove` — the only writer of the launch policy.
+ *
+ * LOCAL ONLY, like `connect dsh`: nothing over the network reaches this, so the folders a phone
+ * may start sessions in are always chosen by someone sitting at this computer. Everything that
+ * can refuse does so before the file is written.
+ */
+async function cmdLaunch(args, deps = realDeps()) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case "add":
+            return addSpot(rest, deps);
+        case "list":
+            return listSpots(deps);
+        case "remove":
+            return removeSpotById(rest, deps);
+        default:
+            throw new Error(exports.LAUNCH_USAGE);
+    }
+}
+async function addSpot(args, deps) {
+    const label = (0, args_1.flag)(args, "--label");
+    const runtimeList = (0, args_1.flag)(args, "--runtime");
+    const maxRaw = (0, args_1.flag)(args, "--max");
+    const valued = new Set([label, runtimeList, maxRaw].filter((v) => v !== undefined));
+    const folderArg = args.find((a) => !a.startsWith("--") && !valued.has(a));
+    if (!folderArg)
+        throw new Error(exports.LAUNCH_USAGE);
+    const folder = (0, policy_1.validateNewRoot)(folderArg);
+    if (!folder.ok) {
+        deps.print(folder.reason);
+        return 1;
+    }
+    const spotLabel = (label ?? path.basename(folder.path)).trim();
+    if (!spotLabel || spotLabel.length > policy_2.SPOT_LABEL_MAX) {
+        deps.print(`A label is 1-${policy_2.SPOT_LABEL_MAX} characters.`);
+        return 1;
+    }
+    const requested = (runtimeList ?? "claude").split(",").map((r) => r.trim()).filter(Boolean);
+    const unknown = requested.filter((r) => !(0, policy_2.isLaunchRuntime)(r));
+    if (requested.length === 0 || unknown.length > 0) {
+        deps.print(`Unknown runtime ${unknown.join(", ") || "(none given)"}. Choose from: ${policy_2.LAUNCH_RUNTIMES.join(", ")}.`);
+        return 1;
+    }
+    const maxSessions = maxRaw === undefined ? policy_2.DEFAULT_MAX_SESSIONS : Number(maxRaw);
+    if (!Number.isInteger(maxSessions) || maxSessions < 1 || maxSessions > policy_2.MAX_SESSIONS_PER_COMPUTER) {
+        deps.print(`--max is a whole number from 1 to ${policy_2.MAX_SESSIONS_PER_COMPUTER} (the most sessions one computer runs).`);
+        return 1;
+    }
+    const policy = (0, policy_2.loadLaunchPolicy)(deps.policyFile);
+    const existing = policy?.spots.find((s) => s.path === folder.path);
+    const spot = {
+        id: existing?.id ?? (0, policy_2.suggestSpotId)(policy, folder.path),
+        label: spotLabel,
+        path: folder.path,
+        runtimes: [...new Set(requested)],
+        maxSessions,
+    };
+    (0, policy_2.saveLaunchPolicy)((0, policy_2.upsertSpot)(policy, spot), deps.policyFile);
+    deps.print(`${existing ? "Updated" : "Added"} "${spot.label}" (${spot.id}): ${spot.path}`);
+    deps.print(`  Agents: ${spot.runtimes.join(", ")} · at most ${spot.maxSessions} at once`);
+    deps.print(`  ${exports.APPROVALS_NOTICE}`);
+    if (spot.runtimes.includes("claude"))
+        await offerClaudeTrust(spot.path, deps);
+    return 0;
+}
+/** How to trust a folder by hand: the one answer Claude Code itself accepts. */
+const trustByHand = (folder) => `run \`claude\` in ${folder} once and choose "Yes, I trust this folder".`;
+exports.trustByHand = trustByHand;
+/**
+ * A `claude` started from the phone in a folder Claude Code has not trusted waits at its
+ * "Quick safety check" forever, so the relay refuses those (FOLDER_NOT_TRUSTED). This is the one
+ * place trust may be written: here, by the person at this computer, after they typed y.
+ * The spot is kept either way.
+ */
+async function offerClaudeTrust(folder, deps) {
+    if (deps.trust.isTrusted(folder))
+        return;
+    deps.print(`Claude Code hasn't trusted this folder yet, so a session started here from BayChat would wait at its safety question with nobody to answer.`);
+    if (!deps.interactive) {
+        deps.print(`To fix that, ${(0, exports.trustByHand)(folder)}`);
+        return;
+    }
+    const answer = await deps.ask("Trust this folder for Claude Code now? (y/N) ");
+    if (!/^\s*y(es)?\s*$/i.test(answer)) {
+        deps.print(`Not trusted. Sessions from BayChat can't start here until you ${(0, exports.trustByHand)(folder)}`);
+        return;
+    }
+    const result = deps.trust.trust(folder);
+    if (result.ok) {
+        deps.print(`Trusted. Claude Code will start in ${folder} without asking (a copy of the old settings is in ${deps.trust.file}.bak).`);
+        return;
+    }
+    deps.print(`Couldn't record it: ${(0, claude_trust_1.trustProblemText)(result.reason, deps.trust.file)} Instead, ${(0, exports.trustByHand)(folder)}`);
+}
+function listSpots(deps) {
+    const policy = (0, policy_2.loadLaunchPolicy)(deps.policyFile);
+    if (!policy || policy.spots.length === 0) {
+        deps.print("BayChat may not start sessions on this computer. Add a folder with `baychat launch add <folder>`.");
+        return 0;
+    }
+    for (const s of policy.spots)
+        deps.print(`${s.id}  "${s.label}"  ${s.path}  [${s.runtimes.join(", ")}] max ${s.maxSessions}`);
+    return 0;
+}
+function removeSpotById(args, deps) {
+    const id = args.find((a) => !a.startsWith("--"));
+    if (!id)
+        throw new Error(exports.LAUNCH_USAGE);
+    const policy = (0, policy_2.loadLaunchPolicy)(deps.policyFile);
+    if (!policy?.spots.some((s) => s.id === id)) {
+        deps.print(`No folder with id "${id}". \`baychat launch list\` shows them.`);
+        return 1;
+    }
+    (0, policy_2.saveLaunchPolicy)((0, policy_2.removeSpot)(policy, id), deps.policyFile);
+    deps.print(`Removed "${id}". Sessions already running there keep running.`);
+    return 0;
+}

package/dist/launch/policy.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SESSIONS_PER_COMPUTER = exports.DEFAULT_MAX_SESSIONS = exports.MAX_SPOTS = exports.SPOT_LABEL_MAX = exports.SPOT_ID_RE = exports.LAUNCH_RUNTIMES = void 0;
+exports.launchPolicyPath = launchPolicyPath;
+exports.isLaunchRuntime = isLaunchRuntime;
+exports.loadLaunchPolicy = loadLaunchPolicy;
+exports.saveLaunchPolicy = saveLaunchPolicy;
+exports.upsertSpot = upsertSpot;
+exports.removeSpot = removeSpot;
+exports.suggestSpotId = suggestSpotId;
+exports.resolveSpotFolder = resolveSpotFolder;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const policy_1 = require("../relay/acp/policy");
+/**
+ * Where BayChat may START sessions on this computer: `~/.baychat/launch-policy.json` (0600).
+ *
+ * ── WHAT MAKES THIS A BOUNDARY ────────────────────────────────────────────────────────
+ * Nothing that arrives over the network writes this file. Only `baychat launch add|remove`, run
+ * by a person at this machine, changes it. The relay advertises its spots by LABEL only and
+ * re-reads this file for every launch, so a deleted spot stops launches at once. Invalid is
+ * treated as absent: a file we cannot read offers nothing — it never means "allow everything".
+ *
+ * Folder rules are `connect`'s (relay/acp/policy.ts `validateNewRoot`): never `/`, never the home
+ * folder itself, only a real directory. The path is stored as its realpath when the spot is added
+ * and resolved AGAIN at launch (`resolveSpotFolder`), so a symlink swapped in afterwards is refused.
+ */
+/** Every runtime a spot may name. Phase 1 launches only `claude`; the relay refuses the rest. */
+exports.LAUNCH_RUNTIMES = ["claude", "codex", "dsh", "cursor-cli"];
+exports.SPOT_ID_RE = /^[a-z0-9-]{1,32}$/;
+exports.SPOT_LABEL_MAX = 40;
+exports.MAX_SPOTS = 20;
+exports.DEFAULT_MAX_SESSIONS = 3;
+/** The hard cap per computer. A spot's own cap can never exceed it. */
+exports.MAX_SESSIONS_PER_COMPUTER = 6;
+function launchPolicyPath() {
+    return path.join((0, config_1.configDir)(), "launch-policy.json");
+}
+function isLaunchRuntime(value) {
+    return typeof value === "string" && exports.LAUNCH_RUNTIMES.includes(value);
+}
+/** The policy, or null when it is missing, unreadable or invalid in ANY part (offers nothing). */
+function loadLaunchPolicy(file = launchPolicyPath()) {
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        // Missing is the ordinary not-set-up state, read on every poll; logging it would be noise.
+        return null;
+    }
+    const spots = raw?.spots;
+    if (!Array.isArray(spots) || spots.length > exports.MAX_SPOTS)
+        return null;
+    const clean = [];
+    for (const entry of spots) {
+        const spot = parseSpot(entry);
+        if (!spot || clean.some((s) => s.id === spot.id))
+            return null;
+        clean.push(spot);
+    }
+    return { spots: clean };
+}
+function saveLaunchPolicy(policy, file = launchPolicyPath()) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(policy, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(file, 0o600); // writeFile's mode applies only when it CREATES the file
+}
+/** Add `spot`, replacing any spot with the same id or the same folder. Pure. */
+function upsertSpot(policy, spot) {
+    const others = (policy?.spots ?? []).filter((s) => s.id !== spot.id && s.path !== spot.path);
+    return { spots: [...others, spot] };
+}
+/** `policy` without the spot `id`. Removing a spot that is not there changes nothing. Pure. */
+function removeSpot(policy, id) {
+    return { spots: (policy?.spots ?? []).filter((s) => s.id !== id) };
+}
+/** A spot id that is free in `policy`, derived from the folder's name. Pure. */
+function suggestSpotId(policy, folder) {
+    const base = path.basename(folder).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 28) || "spot";
+    const taken = new Set((policy?.spots ?? []).map((s) => s.id));
+    if (!taken.has(base))
+        return base;
+    for (let n = 2;; n++)
+        if (!taken.has(`${base}-${n}`))
+            return `${base}-${n}`;
+}
+/**
+ * The spot's folder, checked NOW: still a real directory, still not `/` or home, and its realpath
+ * still the one recorded at `add`. Anything else (a component swapped for a symlink, a deleted
+ * folder, a hand-edited path with `..`) is refused rather than followed.
+ */
+function resolveSpotFolder(spot) {
+    const now = (0, policy_1.validateNewRoot)(spot.path);
+    if (!now.ok)
+        return { ok: false, reason: now.reason };
+    if (now.path !== spot.path) {
+        return { ok: false, reason: `The folder for "${spot.label}" now resolves to somewhere else. Run \`baychat launch add\` again if that is intended.` };
+    }
+    return { ok: true, path: now.path };
+}
+function parseSpot(entry) {
+    if (!entry || typeof entry !== "object")
+        return null;
+    const { id, label, path: p, runtimes, maxSessions } = entry;
+    if (typeof id !== "string" || !exports.SPOT_ID_RE.test(id))
+        return null;
+    if (typeof label !== "string" || label.trim().length === 0 || label.length > exports.SPOT_LABEL_MAX)
+        return null;
+    // `add` stores a realpath, which is always absolute and normalised; anything else was hand-edited.
+    if (typeof p !== "string" || !path.isAbsolute(p) || path.normalize(p) !== p)
+        return null;
+    if (!Array.isArray(runtimes) || runtimes.length === 0 || !runtimes.every(isLaunchRuntime))
+        return null;
+    if (typeof maxSessions !== "number" || !Number.isInteger(maxSessions) || maxSessions < 1 || maxSessions > exports.MAX_SESSIONS_PER_COMPUTER)
+        return null;
+    return { id, label, path: p, runtimes: [...new Set(runtimes)], maxSessions };
+}

package/dist/machine-name.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWsl = isWsl;
+exports.machineName = machineName;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+/** The server caps a device name at 60 characters (`createDeviceLink`). */
+const MAX_NAME_LENGTH = 60;
+const WSL_MARK = " (WSL)";
+/**
+ * Is this process running inside WSL?
+ *
+ * `WSL_DISTRO_NAME` is set in every shell WSL opens; a process WSL started some other way (a
+ * systemd unit) may not have it, so the kernel's own name — "microsoft" in `/proc/version`
+ * on WSL 1 and 2 alike — is asked as well. Only on Linux: nothing else can be WSL.
+ */
+function isWsl(platform = process.platform, env = process.env, procVersion = readProcVersion) {
+    if (platform !== "linux")
+        return false;
+    if (env.WSL_DISTRO_NAME)
+        return true;
+    return /microsoft/i.test(procVersion());
+}
+/**
+ * The name a login gives this computer, which is its identity on the server: a new login
+ * REPLACES the live login of the same name (one machine, one row). WSL reports the hostname
+ * Windows does, so a login from inside WSL is "<hostname> (WSL)" — otherwise Windows and WSL
+ * on one PC were one computer to BayChat, and each login signed the other out.
+ */
+function machineName(hostname = os.hostname(), wsl = isWsl()) {
+    if (!wsl)
+        return hostname.slice(0, MAX_NAME_LENGTH);
+    return hostname.slice(0, MAX_NAME_LENGTH - WSL_MARK.length) + WSL_MARK;
+}
+/** `/proc/version`, or "" where there is none — not an error: only Linux has it. */
+function readProcVersion() {
+    try {
+        return fs.readFileSync("/proc/version", "utf8");
+    }
+    catch {
+        return "";
+    }
+}