metheus-governance-mcp-cli 0.2.290 → 0.2.291

package/cli.mjs

@@ -12329,16 +12329,53 @@ function sleepSyncMilliseconds(durationMs) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, numericDurationMs);
 }
 
-function ensureDetachedRunnerBootstrapped(childPID, logFilePath = "") {
-  sleepSyncMilliseconds(1200);
-  if (isProcessAlive(childPID)) {
-    return;
+function buildDetachedRunnerBootstrapLogPaths(logFilePath = "") {
+  const normalizedLogFilePath = String(logFilePath || "").trim();
+  if (!normalizedLogFilePath) {
+    return { stdoutPath: "", stderrPath: "" };
   }
+  const parsed = path.parse(normalizedLogFilePath);
+  const baseName = parsed.name || "runner-start";
+  return {
+    stdoutPath: path.join(parsed.dir, `${baseName}.bootstrap.out.log`),
+    stderrPath: path.join(parsed.dir, `${baseName}.bootstrap.err.log`),
+  };
+}
+
+function ensureDetachedRunnerBootstrapped(childPID, logFilePath = "", bootstrapLogPaths = {}) {
   const normalizedLogFilePath = String(logFilePath || "").trim();
-  if (normalizedLogFilePath && fs.existsSync(normalizedLogFilePath)) {
-    throw new Error(`detached runner exited during bootstrap; inspect ${normalizedLogFilePath}`);
+  const normalizedBootstrapStdoutPath = String(safeObject(bootstrapLogPaths).stdoutPath || "").trim();
+  const normalizedBootstrapStderrPath = String(safeObject(bootstrapLogPaths).stderrPath || "").trim();
+  const deadlineMs = Date.now() + 5000;
+  while (Date.now() < deadlineMs) {
+    if (!isProcessAlive(childPID)) {
+      if (normalizedBootstrapStderrPath && fs.existsSync(normalizedBootstrapStderrPath)) {
+        throw new Error(`detached runner exited during bootstrap; inspect ${normalizedBootstrapStderrPath}`);
+      }
+      if (normalizedBootstrapStdoutPath && fs.existsSync(normalizedBootstrapStdoutPath)) {
+        throw new Error(`detached runner exited during bootstrap; inspect ${normalizedBootstrapStdoutPath}`);
+      }
+      if (normalizedLogFilePath && fs.existsSync(normalizedLogFilePath)) {
+        throw new Error(`detached runner exited during bootstrap; inspect ${normalizedLogFilePath}`);
+      }
+      throw new Error("detached runner exited during bootstrap before the polling loop became stable");
+    }
+    if (normalizedLogFilePath && fs.existsSync(normalizedLogFilePath)) {
+      try {
+        if (fs.statSync(normalizedLogFilePath).size > 0) {
+          return;
+        }
+      } catch {}
+    }
+    sleepSyncMilliseconds(250);
   }
-  throw new Error("detached runner exited during bootstrap before the polling loop became stable");
+  if (normalizedBootstrapStderrPath && fs.existsSync(normalizedBootstrapStderrPath)) {
+    throw new Error(`detached runner stayed alive but did not create the runner log; inspect ${normalizedBootstrapStderrPath}`);
+  }
+  if (normalizedBootstrapStdoutPath && fs.existsSync(normalizedBootstrapStdoutPath)) {
+    throw new Error(`detached runner stayed alive but did not create the runner log; inspect ${normalizedBootstrapStdoutPath}`);
+  }
+  throw new Error("detached runner stayed alive but did not create the runner log during bootstrap");
 }
 
 function buildRunnerProjectUpNextSteps({
@@ -12800,16 +12837,16 @@ async function waitForRunnerPIDFile(pidFilePath, timeoutMs = 8000) {
   throw new Error(`detached runner launch did not publish a child process id: ${pidFilePath}`);
 }
 
-function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand, logFilePath = "") {
-  const normalizedRoutes = ensureArray(routes).map((route) => normalizeRunnerRoute(route));
-  const cliPath = fileURLToPath(import.meta.url);
-  return normalizeRunnerProcessLaunchEntry({
-    launch_id: `${Date.now()}-${childPID}`,
-    pid: childPID,
-    started_at: new Date().toISOString(),
-    command: [process.execPath, cliPath, "--no-update", "runner", "start", ...serializeCLIFlags(flags, { omit: ["json", "start", "start-detached", "detached"] })].join(" "),
-    cli_path: cliPath,
-    working_directory: path.dirname(cliPath),
+function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand, logFilePath = "") {
+  const normalizedRoutes = ensureArray(routes).map((route) => normalizeRunnerRoute(route));
+  const cliPath = fileURLToPath(import.meta.url);
+  return normalizeRunnerProcessLaunchEntry({
+    launch_id: `${Date.now()}-${childPID}`,
+    pid: childPID,
+    started_at: new Date().toISOString(),
+    command: [process.execPath, cliPath, "runner", "start", "--no-update", ...serializeCLIFlags(flags, { omit: ["json", "start", "start-detached", "detached"] })].join(" "),
+    cli_path: cliPath,
+    working_directory: path.dirname(cliPath),
     route_set_signature: runnerDetachedRouteSetSignature(normalizedRoutes),
     route_keys: normalizedRoutes.map((route) => runnerRouteKey(route)),
     route_names: normalizedRoutes.map((route) => route.name || runnerRouteKey(route)),
@@ -12831,46 +12868,43 @@ function findExistingDetachedRunnerLaunch(registry, routes) {
   }) || null;
 }
 
-async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
-  const cliPath = fileURLToPath(import.meta.url);
-  const detachedLogFilePath = resolveRunnerLogFilePath(flags["log-file"], routes, sourceCommand);
-  const startFlags = {
-    ...safeObject(flags),
-    ...(detachedLogFilePath ? { "log-file": detachedLogFilePath } : {}),
-  };
-  const startArgs = [cliPath, "--no-update", "runner", "start", ...serializeCLIFlags(startFlags, {
-    omit: ["json", "start", "start-detached", "detached"],
-  })];
-  if (process.platform === "win32") {
-    const script = [
-      `$wd = ${powershellSingleQuote(path.dirname(cliPath))}`,
-      `$node = ${powershellSingleQuote(process.execPath)}`,
-      `$args = @(${startArgs.map((item) => powershellSingleQuote(item)).join(", ")})`,
-      "$p = Start-Process -FilePath $node -WorkingDirectory $wd -ArgumentList $args -WindowStyle Normal -PassThru",
-      "Write-Output $p.Id",
-    ].join("; ");
-    const launched = spawnSync("powershell.exe", [
-      "-NoLogo",
-      "-NoProfile",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-Command",
-      script,
-    ], {
-      encoding: "utf8",
-      windowsHide: true,
-    });
-    if (launched.error) {
-      throw launched.error;
-    }
-    if (launched.status !== 0) {
-      throw new Error(String(launched.stderr || launched.stdout || "failed to launch detached runner").trim());
-    }
-    const childPID = intFromRawAllowZero(String(launched.stdout || "").trim().split(/\r?\n/).pop(), 0);
-    if (childPID <= 0) {
-      throw new Error("detached runner launch did not return a child process id");
+async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
+  const cliPath = fileURLToPath(import.meta.url);
+  const detachedLogFilePath = resolveRunnerLogFilePath(flags["log-file"], routes, sourceCommand);
+  const bootstrapLogPaths = buildDetachedRunnerBootstrapLogPaths(detachedLogFilePath);
+  const startFlags = {
+    ...safeObject(flags),
+    tui: boolFromRaw(flags.tui, false),
+    ...(detachedLogFilePath ? { "log-file": detachedLogFilePath } : {}),
+  };
+  const startArgs = [cliPath, "runner", "start", "--no-update", ...serializeCLIFlags(startFlags, {
+    omit: ["json", "start", "start-detached", "detached"],
+  })];
+  if (process.platform === "win32") {
+    const stdoutFd = bootstrapLogPaths.stdoutPath ? fs.openSync(bootstrapLogPaths.stdoutPath, "a") : "ignore";
+    const stderrFd = bootstrapLogPaths.stderrPath ? fs.openSync(bootstrapLogPaths.stderrPath, "a") : "ignore";
+    let child = null;
+    try {
+      child = spawn(process.execPath, startArgs, {
+        cwd: path.dirname(cliPath),
+        detached: true,
+        stdio: ["ignore", stdoutFd, stderrFd],
+        windowsHide: true,
+      });
+      if (!child.pid) {
+        throw new Error("detached runner launch did not return a child process id");
+      }
+      child.unref();
+    } finally {
+      if (typeof stdoutFd === "number") {
+        try { fs.closeSync(stdoutFd); } catch {}
+      }
+      if (typeof stderrFd === "number") {
+        try { fs.closeSync(stderrFd); } catch {}
+      }
     }
-    ensureDetachedRunnerBootstrapped(childPID, detachedLogFilePath);
+    const childPID = intFromRawAllowZero(child?.pid, 0);
+    ensureDetachedRunnerBootstrapped(childPID, detachedLogFilePath, bootstrapLogPaths);
     return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
   }
   const launchTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-launch-"));
@@ -12901,7 +12935,7 @@ async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
         throw new Error(String(launched.stderr || launched.stdout || "failed to launch detached runner in Terminal.app").trim());
       }
       const childPID = await waitForRunnerPIDFile(pidFilePath);
-      ensureDetachedRunnerBootstrapped(childPID, detachedLogFilePath);
+      ensureDetachedRunnerBootstrapped(childPID, detachedLogFilePath, bootstrapLogPaths);
       return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
     }
     const terminalLauncher = resolveLinuxDetachedTerminalLauncher(scriptPath);
@@ -12918,7 +12952,7 @@ async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
       throw new Error("detached terminal launcher did not return a process id");
     }
     const runnerPID = await waitForRunnerPIDFile(pidFilePath);
-    ensureDetachedRunnerBootstrapped(runnerPID, detachedLogFilePath);
+    ensureDetachedRunnerBootstrapped(runnerPID, detachedLogFilePath, bootstrapLogPaths);
     return buildRunnerDetachedLaunchRecord(runnerPID, routes, startFlags, sourceCommand, detachedLogFilePath);
   } finally {
     try {
@@ -19251,25 +19285,28 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     }
   }
 
-  try {
-    const detachedArgs = serializeCLIFlags({
-      "project-id": selftestProjectID,
-      provider: "telegram",
-      "destination-id": "dest-1",
-      "start-detached": "true",
-      detached: "true",
-      start: "true",
-    }, {
-      omit: ["start", "start-detached", "detached"],
+  try {
+    const detachedArgs = serializeCLIFlags({
+      "project-id": selftestProjectID,
+      provider: "telegram",
+      "destination-id": "dest-1",
+      tui: "false",
+      "start-detached": "true",
+      detached: "true",
+      start: "true",
+    }, {
+      omit: ["start", "start-detached", "detached"],
     });
-    push(
-      "detached_runner_cli_args_strip_control_flags",
-      detachedArgs.includes("--project-id")
-        && detachedArgs.includes(selftestProjectID)
-        && !detachedArgs.includes("--start")
-        && !detachedArgs.includes("--start-detached")
-        && !detachedArgs.includes("--detached"),
-      detachedArgs.join(" "),
+    push(
+      "detached_runner_cli_args_strip_control_flags",
+      detachedArgs.includes("--project-id")
+        && detachedArgs.includes(selftestProjectID)
+        && detachedArgs.includes("--tui")
+        && detachedArgs.includes("false")
+        && !detachedArgs.includes("--start")
+        && !detachedArgs.includes("--start-detached")
+        && !detachedArgs.includes("--detached"),
+      detachedArgs.join(" "),
     );
   } catch (err) {
     push("detached_runner_cli_args_strip_control_flags", false, String(err?.message || err));
@@ -19293,43 +19330,45 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("runner_default_log_file_path_uses_runner_logs_directory", false, String(err?.message || err));
   }
 
-  try {
-    const detachedLaunch = buildRunnerDetachedLaunchRecord(
-      4321,
-      [{ name: "telegram-monitor-selftest", projectID: selftestProjectID, provider: "telegram", destinationLabel: "Selftest Room" }],
-      {},
-      "runner start-detached",
-      "C:\\logs\\runner-selftest.jsonl",
-    );
-    push(
-      "detached_runner_launch_record_persists_log_file",
-      String(detachedLaunch.log_file || "").trim() === "C:\\logs\\runner-selftest.jsonl",
-      `log_file=${String(detachedLaunch.log_file || "").trim() || "(none)"}`,
-    );
-  } catch (err) {
-    push("detached_runner_launch_record_persists_log_file", false, String(err?.message || err));
-  }
+  try {
+    const detachedLaunch = buildRunnerDetachedLaunchRecord(
+      4321,
+      [{ name: "telegram-monitor-selftest", projectID: selftestProjectID, provider: "telegram", destinationLabel: "Selftest Room" }],
+      { tui: false },
+      "runner start-detached",
+      "C:\\logs\\runner-selftest.jsonl",
+    );
+    push(
+      "detached_runner_launch_record_persists_log_file",
+      String(detachedLaunch.log_file || "").trim() === "C:\\logs\\runner-selftest.jsonl"
+        && String(detachedLaunch.command || "").includes(" runner start --no-update ")
+        && String(detachedLaunch.command || "").includes("--tui false"),
+      `log_file=${String(detachedLaunch.log_file || "").trim() || "(none)"} command=${String(detachedLaunch.command || "").trim() || "(none)"}`,
+    );
+  } catch (err) {
+    push("detached_runner_launch_record_persists_log_file", false, String(err?.message || err));
+  }
 
   let detachedRunnerPosixTempDir = "";
   try {
     detachedRunnerPosixTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-detached-script-selftest-"));
     const scriptPath = path.join(detachedRunnerPosixTempDir, "start-runner.sh");
     const pidFilePath = path.join(detachedRunnerPosixTempDir, "runner.pid");
-    buildRunnerDetachedPosixLaunchScript({
-      scriptPath,
-      pidFilePath,
-      workingDirectory: detachedRunnerPosixTempDir,
-      nodePath: "/usr/local/bin/node",
-      startArgs: ["/tmp/cli.mjs", "--no-update", "runner", "start", "--project-id", selftestProjectID],
-    });
+    buildRunnerDetachedPosixLaunchScript({
+      scriptPath,
+      pidFilePath,
+      workingDirectory: detachedRunnerPosixTempDir,
+      nodePath: "/usr/local/bin/node",
+      startArgs: ["/tmp/cli.mjs", "runner", "start", "--no-update", "--project-id", selftestProjectID],
+    });
     const scriptText = fs.readFileSync(scriptPath, "utf8");
-    push(
-      "detached_runner_posix_launch_script_serializes_runner_command",
-      scriptText.includes(`echo $$ > ${posixSingleQuote(pidFilePath)}`)
-        && scriptText.includes(`cd ${posixSingleQuote(detachedRunnerPosixTempDir)} || exit 1`)
-        && scriptText.includes(`exec ${posixSingleQuote("/usr/local/bin/node")} ${posixSingleQuote("/tmp/cli.mjs")} ${posixSingleQuote("--no-update")} ${posixSingleQuote("runner")} ${posixSingleQuote("start")}`),
-      scriptText.replace(/\r?\n/g, " | "),
-    );
+    push(
+      "detached_runner_posix_launch_script_serializes_runner_command",
+      scriptText.includes(`echo $$ > ${posixSingleQuote(pidFilePath)}`)
+        && scriptText.includes(`cd ${posixSingleQuote(detachedRunnerPosixTempDir)} || exit 1`)
+        && scriptText.includes(`exec ${posixSingleQuote("/usr/local/bin/node")} ${posixSingleQuote("/tmp/cli.mjs")} ${posixSingleQuote("runner")} ${posixSingleQuote("start")} ${posixSingleQuote("--no-update")}`),
+      scriptText.replace(/\r?\n/g, " | "),
+    );
   } catch (err) {
     push("detached_runner_posix_launch_script_serializes_runner_command", false, String(err?.message || err));
   } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.290",
+  "version": "0.2.291",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [