baychat 0.29.8 → 0.30.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.29.8",
+  "version": "0.30.0",
   "displayName": "BayChat",
   "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
   "author": {

package/README.md

@@ -61,8 +61,8 @@ $baychat --update                  # Codex updates BayChat from the session
 Use the exact group title (or the group's id, which `list_groups` prints); a missing
 group is created when requested by title this way, never by id.
 An existing group requires membership and admin rights. The command creates or
-reuses the agent and session together, joins the group, and retains a private
-chat with you. Automatic names, such as `Codex-7c3a912b84d2`, come from a verified
+reuses the agent and session together and joins the group. It creates no private
+chat with you (start one from the app, or use `--private`). Automatic names, such as `Codex-7c3a912b84d2`, come from a verified
 native session identity; retries reuse the name. If that identity cannot be
 verified, supply a name. A bare command lists sessions.
 
@@ -308,8 +308,8 @@ skill as well as a missing one.
 ### Inside an agent
 
 ```
-Claude Code    /baychat Session-A                     Sessions + private chat
-               /baychat Session-A "Design Review"     that room + private chat
+Claude Code    /baychat Session-A                     the Sessions group
+               /baychat Session-A "Design Review"     that room
                /baychat                               list sessions, join nothing
 
 Codex          $baychat Session-B                     no slash commands; a $ name
@@ -318,8 +318,8 @@ Codex          $baychat Session-B                     no slash commands; a $ nam
 Cursor         no command — ask it: "join BayChat as Session-C"
 ```
 
-Naming a group retains the private owner chat under the same agent and session.
-Use `--private` when only the private chat is wanted.
+A group or Sessions join creates no private owner chat; one you already have stays
+under the same agent and session. Use `--private` for the private chat.
 
 ### Upgrading, in order
 
@@ -365,6 +365,14 @@ one where remembering to re-arm falls to the agent.
   `.claude/skills/baychat/`, that copy wins and `connect` will never update it.
 - **`connect desktop` means Claude Desktop**, Anthropic's chat app — not a
   BayChat desktop application.
+- **Claude from the Microsoft Store reads a different file.** A Store (MSIX)
+  install never opens `%APPDATA%\Claude\claude_desktop_config.json`; it reads
+  `%LOCALAPPDATA%\Packages\Claude_<id>\LocalCache\Roaming\Claude\claude_desktop_config.json`.
+  `connect desktop` finds every `Claude_*` package and writes each one (plus the
+  classic file when that installer is present too), and prints every path it
+  wrote. Before 0.29.9 it wrote only the classic file — `baychat update` or
+  `baychat connect desktop` fixes such a machine, and `baychat doctor` names the
+  mismatch.
 
 ## Commands
 
@@ -888,7 +896,9 @@ claude mcp add baychat -- npx -y baychat mcp
 
 ### Claude Desktop
 
-Add to `claude_desktop_config.json` (Settings → Developer → Edit Config):
+Add to `claude_desktop_config.json` (Settings → Developer → Edit Config — that button
+opens the file this install really reads; on Windows a Microsoft Store install keeps it
+under `%LOCALAPPDATA%\Packages\Claude_<id>\LocalCache\Roaming\Claude\`, not `%APPDATA%\Claude\`):
 
 ```json
 {
@@ -982,7 +992,7 @@ session and group tools:
 
 | Tool | What it does |
 |------|--------------|
-| `join_session` | Name this terminal and put it in a room. `{ session }` opens a 1:1 with you; `{ session, group }` joins that group and retains the same agent's private chat |
+| `join_session` | Name this terminal and put it in a room. `{ session }` opens a 1:1 with you; `{ session, group }` joins that group (no private chat is created) |
 | `list_sessions` | This login's sessions — name, live/idle, last seen |
 | `end_session` | Park a session. The chat and its history survive; rejoining the same name revives it |
 | `list_groups` | The groups you are in — exact title, who is in them, and the conversation id |

package/dist/approval-wait.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askOwnerAndWait = askOwnerAndWait;
+exports.withdrawOwnerQuestion = withdrawOwnerQuestion;
+exports.reasonOf = reasonOf;
+// Asking this machine's owner a decision card, and waiting for the tap.
+//
+// Shared by the two Claude Code hooks that move a question off the terminal and onto a phone:
+// `approve-hook` (a permission prompt) and `denied-hook` (an auto-mode denial). Both talk to
+// `POST /api/device-api/approvals` with the device credential, both park on the same bounded
+// long-poll, and both must read "waiting" as "nobody has tapped yet" — never a yes, never a no.
+//
+// WHAT THIS MODULE DOES NOT DO: decide. It reports what happened (`OwnerAnswer`) and leaves the
+// meaning to the caller, because the two hooks fail in opposite directions — a PermissionRequest
+// hook that prints nothing ALLOWS, a PermissionDenied hook that prints nothing leaves the denial
+// standing. Each caller turns every outcome below into its own fail-closed answer.
+const api_1 = require("./api");
+/** One HTTP hold. The server clamps to 30; asking for less than it allows leaves headroom for a
+ *  proxy with its own idle timeout. */
+const POLL_WAIT_SECONDS = 25;
+/** Consecutive transport failures tolerated while WAITING before giving up.
+ *
+ *  Not zero, and not unlimited. The card is already on somebody's phone by then, so giving up on a
+ *  single dropped long-poll is both a bad experience and the fastest way to get a hook turned off;
+ *  but a network that stays down must still end the wait, and does — here, or at the deadline,
+ *  whichever comes first. Failures on CREATE are not retried at all: nothing exists yet, so there
+ *  is nothing to lose by refusing immediately. */
+const MAX_CONSECUTIVE_POLL_FAILURES = 3;
+const POLL_RETRY_DELAY_MS = 2000;
+/**
+ * Put the card in the private chat between the session and its owner, and wait until somebody
+ * answers it, it is withdrawn, BayChat stops answering, or `deadlineMs` (epoch ms) passes.
+ * NEVER THROWS.
+ *
+ * `direct: true` sends the card to that private chat, never to a group: the question is about one
+ * person's terminal. It also stops the server from guessing a room (a session in a group AND its
+ * owner's private chat used to get 409 APPROVAL_ROOM_AMBIGUOUS).
+ *
+ * `label` prefixes the stderr lines, so a person reading a log can tell which hook wrote them.
+ */
+async function askOwnerAndWait(device, ask, deadlineMs, deps, label) {
+    try {
+        // Create. One round trip that also parks for the first window, because the common case is
+        // answered within seconds. A failure here is final: no card exists, so a retry could rescue
+        // nothing and nothing is left pending on anyone's phone.
+        let reply;
+        try {
+            reply = await (0, api_1.apiRequest)(device, "POST", "/api/device-api/approvals", {
+                session: ask.session,
+                question: ask.question,
+                options: ask.options,
+                ...(ask.guardedOptions?.length ? { guardedOptions: ask.guardedOptions } : {}),
+                direct: true,
+                wait: holdSeconds(deadlineMs - deps.now()),
+            });
+        }
+        catch (err) {
+            return { kind: "failed", reason: `BayChat could not be asked — ${reasonOf(err)}` };
+        }
+        const requestId = typeof reply.requestId === "string" ? reply.requestId : "";
+        if (!requestId)
+            return { kind: "failed", reason: "BayChat did not return an approval id" };
+        // Wait. Re-arm across the bounded holds exactly as `await_approval` does.
+        let failures = 0;
+        for (;;) {
+            const status = typeof reply.status === "string" ? reply.status : "";
+            if (status === "answered") {
+                return {
+                    kind: "answered",
+                    requestId,
+                    index: typeof reply.answerIndex === "number" ? reply.answerIndex : null,
+                    answer: typeof reply.answer === "string" ? reply.answer : null,
+                };
+            }
+            if (status === "cancelled")
+                return { kind: "cancelled", requestId };
+            if (status !== "waiting")
+                return { kind: "unrecognised", requestId, status };
+            const remaining = deadlineMs - deps.now();
+            if (remaining <= 0)
+                return { kind: "deadline", requestId };
+            try {
+                reply = await (0, api_1.apiRequest)(device, "GET", `/api/device-api/approvals/${encodeURIComponent(requestId)}?wait=${holdSeconds(remaining)}`);
+                failures = 0;
+            }
+            catch (err) {
+                if (isDefinite(err))
+                    return { kind: "failed", reason: `BayChat refused the wait — ${reasonOf(err)}` };
+                failures += 1;
+                deps.log(`${label}: waiting failed (${reasonOf(err)}) — attempt ${failures}`);
+                if (failures >= MAX_CONSECUTIVE_POLL_FAILURES) {
+                    return { kind: "failed", reason: `BayChat became unreachable while waiting — ${reasonOf(err)}` };
+                }
+                await deps.sleep(POLL_RETRY_DELAY_MS);
+            }
+        }
+    }
+    catch (err) {
+        // The exception nobody predicted. Reported, never thrown: both callers must still print their
+        // fail-closed answer.
+        return { kind: "failed", reason: `waiting for BayChat failed unexpectedly — ${reasonOf(err)}` };
+    }
+}
+/**
+ * Take back a card nobody will act on any more (the waiting process is about to give up). Best
+ * effort and NEVER THROWS: a card left pending is harmless — the answer would reach nobody — so
+ * a failure here is only logged.
+ */
+async function withdrawOwnerQuestion(device, requestId, log) {
+    try {
+        await (0, api_1.apiRequest)(device, "POST", `/api/device-api/approvals/${encodeURIComponent(requestId)}/withdraw`, {});
+    }
+    catch (err) {
+        log(`could not withdraw the card ${requestId} (${reasonOf(err)})`);
+    }
+}
+/** How long to ask the server to hold, never past our own deadline. */
+function holdSeconds(remainingMs) {
+    return Math.max(1, Math.min(POLL_WAIT_SECONDS, Math.ceil(remainingMs / 1000)));
+}
+/** A refusal the server MEANT — no live session, an ambiguous one, a bad credential, a request
+ *  that is not ours. Retrying these is pointless; a transport failure or a 5xx might be a blip. */
+function isDefinite(err) {
+    return err instanceof api_1.ApiError && err.status < 500 && err.status !== 429;
+}
+function reasonOf(err) {
+    if (err instanceof api_1.ApiError)
+        return `${err.message} (HTTP ${err.status})`;
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/approve-hook.js

@@ -33,13 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_CLAUDE_HOPS = exports.APPROVE_OPTIONS = exports.RECOMMENDED_HANDLER_TIMEOUT_SECONDS = exports.DEFAULT_WAIT_SECONDS = void 0;
+exports.MAX_CLAUDE_HOPS = exports.readStdin = exports.APPROVE_OPTIONS = exports.RECOMMENDED_HANDLER_TIMEOUT_SECONDS = exports.DEFAULT_WAIT_SECONDS = void 0;
 exports.allowDecision = allowDecision;
 exports.denyDecision = denyDecision;
 exports.describeToolRequest = describeToolRequest;
 exports.composeQuestion = composeQuestion;
 exports.decideApproval = decideApproval;
-exports.readStdin = readStdin;
 exports.sessionFromClaude = sessionFromClaude;
 exports.parseEtime = parseEtime;
 exports.decideApprovalOrDefer = decideApprovalOrDefer;
@@ -95,8 +94,9 @@ exports.cmdApproveHook = cmdApproveHook;
 // exists solely because the alternative (being killed by the handler timeout) would allow.
 const child_process_1 = require("child_process");
 const os = __importStar(require("os"));
-const api_1 = require("./api");
+const approval_wait_1 = require("./approval-wait");
 const config_1 = require("./config");
+const hook_stdin_1 = require("./hook-stdin");
 const claude_link_1 = require("./channel/claude-link");
 function allowDecision() {
     return {
@@ -148,18 +148,6 @@ exports.DEFAULT_WAIT_SECONDS = 3600;
 /** What the documented settings.json block must set. Strictly greater than DEFAULT_WAIT_SECONDS,
  *  with room for process start-up and the final write, so OUR deadline always lands first. */
 exports.RECOMMENDED_HANDLER_TIMEOUT_SECONDS = 3900;
-/** One HTTP hold. The server clamps to 30; asking for less than it allows leaves headroom for a
- *  proxy with its own idle timeout. */
-const POLL_WAIT_SECONDS = 25;
-/** Consecutive transport failures tolerated while WAITING, before denying.
- *
- *  Not zero, and not unlimited. The card is already on somebody's phone by then, so denying on a
- *  single dropped long-poll is both a bad experience and the fastest way to get this hook turned
- *  off; but a network that stays down must still land on a deny, and does — here, or at the
- *  deadline, whichever comes first. Failures on CREATE are not retried at all: nothing exists
- *  yet, so there is nothing to lose by refusing immediately. */
-const MAX_CONSECUTIVE_POLL_FAILURES = 3;
-const POLL_RETRY_DELAY_MS = 2000;
 /** The card's own limits, mirrored from apps/api/src/lib/cards.ts. Restating them is how they
  *  drift, so they are only ever used to TRIM — the server still refuses anything malformed. */
 const QUESTION_MAX = 2000;
@@ -255,21 +243,6 @@ function parseArgs(argv) {
         waitSeconds: Number.isFinite(rawTimeout) && rawTimeout > 0 ? rawTimeout : exports.DEFAULT_WAIT_SECONDS,
     };
 }
-/** How long to ask the server to hold, never past our own deadline. */
-function holdSeconds(remainingMs) {
-    return Math.max(1, Math.min(POLL_WAIT_SECONDS, Math.ceil(remainingMs / 1000)));
-}
-/** A refusal the server MEANT — no live session, an ambiguous one, a bad credential, a request
- *  that is not ours. Retrying these is pointless, so they deny immediately; a transport failure
- *  or a 5xx might be a blip and is retried by the caller. */
-function isDefinite(err) {
-    return err instanceof api_1.ApiError && err.status < 500 && err.status !== 429;
-}
-function reasonOf(err) {
-    if (err instanceof api_1.ApiError)
-        return `${err.message} (HTTP ${err.status})`;
-    return err instanceof Error ? err.message : String(err);
-}
 // ─── The decision ────────────────────────────────────────────────────────────
 /**
  * Turn one hook invocation into one decision. NEVER THROWS and never returns undefined: the
@@ -309,121 +282,49 @@ async function decideApproval(rawStdin, argv = [], deps = {}) {
             host: (deps.hostname ?? os.hostname)(),
             permissionMode: str(input.permission_mode),
         });
-        // ── Create. One round trip that also parks for the first window, because the common case
-        // is answered within seconds. A failure here is final: no card exists, so there is nothing
-        // a retry could rescue and nothing left pending on anyone's phone.
-        //
-        // `direct: true` sends the card to the private chat between this session and its owner,
-        // never to a group. A prompt about one person's terminal belongs to that person. It also
-        // stops the server from guessing a room: a session in a group AND its owner's private chat
-        // used to get 409 APPROVAL_ROOM_AMBIGUOUS, which denied every prompt with no card shown.
-        // The Claude Code channel's relay (channel/permission.ts) asks the same way.
-        let reply;
-        try {
-            reply = await (0, api_1.apiRequest)(device, "POST", "/api/device-api/approvals", {
-                session: opts.session,
-                question,
-                options: [...exports.APPROVE_OPTIONS],
-                direct: true,
-                wait: holdSeconds(deadline - now()),
-            });
-        }
-        catch (err) {
-            return denyClosed(`BayChat could not be asked — ${reasonOf(err)}`);
-        }
-        const requestId = str(reply.requestId);
-        if (!requestId)
-            return denyClosed("BayChat did not return an approval id");
-        // ── Wait. Re-arm across the bounded holds exactly as `await_approval` does: "waiting" is a
-        // success meaning nobody has tapped yet, never a lapse and never a no.
-        let failures = 0;
-        for (;;) {
-            const settled = verdictOf(reply, requestId);
-            if (settled)
-                return settled;
-            const remaining = deadline - now();
-            if (remaining <= 0) {
-                return deny(`nobody answered within ${opts.waitSeconds}s.`, "The decision card is still in BayChat; this call was refused because waiting longer " +
-                    "would have let the hook time out, and a timed-out hook silently ALLOWS.");
-            }
-            try {
-                reply = await (0, api_1.apiRequest)(device, "GET", `/api/device-api/approvals/${encodeURIComponent(requestId)}?wait=${holdSeconds(remaining)}`);
-                failures = 0;
-            }
-            catch (err) {
-                if (isDefinite(err)) {
-                    return denyClosed(`BayChat refused the wait — ${reasonOf(err)}`);
-                }
-                failures += 1;
-                log(`baychat approve-hook: waiting failed (${reasonOf(err)}) — attempt ${failures}`);
-                if (failures >= MAX_CONSECUTIVE_POLL_FAILURES) {
-                    return denyClosed(`BayChat became unreachable while waiting — ${reasonOf(err)}`);
-                }
-                await sleep(POLL_RETRY_DELAY_MS);
-            }
-        }
+        // The card goes to the private chat between this session and its owner, and the wait
+        // re-arms across bounded holds until somebody taps (approval-wait.ts). Every outcome that is
+        // not "answered with index 0" becomes a deny below.
+        const outcome = await (0, approval_wait_1.askOwnerAndWait)(device, { session: opts.session, question, options: [...exports.APPROVE_OPTIONS] }, deadline, { now, sleep, log }, "baychat approve-hook");
+        return verdictOf(outcome, opts.waitSeconds);
     }
     catch (err) {
         // The catch that makes the guarantee true. Anything at all — a thrown non-Error, an OOM in a
         // dependency, a bug three refactors from now — lands here as a deny rather than as a crash,
         // and a crash is an ALLOW.
-        log(`baychat approve-hook: unexpected failure (${reasonOf(err)})`);
+        log(`baychat approve-hook: unexpected failure (${(0, approval_wait_1.reasonOf)(err)})`);
         return denyClosed("the approval gate hit an unexpected error");
     }
 }
 /**
- * Read one server reply as a verdict, or null to keep waiting.
+ * Turn what happened into the decision.
  *
- * ONLY `status === "answered"` WITH `answerIndex === 0` ALLOWS. Every other combination — a
- * cancelled card, an index we did not offer, a status this client has never heard of, a missing
- * field — is a deny. That asymmetry is the point: a future server change can make this hook
- * over-refuse, and can never make it over-permit.
+ * ONLY `answered` WITH index 0 ALLOWS. Every other combination — a cancelled card, an index we
+ * did not offer, a status this client has never heard of, a missing field — is a deny. That
+ * asymmetry is the point: a future server change can make this hook over-refuse, and can never
+ * make it over-permit.
  */
-function verdictOf(reply, requestId) {
-    const status = str(reply.status);
-    if (status === "waiting")
-        return null;
-    if (status === "answered") {
-        if (reply.answerIndex === ALLOW_INDEX)
-            return allowDecision();
-        return deny(`answered "${reply.answer ?? exports.APPROVE_OPTIONS[1]}" in BayChat.`);
-    }
-    if (status === "cancelled") {
-        return deny("the decision was withdrawn in BayChat without an answer.");
+function verdictOf(outcome, waitSeconds) {
+    switch (outcome.kind) {
+        case "answered":
+            if (outcome.index === ALLOW_INDEX)
+                return allowDecision();
+            return deny(`answered "${outcome.answer ?? exports.APPROVE_OPTIONS[1]}" in BayChat.`);
+        case "cancelled":
+            return deny("the decision was withdrawn in BayChat without an answer.");
+        case "deadline":
+            return deny(`nobody answered within ${waitSeconds}s.`, "The decision card is still in BayChat; this call was refused because waiting longer " +
+                "would have let the hook time out, and a timed-out hook silently ALLOWS.");
+        case "failed":
+            return denyClosed(outcome.reason);
+        case "unrecognised":
+            return denyClosed(`BayChat answered with a status this client does not understand ("${outcome.status}") for ${outcome.requestId}`);
     }
-    return denyClosed(`BayChat answered with a status this client does not understand ("${status}") for ${requestId}`);
 }
 // ─── stdin ───────────────────────────────────────────────────────────────────
-/**
- * The hook's JSON input.
- *
- * Bounded, because a stdin that never closes would stall us until the handler timeout kills the
- * process — and being killed ALLOWS. On timeout we return what arrived (usually nothing), which
- * fails to parse, which denies.
- */
-function readStdin(stream = process.stdin, timeoutMs = 10_000) {
-    return new Promise((resolve) => {
-        let text = "";
-        let done = false;
-        const finish = () => {
-            if (done)
-                return;
-            done = true;
-            clearTimeout(timer);
-            resolve(text);
-        };
-        const timer = setTimeout(finish, timeoutMs);
-        // Do not hold the process open on the timer alone.
-        if (typeof timer.unref === "function")
-            timer.unref();
-        stream.setEncoding?.("utf8");
-        stream.on("data", (chunk) => {
-            text += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-        });
-        stream.on("end", finish);
-        stream.on("error", finish);
-    });
-}
+// The bounded stdin read lives in hook-stdin.ts, shared with the denied-command hooks.
+var hook_stdin_2 = require("./hook-stdin");
+Object.defineProperty(exports, "readStdin", { enumerable: true, get: function () { return hook_stdin_2.readStdin; } });
 // ─── The command ─────────────────────────────────────────────────────────────
 // ─── --session-from-claude ───────────────────────────────────────────────────
 /** How many ancestors of the hook process are searched for the Claude Code that ran it. The hook
@@ -508,7 +409,7 @@ async function decideApprovalOrDefer(rawStdin, argv = [], deps = {}) {
 async function cmdApproveHook(argv = [], stdin = process.stdin) {
     let decision;
     try {
-        decision = await decideApprovalOrDefer(await readStdin(stdin), argv);
+        decision = await decideApprovalOrDefer(await (0, hook_stdin_1.readStdin)(stdin), argv);
     }
     catch (err) {
         // decideApproval does not throw; readStdin does not reject. This is here anyway, because the

package/dist/cli-help.js

@@ -159,6 +159,17 @@ Usage:
                                         docs/features/REMOTE_APPROVAL_HOOK.md before
                                         switching it on, because it moves the last line
                                         between an agent and this machine onto a phone
+  baychat denied-hook [--session <name> | --session-from-claude] [--timeout <sec>]
+                                        Claude Code PermissionDenied hook: when auto
+                                        mode blocks a call, put a card in BayChat; on
+                                        your yes, write that exact allow rule to the
+                                        project's .claude/settings.local.json and let
+                                        the session retry. Prints the retry or nothing;
+                                        every error leaves the denial standing
+  baychat permissions [list | remove <id> | on | off]
+                                        The denied-command card: on/off for sessions
+                                        BayChat starts (OFF by default), and the rules
+                                        it kept. See docs/features/DENIED_COMMAND_CARD.md
   baychat relay attach --session <name> [--runtime claude|codex|hermes]
                         [--resume-id <id>] [--timeout <sec>]
                                         Register this session with the relay and block
@@ -206,10 +217,21 @@ function helpRequest(command, args) {
  * Commands whose arguments belong to someone else, so `--help` among them is data:
  * - `claude` passes every argument to Claude Code — `baychat claude --help` is Claude Code's help;
  * - `send` and `search` take free text, which may say "--help";
- * - `approve-hook` must write exactly one decision object to stdout, whatever it is given;
+ * - `approve-hook` must write exactly one decision object to stdout, whatever it is given, and
+ *   `denied-hook` / `denied-after` must never print help where Claude Code reads a hook's output;
  * - `help` (and its spellings) already prints help, and its arguments are a question.
  */
-const ARGS_ARE_NOT_OURS = new Set(["claude", "send", "search", "approve-hook", "help", "--help", "-h"]);
+const ARGS_ARE_NOT_OURS = new Set([
+    "claude",
+    "send",
+    "search",
+    "approve-hook",
+    "denied-hook",
+    "denied-after",
+    "help",
+    "--help",
+    "-h",
+]);
 /** Commands with a usage of their own, fuller than their lines in `HELP`. */
 const OWN_USAGE = { login: exports.LOGIN_HELP, bays: bays_command_1.BAYS_USAGE, launch: command_1.LAUNCH_USAGE };
 /**

package/dist/client-paths.js

@@ -15,36 +15,89 @@
 // genuinely do not know. Guessing a path is worse than declining: a wrong guess
 // writes a file no client reads, and the user is left debugging a config that
 // looks correct.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeStoreConfigPaths = claudeStoreConfigPaths;
+exports.isClaudeStoreConfigPath = isClaudeStoreConfigPath;
 exports.configPathFor = configPathFor;
+exports.configDirOf = configDirOf;
 exports.currentPathEnv = currentPathEnv;
 exports.needsRestart = needsRestart;
 exports.configPathsFor = configPathsFor;
 exports.inspectableConfigPaths = inspectableConfigPaths;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** The name Claude's MSIX package directory has under `%LOCALAPPDATA%\Packages`. */
+const CLAUDE_STORE_PACKAGE = /^Claude_[A-Za-z0-9]+$/i;
 /**
- * Claude Desktop's config location, which is the only genuinely
- * platform-dependent one of the three.
+ * Microsoft Store installs of Claude Desktop on this machine, as config paths.
  *
- * Returns null on an unrecognised platform, and on Windows without `APPDATA` —
- * there is no sound fallback for either, and inventing one writes a file nothing
- * will read.
+ * WHY THIS EXISTS. Claude from the Microsoft Store is an MSIX package, and
+ * Windows gives a packaged app a virtualised AppData: it reads
+ * `%LOCALAPPDATA%\Packages\Claude_<publisherId>\LocalCache\Roaming\Claude\
+ * claude_desktop_config.json`, not `%APPDATA%\Claude\…`. On 2026-10-12 a real
+ * user ran `baychat connect desktop`, was told it worked, and Claude never saw
+ * BayChat — the file had gone to `%APPDATA%`, next to a Store install
+ * (`Claude_pzs8sxrjxfjjc`) that does not read there.
+ *
+ * Found by LOOKING, never by building a publisher id: the id is Microsoft's, and
+ * a guessed one is a file no Claude opens. More than one package can exist, so
+ * every match is returned, sorted, so the order never depends on the disk.
+ */
+function claudeStoreConfigPaths(env) {
+    if (env.platform !== "win32" || !env.localAppData || !env.listDirs)
+        return [];
+    const packages = `${env.localAppData}\\Packages`;
+    return env
+        .listDirs(packages)
+        .filter((name) => CLAUDE_STORE_PACKAGE.test(name))
+        .sort()
+        .map((name) => `${packages}\\${name}\\LocalCache\\Roaming\\Claude\\claude_desktop_config.json`);
+}
+/** Is this one of the Microsoft Store (MSIX) copies of Claude Desktop's config? */
+function isClaudeStoreConfigPath(filePath) {
+    return /\\Packages\\Claude_[A-Za-z0-9]+\\LocalCache\\Roaming\\Claude\\/i.test(filePath);
+}
+/** The classic installer's Windows location, or null without `APPDATA`. */
+function claudeClassicWindowsPath(env) {
+    return env.appData ? `${env.appData}\\Claude\\claude_desktop_config.json` : null;
+}
+/**
+ * Every Claude Desktop config location to WRITE here, most likely-read first.
+ *
+ * The only genuinely platform-dependent client of the three. On Windows it is a
+ * list: each Store package is a real installation, and the classic
+ * `%APPDATA%\Claude` is kept only when that directory exists (the plain
+ * installer has run) or when no Store package was found (a plain installer is
+ * then the only thing it can be). Writing the classic file next to a Store-only
+ * install is how this bug looked like success.
+ *
+ * Empty on an unrecognised platform, and on Windows with neither location known —
+ * there is no sound fallback, and inventing one writes a file nothing will read.
  */
-function claudeDesktopPath(env) {
+function claudeDesktopPaths(env) {
     if (env.platform === "darwin") {
-        return `${env.home}/Library/Application Support/Claude/claude_desktop_config.json`;
+        return [`${env.home}/Library/Application Support/Claude/claude_desktop_config.json`];
     }
     if (env.platform === "win32") {
-        if (!env.appData)
-            return null;
-        return `${env.appData}\\Claude\\claude_desktop_config.json`;
+        const store = claudeStoreConfigPaths(env);
+        const classic = claudeClassicWindowsPath(env);
+        if (!classic)
+            return store;
+        if (store.length === 0)
+            return [classic];
+        const classicDirExists = (env.listDirs?.(env.appData) ?? []).some((name) => name.toLowerCase() === "claude");
+        return classicDirExists ? [...store, classic] : store;
     }
     if (env.platform === "linux") {
         const base = env.xdgConfigHome && env.xdgConfigHome.trim() !== ""
             ? env.xdgConfigHome
             : `${env.home}/.config`;
-        return `${base}/Claude/claude_desktop_config.json`;
+        return [`${base}/Claude/claude_desktop_config.json`];
     }
-    return null;
+    return [];
 }
 /**
  * The absolute config path to write for a client, or null when it cannot be
@@ -62,7 +115,32 @@ function configPathFor(client, env) {
         case "cursor":
             return `${env.home}/.cursor/mcp.json`;
         case "desktop":
-            return claudeDesktopPath(env);
+            // The first location the installed app reads — the Store copy when there is one.
+            return claudeDesktopPaths(env)[0] ?? null;
+    }
+}
+/**
+ * The directory a config file lives in, for `mkdirp`.
+ *
+ * A drive-letter path is split the Windows way whatever this process runs on, so
+ * a Windows target resolved in a test (or under WSL) gets its real parent rather
+ * than `.`.
+ */
+function configDirOf(filePath) {
+    return /^[A-Za-z]:\\/.test(filePath) ? node_path_1.default.win32.dirname(filePath) : node_path_1.default.dirname(filePath);
+}
+/** Real `listDirs`: subdirectory names, or `[]` when the directory cannot be read. */
+function listDirsOnDisk(dir) {
+    try {
+        return node_fs_1.default
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        // Missing or unreadable is the ordinary answer for `Packages` on a machine
+        // with no Store apps, and "nothing found here" is exactly what it means.
+        return [];
     }
 }
 /** Read the path environment from the current process. */
@@ -71,6 +149,8 @@ function currentPathEnv() {
         home: process.env.HOME || process.env.USERPROFILE || "",
         platform: process.platform,
         appData: process.env.APPDATA,
+        localAppData: process.env.LOCALAPPDATA,
+        listDirs: listDirsOnDisk,
         xdgConfigHome: process.env.XDG_CONFIG_HOME,
     };
 }
@@ -108,6 +188,10 @@ function needsRestart(client) {
  * whose binary we could not resolve, is still served.
  */
 function configPathsFor(client, env) {
+    // Claude Desktop can be several real installations at once (Store packages and
+    // the classic installer); every one of them is a target.
+    if (client === "desktop")
+        return claudeDesktopPaths(env);
     const canonical = configPathFor(client, env);
     const paths = [];
     const snap = snapConfigPath(client, env);
@@ -146,6 +230,13 @@ function snapConfigPath(client, env) {
  */
 function inspectableConfigPaths(client, env) {
     const paths = configPathsFor(client, env);
+    if (client === "desktop" && env.platform === "win32") {
+        // The classic file is worth reading even when it is not a write target: a
+        // copy left there by an older `connect` still holds a live token, and it is
+        // the evidence `doctor` needs to name the mismatch.
+        const classic = claudeClassicWindowsPath(env);
+        return classic && !paths.includes(classic) ? [...paths, classic] : paths;
+    }
     if (env.platform !== "linux")
         return paths;
     const snap = `${env.home}/snap/${client}/current/config.toml`;