baychat 0.37.0 → 0.39.0

package/dist/relay/daemon.js

@@ -1887,6 +1887,7 @@ class RelayDaemon {
      */
     registerChannel(frame, sock) {
         const previous = this.channels.get(frame.session);
+        const before = this.registry.get(frame.session);
         if (previous && previous !== sock) {
             this.log(`replacing channel for ${frame.session}: dropping the previous one`);
             (0, socket_1.writeFrame)(previous, { type: "error", message: channel_sessions_1.CHANNEL_REPLACED });
@@ -1905,6 +1906,12 @@ class RelayDaemon {
         (0, socket_1.writeFrame)(sock, { type: "attached", session: frame.session, delivery: "channel" });
         const where = frame.pane?.kind === "tmux" ? `tmux pane ${frame.pane.pane}` : (frame.pane?.kind ?? "no multiplexer");
         this.log(`channel registered: ${frame.session} (${frame.runtime}, commands only, ${where})`);
+        // Another Claude Code process took this name (a new terminal, 2026-10-30): its memory starts
+        // empty, so the server must not keep showing the old process's reading and tidy count.
+        // The same process re-registering (a reconnect) keeps its pid and sends nothing.
+        if (before?.ownerPid && frame.ownerPid && before.ownerPid !== frame.ownerPid) {
+            this.reportContext(frame.session, { runtime: "claude-code", event: "session_start", source: "exact" });
+        }
     }
     /**
      * Forget every channel session that is DEAD: its channel link is closed and its Claude Code

package/dist/relay/launcher/loop.js

@@ -133,7 +133,18 @@ async function reportSessionSpots(deps, auth, signal, last, log) {
     if (key === last)
         return last;
     try {
-        await deps.request(auth, "PUT", "/api/device-api/launch-sessions", { sessions }, signal);
+        try {
+            await deps.request(auth, "PUT", "/api/device-api/launch-sessions", { sessions }, signal);
+        }
+        catch (err) {
+            // A server older than the `withinSpotId` hint (2026-10-30) refuses the whole report as
+            // INVALID_SESSION_SPOTS: send it again without the hints, so "Start again" places still land.
+            const hinted = sessions.some((s) => s.withinSpotId !== undefined);
+            if (!(hinted && err instanceof api_1.ApiError && err.status === 400))
+                throw err;
+            const plain = sessions.map(({ withinSpotId: _hint, ...rest }) => rest);
+            await deps.request(auth, "PUT", "/api/device-api/launch-sessions", { sessions: plain }, signal);
+        }
         return key;
     }
     catch (err) {

package/dist/relay/launcher/session-spots.js

@@ -37,6 +37,7 @@ exports.MAX_SESSION_SPOTS = void 0;
 exports.sessionSpots = sessionSpots;
 exports.realRealpath = realRealpath;
 const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const policy_1 = require("../../launch/policy");
 const argv_1 = require("./argv");
 /** The server takes at most this many per report. */
@@ -56,13 +57,27 @@ function sessionSpots(sessions, policy, deps) {
             continue;
         const real = deps.realpath(dir);
         const runtime = session.runtime;
-        const match = real ? folders.find((f) => f.path === real && f.spot.runtimes.includes(runtime)) : undefined;
-        out.push({ name: session.name, spotId: match?.spot.id ?? null, runtime, listen: session.delivery === "channel" ? "channel" : "monitor" });
+        const offered = folders.filter((f) => f.spot.runtimes.includes(runtime));
+        const match = real ? offered.find((f) => f.path === real) : undefined;
+        // The deepest spot folder above it: the longest path that is a proper prefix at a separator.
+        const within = real && !match ? offered.filter((f) => isInside(real, f.path)).sort((a, b) => b.path.length - a.path.length)[0] : undefined;
+        out.push({
+            name: session.name,
+            spotId: match?.spot.id ?? null,
+            ...(within ? { withinSpotId: within.spot.id } : {}),
+            runtime,
+            listen: session.delivery === "channel" ? "channel" : "monitor",
+        });
         if (out.length === exports.MAX_SESSION_SPOTS)
             break;
     }
     return out.sort((a, b) => a.name.localeCompare(b.name));
 }
+/** Is `dir` strictly inside `parent` (both realpaths)? `/work/web2` is not inside `/work/web`. */
+function isInside(dir, parent) {
+    const prefix = parent.endsWith(path.sep) ? parent : parent + path.sep;
+    return dir.startsWith(prefix);
+}
 function realRealpath(dir) {
     try {
         return fs.realpathSync(dir);

package/dist/setup-command.js

@@ -0,0 +1,126 @@
+"use strict";
+// `npx baychat` and `baychat setup` — ONE COMMAND (Karmen + Lorenzo, 31 Oct 2026; plan in BAYCHAT, vps-reviewed).
+//
+// Bare `baychat`: the first time (no "set up" mark yet), sign in once and set up every agent app found (setup-plan.ts),
+// print one checklist, then start a session — only inside a project (vps: never in the home folder, where a session
+// could read and write everything). Once set up, bare `baychat` goes straight to the start, as before, without asking
+// every app again. `baychat setup` always looks again (after installing a new app).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetup = runSetup;
+exports.runBare = runBare;
+exports.runSetupCommand = runSetupCommand;
+exports.setupMarkPath = setupMarkPath;
+exports.realSetupDeps = realSetupDeps;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const commands_1 = require("./commands");
+const connect_1 = require("./connect");
+const connect_claude_1 = require("./connect-claude");
+const doctor_1 = require("./doctor");
+const doctor_command_1 = require("./doctor-command");
+const machine_name_1 = require("./machine-name");
+const multiplexer_launch_1 = require("./multiplexer-launch");
+const setup_facts_1 = require("./setup-facts");
+const start_command_1 = require("./start-command");
+const setup_plan_1 = require("./setup-plan");
+/** Look, set up what is missing, and say what is ready. Returns 2 when the login was not approved. */
+async function runSetup(deps) {
+    const facts = await deps.facts();
+    const steps = (0, setup_plan_1.planSetup)(facts);
+    const done = new Set();
+    const failed = new Set();
+    for (const step of steps) {
+        if (step.kind === "login") {
+            deps.log("Sign this computer in to BayChat (once): scan the code with the BayChat app.");
+            if (!(await deps.login()))
+                return 2;
+            continue;
+        }
+        deps.log(`Setting up ${step.client}…`);
+        if ((await deps.connect(step.client)) === 0)
+            done.add(step.client);
+        else
+            failed.add(step.client);
+    }
+    deps.log("");
+    for (const line of (0, setup_plan_1.setupChecklist)(facts, { done, failed }))
+        deps.log(`  ${line}`);
+    deps.markSetUp();
+    return 0;
+}
+/**
+ * Bare `baychat`: set up the first time, then start — in a project only. Once set up, a project starts straight away;
+ * any other folder (the home folder above all) asks first, default no (vps, 31 Oct: nobody gives an agent all of home
+ * by accident).
+ */
+async function runBare(deps) {
+    if (deps.wasSetUp()) {
+        if (deps.inProject())
+            return deps.start();
+        if (await deps.confirm("This isn't a project folder. Start a session here anyway? (y/N) "))
+            return deps.start();
+        deps.log("  Not started. cd into a project and run npx baychat again (or start a session from the BayChat app).");
+        return 0;
+    }
+    const code = await runSetup(deps);
+    if (code !== 0)
+        return code;
+    return startOrPoint(deps);
+}
+/** `baychat setup`: always look again; start only when asked to and in a project. */
+async function runSetupCommand(deps) {
+    const code = await runSetup(deps);
+    if (code !== 0)
+        return code;
+    deps.log("");
+    deps.log("  Next: run npx baychat in a project folder to start a session (or start one from the BayChat app).");
+    return 0;
+}
+async function startOrPoint(deps) {
+    deps.log("");
+    if (deps.inProject())
+        return deps.start();
+    deps.log("  Next: cd into a project and run npx baychat again (or start a session from the BayChat app).");
+    return 0;
+}
+/** Where the "set up" mark lives: beside the credentials, removed with them. */
+function setupMarkPath() {
+    return path_1.default.join((0, config_1.configDir)(), "setup-done.json");
+}
+/** The real dependencies. `wsl` only for tests: a test run inside WSL still exercises the Claude Desktop path. */
+function realSetupDeps(over = {}) {
+    const exists = (p) => fs_1.default.existsSync(p);
+    return {
+        facts: async () => {
+            const env = await (0, doctor_command_1.currentDoctorEnv)();
+            return (0, setup_facts_1.setupFactsFrom)(env, (0, doctor_1.buildReport)(env), { wsl: over.wsl ?? (0, machine_name_1.isWsl)(), exists });
+        },
+        login: () => (0, commands_1.cmdLogin)({ registerClaude: false, hint: false }),
+        connect: (client) => (client === "claude" ? (0, connect_claude_1.cmdConnectClaude)({}) : (0, connect_1.cmdConnect)(client, {})),
+        start: () => (0, start_command_1.cmdStart)([]),
+        inProject: () => (0, setup_plan_1.isProjectDir)(process.cwd(), exists, os_1.default.homedir()),
+        confirm: async (question) => {
+            if (!process.stdin.isTTY)
+                return false;
+            return /^y(es)?$/i.test((await (0, multiplexer_launch_1.askLine)(question)).trim());
+        },
+        // Signed out since (or the credentials were removed): look again, which signs in.
+        wasSetUp: () => exists(setupMarkPath()) && (0, config_1.loadDeviceCredentials)() !== null,
+        markSetUp: () => {
+            try {
+                fs_1.default.mkdirSync(path_1.default.dirname(setupMarkPath()), { recursive: true });
+                fs_1.default.writeFileSync(setupMarkPath(), JSON.stringify({ at: new Date().toISOString() }) + "\n");
+            }
+            catch (err) {
+                // Only costs a second look next time.
+                console.warn(`Could not record that setup is done: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        log: (line) => console.log(line),
+    };
+}

package/dist/setup-facts.js

@@ -0,0 +1,44 @@
+"use strict";
+// The facts `planSetup` decides from, read off this computer through what `baychat doctor` already knows: its report
+// says whether BayChat is in each app (it asks `claude mcp list` / `codex mcp list` themselves, and reads every file
+// Claude Desktop or Cursor may open), and its binary resolver says what is installed. Nothing new is guessed here.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configuredFrom = configuredFrom;
+exports.installedFrom = installedFrom;
+exports.setupFactsFrom = setupFactsFrom;
+const path_1 = __importDefault(require("path"));
+const client_paths_1 = require("./client-paths");
+const setup_plan_1 = require("./setup-plan");
+/** Is BayChat in this app already? Doctor's MCP check passes for it (an unknown answer counts as no: connect again). */
+function configuredFrom(report) {
+    const out = {};
+    for (const client of setup_plan_1.SETUP_CLIENTS) {
+        const runtime = report.runtimes.find((r) => r.runtime === client);
+        out[client] = Boolean(runtime?.checks.some((c) => c.name === "mcp" && c.status === "pass"));
+    }
+    return out;
+}
+/** Is the app on this computer? A CLI is a resolvable binary; a GUI app is the folder its config lives in. */
+function installedFrom(env, exists) {
+    const pathEnv = env.pathEnv ?? { home: env.home, platform: env.platform };
+    return {
+        claude: env.resolveBinary("claude").ok,
+        desktop: (0, client_paths_1.configPathsFor)("desktop", pathEnv).some((file) => exists((0, client_paths_1.configDirOf)(file))),
+        codex: env.resolveBinary("codex").ok || exists(path_1.default.join(pathEnv.codexHome ?? path_1.default.join(env.home, ".codex"))),
+        cursor: exists(path_1.default.join(env.home, ".cursor")) || env.resolveBinary("cursor-agent").ok,
+    };
+}
+/** Every fact `planSetup` needs. */
+function setupFactsFrom(env, report, host) {
+    const expires = env.device ? Date.parse(env.device.expiresAt) : NaN;
+    return {
+        signedIn: env.device !== null && Number.isFinite(expires) && expires > env.now,
+        installed: installedFrom(env, host.exists),
+        configured: configuredFrom(report),
+        wsl: host.wsl,
+        hermesFound: env.resolveBinary("hermes").ok || host.exists(path_1.default.join(env.home, ".hermes")),
+    };
+}

package/dist/setup-plan.js

@@ -0,0 +1,94 @@
+"use strict";
+// What `npx baychat` (and `baychat setup`) should DO, decided before anything is done.
+//
+// ONE COMMAND (Karmen + Lorenzo, 31 Oct 2026): people did not know which of `login`, `connect desktop`,
+// `connect codex`… was theirs. Now the one line signs this computer in ONCE (the phone QR) and sets up every agent
+// app it finds that is not set up yet — through the very same `connect` paths, so nothing new is written anywhere.
+// Hermes is named, not set up: it gets an agent of its own, chosen on the phone (a second QR), which is not "one".
+//
+// Facts in, steps out — like `connect-plan.ts` — so the order is testable without a phone, a network or the apps.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETUP_CLIENTS = void 0;
+exports.planSetup = planSetup;
+exports.setupChecklist = setupChecklist;
+exports.isProjectDir = isProjectDir;
+/** The apps one command sets up, in the order it does them. */
+exports.SETUP_CLIENTS = ["claude", "desktop", "codex", "cursor"];
+const LABELS = {
+    claude: "Claude Code",
+    desktop: "Claude Desktop",
+    codex: "Codex",
+    cursor: "Cursor",
+};
+/** The steps: the one login when there is none, then every app found and not yet set up. */
+function planSetup(facts) {
+    const steps = facts.signedIn ? [] : [{ kind: "login" }];
+    for (const client of exports.SETUP_CLIENTS) {
+        if (client === "desktop" && facts.wsl)
+            continue;
+        if (facts.installed[client] && !facts.configured[client])
+            steps.push({ kind: "connect", client });
+    }
+    return steps;
+}
+/** The closing list, one line per app: ready, set up now, not here, or not finished (with what to run). */
+function setupChecklist(facts, outcome) {
+    const lines = exports.SETUP_CLIENTS.map((client) => {
+        const label = LABELS[client];
+        if (client === "desktop" && facts.wsl)
+            return `– ${label} (it runs on Windows: run npx baychat once in Windows PowerShell)`;
+        if (outcome.failed.has(client))
+            return `✗ ${label} (did not finish; run npx baychat connect ${client})`;
+        if (outcome.done.has(client))
+            return client === "desktop" ? `✓ ${label} (just set up; restart it once)` : `✓ ${label} (just set up)`;
+        if (facts.configured[client])
+            return `✓ ${label}`;
+        return `– ${label} (not on this computer)`;
+    });
+    if (facts.hermesFound)
+        lines.push("• Hermes found: npx baychat connect hermes (it gets its own agent, chosen on your phone)");
+    return lines;
+}
+/** Files that make a folder a project worth starting an agent in. */
+const PROJECT_MARKERS = [
+    "package.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "Gemfile",
+    "pom.xml",
+    "build.gradle",
+    "composer.json",
+    "deno.json",
+    "Package.swift",
+    "mix.exs",
+];
+/**
+ * May a session start here? vps, 31 Oct: a first-time user often runs `npx baychat` in the home folder, and a session
+ * started there can read and write all of it. So only in a project: a folder with a project file, or inside a git
+ * repository (found by walking up, stopping BEFORE the home folder). The home folder itself never counts.
+ */
+function isProjectDir(cwd, exists, home) {
+    const sep = cwd.includes("\\") && !cwd.includes("/") ? "\\" : "/";
+    const trim = (p) => (p.length > 1 && (p.endsWith("/") || p.endsWith("\\")) ? p.slice(0, -1) : p);
+    const here = trim(cwd);
+    const stop = trim(home);
+    if (here === stop)
+        return false;
+    const join = (dir, name) => `${dir}${sep}${name}`;
+    if (PROJECT_MARKERS.some((marker) => exists(join(here, marker))))
+        return true;
+    for (let dir = here; dir !== stop;) {
+        if (exists(join(dir, ".git")))
+            return true;
+        const cut = dir.lastIndexOf(sep);
+        if (cut <= 0 || dir.slice(0, cut) === dir)
+            break;
+        const parent = dir.slice(0, cut);
+        if (parent.length < stop.length)
+            break;
+        dir = parent;
+    }
+    return false;
+}

package/dist/start-command.js

@@ -95,7 +95,7 @@ function startRefusal(runtime) {
 }
 async function cmdStart(args) {
     if (!(0, config_1.loadDeviceCredentials)()) {
-        console.error("This machine is not signed in yet. Run `npx baychat login` first.");
+        console.error("This machine is not signed in yet. Run `npx baychat` first: it signs in and sets up your agent apps.");
         return 1;
     }
     // THE UPDATE NOBODY HAS TO REMEMBER.

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "BayChat's denied-command card for every session, also ones started by hand: an auto-mode denial becomes a card in the session's BayChat chat once it has joined (docs/features/DENIED_COMMAND_CARD.md). After a compact, a channel session is told when its BayChat feed is down (channel-check). No PostToolUse hook: it would start baychat on every tool call.",
+  "description": "BayChat's denied-command card for every session, also ones started by hand: an auto-mode denial becomes a card in the session's BayChat chat once it has joined (docs/features/DENIED_COMMAND_CARD.md). After a compact, a channel session is told when its BayChat feed is down (channel-check). A question left open in the terminal (a permission dialog, an MCP form) becomes one line on the owner's phone (notify-hook). No PostToolUse hook: it would start baychat on every tool call.",
   "hooks": {
     "PermissionDenied": [
       {
@@ -9,7 +9,7 @@
             "type": "command",
             "command": "baychat denied-hook --session-from-claude --plugin --timeout 3600",
             "timeout": 3900,
-            "statusMessage": "Blocked by auto mode \u2014 asking in BayChat\u2026"
+            "statusMessage": "Blocked by auto mode — asking in BayChat…"
           }
         ]
       }
@@ -25,6 +25,18 @@
           }
         ]
       }
+    ],
+    "Notification": [
+      {
+        "matcher": "permission_prompt|elicitation_dialog|elicitation_url_dialog",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "baychat notify-hook",
+            "timeout": 30
+          }
+        ]
+      }
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex, Cursor) with BayChat, or have the relay run DeepSeek or the Cursor CLI for you",
   "bin": {
     "baychat": "dist/index.js"