baychat 0.29.8 → 0.30.0

package/dist/doctor.js

@@ -475,7 +475,11 @@ function runtimeReport(runtime, env) {
     const spec = runtimes_1.RUNTIME_SPECS[runtime];
     const mcp = mcpCheck(runtime, env);
     const skill = skillCheck(runtime, env);
-    if (mcp.status === "fail" && skill.status !== "pass") {
+    // A Claude Desktop that names BayChat in one of its files is connected, even when the
+    // file it reads does not — that is the half-finished install `mcpCheck` fails on, and it
+    // must be shown, not folded into "not configured".
+    const halfConnected = runtime === "desktop" && desktopConfigState(env).named.length > 0;
+    if (mcp.status === "fail" && skill.status !== "pass" && !halfConnected) {
         return {
             runtime,
             label: spec.label,
@@ -587,10 +591,12 @@ function mcpCheck(runtime, env) {
             ? { name: "mcp", status: "pass", detail: `${command} lists baychat` }
             : { name: "mcp", status: "fail", detail: `\`${command} mcp list\` does not list baychat`, remedy };
     }
+    if (runtime === "desktop")
+        return desktopMcpCheck(env, remedy);
     // No CLI to ask — a GUI client. Every location this client might read is
     // checked, because "the file we would write" and "the file it opens" are not
     // reliably the same question.
-    const paths = (0, client_paths_1.configPathsFor)(runtime, { home: env.home, platform: env.platform });
+    const paths = (0, client_paths_1.configPathsFor)(runtime, pathEnvOf(env));
     if (paths.length === 0) {
         return { name: "mcp", status: "skip", detail: `no known config location on ${env.platform}` };
     }
@@ -607,6 +613,50 @@ function mcpCheck(runtime, env) {
         remedy,
     };
 }
+function pathEnvOf(env) {
+    return env.pathEnv ?? { home: env.home, platform: env.platform };
+}
+/** Claude Desktop's config files here: all of them, the ones naming BayChat, and the Store copies. */
+function desktopConfigState(env) {
+    const pathEnv = pathEnvOf(env);
+    const paths = (0, client_paths_1.inspectableConfigPaths)("desktop", pathEnv);
+    const named = paths.filter((p) => env.readText(p)?.includes("baychat"));
+    return { paths, named, store: (0, client_paths_1.claudeStoreConfigPaths)(pathEnv) };
+}
+/**
+ * Claude Desktop's `mcp` check — a GUI app, so its config files are the only evidence.
+ *
+ * THE MICROSOFT STORE CASE. Claude from the Store reads its own virtualised copy
+ * (`%LOCALAPPDATA%\Packages\Claude_…\LocalCache\Roaming\Claude\`), so a BayChat entry
+ * in the classic `%APPDATA%\Claude` file — which is what `connect desktop` wrote before
+ * 0.29.9 — is a config that looks right and that the app never opens. That is a FAIL that
+ * names both files, not a pass on the one we happened to find.
+ */
+function desktopMcpCheck(env, remedy) {
+    const { paths, named, store } = desktopConfigState(env);
+    if (paths.length === 0) {
+        return { name: "mcp", status: "skip", detail: `no known config location on ${env.platform}` };
+    }
+    const label = (p) => `${display(p, env)}${(0, client_paths_1.isClaudeStoreConfigPath)(p) ? " (Microsoft Store)" : ""}`;
+    const missingStore = store.filter((p) => !named.includes(p));
+    if (named.length > 0 && missingStore.length > 0) {
+        return {
+            name: "mcp",
+            status: "fail",
+            detail: `baychat is in ${named.map(label).join(" and ")}, but not in ${missingStore.map(label).join(" or ")}` +
+                " — the copy Claude from the Microsoft Store reads",
+            remedy,
+        };
+    }
+    if (named.length > 0)
+        return { name: "mcp", status: "pass", detail: named.map(label).join(" + ") };
+    return {
+        name: "mcp",
+        status: "fail",
+        detail: `no baychat entry in ${paths.map(label).join(" or ")}`,
+        remedy,
+    };
+}
 /**
  * Is the runtime's BayChat skill on disk?
  *

package/dist/help-topics.js

@@ -136,10 +136,11 @@ A session is one terminal, named by you. It appears in the app as an agent your
 messages can reach, and it survives being parked.
 
     join_session({ session: "Session-A" })                      → a 1:1 with you
-    join_session({ session: "Session-A", group: "Ad Review" })   → that group + your private chat
+    join_session({ session: "Session-A", group: "Ad Review" })   → that group only
 
-**The group form also keeps a private chat with you**, under the same agent and
-session name. The join result includes its directConversationId.
+**A group join creates no private chat.** If you already have one with this
+session (same agent, same name), the result names it as directConversationId;
+otherwise there is none until you start one.
 
     list_sessions()   → name, live or idle, last seen
     end_session(...)  → park it; the chat and its history survive, and rejoining
@@ -167,7 +168,14 @@ a decision that expires silently is worse than one that waits.
 cards. It is on only for Claude Code sessions BayChat starts (from the phone,
 \`baychat claude\` or \`baychat start\`), never for a plain \`claude\`, and it moves
 the last line between an agent and your machine onto a phone — read
-docs/features/REMOTE_APPROVAL_HOOK.md. It fails CLOSED: every error denies.`,
+docs/features/REMOTE_APPROVAL_HOOK.md. It fails CLOSED: every error denies.
+
+When auto mode blocks a call outright there is no prompt to answer. With
+\`baychat permissions on\` (off by default), BayChat-started sessions then put a
+card in BayChat — Allow once / Always allow this exact command / No — and a yes
+writes that one exact rule to the project's .claude/settings.local.json and lets
+the session retry. \`baychat permissions\` lists and removes what it kept. See
+docs/features/DENIED_COMMAND_CARD.md.`,
 };
 exports.HELP_TOPICS = [GROUPS, SESSIONS, TOOLS, APPROVALS];
 /** Exact name first, then keyword, then a substring of the body. */

package/dist/hook-stdin.js

@@ -0,0 +1,35 @@
+"use strict";
+// A Claude Code hook's JSON input, read from stdin with a deadline. Imports nothing but Node, so
+// the fast-path hooks (denied/after-hook.ts) can use it without loading the CLI.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStdin = readStdin;
+/**
+ * The hook's JSON input.
+ *
+ * Bounded, because a stdin that never closes would stall us until the handler timeout kills the
+ * process — and for approve-hook being killed ALLOWS. On timeout we return what arrived (usually
+ * nothing), which fails to parse, which each hook turns into its own fail-closed answer.
+ */
+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);
+    });
+}

