capacitor-mobile-claw 1.0.0

package/nodejs-assets/nodejs-project/mcp-agent-tools.js

@@ -0,0 +1,57 @@
+/**
+ * MCP-to-AgentTool adapter.
+ *
+ * Converts MCP tool descriptors (from tools/list) into pi-agent-core AgentTool
+ * format so the on-device agent can call device MCP tools alongside its native
+ * file/git/code tools.
+ *
+ * The adapter wraps each MCP tool's JSON Schema inputSchema with TypeBox's
+ * Type.Unsafe() — this is a pass-through that satisfies pi-agent-core's
+ * TypeBox requirement while preserving the original JSON Schema for the LLM.
+ */
+
+import { Type } from '@sinclair/typebox';
+
+/**
+ * Build pi-agent-core AgentTool[] from MCP tool descriptors.
+ *
+ * @param {object} mcpClient - The MCP bridge client ({ callTool })
+ * @param {Array<{ name: string, description: string, inputSchema: object }>} mcpTools
+ * @returns {Array} AgentTool-compatible objects
+ */
+export function buildMcpAgentTools(mcpClient, mcpTools) {
+  return mcpTools.map(tool => ({
+    name: tool.name,
+    label: tool.name.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+    description: `[Device] ${tool.description}`,
+    parameters: Type.Unsafe(tool.inputSchema || { type: 'object', properties: {} }),
+    execute: async (_toolCallId, params) => {
+      try {
+        const result = await mcpClient.callTool(tool.name, params);
+
+        // MCP returns { content: [{ type: 'text', text: '...' }], isError?: boolean }
+        const text = result?.content
+          ?.filter(c => c.type === 'text')
+          .map(c => c.text)
+          .join('\n') || JSON.stringify(result);
+
+        if (result?.isError) {
+          return {
+            content: [{ type: 'text', text: `Error: ${text}` }],
+            details: { error: text },
+          };
+        }
+
+        return {
+          content: [{ type: 'text', text }],
+          details: result,
+        };
+      } catch (err) {
+        return {
+          content: [{ type: 'text', text: `MCP tool error: ${err.message}` }],
+          details: { error: err.message },
+        };
+      }
+    },
+  }));
+}

package/nodejs-assets/nodejs-project/mcp-bridge-client.js

@@ -0,0 +1,98 @@
+/**
+ * Lightweight MCP JSON-RPC client over the Capacitor-NodeJS bridge.
+ *
+ * This module runs in the Node.js worker and speaks the MCP protocol
+ * (JSON-RPC 2.0) to the WebView-side MCP server via bridge messages.
+ * It does NOT depend on @modelcontextprotocol/sdk — keeping the worker lean.
+ *
+ * Message format:
+ *   Worker → WebView: { type: 'mcp.jsonrpc', payload: { jsonrpc:'2.0', id, method, params } }
+ *   WebView → Worker: { type: 'mcp.jsonrpc.response', payload: { jsonrpc:'2.0', id, result/error } }
+ */
+
+let requestId = 0;
+const pendingRequests = new Map(); // id → { resolve, reject, timer }
+
+const DEFAULT_TIMEOUT = 10_000; // 10 seconds per request
+
+/**
+ * Initialize the MCP bridge client.
+ *
+ * @param {object} channel - The Capacitor-NodeJS bridge channel
+ * @returns {{ listTools, callTool, destroy }}
+ */
+export function initMcpBridge(channel) {
+  // Listen for JSON-RPC responses from the WebView MCP server
+  channel.addListener('message', (event) => {
+    if (!event || event.type !== 'mcp.jsonrpc.response') return;
+
+    const msg = event.payload;
+    if (!msg || msg.id === undefined) return;
+
+    const pending = pendingRequests.get(msg.id);
+    if (!pending) return;
+
+    pendingRequests.delete(msg.id);
+    clearTimeout(pending.timer);
+
+    if (msg.error) {
+      pending.reject(new Error(msg.error.message || 'MCP RPC error'));
+    } else {
+      pending.resolve(msg.result);
+    }
+  });
+
+  /**
+   * Send a JSON-RPC request to the WebView MCP server.
+   * @param {string} method - e.g. 'tools/list', 'tools/call'
+   * @param {object} params
+   * @param {number} [timeout]
+   * @returns {Promise<any>}
+   */
+  function rpcCall(method, params, timeout = DEFAULT_TIMEOUT) {
+    const id = ++requestId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pendingRequests.delete(id);
+        reject(new Error(`MCP RPC timeout: ${method} (${timeout}ms)`));
+      }, timeout);
+
+      pendingRequests.set(id, { resolve, reject, timer });
+
+      channel.send('message', {
+        type: 'mcp.jsonrpc',
+        payload: { jsonrpc: '2.0', id, method, params: params || {} },
+      });
+    });
+  }
+
+  /**
+   * Discover available MCP tools from the WebView server.
+   * @returns {Promise<Array<{ name: string, description: string, inputSchema: object }>>}
+   */
+  async function listTools() {
+    const result = await rpcCall('tools/list', {});
+    return result.tools || [];
+  }
+
+  /**
+   * Call an MCP tool by name.
+   * @param {string} name - Tool name, e.g. 'ssh_exec', 'camera_take_photo'
+   * @param {object} args - Tool arguments matching the inputSchema
+   * @returns {Promise<{ content: Array<{ type: string, text: string }>, isError?: boolean }>}
+   */
+  async function callTool(name, args) {
+    return rpcCall('tools/call', { name, arguments: args || {} }, 120_000);
+  }
+
+  /** Clean up pending requests. */
+  function destroy() {
+    for (const [id, pending] of pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error('MCP bridge destroyed'));
+    }
+    pendingRequests.clear();
+  }
+
+  return { listTools, callTool, destroy };
+}