capacitor-mobile-claw 1.0.10 → 1.0.12

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

@@ -768,6 +768,37 @@ async function gitDiffTool(args) {
 const pendingPreExecuteHooks = new Map();
 const PRE_EXECUTE_TTL_MS = 120_000; // Auto-cancel after 2 minutes
 
+// Map of requestId → resolver callback for skill bridge tools that wait for client result
+const pendingSkillToolResults = new Map();
+const SKILL_TOOL_TTL_MS = 300_000; // 5 minutes — user may need time to complete OAuth
+
+function waitForSkillToolResult(requestId, eventType, signal) {
+  return new Promise((resolve) => {
+    const ttlTimer = setTimeout(() => {
+      if (pendingSkillToolResults.has(requestId)) {
+        pendingSkillToolResults.delete(requestId);
+        resolve(null);
+      }
+    }, SKILL_TOOL_TTL_MS);
+
+    pendingSkillToolResults.set(requestId, (result) => {
+      clearTimeout(ttlTimer);
+      resolve(result);
+    });
+
+    if (signal) {
+      const onAbort = () => {
+        clearTimeout(ttlTimer);
+        if (pendingSkillToolResults.has(requestId)) {
+          pendingSkillToolResults.delete(requestId);
+          resolve(null);
+        }
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
 function waitForPreExecuteResult(toolCallId, toolName, signal) {
   return new Promise((resolve) => {
     const ttlTimer = setTimeout(() => {
@@ -1057,15 +1088,16 @@ function buildAgentTools() {
 
 // ── AgentEvent → Bridge event mapping ────────────────────────────────────
 
-function bridgeEvent(event) {
+// skillContext: if set, events are tagged as skill events and ignored by the main session view
+function bridgeEvent(event, skillContext = null) {
   switch (event.type) {
     case 'message_update': {
       const e = event.assistantMessageEvent;
       if (e.type === 'text_delta') {
-        channel.send('message', { type: 'agent.event', eventType: 'text_delta', data: { text: e.delta } });
+        channel.send('message', { type: 'agent.event', eventType: 'text_delta', data: { text: e.delta }, skill: skillContext });
       }
       if (e.type === 'thinking_delta') {
-        channel.send('message', { type: 'agent.event', eventType: 'thinking', data: { text: e.delta } });
+        channel.send('message', { type: 'agent.event', eventType: 'thinking', data: { text: e.delta }, skill: skillContext });
       }
       break;
     }
@@ -1074,6 +1106,7 @@ function bridgeEvent(event) {
         type: 'agent.event',
         eventType: 'tool_use',
         data: { toolName: event.toolName, toolCallId: event.toolCallId, args: event.args },
+        skill: skillContext,
       });
       break;
     case 'tool_execution_end':
@@ -1081,6 +1114,7 @@ function bridgeEvent(event) {
         type: 'agent.event',
         eventType: 'tool_result',
         data: { toolName: event.toolName, toolCallId: event.toolCallId, result: event.result },
+        skill: skillContext,
       });
       break;
   }
@@ -1456,12 +1490,25 @@ function buildSkillTools(injectedTools, milestones) {
       return base;
     }
 
-    // bridgeEvent tools — emit tool input as a bridge message to the UI
+    // bridgeEvent tools — emit tool input as a bridge message to the UI.
+    // If waitForResult is true, the tool suspends until the client sends
+    // a skill.tool_result message (same pattern as pendingPreExecuteHooks).
     if (toolDef.bridgeEvent) {
       const eventType = toolDef.bridgeEvent;
-      base.execute = async (_id, params) => {
-        channel.send('message', { type: eventType, ...params });
-        return toToolResult({ success: true, applied: true });
+      const waitForResult = !!toolDef.waitForResult;
+      base.execute = async (_id, params, signal) => {
+        if (!waitForResult) {
+          channel.send('message', { type: eventType, ...params });
+          return toToolResult({ success: true, applied: true });
+        }
+        // Send bridge event then suspend until client responds
+        const requestId = `${eventType}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        channel.send('message', { type: eventType, requestId, ...params });
+        const result = await waitForSkillToolResult(requestId, eventType, signal);
+        if (!result) {
+          return toToolResult({ success: false, error: 'Request timed out or was cancelled.' });
+        }
+        return toToolResult(result);
       };
       return base;
     }
@@ -1472,7 +1519,7 @@ function buildSkillTools(injectedTools, milestones) {
   });
 }
 
-async function runSetupSkill(agentId, locale = 'en', injectedConfig = null) {
+async function runSkill(agentId, locale = 'en', injectedConfig = null) {
   await refreshOAuthTokenIfNeeded(agentId);
   const authProfiles = loadAuthProfiles(agentId);
   const apiKey = resolveApiKey(authProfiles);
@@ -1505,7 +1552,8 @@ async function runSetupSkill(agentId, locale = 'en', injectedConfig = null) {
   const filteredMcp = mcpTools.filter(t => !setupNames.has(t.name));
   const tools = [...setupTools, ...filteredBase, ...filteredMcp];
 
-  const sessionKey = `setup/${Date.now()}`;
+  const skillId = injectedConfig?.id || 'setup';
+  const sessionKey = `${skillId}/${Date.now()}`;
   const agent = new Agent({
     initialState: {
       systemPrompt,
@@ -1524,12 +1572,15 @@ async function runSetupSkill(agentId, locale = 'en', injectedConfig = null) {
   setupMilestonesReached.clear();
 
   agent.subscribe((event) => {
-    bridgeEvent(event);
+    bridgeEvent(event, sessionKey); // tag all events with skill sessionKey
     if (event.type === 'tool_execution_end' && sessionKey) {
       _checkpointMessages(agent, agentId, sessionKey);
     }
   });
 
+  // Notify client that the skill session has started (used to init isolated conversation view)
+  channel.send('message', { type: 'skill.session_started', sessionKey, skillId });
+
   const startTime = Date.now();
   try {
     await agent.prompt(kickoff);
@@ -1541,17 +1592,21 @@ async function runSetupSkill(agentId, locale = 'en', injectedConfig = null) {
     channel.send('message', {
       type: 'agent.completed',
       sessionKey,
+      skill: sessionKey,
       usage,
       cumulativeUsage: usage,
       durationMs: Date.now() - startTime,
     });
+    channel.send('message', { type: 'skill.ended', skillId, sessionKey });
   } catch (err) {
     channel.send('message', {
       type: 'agent.error',
-      error: err.message || 'Setup skill error',
+      skill: sessionKey,
+      error: err.message || 'Skill error',
       code: err.status ? String(err.status) : undefined,
       retryable: isTransientError(err),
     });
+    channel.send('message', { type: 'skill.ended', skillId, sessionKey });
   }
 }
 
@@ -1833,6 +1888,16 @@ channel.addListener('message', async (event) => {
       break;
     }
 
+    case 'skill.tool_result': {
+      // Client resolved a waiting bridgeEvent tool (e.g. accounts_start_oauth after user taps "Connect")
+      const resolver = pendingSkillToolResults.get(msg.requestId);
+      if (resolver) {
+        pendingSkillToolResults.delete(msg.requestId);
+        resolver(msg.result);
+      }
+      break;
+    }
+
     case 'agent.steer': {
       if (currentAgent) {
         currentAgent.steer({ role: 'user', content: msg.text, timestamp: Date.now() });
@@ -1843,7 +1908,7 @@ channel.addListener('message', async (event) => {
     case 'skill.start': {
       const agentId = msg.agentId || 'main';
       const locale = msg.locale || 'en';
-      await runSetupSkill(agentId, locale, msg.config || null);
+      await runSkill(agentId, locale, msg.config || null);
       break;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-mobile-claw",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "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",