baychat 0.14.0 → 0.16.0

package/README.md

@@ -131,6 +131,31 @@ history, which the relay searches in both places.
 If you hit something else, `baychat doctor --json` plus what you expected is
 everything we need.
 
+## Which agents can use this?
+
+**Probably yours.** BayChat reaches an agent on two levels, and the first one asks almost nothing:
+
+- **Level 1 — while it is listening.** The agent runs one command and waits; a message is handed
+  straight over. Any agent that can run a shell command and wait qualifies.
+- **Level 2 — when it is *not* listening.** BayChat restarts the agent and drops it back into the
+  right conversation. This needs the agent to be able to say which session it is, and to have a
+  way to resume that session without a UI (`--resume <id>` and friends).
+
+Adapters ship for **Claude Code**, **Codex**, **Cursor** and **Hermes**. Many others — Gemini CLI,
+Copilot CLI, Goose, OpenCode/Crush, Qwen Code, Kimi Code CLI, CodeBuddy, iFlow, Trae, Aider — look
+compatible on paper, with per-agent detail, exact flags, known bugs and a **date on every row** in
+[`RUNTIME_COMPATIBILITY.md`](https://github.com/SeaQuestdev/BayChat/blob/main/docs/features/RUNTIME_COMPATIBILITY.md).
+
+**Using a different model inside one of those agents changes nothing.** GLM, DeepSeek, MiniMax,
+Kimi and others ship Anthropic-compatible endpoints, and people run them inside Claude Code. The
+relay wakes a *program* — it has no concept of which model is behind it. Point your agent at your
+provider, then join a Bay normally.
+
+> That compatibility table is **read from vendor documentation**, not run by us, for everything
+> except the four with adapters — and these projects move fast. If a row is wrong,
+> [tell us](https://github.com/SeaQuestdev/BayChat/issues) rather than assuming it cannot work.
+> Treat any row older than about three months as unverified.
+
 ## Relay
 
 A Claude Code or Codex session has **no background listener**. It runs when a

package/dist/args.js

@@ -27,6 +27,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flag = flag;
 exports.positional = positional;
+exports.rejectUnknownFlags = rejectUnknownFlags;
 /**
  * The value of `--name`, or undefined when it was not given one.
  *
@@ -55,3 +56,17 @@ function flag(args, name) {
 function positional(args) {
     return args.find((a) => !a.startsWith("--"));
 }
+/**
+ * Refuse a flag this subcommand does not implement.
+ *
+ * Silently ignoring one is the worst option available: `relay status --json`
+ * printed the human table, exited as if it had honoured the request, and left
+ * the caller to discover the absence by parsing prose. A wrong answer that
+ * looks right survives far longer than an error.
+ */
+function rejectUnknownFlags(args, allowed, usage) {
+    const unknown = args.filter((a) => a.startsWith("--") && !allowed.includes(a));
+    if (unknown.length === 0)
+        return;
+    throw new Error(`unknown option${unknown.length > 1 ? "s" : ""} ${unknown.join(", ")}\nUsage: ${usage}`);
+}

package/dist/doctor.js

@@ -410,7 +410,8 @@ function skillCheck(runtime, env) {
         return { name: "skill", status: "skip", detail: spec.fallback ?? "no command mechanism" };
     }
     const file = `${env.home}/${spec.command.dir}/${spec.command.file}`;
-    if (env.readText(file) === null) {
+    const installed = env.readText(file);
+    if (installed === null) {
         return {
             name: "skill",
             status: "fail",
@@ -418,7 +419,25 @@ function skillCheck(runtime, env) {
             remedy: setupCommand(runtime),
         };
     }
-    return { name: "skill", status: "pass", detail: display(file, env) };
+    // PRESENT IS NOT CURRENT. Existence was the whole check, so a skill installed
+    // months ago passed while telling its agent something this package has since
+    // corrected — and `npm publish` does not rewrite an installed file, so the
+    // stale copy simply stays. That is not hypothetical: the file on the machine
+    // where this was written still said Codex exports no thread id and should
+    // background its attach, both of which cost an afternoon of unreachability.
+    //
+    // A doc that is wrong is worse than one that is missing, because a missing one
+    // sends the agent looking.
+    const current = (0, runtimes_1.renderCommandFor)(runtime);
+    if (current !== null && installed.trim() !== current.trim()) {
+        return {
+            name: "skill",
+            status: "fail",
+            detail: `${display(file, env)} is out of date — it does not match the skill this version installs`,
+            remedy: setupCommand(runtime),
+        };
+    }
+    return { name: "skill", status: "pass", detail: `${display(file, env)} (current)` };
 }
 function binaryCheck(runtime, env) {
     const command = HAS_BINARY[runtime];

package/dist/index.js

@@ -10,6 +10,8 @@ const mcp_config_1 = require("./mcp-config");
 const commands_2 = require("./relay/commands");
 const help_topics_1 = require("./help-topics");
 const args_1 = require("./args");
+const owner_pid_1 = require("./relay/owner-pid");
+const profiles_1 = require("./relay/profiles");
 const HELP = `baychat — BayChat connector CLI for agent sessions (Claude Code, Codex)
 
 Usage:
@@ -254,23 +256,34 @@ async function main() {
             const rest = args.filter((a) => a !== sub);
             switch (sub) {
                 case "start":
+                    (0, args_1.rejectUnknownFlags)(rest, ["--foreground"], "baychat relay start [--foreground]");
                     await (0, commands_2.cmdRelayStart)({ foreground: args.includes("--foreground") });
                     return 0;
                 case "status":
+                    (0, args_1.rejectUnknownFlags)(rest, [], "baychat relay status");
                     return await (0, commands_2.cmdRelayStatus)();
                 case "stop":
+                    (0, args_1.rejectUnknownFlags)(rest, [], "baychat relay stop");
                     return await (0, commands_2.cmdRelayStop)();
                 case "attach": {
                     const session = (0, args_1.flag)(rest, "--session");
                     if (!session) {
                         throw new Error("Usage: baychat relay attach --session <name> [--runtime claude|codex|hermes] [--resume-id <id>] [--timeout <sec>]");
                     }
+                    (0, args_1.rejectUnknownFlags)(rest, ["--session", "--runtime", "--resume-id", "--timeout", "--owner-pid"], "baychat relay attach --session <name> [--runtime claude|codex|hermes] [--resume-id <id>] [--timeout <sec>]");
                     const timeoutSec = numberFlag(rest, "--timeout");
                     return await (0, commands_2.cmdRelayAttach)({
                         session,
-                        runtime: (0, args_1.flag)(rest, "--runtime") ?? "claude",
+                        // Detected from the process tree when not given, so a person
+                        // connecting Gemini or Kimi does not have to know the flag exists.
+                        // Defaulting to "claude" for everyone was fine when four runtimes
+                        // were all we served; it is a wrong answer now.
+                        runtime: (0, args_1.flag)(rest, "--runtime") ?? (0, owner_pid_1.detectRuntime)(profiles_1.RUNTIME_PROFILES) ?? "claude",
                         resumeId: (0, args_1.flag)(rest, "--resume-id"),
                         timeoutMs: timeoutSec ? timeoutSec * 1000 : undefined,
+                        // Passed by `relay rearm`, which reads it where the runtime is still
+                        // an ancestor and hands it to a child that has been detached.
+                        ownerPid: numberFlag(rest, "--owner-pid"),
                     });
                 }
                 default:

package/dist/relay/adapters.js

@@ -10,6 +10,7 @@ const attachments_1 = require("../attachments");
 const codex_app_server_1 = require("./codex-app-server");
 const codex_queue_1 = require("./codex-queue");
 const resume_1 = require("./resume");
+const profiles_1 = require("./profiles");
 const spawn_env_1 = require("./spawn-env");
 /** How long a headless turn may run before the relay gives up on it. */
 const HEADLESS_TIMEOUT_MS = 10 * 60_000;
@@ -64,8 +65,24 @@ function buildWakePrompt(session, conversationId, batch, reArm) {
 function reArmLines(session, reArm) {
     if (!reArm)
         return [];
-    const command = `  ${reArm.node} ${reArm.cli} relay attach --session "${session}" --runtime ${reArm.runtime}`;
-    if (reArm.transport === "fifo") {
+    const attach = `${reArm.node} ${reArm.cli} relay attach --session "${session}" --runtime ${reArm.runtime}`;
+    const command = `  ${attach}`;
+    // BOUNDED, and it has to be. A foreground attach blocks until a message
+    // arrives — `cmdRelayAttach` installs a timer only when `--timeout` is given,
+    // and the mailbox path blocks in `readFile(fifo)` with no deadline at all. Told
+    // to run that unbounded inside a HEADLESS turn, the session cannot finish, and
+    // the daemon sits on it to its own 10-minute limit. Registration takes
+    // milliseconds; the wait is not what this is for. Same policy the skill
+    // generator states for `arm-once` — see `reachabilityFor` in runtimes.ts.
+    const boundedCommand = `  ${attach} --timeout 30`;
+    // FOREGROUND for the fifo rung — and for Codex on ANY transport.
+    //
+    // Branching on transport alone was not enough: a detached Codex whose recorded
+    // transport is "socket" or absent fell through to the background text, which
+    // is the instruction that started this whole outage. Codex's sandbox kills a
+    // backgrounded process when the tool command returns, so the runtime — not the
+    // rung — decides this.
+    if (reArm.transport === "fifo" || reArm.runtime === "codex") {
         return [
             "",
             "To stay reachable, run this IN THE FOREGROUND before ending your turn. It",
@@ -73,7 +90,9 @@ function reArmLines(session, reArm) {
             "Do NOT put it in the background: your sandbox kills backgrounded processes",
             "when the command returns, so a backgrounded attach listens to nothing while",
             "looking like it worked.",
-            command,
+            "`--timeout 30` is part of the command, not a suggestion: registering is the",
+            "point, and an unbounded wait would hold this turn open for no benefit.",
+            boundedCommand,
         ];
     }
     return [
@@ -253,18 +272,99 @@ const ADAPTERS = {
     cursor: cursorAdapter,
     hermes: hermesAdapter,
 };
+/**
+ * An agent we ship no knowledge of at all.
+ *
+ * Level 1 and honest about it. This exists so that an unrecognised runtime is
+ * SERVED rather than refused: while its attach is listening it is reached over
+ * the socket like anything else, and when it is not, the message is recorded
+ * pending with a reason a human can act on — instead of `relay attach` exiting
+ * 1 and the agent never joining at all.
+ */
+function unknownAdapter(runtime) {
+    return {
+        runtime,
+        canResume: () => ({
+            ok: false,
+            reason: `no resume is known for "${runtime}" — it is reachable while \`baychat relay attach\` is running, and a message arriving otherwise waits here. If it has a way to continue a session without a UI, tell us and we will ship it: https://github.com/SeaQuestdev/BayChat/issues`,
+        }),
+        discoverResume: async () => ({
+            ok: false,
+            reason: `no on-disk layout is known for "${runtime}", so its sessions cannot be identified from here`,
+        }),
+        headlessCommand() {
+            throw new Error(`${runtime} has no headless command`);
+        },
+    };
+}
+/**
+ * An adapter built from a shipped PROFILE rather than hand-written code.
+ *
+ * The research behind `profiles.ts` found that the shape is universal and only
+ * the spelling differs — so for most runtimes an adapter is an argv template,
+ * and this turns one into the interface the daemon already speaks.
+ */
+function profileAdapter(profile) {
+    return {
+        runtime: profile.id,
+        canResume(target) {
+            if (!profile.headless) {
+                return {
+                    ok: false,
+                    reason: `${profile.label} cannot be resumed without a UI: ${profile.noHeadlessReason} (checked ${profile.checked}, from ${profile.source} — if this has changed, tell us)`,
+                };
+            }
+            // `session-name` runtimes are resumed by the name the human chose, which
+            // IS the BayChat session name — so there is nothing to discover and
+            // nothing that could name someone else's session.
+            const id = profile.sessionId.kind === "session-name" ? target.name : target.resumeId;
+            if (!id) {
+                return {
+                    ok: false,
+                    reason: `no ${profile.label} session id recorded — ${profile.sessionId.kind === "flag-only" ? profile.sessionId.how : "the session did not report one"}. Pass it with \`relay attach --resume-id\`.`,
+                };
+            }
+            return { ok: true };
+        },
+        // Deliberately never guesses. A profile describes how to USE an id, not how
+        // to find one on disk, and "the newest session in this folder" is not an
+        // identification — it is how an agent ends up answering a room it has no
+        // memory of.
+        discoverResume: async () => ({
+            ok: false,
+            reason: `${profile.label} sessions cannot be identified from disk by this CLI — pass \`--resume-id\` at attach time`,
+        }),
+        headlessCommand(target, prompt) {
+            if (!profile.headless)
+                throw new Error(`${profile.id} has no headless command`);
+            const id = profile.sessionId.kind === "session-name" ? target.name : target.resumeId;
+            return {
+                file: target.runtimeBin ?? profile.bin,
+                args: (0, profiles_1.fillTemplate)(profile.headless.args, { id, prompt }),
+            };
+        },
+    };
+}
 function adapterFor(runtime) {
-    return ADAPTERS[runtime];
+    const builtin = ADAPTERS[runtime];
+    if (builtin)
+        return builtin;
+    const profile = (0, profiles_1.profileFor)(runtime);
+    return profile ? profileAdapter(profile) : unknownAdapter(runtime);
 }
