baychat 0.27.1 → 0.29.0

package/dist/relay/launcher/capabilities.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.RUNTIME_BINARY = void 0;
+exports.buildCapabilities = buildCapabilities;
+const os = __importStar(require("os"));
+/** The executable each launch runtime is resolved by. */
+exports.RUNTIME_BINARY = {
+    claude: "claude",
+    codex: "codex",
+    dsh: "dsh",
+    "cursor-cli": "agent",
+};
+const MACHINE_MAX = 64;
+const VERSION_MAX = 64;
+/**
+ * Build the capabilities. A missing policy offers no spots; a spot whose runtimes are all
+ * missing is left out entirely, since the app could not start anything there.
+ */
+function buildCapabilities(policy, deps) {
+    const resolved = new Map();
+    const versionOf = (runtime) => {
+        if (!resolved.has(runtime)) {
+            const r = deps.resolveBinary(exports.RUNTIME_BINARY[runtime]);
+            resolved.set(runtime, r.ok ? r.version.split("\n")[0].trim().slice(0, VERSION_MAX) || null : undefined);
+        }
+        return resolved.get(runtime);
+    };
+    const spots = [];
+    for (const spot of policy?.spots ?? []) {
+        const runtimes = spot.runtimes.flatMap((name) => {
+            const version = versionOf(name);
+            return version === undefined ? [] : [{ name, version }];
+        });
+        if (runtimes.length > 0)
+            spots.push({ id: spot.id, label: spot.label, runtimes });
+    }
+    return {
+        machine: (deps.hostname ?? os.hostname()).replace(/\.local$/, "").slice(0, MACHINE_MAX) || "computer",
+        os: deps.platform ?? process.platform,
+        multiplexer: deps.multiplexer,
+        spots,
+    };
+}

package/dist/relay/launcher/dev-channel-screen.fixtures.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Pane captures for the launcher's screen-matching tests. The stable phrases are the ones the owner
+ * quoted from Claude Code (2026-10-05); the surrounding layout is a representative capture.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_PROMPT = exports.FOLDER_TRUST = exports.DEV_CHANNEL_WARNING_EXIT_SELECTED = exports.DEV_CHANNEL_WARNING = void 0;
+exports.DEV_CHANNEL_WARNING = [
+    "╭──────────────────────────────────────────────────────────────────────────╮",
+    "│ WARNING: Loading development channels                                    │",
+    "│                                                                          │",
+    "│ --dangerously-load-development-channels is for local channel development │",
+    "│ only. Do not use this option to run channels you have downloaded off the │",
+    "│ internet.                                                                │",
+    "│                                                                          │",
+    "│ Channels: server:baychat-channel                                         │",
+    "│                                                                          │",
+    "│ ❯ 1. I am using this for local development                               │",
+    "│   2. Exit                                                                │",
+    "╰──────────────────────────────────────────────────────────────────────────╯",
+    "   Enter to confirm · Esc to cancel",
+    "",
+].join("\n");
+/** The same warning with the selection moved to "Exit". */
+exports.DEV_CHANNEL_WARNING_EXIT_SELECTED = exports.DEV_CHANNEL_WARNING.replace("❯ 1. I am using", "  1. I am using").replace("  2. Exit", "❯ 2. Exit");
+exports.FOLDER_TRUST = [
+    "╭──────────────────────────────────────────────────────────────────────────╮",
+    "│ Do you trust the files in this folder?                                   │",
+    "│                                                                          │",
+    "│ /work/web                                                                │",
+    "│                                                                          │",
+    "│ Quick safety check: Is this a project you created or one you trust?      │",
+    "│                                                                          │",
+    "│ ❯ 1. Yes, I trust this folder                                            │",
+    "│   2. No, exit                                                            │",
+    "╰──────────────────────────────────────────────────────────────────────────╯",
+    "   Enter to confirm · Esc to cancel",
+    "",
+].join("\n");
+/** Claude Code's ordinary prompt, past every question. */
+exports.CLAUDE_PROMPT = ["╭─────────────────────────╮", "│ > /baychat mac-1        │", "╰─────────────────────────╯", "  ? for shortcuts", ""].join("\n");

