baychat 0.13.0 → 0.14.0

package/dist/help-topics.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * `baychat help <topic>` — the instructions a PERSON needs, in the terminal.
+ *
+ * WHY THIS FILE EXISTS. The group tools shipped on 2026-08-25 and were written up in
+ * five places: the connect guide (served at baychat.io/connect.md), the agent protocol,
+ * the npm README, the skill this CLI writes into a client, and the API's own tool
+ * descriptions. Every one of those is read by an AGENT, by a stranger evaluating
+ * BayChat, or by somebody with a browser open.
+ *
+ * None of them is reachable from the terminal the person is actually sitting in.
+ * `baychat --help` lists CLI SUBCOMMANDS, and `list_groups` is not one — it is an MCP
+ * tool their client calls. So the honest answer to "how do I make a group?" was: read a
+ * website. That is how a user ends up reporting that a capability does not exist when it
+ * shipped weeks ago.
+ *
+ * ONE SOURCE, NOT A SIXTH COPY. `ROOMS_TOPIC` below is spliced verbatim into the skill
+ * `runtimes.ts` writes, so the words a person reads here and the words their agent was
+ * given are the same words. A rule written twice is a rule that will one day be true in
+ * only one of the two places.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP_TOPICS = exports.ROOMS_TOPIC = void 0;
+exports.findTopic = findTopic;
+exports.topicIndex = topicIndex;
+/**
+ * The rooms guidance, shared with the skill in `runtimes.ts`.
+ *
+ * Kept as a plain string with no template placeholders precisely so it can be used in
+ * both places unchanged — the moment it needs interpolation it stops being one text.
+ */
+exports.ROOMS_TOPIC = `## Rooms — find one, or open one
+
+\`list_groups\` prints the groups this login is in: the exact title, who is in
+them, and the id. Reach for it whenever a title is uncertain — \`join_session\`
+matches titles exactly and never guesses, so read the title from here and pass it
+back verbatim rather than approximating it.
+
+\`create_group\` (\`session\`, \`title\`, optional \`agents\`) opens a new room and
+lands this session in it, with your owner as its admin — exactly as if they had
+made it in the app. \`agents\` takes the exact names \`list_agents\` prints; an
+unknown one is refused with the roster rather than nearest-matched.
+
+**Only when the user asked for a new room, and only with the title they gave.**
+That does not weaken the rule above — opening a room is still never your choice.
+In particular, \`create_group\` is **not** how you recover from a join that missed:
+a title that missed is a typo far more often than it is a new room, and creating
+one would fork the conversation in two. Run \`list_groups\`, show the user what is
+really there, and stop.
+
+A title that already names one of their groups is refused, and that refusal is
+correct: two rooms sharing one title make either of them impossible to join by
+name until somebody renames one.`;
+const GROUPS = {
+    name: "groups",
+    summary: "Make a group, or find the ones you are already in",
+    keywords: ["group", "groups", "room", "rooms", "create_group", "list_groups", "new group", "channel"],
+    body: `${exports.ROOMS_TOPIC}
+
+## Where these tools live, and why yours may not have them
+
+\`list_groups\` and \`create_group\` are NOT CLI subcommands — you never type them
+into a shell. They are MCP tools your client (Claude Code, Codex, Cursor,
+Desktop) calls on your behalf. You ask in words; the agent makes the call.
+
+    You: "make a group called Ad Review and put Codex in it"
+    → create_group({ session: "<your session>", title: "Ad Review", agents: ["Codex"] })
+
+They are on the SESSION branch only, which means they need a device credential —
+a \`bay_u_\` token from \`baychat login\`. Every call also carries a required
+\`session\` argument, because a terminal has no single agent identity: each call
+names the session it is acting as.
+
+**A standing agent gets neither tool, deliberately.** An agent authenticated with
+a \`bay_\` token is a guest in a room somebody else composed. Letting it create
+rooms would let it invent a room, put the agents it likes in it, and talk to them
+unobserved — the escalation the security model exists to prevent. If your agent
+says it cannot create a group, that is correct behaviour, not a bug: ask a person,
+or run it as a session.
+
+## If your client cannot see them
+
+1. \`baychat login\` — mints the device credential and registers the MCP server.
+   Without this you are on the agent branch and the tools are genuinely absent.
+2. Update: \`npx baychat@latest login\`. A client installed before 2026-08-28 was
+   written a skill listing ten tools, from a build published on 1 August that
+   predates these two entirely.
+3. Restart your client. Tool lists are read once at connect — a running session
+   keeps the list it started with, however current the server is.
+4. \`baychat help tools\` shows what each branch actually gets.`,
+};
+const TOOLS = {
+    name: "tools",
+    summary: "Every MCP tool, and which credential it needs",
+    keywords: ["tool", "tools", "mcp", "skills", "capabilities", "what can it do"],
+    body: `## The two branches
+
+Which tools you get depends on WHAT YOU ARE, not on which client you use.
+
+**Agent branch** — a standing agent holding a \`bay_\` token. Thirteen tools:
+
+    list_conversations   get_room_context     get_conversation_summary
+    get_messages         send_message         set_typing
+    react_to_message     list_files           get_file
+    web_search           web_fetch            list_agents
+    ask_connector
+
+Plus the \`baychat://protocol\` resource, which serves the full agent protocol.
+
+**Session branch** — a person's terminal, holding a \`bay_u_\` device credential
+from \`baychat login\`. Gets all thirteen above, each with a REQUIRED \`session\`
+argument, and these on top:
+
+    join_session    list_sessions   end_session
+    list_groups     create_group
+    request_approval    await_approval
+    create_upload_url   whoami
+
+The extra ones are things a PERSON does: name a terminal, park it, see their
+rooms, open a new one, be asked a yes/no question on their phone. An agent token
+never reaches them.
+
+If you are counting tools and getting ten, your client is running a build from
+before 2026-08-28 — see \`baychat help groups\`.`,
+};
+const SESSIONS = {
+    name: "sessions",
+    summary: "Name this terminal, join a room as it, park it when done",
+    keywords: ["session", "sessions", "join", "join_session", "attach", "terminal", "park", "end_session"],
+    body: `## Sessions
+
+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 INSTEAD
+
+**The group form joins that group and NOT the 1:1** — this catches people out. A
+message you send in the 1:1 lands somewhere a group-joined session cannot see, so
+it reads as the agent ignoring you.
+
+    list_sessions()   → name, live or idle, last seen
+    end_session(...)  → park it; the chat and its history survive, and rejoining
+                        the same name revives the same agent
+
+**Never invent a session name.** The user names the session and the user names
+the group. Given neither, run \`list_sessions\` and stop — do not derive a name
+from the directory, the repo, the branch, or the hostname. Answering in the wrong
+room is the worst failure this feature has.`,
+};
+const APPROVALS = {
+    name: "approvals",
+    summary: "Ask a yes/no question that lands on your phone",
+    keywords: ["approval", "approvals", "permission", "request_approval", "await_approval", "decision", "hook"],
+    body: `## Approvals
+
+\`request_approval\` puts a decision card on the owner's phone; \`await_approval\`
+blocks until they answer. Session branch only — a standing agent has no owner to
+ask and no terminal to block.
+
+There is no timeout by design. A question worth asking is worth waiting for, and
+a decision that expires silently is worse than one that waits.
+
+\`baychat approve-hook\` wires Claude Code's own permission prompts to the same
+cards. It is NOT on by default and moves the last line between an agent and your
+machine onto a phone — read docs/features/REMOTE_APPROVAL_HOOK.md before enabling
+it. It fails CLOSED: every error denies.`,
+};
+exports.HELP_TOPICS = [GROUPS, SESSIONS, TOOLS, APPROVALS];
+/** Exact name first, then keyword, then a substring of the body. */
+function findTopic(query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return undefined;
+    const exact = exports.HELP_TOPICS.find((t) => t.name === q);
+    if (exact)
+        return exact;
+    const keyed = exports.HELP_TOPICS.find((t) => t.keywords.some((k) => k === q));
+    if (keyed)
+        return keyed;
+    // Substring over keywords, so "make a group" and "new room" both land.
+    const loose = exports.HELP_TOPICS.find((t) => t.keywords.some((k) => q.includes(k) || k.includes(q)));
+    if (loose)
+        return loose;
+    return exports.HELP_TOPICS.find((t) => t.body.toLowerCase().includes(q));
+}
+/** The index printed by `baychat help` with no topic, and on a miss. */
+function topicIndex() {
+    const rows = exports.HELP_TOPICS.map((t) => `  baychat help ${t.name.padEnd(10)} ${t.summary}`);
+    return [
+        "Topics — how to actually use BayChat from a client:",
+        "",
+        ...rows,
+        "",
+        "Any wording works: `baychat help \"make a new group\"` finds the groups topic.",
+    ].join("\n");
+}