-/** Every value `relay attach --runtime` accepts, for the error that lists them. */
-exports.KNOWN_RUNTIMES = Object.keys(ADAPTERS);
+/** The runtimes we ship knowledge of, for help text. NOT a list of what is accepted. */
+exports.KNOWN_RUNTIMES = [...Object.keys(ADAPTERS), ...profiles_1.RUNTIME_PROFILES.map((p) => p.id)];
 /**
- * Derived from the adapter table rather than restated, because a second copy of
- * this list is exactly how Cursor came to be told to attach with a value the
- * relay rejected. Having an adapter IS being attachable.
+ * Do we ship knowledge of this runtime?
+ *
+ * ⚠️ This is NO LONGER a gate on attaching — `relay attach` accepts any name and
+ * serves an unknown one at Level 1. It answers "will we do better than the
+ * floor for this?", which is a different question and must not be used to
+ * refuse. Refusing on a name is what kept agents out that needed nothing from
+ * us, and the Cursor outage was the same mistake from the other side.
  */
 function isKnownRuntime(value) {
-    return Object.prototype.hasOwnProperty.call(ADAPTERS, value);
+    return Object.prototype.hasOwnProperty.call(ADAPTERS, value) || (0, profiles_1.profileFor)(value) !== undefined;
 }
 /**
  * Run a headless turn to completion.