[Init] Initial commit - NetMesh terminal manager

electron/capabilities/codegen/mcpToolRegistry.cjs

@@ -0,0 +1,259 @@
+"use strict";
+
+const { z } = require("zod");
+const { listMcpTools } = require("./toolSurfaces.cjs");
+
+const TERMINAL_EXECUTE_TOOLS = new Set(["terminal_execute"]);
+const TERMINAL_START_TOOLS = new Set(["terminal_start"]);
+const TERMINAL_POLL_TOOLS = new Set(["terminal_poll"]);
+const TERMINAL_STOP_TOOLS = new Set(["terminal_stop"]);
+const SESSION_CLOSE_TOOLS = new Set(["session_close"]);
+const CONTEXT_TOOLS = new Set(["get_environment"]);
+const ATTACHMENT_LIST_TOOLS = new Set(["list_attachments"]);
+const ATTACHMENT_READ_TOOLS = new Set(["read_attachment"]);
+const SFTP_WRITE_TOOLS = new Set([
+  "sftp_write_file",
+  "sftp_mkdir",
+  "sftp_delete",
+  "sftp_rename",
+  "sftp_chmod",
+]);
+
+function buildZodField(field) {
+  let schema = field.type === "number" ? z.number() : z.string();
+  if (field.type === "number") {
+    schema = schema.int().min(0);
+  }
+  if (field.description) {
+    schema = schema.describe(field.description);
+  }
+  if (field.optional) {
+    schema = schema.optional();
+  }
+  return schema;
+}
+
+function buildZodShapeObject(inputShape) {
+  const shape = {};
+  for (const [key, field] of Object.entries(inputShape || {})) {
+    shape[key] = buildZodField(field);
+  }
+  return shape;
+}
+
+function buildZodSchema(inputShape) {
+  return z.object(buildZodShapeObject(inputShape));
+}
+
+function isEmptyMcpInputShape(inputShape) {
+  return Object.keys(inputShape || {}).length === 0;
+}
+
+function formatRpcError(result) {
+  if (result?.error) return `Error: ${result.error}`;
+  if (result?.code) return `Error: Operation failed (${result.code})`;
+  return "Error: Operation failed";
+}
+
+/**
+ * True when the RPC result carries command-run evidence (output and/or exit
+ * code). Non-zero exits from PTY exec set ok:false without an error string —
+ * that is still a completed command, not an operational failure.
+ */
+function hasTerminalExecuteEvidence(result) {
+  if (!result || typeof result !== "object") return false;
+  if (typeof result.stdout === "string" && result.stdout.length > 0) return true;
+  if (typeof result.stderr === "string" && result.stderr.length > 0) return true;
+  return result.exitCode != null;
+}
+
+function formatTerminalExecuteResult(result) {
+  const parts = [];
+  if (result?.stdout) parts.push(result.stdout);
+  if (result?.stderr) parts.push(`[stderr] ${result.stderr}`);
+  if (result?.exitCode != null) {
+    parts.push(`[exit code: ${result.exitCode}]`);
+  }
+  if (result?.error) parts.push(`[error] ${result.error}`);
+  return parts.join("\n");
+}
+
+// Align with Catty executor wording when a command ran but produced no text.
+const TERMINAL_EXECUTE_NO_OUTPUT_TEXT = "Command completed (no output)";
+
+/**
+ * Format terminal_execute for MCP clients.
+ * Match Catty semantics: when the command actually ran, always surface
+ * stdout/stderr/exitCode so the model can judge the failure. Only pure
+ * operational failures (session missing, blocked, etc.) become a bare
+ * "Error: …" payload. See issue #2718.
+ *
+ * Successful empty results (serial/network raw PTY often returns ok:true with
+ * empty stdout/stderr and exitCode:null) must NOT fall back to
+ * "Error: Operation failed" — Codex P2 on PR #2724.
+ */
+function formatTerminalExecuteMcpResponse(result) {
+  if (!result || typeof result !== "object") {
+    return { content: [{ type: "text", text: formatRpcError(result) }], isError: true };
+  }
+
+  // Operational failure with no command evidence (session not found, busy, blocked…).
+  if (result.ok === false && !hasTerminalExecuteEvidence(result)) {
+    return { content: [{ type: "text", text: formatRpcError(result) }], isError: true };
+  }
+
+  // Empty successful payloads (serial/raw PTY): neutral text.
+  // Never fall back to formatRpcError here — that mislabels silent successes (#2724 P2).
+  // When result.error is set, formatTerminalExecuteResult already includes `[error] …`.
+  const text = formatTerminalExecuteResult(result) || TERMINAL_EXECUTE_NO_OUTPUT_TEXT;
+  // Mark isError only for operational/runtime failures that include an error
+  // string (timeout, cancel, stream lost). Non-zero exit alone is success of
+  // the tool call with a failed command — same as Catty ok:true + exitCode.
+  if (result.ok === false && result.error) {
+    return { content: [{ type: "text", text }], isError: true };
+  }
+  return { content: [{ type: "text", text }] };
+}
+
+function createToolHandler(toolDef, deps) {
+  const {
+    rpcCall,
+    scopeParams,
+    guardWriteOperation,
+    catalogDescription,
+  } = deps;
+  const { mcpTool, rpcMethod, description, inputShape, policy } = toolDef;
+
+  return async (args) => {
+    if (TERMINAL_EXECUTE_TOOLS.has(mcpTool) || TERMINAL_START_TOOLS.has(mcpTool)) {
+      const { sessionId, command } = args;
+      const guardErr = guardWriteOperation(command, { skipBlocklist: true });
+      if (guardErr) {
+        return { content: [{ type: "text", text: `Error: ${guardErr}` }], isError: true };
+      }
+      const result = await rpcCall(rpcMethod, { ...scopeParams, sessionId, command });
+      if (TERMINAL_START_TOOLS.has(mcpTool)) {
+        if (!result?.ok) {
+          return { content: [{ type: "text", text: formatRpcError(result) }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              jobId: result.jobId,
+              sessionId: result.sessionId,
+              status: result.status,
+              startedAt: result.startedAt,
+              outputMode: result.outputMode,
+              recommendedPollIntervalMs: result.recommendedPollIntervalMs,
+            }, null, 2),
+          }],
+        };
+      }
+      return formatTerminalExecuteMcpResponse(result);
+    }
+
+    if (TERMINAL_POLL_TOOLS.has(mcpTool) || TERMINAL_STOP_TOOLS.has(mcpTool)) {
+      const params = TERMINAL_POLL_TOOLS.has(mcpTool)
+        ? { ...scopeParams, jobId: args.jobId, offset: args.offset || 0 }
+        : { ...scopeParams, jobId: args.jobId };
+      const result = await rpcCall(rpcMethod, params);
+      if (!result.ok) {
+        return { content: [{ type: "text", text: formatRpcError(result) }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+
+    if (SESSION_CLOSE_TOOLS.has(mcpTool)) {
+      const result = await rpcCall(rpcMethod, { ...scopeParams, sessionId: args.sessionId });
+      if (!result.ok) {
+        return { content: [{ type: "text", text: formatRpcError(result) }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+
+    if (CONTEXT_TOOLS.has(mcpTool)) {
+      const ctx = await rpcCall(rpcMethod, scopeParams);
+      return { content: [{ type: "text", text: JSON.stringify(ctx, null, 2) }] };
+    }
+
+    if (ATTACHMENT_LIST_TOOLS.has(mcpTool)) {
+      const result = await rpcCall(rpcMethod, scopeParams);
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: formatRpcError(result) }],
+          isError: true,
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result.attachments || [], null, 2) }],
+      };
+    }
+
+    if (ATTACHMENT_READ_TOOLS.has(mcpTool)) {
+      const { filePath, filename } = args;
+      const result = await rpcCall(rpcMethod, { ...scopeParams, filePath, filename });
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: formatRpcError(result) }],
+          isError: true,
+        };
+      }
+      const payload = {
+        filename: result.filename,
+        mediaType: result.mediaType,
+        filePath: result.filePath,
+        sizeBytes: result.sizeBytes,
+        ...(result.text != null ? { text: result.text } : { base64Data: result.base64Data }),
+      };
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+    }
+
+    if (policy?.write) {
+      const guardErr = guardWriteOperation("", { skipBlocklist: true });
+      if (guardErr) {
+        return { content: [{ type: "text", text: `Error: ${guardErr}` }], isError: true };
+      }
+    }
+
+    const result = await rpcCall(rpcMethod, { ...scopeParams, ...args });
+    if (result && typeof result === "object" && result.ok === false) {
+      return {
+        content: [{ type: "text", text: formatRpcError(result) }],
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  };
+}
+
+function registerMcpTools(server, deps) {
+  const tools = listMcpTools();
+  for (const toolDef of tools) {
+    if (!toolDef.mcpTool || !toolDef.rpcMethod) continue;
+    const handler = createToolHandler(toolDef, deps);
+    const toolDescription = deps.catalogDescription(toolDef.mcpTool, toolDef.description);
+    // Empty Zod objects reject omitted `arguments`. MCP allows omitting them
+    // for no-arg tools; skip the schema so both omitted and {} are valid.
+    if (isEmptyMcpInputShape(toolDef.inputShape)) {
+      server.tool(toolDef.mcpTool, toolDescription, async () => handler({}));
+      continue;
+    }
+    server.tool(toolDef.mcpTool, toolDescription, buildZodShapeObject(toolDef.inputShape), handler);
+  }
+  return tools.length;
+}
+
+module.exports = {
+  buildZodSchema,
+  buildZodShapeObject,
+  isEmptyMcpInputShape,
+  formatRpcError,
+  formatTerminalExecuteResult,
+  formatTerminalExecuteMcpResponse,
+  hasTerminalExecuteEvidence,
+  registerMcpTools,
+  SFTP_WRITE_TOOLS,
+};