package/dist/index.js

@@ -3,10 +3,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commands_1 = require("./commands");
 const approve_hook_1 = require("./approve-hook");
+const doctor_command_1 = require("./doctor-command");
 const connect_1 = require("./connect");
 const mcp_1 = require("./mcp");
 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 HELP = `baychat — BayChat connector CLI for agent sessions (Claude Code, Codex)
 
 Usage:
@@ -27,6 +30,12 @@ Usage:
   baychat pair <code> [--base <url>]   Redeem a pairing code from the BayChat app
   baychat link [--name <n>] [--base <url>]
                                         Link this session via a QR you scan with your phone
+  baychat help [topic|question]         How to USE BayChat from a client — making a
+                                        group, joining a room, which tools your
+                                        credential gets. Ask it however you like:
+                                        \`baychat help "make a new group"\`. These are
+                                        MCP tools your client calls, not subcommands,
+                                        so they are not in the list below
   baychat whoami                        Show the connected agent identity
   baychat conversations                 List conversations this agent is in
   baychat send <conversationId> <text>  Send a message
@@ -76,6 +85,14 @@ Usage:
                                         came from, so "we can wake this headlessly"
                                         is a claim you can check
   baychat relay stop                    Stop the relay and disable it at boot
+  baychat doctor [--json]               Check every link between this machine and
+                                        BayChat — credential, relay, and per runtime
+                                        its MCP registration, skill, executable and
+                                        live session — and print exactly what to type
+                                        for each thing that is wrong. Exit 0 clear,
+                                        1 broken, 2 messages nothing answered.
+                                        --json emits the same report as data, for
+                                        pasting into a support thread
   baychat approve-hook [--session <name>] [--timeout <sec>]
                                         Claude Code PermissionRequest hook: send the
                                         permission prompt to BayChat as a decision card
@@ -101,46 +118,45 @@ Usage:
 Connect flow: in BayChat, open the agent -> Connect -> copy the pairing code,
 then run \`baychat pair <code>\`. Pairing rotates the agent token; use a
 dedicated agent per session.`;
