baychat 0.29.9 → 0.31.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.29.9",
+  "version": "0.31.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.
 
@@ -289,7 +289,7 @@ Read these as *how often you do it*, not as steps you repeat.
 ### In a plain shell
 
 ```bash
-npm i -g baychat            # install or upgrade — nothing updates itself
+npm i -g baychat            # install once — from 0.31.0 the relay keeps it current
 baychat login               # once per computer: the QR
 baychat connect             # list the apps it can configure
 baychat connect claude      # refresh Claude Code's skill (no QR, no re-pairing)
@@ -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,12 +318,45 @@ 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
+### Staying up to date
 
-Publishing a new version upgrades nobody by itself.
+From 0.31.0 **the relay updates BayChat by itself**, the way Claude Code does. About once a
+day it asks npm for the newest `baychat`; a patch or minor release is installed with the same
+command `baychat update` uses, in a quiet moment — never while an agent turn is being delivered,
+a session command is running, a session is being started from BayChat, or a card on your phone
+is waiting for an answer. Then the relay restarts onto the new code and your next `baychat`
+command says so in one line:
+
+```text
+BayChat updated itself to 0.31.1 (from 0.31.0).
+```
+
+A new major version, or a release marked as needing you, is not installed by itself: your phone
+gets a card, *"New BayChat for your computer (…): <reason> · Update now / Later"*. Only you can
+answer it. "Later" asks again in three days.
+
+If an install fails, the version you have keeps running and it tries again a day later.
+
+```bash
+baychat update --auto off   # switch automatic updates off for this computer
+baychat update --auto on    # and back on (the default)
+baychat doctor              # shows the state: on/off, last check, latest version
+```
+
+`BAYCHAT_AUTO_UPDATE=0` also switches them off, for CI and managed machines — but only for
+processes that see it; for the relay itself, use `baychat update --auto off`.
+
+Only a **global npm install** whose relay runs under systemd or launchd (what
+`baychat relay start` sets up on Linux and macOS) updates itself. On **Windows** the relay only
+tells you for now — install with `baychat update`. An `npx` copy, a project install, a relay
+started by hand with `--foreground`, or one running as root is also only told about new versions.
+
+### Upgrading by hand
+
+`baychat update` still does the whole update at once, any time.
 
 ```text
 $baychat --update     # in Codex