package/dist/index.js

@@ -12,7 +12,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /** Kept in step with `FAST_CONTEXT_COMMANDS` in claude-context.ts (a test pins the two). */
 const FAST_COMMANDS = new Set(["context-statusline", "context-hook", "context-flush"]);
 const command = process.argv[2];
-if (command !== undefined && FAST_COMMANDS.has(command)) {
+if (command === "denied-after") {
+    // The denied-command card's after-hook runs on every matching tool call (as an async hook), so
+    // it too must not load the CLI. It imports only its own files and Node.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const after = require("./denied/after-hook");
+    after.cmdDeniedAfter().then((code) => {
+        process.exitCode = code;
+    }, (err) => {
+        process.stderr.write(`baychat denied-after: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exitCode = 0;
+    });
+}
+else if (command !== undefined && FAST_COMMANDS.has(command)) {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const fast = require("./claude-context");
     fast.runFastContextCommand(command, process.argv.slice(3)).then(

package/dist/main.js

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commands_1 = require("./commands");
 const approve_hook_1 = require("./approve-hook");
+const denied_hook_1 = require("./denied-hook");
+const permissions_command_1 = require("./permissions-command");
 const context_hooks_command_1 = require("./context-hooks-command");
 const session_name_1 = require("./session-name");
 const start_command_1 = require("./start-command");
@@ -301,6 +303,13 @@ async function main() {
             // exit-1 hook with no JSON on stdout is a NON-BLOCKING error: the tool call proceeds. The
             // guard in the catch below covers that anyway.
             return await (0, approve_hook_1.cmdApproveHook)(args);
+        case "denied-hook":
+            // Never throws and always returns 0; prints `retry` or nothing (see denied-hook.ts). For
+            // this event Claude Code ignores the exit code, and printing nothing leaves the denial
+            // standing — so a crash here is already the safe outcome.
+            return await (0, denied_hook_1.cmdDeniedHook)(args);
+        case "permissions":
+            return await (0, permissions_command_1.cmdPermissions)(args);
         case "context-hooks":
             return await (0, context_hooks_command_1.cmdContextHooks)(args);
         case "doctor":

package/dist/permissions-command.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdPermissions = cmdPermissions;
+// `baychat permissions` — the denied-command card's switch, and the rules it left on this computer.
+//
+//   baychat permissions [list]        what BayChat keeps (and any once-rule still waiting)
+//   baychat permissions remove <id>   take one back out of its settings file
+//   baychat permissions on | off      the card itself, for sessions BayChat starts from now on
+//   baychat permissions sweep         (internal) take back once-rules whose time is up
+//
+// Only rules BayChat wrote are listed or removed. A rule the person wrote themselves never
+// appears here, because a rule that was already in the file was never recorded (denied/grants.ts).
+const grants_1 = require("./denied/grants");
+const opt_in_1 = require("./denied/opt-in");
+/** The longest a scheduled sweep may sleep: a once-rule's TTL is minutes, never hours. */
+const MAX_SWEEP_DELAY_MS = 60 * 60_000;
+const USAGE = "Usage: baychat permissions [list | remove <id> | on | off]";
+async function cmdPermissions(args, deps = {}) {
+    const out = deps.out ?? ((line) => console.log(line));
+    const err = deps.err ?? ((line) => console.error(line));
+    const [sub = "list", ...rest] = args;
+    switch (sub) {
+        case "list": {
+            out((0, opt_in_1.deniedCardEnabled)()
+                ? "The denied-command card is ON for sessions BayChat starts (`baychat permissions off` turns it off)."
+                : "The denied-command card is OFF (`baychat permissions on` turns it on).");
+            const grants = (0, grants_1.listGrants)();
+            if (grants.length === 0) {
+                out("BayChat keeps no permission rules on this computer.");
+                return 0;
+            }
+            out("");
+            for (const grant of grants)
+                out(describeGrant(grant));
+            return 0;
+        }
+        case "remove": {
+            const id = rest[0];
+            if (!id) {
+                err(USAGE);
+                return 1;
+            }
+            if (!(await (0, grants_1.revokeGrant)(id))) {
+                err(`No rule with id ${id}. \`baychat permissions list\` shows them.`);
+                return 1;
+            }
+            out(`Removed ${id}. Claude Code reloads its settings, so running sessions stop allowing it too.`);
+            return 0;
+        }
+        case "on": {
+            // A deliberate act by a person: the card lets a phone add rules on this computer, so a
+            // session's own shell (no terminal) cannot switch it on for itself.
+            if (!(deps.isInteractive ?? (() => Boolean(process.stdin.isTTY && process.stdout.isTTY)))()) {
+                err("`baychat permissions on` must be run by you, in a terminal.");
+                return 1;
+            }
+            (0, opt_in_1.enableDeniedCard)();
+            out("The denied-command card is ON. Sessions BayChat starts from now on will put a card in BayChat when");
+            out("Claude Code's auto mode blocks a call. Read docs/features/DENIED_COMMAND_CARD.md for what it can and can't allow.");
+            return 0;
+        }
+        case "off":
+            (0, opt_in_1.disableDeniedCard)();
+            out("The denied-command card is OFF for sessions BayChat starts from now on. Rules it kept stay until removed.");
+            return 0;
+        case "sweep": {
+            const now = deps.now ?? Date.now;
+            const at = Number(rest[rest.indexOf("--at") + 1]);
+            if (rest.includes("--at") && Number.isFinite(at)) {
+                const delay = Math.min(Math.max(at - now(), 0), MAX_SWEEP_DELAY_MS);
+                await (deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(delay + 1000);
+            }
+            await (0, grants_1.sweepExpiredGrants)(now());
+            return 0;
+        }
+        default:
+            err(USAGE);
+            return 1;
+    }
+}
+function describeGrant(grant) {
+    const when = grant.kind === "once" ? `once, until ${grant.expiresAt ?? "?"}` : `always, since ${grant.addedAt}`;
+    // A once-rule can carry a secret from the command (it is never offered as "always" then), so it
+    // is listed as the card showed it, masked; an always-rule never holds one and is listed as written.
+    const rules = grant.kind === "once" ? grant.shown : grant.rules.length ? grant.rules.join(", ") : "(the rule was already there)";
+    return `${grant.id}  ${rules}\n          ${when} · ${grant.settingsFile}${grant.session ? ` · ${grant.session}` : ""}`;
+}