package/dist/relay/launcher/dev-channel-screen.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Recognising the two Claude Code screens a detached launch can stop at — pure, so the rule that
+ * decides whether a key is ever pressed is testable on captured text.
+ *
+ * ── STRICT ON PURPOSE ─────────────────────────────────────────────────────────────────
+ * The only key the launcher ever sends is ONE Enter, and only on the development-channels warning
+ * after the computer's owner tapped Allow (Karmen, 2026-10-05). So the warning is recognised only
+ * when ALL of its stable phrases are on screen, and the Enter only when the selected row is
+ * option 1 ("I am using this for local development"). Anything less is "other", and "other" is
+ * never answered.
+ *
+ * The folder-trust screen ("Quick safety check") is recognised so it can be REFUSED: trust is the
+ * person at the computer's decision (launch/claude-trust.ts), never the network's.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOLDER_TRUST_PHRASES = exports.DEV_CHANNEL_WARNING_PHRASES = void 0;
+exports.classifyPane = classifyPane;
+exports.firstOptionSelected = firstOptionSelected;
+exports.safeToConfirm = safeToConfirm;
+/** Every one of these must be on screen for the development-channels warning. */
+exports.DEV_CHANNEL_WARNING_PHRASES = ["Loading development channels", "I am using this for local development", "Enter to confirm"];
+/** Both of these must be on screen for Claude Code's workspace-trust question. */
+exports.FOLDER_TRUST_PHRASES = ["Quick safety check", "Yes, I trust this folder"];
+function classifyPane(text) {
+    if (exports.DEV_CHANNEL_WARNING_PHRASES.every((p) => text.includes(p)))
+        return "dev-channel-warning";
+    if (exports.FOLDER_TRUST_PHRASES.every((p) => text.includes(p)))
+        return "folder-trust";
+    return "other";
+}
+/**
+ * The selection marker on option 1 of the warning, on one line. Only whitespace and a box border
+ * (`│`) may come before the marker; nothing else.
+ */
+const FIRST_OPTION_SELECTED = /^[\s│]*❯\s*1\.\s*I am using this for local development/;
+/** True only when option 1 ("I am using this for local development") is the selected row. */
+function firstOptionSelected(text) {
+    const lines = text.split("\n");
+    const selected = lines.filter((line) => line.includes("❯"));
+    // Exactly one selection marker, and it is on option 1.
+    return selected.length === 1 && FIRST_OPTION_SELECTED.test(selected[0]);
+}
+/** May the one Enter be pressed on this screen? The warning, with option 1 selected. */
+function safeToConfirm(text) {
+    return classifyPane(text) === "dev-channel-warning" && firstOptionSelected(text);
+}

