metheus-governance-mcp-cli 0.2.58 → 0.2.59

package/cli.mjs

@@ -6,7 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import readline from "node:readline";
 import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import http from "node:http";
 import https from "node:https";
@@ -1363,7 +1363,7 @@ function buildRunnerShellInvocation(command) {
   };
 }
 
-function runLocalAICommand({ command, inputPayload, route, destination }) {
+async function runLocalAICommand({ command, inputPayload, route, destination }) {
   const invocation = buildRunnerShellInvocation(command);
   const stdinText = `${JSON.stringify(inputPayload, null, 2)}\n`;
   const env = {
@@ -1374,16 +1374,72 @@ function runLocalAICommand({ command, inputPayload, route, destination }) {
     METHEUS_RUNNER_CHAT_ID: String(destination.chatID || "").trim(),
     METHEUS_RUNNER_DESTINATION_LABEL: String(destination.label || "").trim(),
   };
-  const result = spawnSync(invocation.file, invocation.args, {
-    encoding: "utf8",
-    input: stdinText,
-    env,
-    maxBuffer: 4 * 1024 * 1024,
+  const result = await new Promise((resolve, reject) => {
+    const child = spawn(invocation.file, invocation.args, {
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdoutText = "";
+    let stderrText = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    const maxBufferBytes = 4 * 1024 * 1024;
+    let settled = false;
+
+    function finishWithError(error) {
+      if (settled) return;
+      settled = true;
+      try {
+        child.kill();
+      } catch {}
+      reject(error);
+    }
+
+    function appendOutput(chunk, target) {
+      const text = String(chunk || "");
+      if (!text) return;
+      const bytes = Buffer.byteLength(text);
+      if (target === "stdout") {
+        stdoutBytes += bytes;
+        if (stdoutBytes > maxBufferBytes) {
+          finishWithError(new Error("runner command exceeded stdout buffer limit"));
+          return;
+        }
+        stdoutText += text;
+        return;
+      }
+      stderrBytes += bytes;
+      if (stderrBytes > maxBufferBytes) {
+        finishWithError(new Error("runner command exceeded stderr buffer limit"));
+        return;
+      }
+      stderrText += text;
+    }
+
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    });
+    child.stdout.on("data", (chunk) => appendOutput(chunk, "stdout"));
+    child.stderr.on("data", (chunk) => appendOutput(chunk, "stderr"));
+    child.on("close", (status, signal) => {
+      if (settled) return;
+      settled = true;
+      resolve({
+        status,
+        signal,
+        stdoutText: stdoutText.trim(),
+        stderrText: stderrText.trim(),
+      });
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(stdinText);
   });
-  const stdoutText = String(result.stdout || "").trim();
-  const stderrText = String(result.stderr || "").trim();
-  if (result.error) {
-    throw new Error(String(result.error?.message || result.error));
+  const stdoutText = String(result.stdoutText || "").trim();
+  const stderrText = String(result.stderrText || "").trim();
+  if (result.signal) {
+    throw new Error(stderrText || stdoutText || `runner command terminated by signal ${result.signal}`);
   }
   if (result.status !== 0) {
     throw new Error(stderrText || stdoutText || `runner command exited with status ${result.status}`);
@@ -1768,12 +1824,41 @@ async function processRunnerRouteOnce(route, runtime, mode) {
     selectedRecord,
     contextWindow,
   });
-  const aiResult = runLocalAICommand({
-    command: normalizedRoute.command,
-    inputPayload: aiPayload,
-    route: normalizedRoute,
+  await maybeSendRunnerChatAction({
+    provider: normalizedRoute.provider,
     destination,
+    timeoutSeconds: runtime.timeoutSeconds,
+    action: "typing",
   });
+  let typingRequestInFlight = false;
+  const typingInterval = setInterval(() => {
+    if (typingRequestInFlight) return;
+    typingRequestInFlight = true;
+    maybeSendRunnerChatAction({
+      provider: normalizedRoute.provider,
+      destination,
+      timeoutSeconds: runtime.timeoutSeconds,
+      action: "typing",
+    })
+      .catch(() => {})
+      .finally(() => {
+        typingRequestInFlight = false;
+      });
+  }, 4000);
+  if (typeof typingInterval.unref === "function") {
+    typingInterval.unref();
+  }
+  let aiResult;
+  try {
+    aiResult = await runLocalAICommand({
+      command: normalizedRoute.command,
+      inputPayload: aiPayload,
+      route: normalizedRoute,
+      destination,
+    });
+  } finally {
+    clearInterval(typingInterval);
+  }
   if (aiResult.skip) {
     saveRunnerRouteState(
       routeKey,
@@ -2177,6 +2262,73 @@ async function deliverLocalProviderMessage({
   throw new Error(`${providerEnvConfig(normalizedProvider).label} local delivery is not implemented yet`);
 }
 
+async function sendLocalProviderChatAction({
+  provider,
+  token,
+  destination,
+  action,
+  timeoutSeconds,
+}) {
+  const normalizedProvider = normalizeBotProvider(provider);
+  if (normalizedProvider === "telegram") {
+    const requestURL = `https://api.telegram.org/bot${token}/sendChatAction`;
+    const payload = {
+      chat_id: destination.chatID,
+      action: String(action || "typing").trim() || "typing",
+    };
+    const response = await postJSONWithoutAuth(requestURL, timeoutSeconds, payload);
+    const responseJSON = parseJSONText(response.bodyText);
+    return {
+      statusCode: response.statusCode,
+      body: responseJSON || response.bodyText,
+      ok: response.statusCode >= 200 && response.statusCode < 300 && Boolean(responseJSON?.ok ?? true),
+      url: sanitizeTelegramAPIURL(requestURL),
+    };
+  }
+  return {
+    statusCode: 204,
+    body: { ok: true, skipped: true },
+    ok: true,
+    url: "",
+  };
+}
+
+async function maybeSendRunnerChatAction({
+  provider,
+  destination,
+  timeoutSeconds,
+  action = "typing",
+}) {
+  const providerEnv = loadProviderEnvConfig(provider);
+  if (!providerEnv.ok) {
+    return {
+      ok: false,
+      skipped: true,
+      detail: providerEnv.error,
+    };
+  }
+  try {
+    const result = await sendLocalProviderChatAction({
+      provider,
+      token: providerEnv.token,
+      destination,
+      action,
+      timeoutSeconds,
+    });
+    return {
+      ok: Boolean(result.ok),
+      skipped: false,
+      detail: result.ok ? "" : String(safeObject(result.body).description || safeObject(result.body).error || "").trim(),
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      skipped: false,
+      detail: String(err?.message || err),
+    };
+  }
+}
+
 function resolveWorkspaceDir(rawPath) {
   const input = String(rawPath || "").trim();
   if (input) {

package/package.json

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