@@ -992,7 +1025,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,143 @@
+"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");
+const waiting_cards_1 = require("./waiting-cards");
+/** 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. Marked while it
+        // waits, so the relay's automatic update never restarts BayChat under an open question.
+        const unmark = (0, waiting_cards_1.markWaitingCard)(requestId);
+        try {
+            return await waitForAnswer(device, requestId, reply, deadlineMs, deps, label);
+        }
+        finally {
+            unmark();
+        }
+    }
+    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)}` };
+    }
+}
+/** Park on an existing card until it is answered, withdrawn, unreachable or past the deadline. */
+async function waitForAnswer(device, requestId, first, deadlineMs, deps, label) {
+    let reply = first;
+    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);
+        }
+    }
+}
+/**
+ * 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,14 +33,17 @@ 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.procStatFields = procStatFields;
+exports.procStartTicks = procStartTicks;
+exports.psParentOf = psParentOf;
+exports.psAgeMs = psAgeMs;
 exports.parseEtime = parseEtime;
 exports.decideApprovalOrDefer = decideApprovalOrDefer;
 exports.cmdApproveHook = cmdApproveHook;
@@ -94,9 +97,11 @@ exports.cmdApproveHook = cmdApproveHook;
 // exactly like a terminal prompt. Our deadline bounds only how long THIS PROCESS waits, and it
 // exists solely because the alternative (being killed by the handler timeout) would allow.
 const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
 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 +153,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 +248,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 +287,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.`);
+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}`);
     }
-    if (status === "cancelled") {
-        return deny("the decision was withdrawn in BayChat without an answer.");
-    }
-    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
@@ -470,10 +376,39 @@ function psField(pid, field) {
     const out = String(r.stdout ?? "").trim();
     return out || undefined;
 }
+/**
+ * The fields of `/proc/<pid>/stat` (Linux only), numbered as proc(5) numbers them: `[1]` is the
+ * pid, `[4]` the parent, `[22]` the start time in clock ticks since boot. The command name
+ * (field 2) may itself hold spaces and parentheses, so the split starts after its LAST `)`.
+ * Undefined anywhere else, or when the process is gone.
+ */
+function procStatFields(pid, read = (f) => fs.readFileSync(f, "utf8")) {
+    if (process.platform !== "linux" || !Number.isInteger(pid) || pid <= 0)
+        return undefined;
+    try {
+        const text = read(`/proc/${pid}/stat`);
+        const close = text.lastIndexOf(")");
+        if (close < 0)
+            return undefined;
+        // Index 0 unused, 1 = pid, 2 = comm, then field 3 onwards from after the parenthesis.
+        return ["", String(pid), text.slice(text.indexOf("(") + 1, close), ...text.slice(close + 1).trim().split(/\s+/)];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The process's start time as `/proc/<pid>/stat` field 22 (clock ticks since boot), Linux only. */
+function procStartTicks(pid) {
+    const start = procStatFields(pid)?.[22];
+    return start && /^\d+$/.test(start) ? start : undefined;
+}
+/** The parent of `pid`: `/proc` on Linux (no process spawned), `ps` elsewhere. */
 function psParentOf(pid) {
-    const n = Number(psField(pid, "ppid"));
+    const fromProc = Number(procStatFields(pid)?.[4]);
+    const n = Number.isInteger(fromProc) && fromProc > 0 ? fromProc : Number(psField(pid, "ppid"));
     return Number.isInteger(n) && n > 0 ? n : undefined;
 }
+/** How long `pid` has been running, from `ps -o etime` (whole seconds). */
 function psAgeMs(pid) {
     const etime = psField(pid, "etime");
     return etime ? parseEtime(etime) : undefined;
@@ -508,7 +443,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/auto-update/describe.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeAutoUpdate = describeAutoUpdate;
+exports.statusFromFiles = statusFromFiles;
+const self_upgrade_1 = require("../self-upgrade");
+const policy_1 = require("./policy");
+/**
+ * The automatic update in one line, for `relay status` and `baychat doctor`. One wording for both,
+ * so the two can never describe the same machine differently.
+ */
+function describeAutoUpdate(status, now) {
+    const checked = status.lastCheckAt ? `, checked ${ago(now - status.lastCheckAt)}` : ", not checked yet";
+    const latest = status.latest && (0, self_upgrade_1.compareVersions)(status.current, status.latest) === -1 ? `${status.latest} is out` : `${status.current} is the latest`;
+    switch (status.mode) {
+        case "off":
+            return `off (${status.reason}) — running ${status.current}`;
+        case "none":
+            return `not used here (${status.reason ?? "not an npm install"})`;
+        case "notify":
+            // The reason reads on from "notify only": "on Windows (install with `baychat update`)".
+            return `notify only ${status.reason} — ${status.latest ? latest : `running ${status.current}`}${checked}`;
+        case "auto": {
+            if (status.failure)
+                return `on — the last automatic install failed: ${status.failure}`;
+            const waiting = status.cardVersion
+                ? ` — ${status.cardVersion} is waiting for you on your phone`
+                : status.waitingFor
+                    ? ` — waiting: ${status.waitingFor}`
+                    : "";
+            return `on — ${latest}${checked}${waiting}`;
+        }
+    }
+}
+/**
+ * The status as the files say, for `doctor` (which runs whether or not a relay is up). The relay
+ * writes its mode into the state on every look; the person's switch and the environment are read
+ * fresh, because they may have changed since.
+ */
+function statusFromFiles(input) {
+    const { state, setting, env, current } = input;
+    const off = (0, policy_1.autoUpdateOffReason)(env, setting);
+    const base = {
+        current,
+        latest: state.latest,
+        lastCheckAt: state.lastCheckAt,
+        waitingFor: state.waitingFor,
+        cardVersion: state.card?.requestId ? state.card.version : undefined,
+        failure: state.failure?.reason,
+    };
+    if (off)
+        return { ...base, mode: "off", reason: off };
+    if (!state.mode)
+        return { ...base, mode: "none", reason: "the relay has not run a version with automatic updates yet" };
+    if (state.mode === "off")
+        return { ...base, mode: "none", reason: "just turned on; the relay picks it up within a minute" };
+    return { ...base, mode: state.mode, reason: state.modeReason };
+}
+function ago(ms) {
+    const minutes = Math.max(0, Math.round(ms / 60_000));
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return `${hours} h ago`;
+    return `${Math.round(hours / 24)} days ago`;
+}

package/dist/auto-update/notice.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printUpdateNotice = printUpdateNotice;
+const store_1 = require("./store");
+/**
+ * Show the relay's one line about updates ("BayChat updated itself to 0.31.1 (from 0.31.0).") on
+ * the next `baychat` command a PERSON runs — the way Claude Code says it updated.
+ *
+ * Only to a terminal: on stderr, and only when stderr is a TTY, so a hook's verdict, an MCP
+ * server's JSON-RPC, a status line or anything piped never carries it. Commands run by a client
+ * rather than typed are skipped outright, and so is `update` (it answers the notice itself). The
+ * notice is taken when shown, so it is shown once.
+ */
+const NOT_FOR_PEOPLE = new Set([
+    "mcp",
+    "channel",
+    "approve-hook",
+    "denied-hook",
+    "denied-after",
+    "context-statusline",
+    "context-hook",
+    "context-flush",
+    "skill",
+    "session-name",
+    "update",
+]);
+function printUpdateNotice(command, stream = process.stderr, take = store_1.takeUpdateNotice) {
+    if ((command !== undefined && NOT_FOR_PEOPLE.has(command)) || !stream.isTTY)
+        return;
+    let text;
+    try {
+        text = take();
+    }
+    catch {
+        // An unreadable notice is not worth failing the command the person actually asked for.
+        return;
+    }
+    if (text)
+        stream.write(`${text}\n`);
+}