@rubytech/create-maxy-code 0.1.331 → 0.1.333

package/payload/premium-plugins/writer-craft/lib/mcp-spawn-tee/index.js

@@ -1,47 +1,47 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * MCP spawn-tee — parent-side stderr capture + lifecycle observability.
+ * MCP spawn-tee — in-process stderr capture + lifecycle observability.
  *
  * Claude Code spawns each MCP server itself; the platform never holds a
- * ChildProcess handle. This wrapper sits between Claude Code and the real
- * MCP server: Claude Code runs `node <this> <real-entry>`, and the wrapper
- * spawns the real entry with `stdio:['inherit','inherit','pipe']` so stdin
- * and stdout (the JSON-RPC channel) pass through byte-identical. Only stderr
- * is intercepted, and only for logging.
+ * ChildProcess handle. This shim sits between Claude Code and the real MCP
+ * server: Claude Code runs `node <this> <real-entry>`, and the shim runs the
+ * real entry IN ITS OWN PROCESS via dynamic import() — one node runtime, not
+ * two. Before importing, it replaces process.stderr.write with a tee so every
+ * stderr byte the server writes is mirrored to the log sinks; stdin and stdout
+ * (the JSON-RPC channel) are never touched.
  *
- * Because the wrapper IS the helper's parent, it observes the helper's true
- * exit code, signal, and lifetime for every death mode — including a SIGKILL
- * or a transport-layer crash that an in-process handler would miss.
+ *   Claude Code CLI → shim (this file) = node running <real-entry> in-process
+ *        stdin/stdout : untouched (JSON-RPC channel)
+ *        stderr       : process.stderr.write teed → per-date + per-session + passthrough
  *
- *   Claude Code CLI → wrapper (this file) → child = node <real-entry>
- *        child stdin/stdout : inherited (Claude Code pipe, untouched)
- *        child stderr       : piped → per-date log + per-session log + passthrough
- *
- * Destinations (Task 706):
+ * Destinations (Task 706) — unchanged:
  *   - `${LOG_DIR}/mcp-<name>-stderr-<date>.log`  — per-date raw (back-compat;
  *     the in-process mcp-stderr-tee and the [mcp-init-error] probe read it).
  *   - `${LOG_DIR}/mcp-<name>-<SESSION_ID>.log`   — per-session raw + lifecycle
- *     lines; wrapper-only, so it never mixes the enumeration copy with the
- *     live copy. Authoritative sink. Absent when SESSION_ID is unset
- *     (enumeration spawn) — then the per-date file is the fallback.
+ *     lines. Authoritative sink. Absent when SESSION_ID is unset (enumeration
+ *     spawn) — then the per-date file is the fallback.
  *   - `server.log` via the loopback log-ingest route — best-effort mirror of
- *     the [mcp-helper] lifecycle lines. A dropped POST loses nothing because
- *     the per-session file already holds the line (written synchronously).
+ *     the [mcp-helper] lifecycle lines.
  *
- * Lifecycle lines, correlation key `session=<id8> server=<name>`:
+ * Lifecycle lines, correlation key `session=<id8> server=<name>` — unchanged:
  *   [mcp-helper] op=spawn ... pid= entry=
  *   [mcp-helper] op=boot  ... head=<first stderr bytes>
- *   [mcp-helper] op=exit  ... code= signal= lifetimeMs= stderr-tail=   (always)
+ *   [mcp-helper] op=exit  ... code= signal= lifetimeMs= stderr-tail=
+ *
+ * Process model (Task 989): the shim IS the server's process. op=exit fires
+ * from process.on("exit"), so it covers a normal exit, a non-zero exit, an
+ * uncaught throw (code 1), and a catchable-signal exit (SIGTERM/SIGINT/SIGHUP,
+ * whose handlers record the signal name). An external SIGKILL is uncatchable
+ * and leaves no op=exit line — the per-session stderr tail already on disk and
+ * Claude Code's own transport-drop are the evidence for that death mode.
  *
- * The wrapper never writes to fd 1 (stdout) — that is the JSON-RPC channel.
- * SIGTERM/SIGINT are forwarded to the child so a Claude Code shutdown does
- * not orphan it; the child exit code/signal is propagated verbatim.
+ * The shim never writes to fd 1 (stdout) — that is the JSON-RPC channel.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
 const SERVER_NAME = process.env.MCP_SPAWN_TEE_NAME ?? "unknown";
 const LOG_DIR = process.env.LOG_DIR;
 const SESSION_ID = process.env.SESSION_ID;
@@ -49,24 +49,37 @@ const PLATFORM_PORT = process.env.PLATFORM_PORT;
 const ENTRY = process.argv[2];
 const SESSION_ID8 = SESSION_ID ? SESSION_ID.slice(0, 8) : "—";
 const spawnStamp = Date.now();