-function flag(args, name) {
-    const i = args.indexOf(name);
-    return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
-}
-/** The first positional (non `--flag`) argument, so a command's id isn't shadowed
- * by a leading boolean flag like `--catch-up`/`--refresh`. */
-function positional(args) {
-    return args.find((a) => !a.startsWith("--"));
-}
 /** Drop a `--name <value>` pair, so a multi-word positional (a search query)
- * doesn't swallow the flag's value as part of itself. */
+ * doesn't swallow the flag's value as part of itself.
+ *
+ * Only the flag is dropped when its value is missing — the next token is
+ * another option, or there is none. Consuming two entries there would eat an
+ * unrelated argument, the same mistake `flag` refuses to make. */
 function withoutFlag(args, name) {
     const i = args.indexOf(name);
-    return i < 0 ? args : [...args.slice(0, i), ...args.slice(i + 2)];
+    if (i < 0)
+        return args;
+    const next = args[i + 1];
+    const consumed = next !== undefined && !next.startsWith("--") ? 2 : 1;
+    return [...args.slice(0, i), ...args.slice(i + consumed)];
 }
 /** A flag's value as a number, or undefined when absent. A non-numeric value
  * becomes NaN and is rejected by the tool's own bounds check with a message
  * that names the field. */
 function numberFlag(args, name) {
-    const raw = flag(args, name);
+    const raw = (0, args_1.flag)(args, name);
     return raw === undefined ? undefined : Number(raw);
 }
 async function main() {
     const [command, ...args] = process.argv.slice(2);
     switch (command) {
         case "onboard":
-            await (0, commands_1.cmdOnboard)(positional(args), { catchUp: args.includes("--catch-up") });
+            await (0, commands_1.cmdOnboard)((0, args_1.positional)(args), { catchUp: args.includes("--catch-up") });
             return 0;
         case "login": {
-            const loggedIn = await (0, commands_1.cmdLogin)({ base: flag(args, "--base"), token: flag(args, "--token") });
+            const loggedIn = await (0, commands_1.cmdLogin)({ base: (0, args_1.flag)(args, "--base"), token: (0, args_1.flag)(args, "--token") });
             return loggedIn ? 0 : 2; // 2 = the link request expired without approval
         }
         case "pair": {
             if (!args[0])
                 throw new Error("Usage: baychat pair <code>");
-            await (0, commands_1.cmdPair)(args[0], flag(args, "--base"));
+            await (0, commands_1.cmdPair)(args[0], (0, args_1.flag)(args, "--base"));
             return 0;
         }
         case "link": {
-            const linked = await (0, commands_1.cmdLink)({ name: flag(args, "--name"), base: flag(args, "--base") });
+            const linked = await (0, commands_1.cmdLink)({ name: (0, args_1.flag)(args, "--name"), base: (0, args_1.flag)(args, "--base") });
             return linked ? 0 : 2;
         }
         case "qr":
@@ -202,7 +218,7 @@ async function main() {
             return 0;
         }
         case "summary": {
-            const conversationId = positional(args);
+            const conversationId = (0, args_1.positional)(args);
             if (!conversationId)
                 throw new Error("Usage: baychat summary <conversationId> [--refresh]");
             await (0, commands_1.cmdSummary)(conversationId, { refresh: args.includes("--refresh") });
@@ -216,7 +232,7 @@ async function main() {
             return 0;
         }
         case "fetch": {
-            const url = positional(withoutFlag(args, "--max-chars"));
+            const url = (0, args_1.positional)(withoutFlag(args, "--max-chars"));
             if (!url)
                 throw new Error("Usage: baychat fetch <url> [--max-chars <n>]");
             await (0, commands_1.cmdFetch)(url, { maxChars: numberFlag(args, "--max-chars") });
@@ -225,8 +241,8 @@ async function main() {
         case "watch": {
             if (!args[0])
                 throw new Error("Usage: baychat watch <conversationId>");
-            const intervalSec = Number(flag(args, "--interval") ?? "5");
-            const timeoutSec = Number(flag(args, "--timeout") ?? "300");
+            const intervalSec = Number((0, args_1.flag)(args, "--interval") ?? "5");
+            const timeoutSec = Number((0, args_1.flag)(args, "--timeout") ?? "300");
             const got = await (0, commands_1.cmdWatch)(args[0], {
                 intervalMs: intervalSec * 1000,
                 timeoutMs: timeoutSec * 1000,
@@ -234,7 +250,7 @@ async function main() {
             return got ? 0 : 2;
         }
         case "relay": {
-            const sub = positional(args) ?? "";
+            const sub = (0, args_1.positional)(args) ?? "";
             const rest = args.filter((a) => a !== sub);
             switch (sub) {
                 case "start":
@@ -245,15 +261,15 @@ async function main() {
                 case "stop":
                     return await (0, commands_2.cmdRelayStop)();
                 case "attach": {
-                    const session = flag(rest, "--session");
+                    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>]");
                     }
                     const timeoutSec = numberFlag(rest, "--timeout");
                     return await (0, commands_2.cmdRelayAttach)({
                         session,
-                        runtime: flag(rest, "--runtime") ?? "claude",
-                        resumeId: flag(rest, "--resume-id"),
+                        runtime: (0, args_1.flag)(rest, "--runtime") ?? "claude",
+                        resumeId: (0, args_1.flag)(rest, "--resume-id"),
                         timeoutMs: timeoutSec ? timeoutSec * 1000 : undefined,
                     });
                 }
@@ -267,15 +283,20 @@ 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 "doctor":
+            // Deliberately placed with the setup commands: it is the thing you run
+            // when one of them did not take, and the one command that inspects all
+            // of them at once.
+            return await (0, doctor_command_1.cmdDoctor)(args);
         case "connect": {
             // A bare `connect` prints the client menu; positional() skips a leading flag
             // so `connect --base x codex` still finds the client.
-            return await (0, connect_1.cmdConnect)(positional(args), { base: flag(args, "--base") });
+            return await (0, connect_1.cmdConnect)((0, args_1.positional)(args), { base: (0, args_1.flag)(args, "--base") });
         }
         case "mcp-config": {
             // `--client` with no value is a typo, not a request for the menu: pass the
             // empty string so it is rejected by name rather than silently listing.
-            (0, mcp_config_1.cmdMcpConfig)(args.includes("--client") ? (flag(args, "--client") ?? "") : undefined);
+            (0, mcp_config_1.cmdMcpConfig)(args.includes("--client") ? ((0, args_1.flag)(args, "--client") ?? "") : undefined);
             return 0;
         }
         case "mcp": {
@@ -288,9 +309,30 @@ async function main() {
         }
         case "help":
         case "--help":
-        case undefined:
+        case undefined: {
+            // `baychat help <anything>` answers a question about USING BayChat from a
+            // client — how to make a group, what tools you get, why yours are missing.
+            // Those are MCP tools, not subcommands, so they can never appear in the
+            // usage block above, and until this existed the only answer was "read a
+            // website" — which is how a shipped capability gets reported as absent.
+            const query = args.join(" ").trim();
+            if (query) {
+                const topic = (0, help_topics_1.findTopic)(query);
+                if (topic) {
+                    console.log(topic.body);
+                    return 0;
+                }
+                // A miss is not an error: they asked a real question and deserve the
+                // list rather than a usage dump.
+                console.error(`No help topic matches "${query}".\n`);
+                console.log((0, help_topics_1.topicIndex)());
+                return 1;
+            }
             console.log(HELP);
+            console.log("");
+            console.log((0, help_topics_1.topicIndex)());
             return 0;
+        }
         default:
             console.error(`Unknown command: ${command}`);
             console.log(HELP);

package/dist/relay/adapters.js

@@ -7,7 +7,10 @@ exports.isKnownRuntime = isKnownRuntime;
 exports.runHeadless = runHeadless;
 const child_process_1 = require("child_process");
 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 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;
 /**
@@ -18,7 +21,7 @@ const HEADLESS_TIMEOUT_MS = 10 * 60_000;
  * relay carries the message and nothing more. Telling a resumed turn to "answer
  * this" would route around the room's reply policy from outside the room.
  */
-function buildWakePrompt(session, conversationId, batch) {
+function buildWakePrompt(session, conversationId, batch, reArm) {
     const lines = [];
     for (const m of batch) {
         const flag = m.shouldRespond ? " [shouldRespond=true]" : "";
@@ -40,8 +43,47 @@ function buildWakePrompt(session, conversationId, batch) {
         ...lines,
         "",
         `Re-read the room with the BayChat tools (session="${session}") before acting. Reply ONLY if the server marks shouldRespond for you; otherwise stay silent and end the turn.`,
+        ...reArmLines(session, reArm),
     ].join("\n");
 }
+/**
+ * How this session gets woken a SECOND time.
+ *
+ * A headless resume is spawned by the daemon, so it inherits the daemon's
+ * environment — and under systemd that PATH contains neither `node` nor
+ * `baychat` nor the runtime itself. The installed skill tells a woken session to
+ * re-arm with a bare `baychat relay attach`, which a resumed session cannot run:
+ * command not found. It answers once and then goes quiet forever, which is
+ * precisely the failure re-arming exists to prevent — and it looks like the
+ * model forgetting rather than like us handing it an impossible instruction.
+ *
+ * So the daemon, which knows both absolute paths because it IS them, spells the
+ * command out. Omitted entirely when the caller has no paths to offer, rather
+ * than printed with holes in it.
+ */
+function reArmLines(session, reArm) {
+    if (!reArm)
+        return [];
+    const command = `  ${reArm.node} ${reArm.cli} relay attach --session "${session}" --runtime ${reArm.runtime}`;
+    if (reArm.transport === "fifo") {
+        return [
+            "",
+            "To stay reachable, run this IN THE FOREGROUND before ending your turn. It",
+            "blocks until a message arrives, prints it, and exits — that exit is the wake.",
+            "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,
+        ];
+    }
+    return [
+        "",
+        "To stay reachable, run this in the BACKGROUND before ending your turn. It is",
+        "written with absolute paths because a resumed session's PATH may not contain",
+        "node or baychat at all:",
+        command,
+    ];
+}
 /**
  * One attachment line for the wake prompt: what it is, then how to fetch it.
  *
@@ -91,6 +133,19 @@ const claudeAdapter = {
 };
 const codexAdapter = {
     runtime: "codex",
+    queueMessage({ binaryPath, target, message }) {
+        // `codex queue` landed in 0.149.0. Delivering here rather than through the
+        // headless spawn is what lets a woken Codex actually REPLY: the message goes
+        // to the live session, where the human is present to approve, instead of a
+        // separate turn that must run `approvalPolicy: "never"` and is therefore
+        // blocked from calling BayChat's write tools at all.
+        return (0, codex_queue_1.queueToThread)({
+            binaryPath,
+            threadId: target.resumeId,
+            message,
+            cwd: target.resumeCwd ?? target.cwd,
+        });
+    },
     canResume(target) {
         if (!target.resumeId) {
             return {
@@ -109,6 +164,29 @@ const codexAdapter = {
             args: ["exec", "resume", target.resumeId, prompt],
         };
     },
+    /**
+     * Prefer `codex app-server`, which can say what `codex exec` never could.
+     *
+     * `exec resume` reports only an exit code, so "the thread id names nothing on
+     * this machine", "the turn stopped at an approval" and "the model was
+     * unavailable" all arrive as `exited 1`. app-server distinguishes them, and
+     * the reason is what a user needs to act.
+     *
+     * Opting out with BAYCHAT_CODEX_TRANSPORT=exec is deliberate: the app-server
+     * interface is marked `[experimental]` by OpenAI and its shape is not frozen,
+     * so there has to be a way back that does not require a new release.
+     */
+    async runTurn({ binaryPath, target, prompt }) {
+        if (process.env.BAYCHAT_CODEX_TRANSPORT === "exec") {
+            return { kind: "failed", transportUnusable: true, reason: "BAYCHAT_CODEX_TRANSPORT=exec" };
+        }
+        return (0, codex_app_server_1.runCodexTurn)({
+            binaryPath,
+            threadId: target.resumeId,
+            prompt,
+            cwd: target.resumeCwd ?? target.cwd,
+        }, { spawn: child_process_1.spawn });
+    },
 };
 /**
  * Cursor can be woken, and cannot be resumed. Both halves matter.
@@ -200,6 +278,9 @@ function runHeadless(file, args, opts = {}) {
     return new Promise((resolve) => {
         const child = (0, child_process_1.spawn)(file, args, {
             cwd: opts.cwd,
+            // An npm-installed runtime is a script with a `#!/usr/bin/env node`
+            // shebang, and the daemon's systemd PATH has no node. See ./spawn-env.ts.
+            env: (0, spawn_env_1.headlessSpawnEnv)(),
             shell: false,
             stdio: ["ignore", "ignore", "pipe"],
             detached: false,