capacitor-mobile-claw 1.1.0 → 1.2.0

package/nodejs-assets/nodejs-project/fetch-polyfill.js

@@ -0,0 +1,276 @@
+/**
+ * fetch() polyfill — replaces the broken undici-based built-in fetch.
+ *
+ * Capacitor-NodeJS ships Node.js v18.20.4 with --expose_wasm disabled.
+ * The built-in fetch() uses undici whose HTTP parser (llhttp) requires WASM.
+ * This module provides a native https/http implementation.
+ *
+ * MUST be imported before ANY other module that might call fetch().
+ */
+
+// ── WebAssembly stub ────────────────────────────────────────────────────
+// Provide a minimal WebAssembly global so undici's lazyllhttp doesn't crash
+// with "ReferenceError: WebAssembly is not defined". The stub lets the
+// internal module graph load without error, but we replace fetch anyway.
+if (typeof globalThis.WebAssembly === 'undefined') {
+  class _WasmError extends Error { constructor(msg) { super(msg); this.name = this.constructor.name; } }
+  class RuntimeError extends _WasmError {}
+  class CompileError extends _WasmError {}
+  class LinkError extends _WasmError {}
+
+  const _noWasm = (name) => { throw new CompileError(`WebAssembly.${name}() is not available (WASM disabled)`); };
+
+  globalThis.WebAssembly = {
+    // All compilation/instantiation methods throw CompileError so callers
+    // (sql.js, undici, pyodide) fall into their error/catch handlers cleanly.
+    compile: async () => _noWasm('compile'),
+    instantiate: async () => _noWasm('instantiate'),
+    instantiateStreaming: async () => _noWasm('instantiateStreaming'),
+    compileStreaming: async () => _noWasm('compileStreaming'),
+    validate: () => false,
+    Module: class Module { constructor() { _noWasm('Module'); } },
+    Instance: class Instance { constructor() { _noWasm('Instance'); } },
+    Memory: class Memory { constructor() { _noWasm('Memory'); } },
+    Table: class Table { constructor() { _noWasm('Table'); } },
+    Global: class Global { constructor() { _noWasm('Global'); } },
+    RuntimeError,
+    CompileError,
+    LinkError,
+  };
+  // Mark as stub so other modules can detect it
+  globalThis.WebAssembly._isStub = true;
+  // Catch unhandled rejections from lazy undici WASM compilation attempts.
+  // Node.js v18's built-in fetch triggers undici's lazyllhttp which calls
+  // WebAssembly.compile() — our stub rejects it, but the error may propagate
+  // as an unhandled rejection and crash the process. Suppress these errors.
+  process.on('unhandledRejection', (reason) => {
+    const msg = reason?.message || String(reason);
+    if (msg.includes('WASM disabled') || msg.includes('WebAssembly') ||
+        reason instanceof CompileError || reason instanceof _WasmError) {
+      // Silently swallow — we replace fetch with our native polyfill anyway
+      return;
+    }
+    // Let other unhandled rejections through to default handler
+    console.error('[unhandledRejection]', reason);
+  });
+
+  console.log('[fetch-polyfill] Installed WebAssembly stub (WASM disabled in this runtime)');
+}
+
+import * as _https from 'node:https';
+import * as _http from 'node:http';
+import { Readable } from 'node:stream';
+
+class _Headers {
+  #map = new Map();
+  constructor(init) {
+    if (init instanceof _Headers) {
+      init.forEach((v, k) => this.set(k, v));
+    } else if (Array.isArray(init)) {
+      for (const [k, v] of init) this.set(k, v);
+    } else if (init && typeof init === 'object') {
+      for (const [k, v] of Object.entries(init)) this.set(k, v);
+    }
+  }
+  get(k) { return this.#map.get(k.toLowerCase()) ?? null; }
+  set(k, v) { this.#map.set(k.toLowerCase(), String(v)); }
+  has(k) { return this.#map.has(k.toLowerCase()); }
+  delete(k) { this.#map.delete(k.toLowerCase()); }
+  forEach(cb) { this.#map.forEach((v, k) => cb(v, k, this)); }
+  *entries() { yield* this.#map.entries(); }
+  *keys() { yield* this.#map.keys(); }
+  *values() { yield* this.#map.values(); }
+  [Symbol.iterator]() { return this.entries(); }
+}
+
+class _Response {
+  #body; #bodyUsed = false; #status; #statusText; #headers; #url;
+  constructor(body, { status = 200, statusText = '', headers = {}, url = '' } = {}) {
+    this.#body = body;
+    this.#status = status;
+    this.#statusText = statusText;
+    this.#headers = new _Headers(headers);
+    this.#url = url;
+  }
+  get ok() { return this.#status >= 200 && this.#status < 300; }
+  get status() { return this.#status; }
+  get statusText() { return this.#statusText; }
+  get headers() { return this.#headers; }
+  get url() { return this.#url; }
+  get bodyUsed() { return this.#bodyUsed; }
+  get body() {
+    if (this.#body instanceof Readable) {
+      if (typeof Readable.toWeb === 'function') {
+        return Readable.toWeb(this.#body);
+      }
+      const nodeStream = this.#body;
+      return new ReadableStream({
+        start(controller) {
+          nodeStream.on('data', (chunk) => controller.enqueue(typeof chunk === 'string' ? new TextEncoder().encode(chunk) : chunk));
+          nodeStream.on('end', () => controller.close());
+          nodeStream.on('error', (err) => controller.error(err));
+        },
+        cancel() { nodeStream.destroy(); },
+      });
+    }
+    return null;
+  }
+  async text() {
+    this.#bodyUsed = true;
+    if (this.#body instanceof Readable) {
+      const chunks = [];
+      for await (const chunk of this.#body) chunks.push(chunk);
+      return Buffer.concat(chunks).toString('utf-8');
+    }
+    if (Buffer.isBuffer(this.#body)) return this.#body.toString('utf-8');
+    return String(this.#body ?? '');
+  }
+  async json() { return JSON.parse(await this.text()); }
+  async arrayBuffer() {
+    this.#bodyUsed = true;
+    if (this.#body instanceof Readable) {
+      const chunks = [];
+      for await (const chunk of this.#body) chunks.push(chunk);
+      const buf = Buffer.concat(chunks);
+      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    if (Buffer.isBuffer(this.#body)) {
+      return this.#body.buffer.slice(this.#body.byteOffset, this.#body.byteOffset + this.#body.byteLength);
+    }
+    const buf = Buffer.from(String(this.#body ?? ''), 'utf-8');
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  async blob() {
+    const ab = await this.arrayBuffer();
+    const { Blob: B } = await import('node:buffer');
+    return new B([ab], { type: this.#headers.get('content-type') || '' });
+  }
+}
+
+function _nativeFetch(input, init = {}) {
+  return new Promise((resolve, reject) => {
+    const urlStr = typeof input === 'string' ? input : (input?.url ?? String(input));
+    const parsed = new URL(urlStr);
+    const transport = parsed.protocol === 'https:' ? _https : _http;
+    const method = (init.method || 'GET').toUpperCase();
+    const headers = {};
+
+    if (init.headers) {
+      if (init.headers instanceof _Headers || (init.headers.forEach && init.headers.entries)) {
+        init.headers.forEach((v, k) => { headers[k] = v; });
+      } else if (Array.isArray(init.headers)) {
+        for (const [k, v] of init.headers) headers[k.toLowerCase()] = v;
+      } else {
+        for (const [k, v] of Object.entries(init.headers)) headers[k.toLowerCase()] = v;
+      }
+    }
+
+    let bodyData = null;
+    if (init.body != null) {
+      if (typeof init.body === 'string') {
+        bodyData = Buffer.from(init.body, 'utf-8');
+      } else if (Buffer.isBuffer(init.body)) {
+        bodyData = init.body;
+      } else if (init.body instanceof Uint8Array) {
+        bodyData = Buffer.from(init.body);
+      } else {
+        bodyData = Buffer.from(String(init.body), 'utf-8');
+      }
+      if (!headers['content-length']) {
+        headers['content-length'] = String(bodyData.length);
+      }
+    }
+
+    const reqOpts = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method,
+      headers,
+    };
+
+    const req = transport.request(reqOpts, (res) => {
+      if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+        const redirectUrl = new URL(res.headers.location, urlStr);
+        const redirectInit = { ...init };
+        if (res.statusCode === 303) {
+          redirectInit.method = 'GET';
+          delete redirectInit.body;
+        }
+        res.resume();
+        _nativeFetch(redirectUrl.href, redirectInit).then(resolve, reject);
+        return;
+      }
+
+      const responseHeaders = {};
+      for (const [k, v] of Object.entries(res.headers)) {
+        if (v != null) responseHeaders[k] = Array.isArray(v) ? v.join(', ') : v;
+      }
+
+      const response = new _Response(res, {
+        status: res.statusCode,
+        statusText: res.statusMessage || '',
+        headers: responseHeaders,
+        url: urlStr,
+      });
+      resolve(response);
+    });
+
+    if (init.signal) {
+      if (init.signal.aborted) {
+        req.destroy();
+        reject(new DOMException('The operation was aborted.', 'AbortError'));
+        return;
+      }
+      const onAbort = () => {
+        req.destroy();
+        reject(new DOMException('The operation was aborted.', 'AbortError'));
+      };
+      init.signal.addEventListener('abort', onAbort, { once: true });
+      req.on('close', () => init.signal.removeEventListener('abort', onAbort));
+    }
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+
+    if (bodyData) req.write(bodyData);
+    req.end();
+  });
+}
+
+// DOMException may not exist in Node.js v18
+if (typeof globalThis.DOMException === 'undefined') {
+  globalThis.DOMException = class DOMException extends Error {
+    #name;
+    constructor(message, name = 'Error') { super(message); this.#name = name; }
+    get name() { return this.#name; }
+  };
+}
+
+// Replace the broken undici-based fetch with our native implementation.
+// In Node.js v18, globalThis.fetch may be a lazy getter that triggers undici
+// loading on first access. Use delete + defineProperty to fully replace it.
+try { delete globalThis.fetch; } catch {}
+Object.defineProperty(globalThis, 'fetch', {
+  value: _nativeFetch, writable: true, configurable: true, enumerable: true,
+});
+try { delete globalThis.Headers; } catch {}
+Object.defineProperty(globalThis, 'Headers', {
+  value: _Headers, writable: true, configurable: true, enumerable: true,
+});
+try { delete globalThis.Response; } catch {}
+Object.defineProperty(globalThis, 'Response', {
+  value: _Response, writable: true, configurable: true, enumerable: true,
+});
+if (!globalThis.Request) {
+  globalThis.Request = class Request {
+    constructor(input, init = {}) {
+      this.url = typeof input === 'string' ? input : input.url;
+      this.method = init.method || 'GET';
+      this.headers = new _Headers(init.headers);
+      this.body = init.body ?? null;
+    }
+  };
+}
+
+console.log('[fetch-polyfill] Replaced built-in fetch with native https implementation');

package/nodejs-assets/nodejs-project/main.js

@@ -15,8 +15,28 @@
  * - Auth profile management (auth-profiles.json)
  */
 
+// ── DEBUG: Global crash catchers (iOS only shows console.error) ──────────
+// Must be BEFORE any imports so we catch errors during module evaluation.
+process.on('uncaughtException', (err) => {
+  console.error(`[DEBUG] UNCAUGHT EXCEPTION: ${err.message}`);
+  console.error(err.stack || '(no stack)');
+});
+process.on('unhandledRejection', (reason) => {
+  const msg = reason?.message || String(reason);
+  // Don't log WASM-related rejections (handled by fetch-polyfill)
+  if (msg.includes('WASM disabled') || msg.includes('WebAssembly')) return;
+  console.error(`[DEBUG] UNHANDLED REJECTION: ${msg}`);
+  if (reason?.stack) console.error(reason.stack);
+});
+
+// ── fetch() polyfill — MUST be first import ─────────────────────────────
+// Replaces the broken undici-based built-in fetch (requires WebAssembly)
+// with a native https/http implementation. Being a separate module imported
+// first ensures globalThis.fetch is replaced before any dependency evaluates.
+import './fetch-polyfill.js';
+
 // ── Node.js v18 polyfills (Capacitor-NodeJS ships v18.20.4) ──────────────
-// undici and Anthropic SDK expect globals that only exist in Node.js >=20.
+// Anthropic SDK expects globals that only exist in Node.js >=20.
 import { Blob } from 'node:buffer';
 if (typeof globalThis.File === 'undefined') {
   globalThis.File = class File extends Blob {
@@ -50,6 +70,7 @@ if (typeof globalThis.FormData === 'undefined') {
 import { createRequire } from 'node:module';
 const _require = createRequire(import.meta.url);
 const { channel } = _require('bridge');
+console.error(`[DEBUG] Bridge channel loaded OK`);
 
 import { resolve, join } from 'node:path';
 import {
@@ -69,6 +90,7 @@ import { initMcpBridge } from './mcp-bridge-client.js';
 import { buildMcpAgentTools } from './mcp-agent-tools.js';
 
 const mcpBridge = initMcpBridge(channel);
+console.error(`[DEBUG] MCP bridge initialized`);
 
 // Cache for discovered MCP tools — avoids re-discovery on every agent run
 let cachedMcpTools = null;
@@ -569,25 +591,13 @@ function executeJsTool(args) {
 }
 
 // ── Python execution (Phase 5) ───────────────────────────────────────────
+// Pyodide requires WebAssembly which is disabled in Capacitor-NodeJS v18.
+// Stub it out — execute_python returns a clear error message.
 
-import { loadPyodide } from 'pyodide';
-
-let pyodideInstance = null;
+// import { loadPyodide } from 'pyodide';  // DISABLED: requires WebAssembly
 
 async function getPyodide() {
-  if (!pyodideInstance) {
-    pyodideInstance = await loadPyodide();
-    // Block dangerous modules for sandbox security
-    pyodideInstance.runPython(`
-import sys
-for _mod in ['subprocess', 'socket', 'http', 'urllib', 'ftplib', 'smtplib',
-             'webbrowser', 'ctypes', 'multiprocessing', 'shutil', 'tempfile',
-             'signal', 'resource']:
-    sys.modules[_mod] = None
-del _mod
-`);
-  }
-  return pyodideInstance;
+  throw new Error('Python execution is unavailable: WebAssembly is disabled in this Node.js runtime.');
 }
 
 async function executePythonTool(args) {
@@ -1676,26 +1686,42 @@ function _legacySetupTools() {
 // ── Main agent run function ──────────────────────────────────────────────
 
 async function runAgentLoop(agentId, sessionKey, prompt, requestedModel) {
-  await refreshOAuthTokenIfNeeded(agentId);
+  console.error(`[DEBUG] runAgentLoop START: agentId=${agentId} sessionKey=${sessionKey} model=${requestedModel}`);
+  try {
+    await refreshOAuthTokenIfNeeded(agentId);
+  } catch (oauthErr) {
+    console.error(`[DEBUG] OAuth refresh failed: ${oauthErr.message}`);
+  }
   const authProfiles = loadAuthProfiles(agentId);
+  const profileKeys = Object.keys(authProfiles.profiles || {});
+  const profileTypes = profileKeys.map(k => `${k}:${authProfiles.profiles[k]?.type}`);
+  console.error(`[DEBUG] Auth profiles: ${profileKeys.length} profiles [${profileTypes.join(', ')}] lastGood=${JSON.stringify(authProfiles.lastGood)}`);
   const apiKey = resolveApiKey(authProfiles);
 
   if (!apiKey) {
+    console.error(`[DEBUG] NO API KEY — sending agent.error`);
     channel.send('message', {
       type: 'agent.error',
       error: 'No Anthropic API key configured. Go to Settings to add one.',
     });
     return;
   }
+  console.error(`[DEBUG] API key resolved: type=${apiKey.startsWith('sk-ant-oat') ? 'oauth' : apiKey.startsWith('sk-ant-') ? 'api_key' : 'unknown'} len=${apiKey.length} prefix=${apiKey.slice(0,12)}...`);
 
   const systemPrompt = loadSystemPrompt();
+  console.error(`[DEBUG] System prompt loaded: ${systemPrompt.length} chars`);
   const modelId = requestedModel || 'claude-sonnet-4-5';
+  console.error(`[DEBUG] Getting model: provider=anthropic modelId=${modelId}`);
   const model = getModel('anthropic', modelId);
+  console.error(`[DEBUG] Model resolved: ${JSON.stringify({id: model?.id, provider: model?.provider, api: model?.api}).slice(0,200)}`);
 
   // Merge local tools with MCP device tools (if bridge is available)
   const localTools = buildAgentTools();
+  console.error(`[DEBUG] Local tools: ${localTools.length}`);
   const mcpTools = await discoverMcpTools();
+  console.error(`[DEBUG] MCP tools: ${mcpTools.length}`);
   const tools = [...localTools, ...mcpTools];
+  console.error(`[DEBUG] Total tools: ${tools.length}`);
 
   // Create Agent instance
   const agent = new Agent({
@@ -1766,9 +1792,11 @@ async function runAgentLoop(agentId, sessionKey, prompt, requestedModel) {
 
 channel.addListener('message', async (event) => {
   const msg = event;
+  console.error(`[DEBUG] << RECV msg type=${msg?.type} keys=${Object.keys(msg||{}).join(',')}`);
 
   switch (msg.type) {
     case 'agent.start': {
+      console.error(`[DEBUG] agent.start: prompt=${(msg.prompt||'').slice(0,80)} model=${msg.model} agentId=${msg.agentId} sessionKey=${msg.sessionKey}`);
       // Idempotency: silently drop duplicate messages
       if (msg.idempotencyKey) {
         if (recentIdempotencyKeys.has(msg.idempotencyKey)) break;
@@ -2350,7 +2378,11 @@ channel.addListener('message', async (event) => {
 
 // ── Init ──────────────────────────────────────────────────────────────────
 
+console.error(`[DEBUG] Starting init sequence...`);
+console.error(`[DEBUG] OPENCLAW_ROOT=${OPENCLAW_ROOT}`);
+console.error(`[DEBUG] DATADIR=${process.env.DATADIR || '(unset)'}, HOME=${process.env.HOME || '(unset)'}`);
 ensureOpenClawDirs();
+console.error(`[DEBUG] Dirs ensured. Sending worker.loading_phase=engine`);
 channel.send('message', { type: 'worker.loading_phase', phase: 'engine' });
 
 // Initialize SQLite, migrate legacy JSONL data, then signal ready and warm MCP discovery
@@ -2363,30 +2395,36 @@ initWorkerDb(OPENCLAW_ROOT).then(() => {
     console.warn(`[init] JSONL migration failed (non-fatal): ${err.message}`);
   }
 }).catch(err => {
-  console.warn(`[init] SQLite init failed, using JSONL fallback: ${err.message}`);
+  console.error(`[DEBUG] SQLite init failed, using JSONL fallback: ${err.message}`);
 }).finally(() => {
-  // Send ready as soon as DB init/migration settles — do not block on MCP discovery.
-  channel.send('message', {
-    type: 'worker.ready',
-    nodeVersion: process.version,
-    openclawRoot: OPENCLAW_ROOT,
-    mcpToolCount: 0,
-  });
-  console.log(`[mobile-claw worker] Ready. Node ${process.version}, root=${OPENCLAW_ROOT}, mcpTools=0 (discovering...)`);
+  try {
+    console.error(`[DEBUG] .finally() entered — sending worker.ready`);
+    channel.send('message', {
+      type: 'worker.ready',
+      nodeVersion: process.version,
+      openclawRoot: OPENCLAW_ROOT,
+      mcpToolCount: 0,
+    });
+    console.error(`[DEBUG] worker.ready SENT. Node=${process.version} root=${OPENCLAW_ROOT}`);
 
-  // Pre-discover MCP device tools at startup (non-blocking, best-effort).
-  // Results are cached so the first agent run doesn't wait for discovery.
-  channel.send('message', { type: 'worker.loading_phase', phase: 'tools' });
-  discoverMcpTools().then(tools => {
-    if (tools.length > 0) {
-      channel.send('message', {
-        type: 'worker.tools_updated',
-        mcpToolCount: tools.length,
-      });
-      console.log(`[mobile-claw worker] MCP tools ready: ${tools.length}`);
-    }
-    channel.send('message', { type: 'worker.loading_phase', phase: 'ready' });
-  }).catch(() => {
-    channel.send('message', { type: 'worker.loading_phase', phase: 'ready' });
-  });
+    // Pre-discover MCP device tools at startup (non-blocking, best-effort).
+    channel.send('message', { type: 'worker.loading_phase', phase: 'tools' });
+    discoverMcpTools().then(tools => {
+      console.error(`[DEBUG] MCP discovery resolved: ${tools.length} tools`);
+      if (tools.length > 0) {
+        channel.send('message', {
+          type: 'worker.tools_updated',
+          mcpToolCount: tools.length,
+        });
+      }
+      channel.send('message', { type: 'worker.loading_phase', phase: 'ready' });
+      console.error(`[DEBUG] All loading phases complete — worker fully ready`);
+    }).catch((mcpErr) => {
+      console.error(`[DEBUG] MCP discovery FAILED: ${mcpErr?.message || mcpErr}`);
+      channel.send('message', { type: 'worker.loading_phase', phase: 'ready' });
+    });
+  } catch (finallyErr) {
+    console.error(`[DEBUG] FATAL in .finally(): ${finallyErr?.message || finallyErr}`);
+    console.error(finallyErr?.stack || '(no stack)');
+  }
 });

package/nodejs-assets/nodejs-project/worker-db.js

@@ -113,7 +113,14 @@ export async function initWorkerDb(openclawRoot) {
   dbPath = join(openclawRoot, 'mobile-claw.db');
   mkdirSync(openclawRoot, { recursive: true });
 
-  // Load sql.js — try WASM first, fall back to asm.js (pure JS)
+  // Load sql.js — skip entirely if WebAssembly is unavailable (Capacitor-NodeJS v18)
+  // sql.js's WASM and asm.js builds both use Emscripten which references WebAssembly
+  // globals at load time, so we can't even require() it without a real WASM runtime.
+  // The caller (main.js) falls back to JSONL persistence when initWorkerDb throws.
+  if (typeof WebAssembly === 'undefined' || globalThis.WebAssembly?._isStub) {
+    throw new Error('WebAssembly is not available — using JSONL fallback');
+  }
+
   let SQL;
   try {
     const initSqlJs = _require('sql.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-mobile-claw",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "On-device AI agent engine for Capacitor apps — embedded Node.js worker with LLM, file tools, code execution, git, and extensible MCP server",
   "main": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",