-// Per-session raw + lifecycle log (Task 706). Wrapper-only. Empty SESSION_ID
-// (enumeration spawn) → undefined, and the per-date file is the fallback.
+// Per-session raw + lifecycle log (Task 706). Empty SESSION_ID (enumeration
+// spawn) → undefined, and the per-date file is the fallback.
 const perSessionPath = LOG_DIR && SESSION_ID
     ? (0, node_path_1.resolve)(LOG_DIR, `mcp-${SERVER_NAME}-${SESSION_ID}.log`)
     : undefined;
 const perDatePath = LOG_DIR
     ? (0, node_path_1.resolve)(LOG_DIR, `mcp-${SERVER_NAME}-stderr-${new Date(spawnStamp).toISOString().slice(0, 10)}.log`)
     : undefined;
-// Rolling tail of child stderr for op=exit. Capped so a chatty child cannot
+// Rolling tail of entry stderr for op=exit. Capped so a chatty server cannot
 // grow the buffer without bound.
 const TAIL_CAP = 2048;
 let stderrTail = "";
 let bootEmitted = false;
+let exitEmitted = false;
+let exitSignal;
+// The real stderr writer, captured before the tee replaces it. Lifecycle lines
+// and stderr passthrough both go through this so they are never re-teed into
+// the per-date sink nor recursed back into the patched writer.
+const rawStderrWrite = process.stderr.write.bind(process.stderr);
+// LOG_DIR is created once, lazily, on the first successful append — not per
+// chunk. teeWrite runs on the server's own stderr hot path now, so a per-call
+// mkdirSync would be two syscalls per log line for nothing.
+let logDirReady = false;
 function appendSafe(path, data) {
     if (!path || !LOG_DIR)
         return;
     try {
-        (0, node_fs_1.mkdirSync)(LOG_DIR, { recursive: true });
+        if (!logDirReady) {
+            (0, node_fs_1.mkdirSync)(LOG_DIR, { recursive: true });
+            logDirReady = true;
+        }
         (0, node_fs_1.appendFileSync)(path, data);
     }
     catch {
@@ -74,15 +87,16 @@ function appendSafe(path, data) {
     }
 }
 // Best-effort mirror of a lifecycle line to server.log via the loopback
-// log-ingest route. Fire-and-forget: the per-session file is authoritative,
-// so a dropped POST (unreachable port, process exiting) loses nothing.
+// log-ingest route. Fire-and-forget: the per-session file is authoritative, so
+// a dropped POST loses nothing. On the "exit" event the loop is stopping, so
+// the op=exit mirror may not flush — the per-session line, written sync, holds.
 function postToServerLog(suffix, level) {
     if (!PLATFORM_PORT)
         return;
     try {
         const ctrl = new AbortController();
         const t = setTimeout(() => ctrl.abort(), 500);
-        t.unref?.(); // never let the abort timer keep the wrapper's event loop alive
+        t.unref?.(); // never let the abort timer keep the shim's event loop alive
         void fetch(`http://127.0.0.1:${PLATFORM_PORT}/api/admin/log-ingest`, {
             method: "POST",
             headers: { "content-type": "application/json" },
@@ -95,14 +109,15 @@ function postToServerLog(suffix, level) {
     }
 }
 // Emit one [mcp-helper] lifecycle line: authoritative per-session file (sync,
-// survives process.exit), the wrapper's own stderr (journald / Claude Code
-// visibility), and a best-effort server.log mirror. `suffix` is the line body
-// after the tag and carries no newline (the log-ingest route rejects newlines).
+// survives process.exit), the shim's own stderr via the RAW writer (journald /
+// Claude Code visibility, never re-teed), and a best-effort server.log mirror.
+// `suffix` is the line body after the tag and carries no newline (the
+// log-ingest route rejects newlines).
 function emitLifecycle(suffix, level) {
     const line = `[mcp-helper] ${suffix}\n`;
     appendSafe(perSessionPath, line);
     try {
-        process.stderr.write(line);
+        rawStderrWrite(line);
     }
     catch { /* stderr closed */ }
     postToServerLog(suffix, level);
@@ -111,49 +126,68 @@ if (!ENTRY) {
     emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason="no entry given (argv[2] missing)"`, "error");
     process.exit(2);
 }
-const child = (0, node_child_process_1.spawn)(process.execPath, [ENTRY], {
-    stdio: ["inherit", "inherit", "pipe"],
-    env: process.env,
-});
-emitLifecycle(`op=spawn session=${SESSION_ID8} server=${SERVER_NAME} pid=${child.pid ?? -1} entry=${ENTRY}`, "info");
-child.on("error", (err) => {
-    const msg = err instanceof Error ? err.message : String(err);
-    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason=${JSON.stringify(`spawn error: ${msg}`)}`, "error");
-    process.exit(127);
+// Replace process.stderr.write with a tee: mirror every server stderr byte to
+// the per-date and per-session sinks, keep a rolling tail for op=exit, emit
+// op=boot on the first bytes, then pass the write through to the real stderr.
+const teeWrite = ((...args) => {
+    const chunk = args[0];
+    appendSafe(perDatePath, chunk); // per-date raw (back-compat)
+    appendSafe(perSessionPath, chunk); // per-session raw (Task 706)
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    stderrTail = (stderrTail + text).slice(-TAIL_CAP);
+    if (!bootEmitted) {
+        bootEmitted = true;
+        const head = text.split("\n")[0].slice(0, 200);
+        emitLifecycle(`op=boot session=${SESSION_ID8} server=${SERVER_NAME} head=${JSON.stringify(head)}`, "info");
+    }
+    return rawStderrWrite(...args); // passthrough
 });
-if (child.stderr) {
-    child.stderr.on("data", (chunk) => {
-        appendSafe(perDatePath, chunk); // per-date raw (back-compat)
-        appendSafe(perSessionPath, chunk); // per-session raw (Task 706)
-        try {
-            process.stderr.write(chunk);
-        }
-        catch { /* stderr closed */ } // passthrough
-        stderrTail = (stderrTail + chunk.toString("utf8")).slice(-TAIL_CAP);
-        if (!bootEmitted) {
-            bootEmitted = true;
-            const head = chunk.toString("utf8").split("\n")[0].slice(0, 200);
-            emitLifecycle(`op=boot session=${SESSION_ID8} server=${SERVER_NAME} head=${JSON.stringify(head)}`, "info");
+process.stderr.write = teeWrite;
+// Catchable-signal handling. The shim drives the exit ONLY when it is the sole
+// listener for the signal — i.e. the imported entry installed no handler of its
+// own. In that case it records the signal (so op=exit carries signal=<sig>) and
+// exits with 128+signum, mirroring the prior wrapper's exit-status convention.
+//
+// When the entry DID install a handler, the shim defers entirely and records
+// nothing: the entry's handler decides the exit code, and op=exit reflects that
+// exit verbatim. This matches the prior two-process model, where a child that
+// caught the signal and exited cleanly was observed as code=0 signal=— (a clean
+// self-exit), not as a signal death. Setting exitSignal here unconditionally
+// would mislabel every graceful signal-driven shutdown as a signal kill.
+function onSignal(sig, code) {
+    return () => {
+        if (process.listenerCount(sig) === 1) {
+            exitSignal = sig;
+            process.exit(code);
         }
-    });
+    };
 }
-const forward = (signal) => { if (!child.killed)
-    child.kill(signal); };
-process.on("SIGTERM", () => forward("SIGTERM"));
-process.on("SIGINT", () => forward("SIGINT"));
-// Signal → number, so a signal-killed child propagates as 128+signum (the
-// shell convention). `code` is null on a signal exit, so `128 + (code ?? 0)`
-// would collapse every signal to 128 and lose the signal identity in the
-// wrapper's own exit status.
-const SIGNUM = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15 };
-child.on("exit", (code, signal) => {
+process.on("SIGTERM", onSignal("SIGTERM", 143));
+process.on("SIGINT", onSignal("SIGINT", 130));
+process.on("SIGHUP", onSignal("SIGHUP", 129));
+// op=exit, emitted once from the process "exit" event. Sync-only — the loop is
+// stopping. When a catchable signal caused the exit, report code=— signal=<sig>
+// to match the prior wrapper's format; otherwise code=<exit code> signal=—.
+process.on("exit", (code) => {
+    if (exitEmitted)
+        return;
+    exitEmitted = true;
     const lifetimeMs = Date.now() - spawnStamp;
     const tail = stderrTail.slice(-200);
-    const level = signal || (code ?? 0) !== 0 ? "error" : "info";
-    emitLifecycle(`op=exit session=${SESSION_ID8} server=${SERVER_NAME} pid=${child.pid ?? -1} ` +
-        `code=${code ?? "—"} signal=${signal ?? "—"} lifetimeMs=${lifetimeMs} stderr-tail=${JSON.stringify(tail)}`, level);
-    if (signal)
-        process.exit(128 + (SIGNUM[signal] ?? 0));
-    process.exit(code ?? 0);
+    const codeField = exitSignal ? "—" : String(code);
+    const level = exitSignal || code !== 0 ? "error" : "info";
+    emitLifecycle(`op=exit session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} ` +
+        `code=${codeField} signal=${exitSignal ?? "—"} lifetimeMs=${lifetimeMs} stderr-tail=${JSON.stringify(tail)}`, level);
+});
+emitLifecycle(`op=spawn session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} entry=${ENTRY}`, "info");
+// Run the real MCP server in THIS process. Dynamic import() (not top-level
+// await — this file compiles to CommonJS) loads the ESM entry; a load-time
+// failure mirrors the old child spawn-error path (op=error, exit 127). The
+// op=exit handler is suppressed on this path so op=error stays the sole record.
+import((0, node_url_1.pathToFileURL)(ENTRY).href).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    exitEmitted = true;
+    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason=${JSON.stringify(`import error: ${msg}`)}`, "error");
+    process.exit(127);
 });
 //# sourceMappingURL=index.js.map