[Init] Initial commit - NetMesh terminal manager

electron/bridges/aiBridge/agentCliHelpers.cjs

@@ -0,0 +1,416 @@
+/* eslint-disable no-undef */
+const { StringDecoder } = require("node:string_decoder");
+
+const DEFAULT_CODEX_CLI_TIMEOUT_MS = 10_000;
+const CODEX_AUTH_VALIDATION_TIMEOUT_MS = 10_000;
+const MAX_AGENT_CLI_BUFFER_CHARS = 10 * 1024 * 1024;
+
+function createAgentCliHelpers(ctx) {
+  with (ctx) {
+  const codexAuthValidationInFlight = new Map();
+  async function runCommand(command, args, options) {
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      let closed = false;
+      let timeoutId = null;
+      let killId = null;
+      function clearTimers() {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+        if (killId) {
+          clearTimeout(killId);
+          killId = null;
+        }
+      }
+      const spawnSpec = prepareCommandForSpawn(command, args || []);
+      const child = spawn(spawnSpec.command, spawnSpec.args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        cwd: options?.cwd || undefined,
+        env: options?.env || process.env,
+        shell: spawnSpec.shell,
+        windowsHide: true,
+      });
+
+      let stdout = "";
+      let stderr = "";
+      let stdoutBytes = 0;
+      let stderrBytes = 0;
+      let stdoutTruncated = false;
+      let stderrTruncated = false;
+      const stdoutDecoder = new StringDecoder("utf8");
+      const stderrDecoder = new StringDecoder("utf8");
+      const timeoutMs = Number.isFinite(options?.timeoutMs) ? Number(options.timeoutMs) : 0;
+
+      child.stdout.on("data", (chunk) => {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        const remaining = Math.max(0, MAX_AGENT_CLI_BUFFER_CHARS - stdoutBytes);
+        const accepted = buffer.length <= remaining ? buffer : buffer.subarray(0, remaining);
+        if (accepted.length > 0) stdout += stdoutDecoder.write(accepted);
+        stdoutBytes += accepted.length;
+        if (accepted.length < buffer.length) stdoutTruncated = true;
+      });
+
+      child.stderr.on("data", (chunk) => {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        const remaining = Math.max(0, MAX_AGENT_CLI_BUFFER_CHARS - stderrBytes);
+        const accepted = buffer.length <= remaining ? buffer : buffer.subarray(0, remaining);
+        if (accepted.length > 0) stderr += stderrDecoder.write(accepted);
+        stderrBytes += accepted.length;
+        if (accepted.length < buffer.length) stderrTruncated = true;
+      });
+
+      child.once("error", (error) => {
+        closed = true;
+        if (settled) return;
+        settled = true;
+        clearTimers();
+        reject(error);
+      });
+
+      child.once("close", (exitCode) => {
+        closed = true;
+        clearTimers();
+        if (settled) return;
+        settled = true;
+        if (!stdoutTruncated || stdoutDecoder.lastNeed === 0) stdout += stdoutDecoder.end();
+        if (!stderrTruncated || stderrDecoder.lastNeed === 0) stderr += stderrDecoder.end();
+        resolve({
+          stdout: stripAnsi(stdout),
+          stderr: stripAnsi(stderr),
+          exitCode,
+        });
+      });
+
+      if (timeoutMs > 0) {
+        timeoutId = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          const error = new Error(`Command timed out after ${timeoutMs}ms`);
+          error.code = "ETIMEDOUT";
+          try {
+            if (!closed) child.kill("SIGTERM");
+          } catch {}
+          killId = setTimeout(() => {
+            try {
+              if (!closed) child.kill("SIGKILL");
+            } catch {}
+          }, 750);
+          if (typeof killId.unref === "function") killId.unref();
+          reject(error);
+        }, timeoutMs);
+        if (typeof timeoutId.unref === "function") timeoutId.unref();
+      }
+    });
+  }
+
+  function getCommandOutput(result) {
+    return [result?.stdout, result?.stderr]
+      .filter((chunk) => typeof chunk === "string" && chunk.length > 0)
+      .join("\n")
+      .trim();
+  }
+
+  function getFirstCommandOutputLine(result) {
+    return getCommandOutput(result).split(/\r?\n/)[0] || "";
+  }
+
+  async function probeCliVersion(probeCmd, probeArgs, env) {
+    try {
+      const result = await runCommand(probeCmd, probeArgs, { env, timeoutMs: 5000 });
+      return {
+        launched: true,
+        exitCode: result.exitCode,
+        output: getCommandOutput(result),
+        version: getFirstCommandOutputLine(result),
+      };
+    } catch {
+      return {
+        launched: false,
+        exitCode: null,
+        output: "",
+        version: "",
+      };
+    }
+  }
+
+  async function runCodexCli(args, options) {
+    const shellEnv = await getShellEnv();
+    const requestedPath = String(options?.codexPath || "").trim();
+    const configuredPath = requestedPath ? normalizeCliPathForPlatform?.(requestedPath) : null;
+    if (requestedPath && !configuredPath) {
+      throw new Error(`Codex CLI path not found: ${requestedPath}`);
+    }
+    const codexCliPath = configuredPath || await resolveCliFromPathAsync("codex", shellEnv) || "codex";
+    return await runCommand(codexCliPath, args, {
+      cwd: options?.cwd?.trim() || undefined,
+      env: shellEnv,
+      timeoutMs: Number.isFinite(options?.timeoutMs)
+        ? Number(options.timeoutMs)
+        : DEFAULT_CODEX_CLI_TIMEOUT_MS,
+    });
+  }
+
+  async function runCodexCliChecked(args, options) {
+    const result = await runCodexCli(args, options);
+    if (result.exitCode === 0) {
+      return result;
+    }
+
+    const errorText =
+      result.stderr.trim() ||
+      result.stdout.trim() ||
+      `Codex command failed with exit code ${result.exitCode ?? "unknown"}`;
+    throw new Error(errorText);
+  }
+
+  async function validateCodexChatGptAuth(options) {
+    const maxAgeMs = options?.maxAgeMs ?? 30000;
+    const now = Date.now();
+    const rawRequestedCodexPath = String(options?.codexPath || "").trim();
+    const requestedCodexPath = rawRequestedCodexPath ? normalizeCliPathForPlatform?.(rawRequestedCodexPath) : null;
+    if (rawRequestedCodexPath && !requestedCodexPath) {
+      const result = {
+        ok: false,
+        checkedAt: now,
+        codexPath: null,
+        error: `Codex CLI path not found: ${rawRequestedCodexPath}`,
+        code: "ENOENT",
+      };
+      setCodexValidationCache(result);
+      return result;
+    }
+    const cached = getCodexValidationCache();
+    if (cached && now - cached.checkedAt < maxAgeMs && (cached.codexPath || null) === requestedCodexPath) return cached;
+    const inFlightKey = requestedCodexPath || "__auto__";
+    const existingValidation = codexAuthValidationInFlight.get(inFlightKey);
+    if (existingValidation) return existingValidation;
+
+    const validationPromise = (async () => {
+      const shellEnv = await getShellEnv();
+      const rawCodexPath = requestedCodexPath || await resolveSdkBinPathAsync("codex", shellEnv);
+      const codexPath = rawCodexPath && typeof resolveCodexExecutableForSdk === "function"
+        ? resolveCodexExecutableForSdk(rawCodexPath) || null
+        : rawCodexPath;
+      if (!codexPath) {
+        const result = { ok: false, checkedAt: now, codexPath: requestedCodexPath, error: "codex binary not found", code: "ENOENT" };
+        setCodexValidationCache(result);
+        return result;
+      }
+
+      const abortController = new AbortController();
+      let timeoutId = null;
+      let iterator = null;
+      try {
+        const timeoutPromise = new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
+            const error = new Error(
+              `Codex ChatGPT auth validation timed out after ${CODEX_AUTH_VALIDATION_TIMEOUT_MS}ms`,
+            );
+            error.code = "ETIMEDOUT";
+            try { abortController.abort(error); } catch {}
+            reject(error);
+          }, CODEX_AUTH_VALIDATION_TIMEOUT_MS);
+          if (typeof timeoutId?.unref === "function") timeoutId.unref();
+        });
+
+        const probePromise = (async () => {
+          // Minimal read-only probe turn through the SDK to confirm auth works.
+          const { Codex } = await (typeof loadCodexSdk === "function"
+            ? loadCodexSdk()
+            : import("@openai/codex-sdk"));
+          const codexOptions = { env: addCodexExecutableEnvForSdk(shellEnv, codexPath) };
+          if (codexPath) codexOptions.codexPathOverride = codexPath;
+          const codex = new Codex(codexOptions);
+          const thread = codex.startThread({ skipGitRepoCheck: true });
+          const { events } = await thread.runStreamed("ping", {
+            sandbox: "read-only",
+            signal: abortController.signal,
+          });
+          iterator = events?.[Symbol.asyncIterator]?.();
+          if (!iterator) throw new Error("Codex auth validation returned no event stream");
+          let failed = null;
+          while (true) {
+            const next = await iterator.next();
+            if (next.done) break;
+            const event = next.value;
+            if (event?.type === "turn.failed") { failed = event.error; break; }
+            if (event?.type === "turn.completed") break;
+            if (event?.type === "item.completed") break;
+          }
+          if (failed) throw failed;
+        })();
+
+        await Promise.race([probePromise, timeoutPromise]);
+        const result = { ok: true, checkedAt: now, codexPath, error: null };
+        setCodexValidationCache(result);
+        return result;
+      } catch (error) {
+        const normalized = extractCodexError(error);
+        const result = { ok: false, checkedAt: now, codexPath, error: normalized.message, code: normalized.code };
+        setCodexValidationCache(result);
+        return result;
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+        try { abortController.abort(); } catch {}
+        try { void Promise.resolve(iterator?.return?.()).catch(() => {}); } catch {}
+      }
+    })();
+
+    codexAuthValidationInFlight.set(inFlightKey, validationPromise);
+    try {
+      return await validationPromise;
+    } finally {
+      if (codexAuthValidationInFlight.get(inFlightKey) === validationPromise) {
+        codexAuthValidationInFlight.delete(inFlightKey);
+      }
+    }
+  }
+
+  function objectToPairs(value) {
+    if (!value || typeof value !== "object") return [];
+    return Object.entries(value)
+      .filter(([name, val]) => typeof name === "string" && typeof val === "string")
+      .map(([name, val]) => ({ name, value: val }));
+  }
+
+  function resolveCodexStdioEnv(transport, shellEnv) {
+    const merged = {};
+
+    if (transport?.env && typeof transport.env === "object") {
+      for (const [name, value] of Object.entries(transport.env)) {
+        if (typeof name === "string" && typeof value === "string") {
+          merged[name] = value;
+        }
+      }
+    }
+
+    if (Array.isArray(transport?.env_vars)) {
+      for (const envName of transport.env_vars) {
+        const value = shellEnv[envName] || process.env[envName];
+        if (typeof value === "string" && value.length > 0 && !merged[envName]) {
+          merged[envName] = value;
+        }
+      }
+    }
+
+    return merged;
+  }
+
+  function resolveCodexHttpHeaders(transport, shellEnv) {
+    const merged = {};
+
+    if (transport?.http_headers && typeof transport.http_headers === "object") {
+      for (const [name, value] of Object.entries(transport.http_headers)) {
+        if (typeof name === "string" && typeof value === "string") {
+          merged[name] = value;
+        }
+      }
+    }
+
+    if (transport?.env_http_headers && typeof transport.env_http_headers === "object") {
+      for (const [headerName, envName] of Object.entries(transport.env_http_headers)) {
+        if (typeof headerName !== "string" || typeof envName !== "string") continue;
+        const value = shellEnv[envName] || process.env[envName];
+        if (typeof value === "string" && value.length > 0) {
+          merged[headerName] = value;
+        }
+      }
+    }
+
+    const bearerEnvVar = typeof transport?.bearer_token_env_var === "string"
+      ? transport.bearer_token_env_var.trim()
+      : "";
+    if (bearerEnvVar && !merged.Authorization) {
+      const token = shellEnv[bearerEnvVar] || process.env[bearerEnvVar];
+      if (typeof token === "string" && token.trim()) {
+        merged.Authorization = `Bearer ${token.trim()}`;
+      }
+    }
+
+    return merged;
+  }
+
+  async function resolveCodexMcpSnapshot(cwd) {
+    const empty = { mcpServers: [], fingerprint: getCodexMcpFingerprint([]) };
+
+    try {
+      const result = await runCodexCliChecked(["mcp", "list", "--json"], {
+        cwd: cwd || undefined,
+      });
+      const parsed = JSON.parse(result.stdout);
+      if (!Array.isArray(parsed)) {
+        return empty;
+      }
+
+      const shellEnv = await getShellEnv();
+      const mcpServers = [];
+
+      for (const entry of parsed) {
+        if (!entry?.enabled || !entry?.transport || typeof entry?.name !== "string") {
+          continue;
+        }
+
+        const transportType = String(entry.transport.type || "").trim().toLowerCase();
+
+        if (transportType === "stdio") {
+          const command = String(entry.transport.command || "").trim();
+          if (!command) continue;
+          mcpServers.push({
+            name: entry.name,
+            type: "stdio",
+            command,
+            args: Array.isArray(entry.transport.args)
+              ? entry.transport.args.filter((arg) => typeof arg === "string")
+              : [],
+            env: objectToPairs(resolveCodexStdioEnv(entry.transport, shellEnv)),
+          });
+          continue;
+        }
+
+        if (transportType === "streamable_http" || transportType === "http" || transportType === "sse") {
+          const url = String(entry.transport.url || "").trim();
+          if (!url) continue;
+          mcpServers.push({
+            name: entry.name,
+            type: "http",
+            url,
+            headers: objectToPairs(resolveCodexHttpHeaders(entry.transport, shellEnv)),
+          });
+        }
+      }
+
+      return {
+        mcpServers,
+        fingerprint: getCodexMcpFingerprint(mcpServers),
+      };
+    } catch (err) {
+      console.error("[Codex] Failed to resolve MCP servers:", err?.message || err);
+      return empty;
+    }
+  }
+
+
+    return {
+      runCommand,
+      getCommandOutput,
+      getFirstCommandOutputLine,
+      probeCliVersion,
+      runCodexCli,
+      runCodexCliChecked,
+      validateCodexChatGptAuth,
+      objectToPairs,
+      resolveCodexStdioEnv,
+      resolveCodexHttpHeaders,
+      resolveCodexMcpSnapshot,
+    };
+  }
+}
+
+module.exports = {
+  createAgentCliHelpers,
+  CODEX_AUTH_VALIDATION_TIMEOUT_MS,
+  DEFAULT_CODEX_CLI_TIMEOUT_MS,
+  MAX_AGENT_CLI_BUFFER_CHARS,
+};