baychat 0.29.9 → 0.31.0

package/dist/main.js

@@ -3,10 +3,13 @@
 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");
 const update_command_1 = require("./update-command");
+const notice_1 = require("./auto-update/notice");
 const session_command_1 = require("./session-command");
 const doctor_command_1 = require("./doctor-command");
 const bays_command_1 = require("./bays-command");
@@ -54,8 +57,13 @@ async function main() {
     // else", and a usage dump printed at somebody who typed the product's own name is the
     // "something else". `--help` still prints the help, and `start` refuses with one sentence
     // when this machine is not signed in, so nothing is launched from an unusable state.
-    if (command === undefined)
+    if (command === undefined) {
+        (0, notice_1.printUpdateNotice)(command);
         return (0, start_command_1.cmdStart)([]);
+    }
+    // "BayChat updated itself to …": the relay's one line for the terminal, shown once, on a command
+    // a person typed (never into a hook's or an MCP server's output).
+    (0, notice_1.printUpdateNotice)(command);
     // Asking for help never acts: `--help`/`-h` on any command prints its usage and runs nothing
     // (cli-help.ts says which commands' arguments are not ours to read — `claude`, `send`, …).
     const help = (0, cli_help_1.helpRequest)(command, args);
@@ -74,7 +82,10 @@ async function main() {
             return (0, start_command_1.cmdStart)(args);
         case "update":
             // `--quiet` is how an old version hands a `start`-driven update to the new one.
-            return (0, update_command_1.cmdUpdate)({ quiet: args.includes("--quiet") });
+            (0, args_1.rejectUnknownFlags)(args, ["--quiet", "--auto"], "baychat update [--auto on|off]");
+            if (args.includes("--auto") && !(0, args_1.flag)(args, "--auto"))
+                throw new Error("Usage: baychat update --auto on|off");
+            return (0, update_command_1.cmdUpdate)({ quiet: args.includes("--quiet"), auto: (0, args_1.flag)(args, "--auto") });
         case "skill": {
             const runtime = args[1];
             if (args.length !== 2 ||
@@ -301,6 +312,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,104 @@
+"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
+//   baychat permissions confirm --grant <id>
+//                                     (internal) confirm an unconfirmed grant against the
+//                                     session's transcript, or take it back (denied/confirm.ts)
+//
+// 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 confirm_1 = require("./denied/confirm");
+const grants_1 = require("./denied/grants");
+const hook_log_1 = require("./denied/hook-log");
+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());
+            await (0, confirm_1.takeBackStaleUnconfirmed)({ log: hook_log_1.logBoth, ...deps.confirm });
+            return 0;
+        }
+        case "confirm": {
+            // Started detached by denied-hook (never by a person); not in USAGE on purpose.
+            const id = rest[rest.indexOf("--grant") + 1];
+            if (!rest.includes("--grant") || !id) {
+                err("Usage: baychat permissions confirm --grant <id>");
+                return 1;
+            }
+            await (0, confirm_1.confirmGrant)(id, { log: hook_log_1.logBoth, ...deps.confirm });
+            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)";
+    const scope = grant.scope === "user" ? "user settings, every project" : "this project";
+    return `${grant.id}  ${rules}\n          ${when} · ${scope} · ${grant.settingsFile}${grant.session ? ` · ${grant.session}` : ""}`;
+}