package/dist/relay/launcher/handle.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIRM_DEADLINE_MS = exports.WARNING_POLL_MS = exports.WARNING_WATCH_MS = void 0;
+exports.handleLaunch = handleLaunch;
+exports.parseLaunch = parseLaunch;
+const policy_1 = require("../../launch/policy");
+const argv_1 = require("./argv");
+const approval_settings_1 = require("./approval-settings");
+const capabilities_1 = require("./capabilities");
+const dev_channel_screen_1 = require("./dev-channel-screen");
+const multiplexer_1 = require("./multiplexer");
+const started_1 = require("./started");
+const refused = (reason) => ({ status: "REFUSED", reason });
+const NO_MULTIPLEXER_HINT = "Install tmux (macOS: `brew install tmux`; Linux: `sudo apt install tmux`) so BayChat can start sessions here.";
+/** How long the pane is watched for the dev-channel warning after a channel launch. */
+exports.WARNING_WATCH_MS = 60_000;
+/** How often the pane is read while watching. */
+exports.WARNING_POLL_MS = 1_000;
+/**
+ * The relay's own limit on waiting for the owner. The server decides "no answer" at 10 min
+ * (CONFIRM_TIMEOUT); this is only for when the server cannot be reached to say so.
+ */
+exports.CONFIRM_DEADLINE_MS = 10 * 60_000 + 30_000;
+const INTERIM_REPORT_ATTEMPTS = 3;
+const RETRY_PAUSE_MS = 2_000;
+async function handleLaunch(launch, deps, io) {
+    if (!launch.commandAuthorized)
+        return refused("NOT_ALLOWED");
+    if ((0, argv_1.launchNameProblem)(launch.sessionName))
+        return refused("NAME_INVALID");
+    if (launch.kind === "STOP")
+        return stopSession(launch, deps);
+    const started = startSession(launch, deps);
+    if ("status" in started)
+        return started;
+    // Monitor sessions have no channel flag, so there is no warning to wait for.
+    if (launch.listen === "monitor")
+        return { status: "STARTED" };
+    return watchForDevChannelWarning(launch, started.entry, deps, io);
+}
+/** Check, spawn and record a START; the report when it ends here, else the recorded session. */
+function startSession(launch, deps) {
+    const spot = deps.loadPolicy()?.spots.find((s) => s.id === launch.spotId);
+    if (!spot)
+        return refused("SPOT_UNKNOWN");
+    if (!(0, policy_1.isLaunchRuntime)(launch.runtime) || !spot.runtimes.includes(launch.runtime))
+        return refused("RUNTIME_NOT_OFFERED");
+    if (launch.runtime !== "claude")
+        return refused("RUNTIME_NOT_YET");
+    if (launch.join && "group" in launch.join && (0, argv_1.roomTitleProblem)(launch.join.group))
+        return refused("ROOM_INVALID");
+    const folder = deps.resolveFolder(spot);
+    if (!folder.ok) {
+        deps.log(`launch ${launch.id}: refused, ${folder.reason}`);
+        return refused("FOLDER_CHANGED");
+    }
+    // An untrusted folder would leave claude waiting at "Is this a project you trust?" forever,
+    // in a detached pane nobody sees. Refuse instead, so the phone can say what to do.
+    if (!deps.isFolderTrusted(folder.path)) {
+        deps.log(`launch ${launch.id}: refused, Claude Code has not trusted ${folder.path}. Run \`baychat launch add\` for it at this computer.`);
+        return refused("FOLDER_NOT_TRUSTED");
+    }
+    const multiplexer = deps.detectMultiplexer();
+    if (!multiplexer) {
+        deps.log(`launch ${launch.id}: refused, no tmux or screen. ${NO_MULTIPLEXER_HINT}`);
+        return refused("NO_MULTIPLEXER");
+    }
+    const live = (0, multiplexer_1.liveLaunchSessions)(multiplexer, deps.run);
+    const recordFile = (0, started_1.startedRecordPath)(deps.launchDir);
+    const started = pruneEnded((0, started_1.loadStarted)(recordFile), live, deps);
+    if (live.includes(launch.sessionName))
+        return refused("NAME_TAKEN");
+    if (live.length >= policy_1.MAX_SESSIONS_PER_COMPUTER)
+        return refused("CAP_REACHED");
+    if (started.filter((s) => s.spotId === spot.id).length >= spot.maxSessions)
+        return refused("CAP_REACHED");
+    const binary = deps.resolveBinary(capabilities_1.RUNTIME_BINARY.claude);
+    if (!binary.ok)
+        return refused("RUNTIME_MISSING");
+    // Monitor: no channel flag and no channel marker — the session listens with listen_messages + Monitor.
+    const channel = launch.listen === "monitor" ? { args: [], env: {} } : deps.channelLaunch(binary.path);
+    const settingsFile = (0, approval_settings_1.approvalPathFor)(launch.sessionName) === "hook" ? (0, approval_settings_1.writeApprovalSettings)(launch.sessionName, deps.cli, deps.launchDir) : undefined;
+    const command = (0, argv_1.buildLaunchCommand)({
+        multiplexer,
+        sessionName: launch.sessionName,
+        folder: folder.path,
+        claudeBin: binary.path,
+        channelArgs: channel.args,
+        env: { ...channel.env, PATH: deps.pathEnv },
+        settingsFile,
+        join: launch.join,
+    });
+    const res = deps.run(command.file, command.args, { cwd: command.cwd, env: command.env });
+    if (res.error || res.status !== 0) {
+        (0, approval_settings_1.removeApprovalSettings)(launch.sessionName, deps.launchDir);
+        deps.log(`launch ${launch.id}: ${command.file} failed: ${res.error?.message ?? (res.stderr.trim() || `exit ${res.status}`)}`);
+        return { status: "FAILED", reason: "SPAWN_FAILED" };
+    }
+    const entry = { name: launch.sessionName, spotId: spot.id, runtime: launch.runtime, multiplexer, launchId: launch.id, startedAt: deps.now().toISOString() };
+    // Recorded BEFORE any watching, so a STOP (the owner's Deny, or Stop) can always find it.
+    (0, started_1.saveStarted)([...started, entry], recordFile);
+    deps.log(`launch ${launch.id}: started "${launch.sessionName}" in "${spot.label}" (${launch.listen}) for ${launch.requestedBy.name}. Approvals for this session come to BayChat.`);
+    return { entry };
+}
+/**
+ * After a channel launch: Claude Code stops at "WARNING: Loading development channels … Enter to
+ * confirm" on every start with the flag, and a detached pane would wait there forever. Watch the
+ * pane; when the warning shows, ask the computer's owner (NEEDS_CONFIRM) and press ONE Enter only
+ * after their Allow, only on that same screen with option 1 selected. Nothing is ever pressed
+ * otherwise. The folder-trust screen is never answered.
+ */
+async function watchForDevChannelWarning(launch, entry, deps, io) {
+    const until = deps.now().getTime() + exports.WARNING_WATCH_MS;
+    for (;;) {
+        const text = deps.capture(entry.multiplexer, entry.name);
+        const screen = text === null ? "other" : (0, dev_channel_screen_1.classifyPane)(text);
+        if (screen === "folder-trust")
+            return stopOwn(launch, entry, deps, { status: "FAILED", reason: "FOLDER_NOT_TRUSTED" }, "Claude Code asks whether to trust the folder");
+        if (screen === "dev-channel-warning")
+            return askOwner(launch, entry, deps, io);
+        // Never seen (it may already be past it), or the relay is shutting down: the pane runs on.
+        if (deps.now().getTime() >= until || io?.signal?.aborted)
+            return { status: "STARTED" };
+        await deps.sleep(exports.WARNING_POLL_MS);
+    }
+}
+async function askOwner(launch, entry, deps, io) {
+    if (!io || !(await sendInterim(io, deps))) {
+        return stopOwn(launch, entry, deps, { status: "FAILED", reason: "CONFIRM_UNREACHABLE" }, "could not ask the owner");
+    }
+    deps.log(`launch ${launch.id}: Claude Code shows the development-channels warning; waiting for the computer owner's OK in BayChat.`);
+    const answer = await awaitDecision(io, deps);
+    if (io.signal?.aborted) {
+        // Shutting down: the report would not be delivered anyway. The server times the question out
+        // and queues a STOP, which the relay carries out when it is back.
+        return refused("CONFIRM_TIMEOUT");
+    }
+    if (!answer)
+        return stopOwn(launch, entry, deps, refused("CONFIRM_TIMEOUT"), "no answer from the owner");
+    if (answer.decision === "deny") {
+        // Press nothing. The server queued a STOP for this session; the next poll carries it out.
+        const reason = answer.reason === "CONFIRM_TIMEOUT" ? "CONFIRM_TIMEOUT" : "OWNER_DECLINED";
+        deps.log(`launch ${launch.id}: the owner did not allow it (${reason}); nothing was pressed.`);
+        return refused(reason);
+    }
+    return confirmWarning(launch, entry, deps);
+}
+/** The owner allowed it: press ONE Enter, only on the same warning with option 1 selected. */
+function confirmWarning(launch, entry, deps) {
+    // Only ever into the pane this launch created and the record lists.
+    const recorded = (0, started_1.loadStarted)((0, started_1.startedRecordPath)(deps.launchDir)).find((s) => s.name === entry.name && s.launchId === launch.id && s.multiplexer === entry.multiplexer);
+    if (!recorded) {
+        deps.log(`launch ${launch.id}: its pane is no longer in the launcher's record; nothing was pressed.`);
+        return { status: "FAILED", reason: "CONFIRM_SCREEN_CHANGED" };
+    }
+    const text = deps.capture(entry.multiplexer, entry.name);
+    if (text === null)
+        return stopOwn(launch, entry, deps, { status: "FAILED", reason: "CONFIRM_SCREEN_CHANGED" }, "its pane cannot be read");
+    const screen = (0, dev_channel_screen_1.classifyPane)(text);
+    if (screen === "folder-trust")
+        return stopOwn(launch, entry, deps, { status: "FAILED", reason: "FOLDER_NOT_TRUSTED" }, "Claude Code asks whether to trust the folder");
+    if (screen === "other") {
+        // Someone at the computer answered it already (or Claude moved on): nothing to press.
+        deps.log(`launch ${launch.id}: the warning is gone; nothing was pressed.`);
+        return { status: "STARTED" };
+    }
+    if (!(0, dev_channel_screen_1.safeToConfirm)(text))
+        return stopOwn(launch, entry, deps, { status: "FAILED", reason: "CONFIRM_SCREEN_CHANGED" }, "the warning changed (option 1 is not selected)");
+    if (!deps.pressEnter(entry.multiplexer, entry.name))
+        return stopOwn(launch, entry, deps, { status: "FAILED", reason: "LAUNCHER_ERROR" }, "Enter could not be sent");
+    deps.log(`launch ${launch.id}: the owner allowed it; pressed Enter once on "I am using this for local development".`);
+    return { status: "STARTED" };
+}
+async function sendInterim(io, deps) {
+    for (let attempt = 1; attempt <= INTERIM_REPORT_ATTEMPTS; attempt++) {
+        try {
+            await io.report({ status: "NEEDS_CONFIRM", reason: "DEV_CHANNEL_WARNING" });
+            return true;
+        }
+        catch (err) {
+            deps.log(`launcher: NEEDS_CONFIRM report failed (${err instanceof Error ? err.message : String(err)})`);
+            if (attempt < INTERIM_REPORT_ATTEMPTS)
+                await deps.sleep(RETRY_PAUSE_MS);
+        }
+    }
+    return false;
+}
+/** Long-poll until the owner decides, or the relay's own deadline passes (null). */
+async function awaitDecision(io, deps) {
+    const until = deps.now().getTime() + exports.CONFIRM_DEADLINE_MS;
+    while (deps.now().getTime() < until && !io.signal?.aborted) {
+        const asked = deps.now().getTime();
+        try {
+            const answer = await io.pollDecision();
+            if (answer.decision === "allow" || answer.decision === "deny")
+                return answer;
+            // A poll that came back at once must not turn into a busy loop.
+            if (deps.now().getTime() - asked < exports.WARNING_POLL_MS)
+                await deps.sleep(exports.WARNING_POLL_MS);
+        }
+        catch (err) {
+            deps.log(`launcher: confirm poll failed (${err instanceof Error ? err.message : String(err)})`);
+            await deps.sleep(RETRY_PAUSE_MS);
+        }
+    }
+    return null;
+}
+/** Kill this launch's own pane (never pressing anything), forget it, and return `report`. */
+function stopOwn(launch, entry, deps, report, why) {
+    deps.log(`launch ${launch.id}: ${why}; nothing was pressed, stopping "${entry.name}".`);
+    stopRecorded(entry, deps);
+    return report;
+}
+/**
+ * STOP kills only what the launcher itself started: the session must be in started.json AND
+ * alive. A hand-made `bc-x` tmux session, or one listed but already gone, is never touched.
+ */
+function stopSession(launch, deps) {
+    const recordFile = (0, started_1.startedRecordPath)(deps.launchDir);
+    const started = (0, started_1.loadStarted)(recordFile);
+    const entry = started.find((s) => s.name === launch.sessionName);
+    if (!entry)
+        return refused("NOT_LAUNCHED");
+    const outcome = stopRecorded(entry, deps);
+    if (outcome === "not-running")
+        return refused("NOT_RUNNING");
+    if (outcome === "failed")
+        return { status: "FAILED", reason: "STOP_FAILED" };
+    deps.log(`launch ${launch.id}: stopped "${entry.name}" for ${launch.requestedBy.name}`);
+    return { status: "STARTED" };
+}
+/**
+ * The one stop routine (STOP, and a launch abandoned while watching its pane): kill the recorded
+ * session if it is alive, then forget it and delete its settings file. A kill that fails leaves
+ * the record, so a later STOP can try again.
+ */
+function stopRecorded(entry, deps) {
+    const recordFile = (0, started_1.startedRecordPath)(deps.launchDir);
+    const forget = () => {
+        (0, started_1.saveStarted)((0, started_1.loadStarted)(recordFile).filter((s) => s.name !== entry.name), recordFile);
+        (0, approval_settings_1.removeApprovalSettings)(entry.name, deps.launchDir);
+    };
+    if (!(0, multiplexer_1.liveLaunchSessions)(entry.multiplexer, deps.run).includes(entry.name)) {
+        forget();
+        return "not-running";
+    }
+    if (!(0, multiplexer_1.killLaunchSession)(entry.multiplexer, entry.name, deps.run))
+        return "failed";
+    forget();
+    return "stopped";
+}
+/** Forget sessions that ended on their own (and delete their settings files); return the rest. */
+function pruneEnded(started, live, deps) {
+    const alive = started.filter((s) => live.includes(s.name));
+    if (alive.length === started.length)
+        return started;
+    for (const gone of started.filter((s) => !alive.includes(s)))
+        (0, approval_settings_1.removeApprovalSettings)(gone.name, deps.launchDir);
+    (0, started_1.saveStarted)(alive, (0, started_1.startedRecordPath)(deps.launchDir));
+    return alive;
+}
+/** The launch in a poll answer, checked field by field; null for anything malformed. */
+function parseLaunch(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const l = raw;
+    if (typeof l.id !== "string" || (l.kind !== "START" && l.kind !== "STOP") || typeof l.sessionName !== "string")
+        return null;
+    const requestedBy = l.requestedBy;
+    if (!requestedBy || typeof requestedBy.id !== "string" || typeof requestedBy.name !== "string")
+        return null;
+    const join = parseJoin(l.join);
+    if (join === undefined)
+        return null;
+    // Missing = an older server = the channel, as before. Anything unknown is malformed.
+    const listen = l.listen === undefined || l.listen === "channel" ? "channel" : l.listen === "monitor" ? "monitor" : null;
+    if (!listen)
+        return null;
+    return {
+        id: l.id,
+        kind: l.kind,
+        spotId: typeof l.spotId === "string" ? l.spotId : null,
+        runtime: typeof l.runtime === "string" ? l.runtime : null,
+        sessionName: l.sessionName,
+        join,
+        listen,
+        requestedBy: { id: requestedBy.id, name: requestedBy.name },
+        requestedByIsOwner: l.requestedByIsOwner === true,
+        // Only an explicit `true` authorises; a missing or odd value is a refusal.
+        commandAuthorized: l.commandAuthorized === true,
+    };
+}
+/** `null` is "join nothing"; undefined is a join that is present but malformed. */
+function parseJoin(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    const j = raw;
+    if (typeof j.group === "string")
+        return { group: j.group };
+    if (j.sessions === true)
+        return { sessions: true };
+    return undefined;
+}