baychat 0.29.9 → 0.30.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.29.9",
+  "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
 
@@ -992,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/denied/after-hook.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterCall = afterCall;
+exports.cmdDeniedAfter = cmdDeniedAfter;
+// `baychat denied-after` — the PostToolUse / PostToolUseFailure hook that takes an "Allow once"
+// rule back out as soon as the retried call has run.
+//
+// It is installed beside `denied-hook` (relay/launcher/approval-settings.ts) as an ASYNC hook:
+// Claude Code starts it and moves on, so it adds nothing to any tool call's latency, and it prints
+// nothing. It runs on every matching tool call, so it is routed by index.ts without loading the
+// CLI, and it returns at once when no once-grant exists — the common case by far.
+//
+// The TTL sweep (grants.ts, ONCE_TTL_MS) is the backstop for a retried call that never finishes,
+// and every run here sweeps too.
+const hook_stdin_1 = require("../hook-stdin");
+const grants_1 = require("./grants");
+const permission_rule_1 = require("./permission-rule");
+/** Handle one finished call. NEVER THROWS; diagnostics go to stderr. */
+async function afterCall(rawStdin, log = defaultLog) {
+    try {
+        if (!(0, grants_1.hasOnceGrants)())
+            return;
+        const input = JSON.parse(rawStdin);
+        const call = typeof input.tool_name === "string" ? (0, permission_rule_1.callKeyOf)(input.tool_name, input.tool_input) : undefined;
+        if (call && typeof input.session_id === "string")
+            await (0, grants_1.consumeOnceGrants)(input.session_id, call);
+        await (0, grants_1.sweepExpiredGrants)();
+    }
+    catch (err) {
+        log(`baychat denied-after: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function defaultLog(line) {
+    process.stderr.write(`${line}\n`);
+}
+/** The command. Always 0: nothing this hook could say would change the call that already ran. */
+async function cmdDeniedAfter(stdin = process.stdin) {
+    await afterCall(await (0, hook_stdin_1.readStdin)(stdin, 5_000));
+    return 0;
+}