@zhihand/mcp 0.22.1 → 0.23.1

package/README.md

@@ -2,7 +2,7 @@
 
 ZhiHand MCP Server — let AI agents see and control your phone.
 
-Version: `0.20.0`
+Version: `0.23.0`
 
 ## What is this?
 

package/dist/daemon/dispatcher.js

@@ -5,8 +5,10 @@ import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_MODELS } from "../core/config.js";
 import { resolveGemini, resolveClaude, resolveCodex } from "../core/resolve-path.js";
-const CLI_TIMEOUT = 120_000; // 120s per prompt
+const CLI_TIMEOUT = 300_000; // 300s (5min) per prompt — MCP tool chains need multiple turns
 const SIGKILL_DELAY = 2_000; // 2s after SIGTERM
+const MCP_PORT = parseInt(process.env.ZHIHAND_PORT ?? "", 10) || 18686;
+const MCP_URL = `http://127.0.0.1:${MCP_PORT}/mcp`;
 const MAX_OUTPUT_BYTES = 100 * 1024; // 100KB (for one-shot backends)
 const MAX_HISTORY_TURNS = 20; // keep last N exchanges in conversation history
 // Gemini session file polling
@@ -208,7 +210,7 @@ function pollGeminiSession(child, startTime, promptText, log, knownSessionFile,
                 }
                 closeChild(child);
                 settle({
-                    text: "Gemini timed out after 120s.",
+                    text: "Gemini timed out after 5 minutes.",
                     success: false,
                     durationMs: elapsed,
                 });
@@ -540,11 +542,14 @@ async function dispatchClaudeWithHistory(prompt, startTime, log, model) {
     log(`[claude] One-shot dispatch (history: ${conversationHistory.length} turns)`);
     // Pass prompt via stdin (-p -) to avoid ARG_MAX limit with long conversation history
     // --permission-mode bypassPermissions: auto-approve all tool calls (like gemini's --approval-mode yolo)
+    // --mcp-config: explicitly pass MCP server URL so Claude finds it regardless of cwd
+    const mcpConfig = JSON.stringify({ mcpServers: { zhihand: { type: "http", url: MCP_URL } } });
     const child = spawn(claudePath, [
         "-p", "-",
         "--model", model,
         "--output-format", "json",
         "--permission-mode", "bypassPermissions",
+        "--mcp-config", mcpConfig,
     ], {
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"],

package/dist/daemon/heartbeat.js

@@ -2,6 +2,7 @@ const HEARTBEAT_INTERVAL = 30_000; // 30s
 const HEARTBEAT_RETRY_INTERVAL = 5_000; // 5s on failure
 let heartbeatTimer;
 let retryTimer;
+let stopped = true;
 let currentMeta = {};
 /** Update the backend/model metadata that will be sent with the next heartbeat. */
 export function setBrainMeta(meta) {
@@ -40,36 +41,65 @@ export async function sendBrainOffline(config) {
 }
 export function startHeartbeatLoop(config, log) {
     let retrying = false;
+    stopped = false;
     async function beat() {
+        // Skip main-timer beats while retry loop is active (avoids overlap & flapping)
+        if (retrying || stopped)
+            return;
         const ok = await sendBrainOnline(config);
-        if (!ok && !retrying) {
-            retrying = true;
-            log("[heartbeat] Failed, retrying every 5s...");
-            // Fast retry to recover before 40s TTL
-            retryTimer = setInterval(async () => {
-                const recovered = await sendBrainOnline(config);
-                if (recovered) {
-                    retrying = false;
-                    if (retryTimer) {
-                        clearInterval(retryTimer);
-                        retryTimer = undefined;
-                    }
-                    log("[heartbeat] Recovered.");
-                }
-            }, HEARTBEAT_RETRY_INTERVAL);
+        if (stopped)
+            return; // check after await — stopHeartbeatLoop() may have been called
+        if (ok) {
+            scheduleNextBeat();
+            return;
         }
+        // Enter retry mode
+        retrying = true;
+        log("[heartbeat] Failed, retrying every 5s...");
+        scheduleRetry();
+    }
+    /** Recursive setTimeout for retry — waits for fetch to settle before scheduling next. */
+    function scheduleRetry() {
+        if (stopped)
+            return;
+        retryTimer = setTimeout(async () => {
+            if (!retrying || stopped)
+                return;
+            const recovered = await sendBrainOnline(config);
+            if (stopped)
+                return; // check after await
+            if (recovered) {
+                retrying = false;
+                retryTimer = undefined;
+                log("[heartbeat] Recovered.");
+                // Resume normal beat cycle
+                scheduleNextBeat();
+                return;
+            }
+            // Still failing — schedule another retry
+            if (retrying && !stopped)
+                scheduleRetry();
+        }, HEARTBEAT_RETRY_INTERVAL);
+    }
+    /** Schedule next normal heartbeat using setTimeout (not setInterval, to avoid overlap). */
+    function scheduleNextBeat() {
+        if (stopped)
+            return;
+        if (heartbeatTimer)
+            clearTimeout(heartbeatTimer);
+        heartbeatTimer = setTimeout(beat, HEARTBEAT_INTERVAL);
     }
     // Immediate first heartbeat
     beat();
-    heartbeatTimer = setInterval(beat, HEARTBEAT_INTERVAL);
 }
 export function stopHeartbeatLoop() {
+    stopped = true;
     if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
+        clearTimeout(heartbeatTimer);
         heartbeatTimer = undefined;
     }
     if (retryTimer) {
-        clearInterval(retryTimer);
+        clearTimeout(retryTimer);
         retryTimer = undefined;
     }
 }

package/dist/daemon/prompt-listener.d.ts

@@ -27,6 +27,8 @@ export declare class PromptListener {
     private resetWatchdog;
     private handleSSEEvent;
     private startPolling;
+    /** Recursive setTimeout: waits for fetch to complete before scheduling next poll. */
+    private schedulePoll;
     private stopPolling;
     private poll;
 }

package/dist/daemon/prompt-listener.js

@@ -1,4 +1,4 @@
-const SSE_WATCHDOG_TIMEOUT = 45_000; // 45s no data → reconnect
+const SSE_WATCHDOG_TIMEOUT = 120_000; // 120s no data → reconnect (servers may not send keepalive frequently)
 const SSE_RECONNECT_DELAY = 3_000;
 const POLL_INTERVAL = 2_000;
 export class PromptListener {
@@ -24,7 +24,7 @@ export class PromptListener {
         this.sseAbort?.abort();
         this.sseAbort = null;
         if (this.pollTimer) {
-            clearInterval(this.pollTimer);
+            clearTimeout(this.pollTimer);
             this.pollTimer = null;
         }
     }
@@ -63,34 +63,39 @@ export class PromptListener {
                 const decoder = new TextDecoder();
                 let buffer = "";
                 let watchdog = this.resetWatchdog();
-                while (!this.stopped) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    // Reset watchdog on any data (including keepalive comments)
-                    clearTimeout(watchdog);
-                    watchdog = this.resetWatchdog();
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    buffer = lines.pop() ?? "";
-                    let eventData = "";
-                    for (const line of lines) {
-                        if (line.startsWith("data: ")) {
-                            eventData += (eventData ? "\n" : "") + line.slice(6);
-                        }
-                        else if (line === "" && eventData) {
-                            try {
-                                const event = JSON.parse(eventData);
-                                this.handleSSEEvent(event);
+                try {
+                    while (!this.stopped) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        // Reset watchdog on any data (including keepalive comments)
+                        clearTimeout(watchdog);
+                        watchdog = this.resetWatchdog();
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split("\n");
+                        buffer = lines.pop() ?? "";
+                        let eventData = "";
+                        for (const line of lines) {
+                            if (line.startsWith("data: ")) {
+                                eventData += (eventData ? "\n" : "") + line.slice(6);
                             }
-                            catch {
-                                // Malformed event
+                            else if (line === "" && eventData) {
+                                try {
+                                    const event = JSON.parse(eventData);
+                                    this.handleSSEEvent(event);
+                                }
+                                catch {
+                                    // Malformed event
+                                }
+                                eventData = "";
                             }
-                            eventData = "";
                         }
                     }
                 }
-                clearTimeout(watchdog);
+                finally {
+                    // Always clear watchdog — prevents leaked timer from aborting next connection
+                    clearTimeout(watchdog);
+                }
             }
             catch (err) {
                 if (this.stopped)
@@ -104,7 +109,7 @@ export class PromptListener {
     }
     resetWatchdog() {
         return setTimeout(() => {
-            this.log("[sse] Watchdog timeout (45s no data). Reconnecting...");
+            this.log("[sse] Watchdog timeout (120s no data). Reconnecting...");
             this.sseAbort?.abort();
         }, SSE_WATCHDOG_TIMEOUT);
     }
@@ -123,11 +128,24 @@ export class PromptListener {
     startPolling() {
         if (this.pollTimer)
             return;
-        this.pollTimer = setInterval(() => this.poll(), POLL_INTERVAL);
+        this.schedulePoll();
+    }
+    /** Recursive setTimeout: waits for fetch to complete before scheduling next poll. */
+    schedulePoll() {
+        if (this.pollTimer)
+            return;
+        this.pollTimer = setTimeout(async () => {
+            this.pollTimer = null;
+            await this.poll();
+            // Schedule next poll only if SSE is still disconnected
+            if (!this.sseConnected && !this.stopped) {
+                this.schedulePoll();
+            }
+        }, POLL_INTERVAL);
     }
     stopPolling() {
         if (this.pollTimer) {
-            clearInterval(this.pollTimer);
+            clearTimeout(this.pollTimer);
             this.pollTimer = null;
         }
     }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare const PACKAGE_VERSION = "0.22.1";
+export declare const PACKAGE_VERSION = "0.23.1";
 export declare function createServer(deviceName?: string): McpServer;
 export declare function startStdioServer(deviceName?: string): Promise<void>;

package/dist/index.js

@@ -5,7 +5,7 @@ import { controlSchema, screenshotSchema, pairSchema } from "./tools/schemas.js"
 import { executeControl } from "./tools/control.js";
 import { handleScreenshot } from "./tools/screenshot.js";
 import { handlePair } from "./tools/pair.js";
-export const PACKAGE_VERSION = "0.22.1";
+export const PACKAGE_VERSION = "0.23.1";
 export function createServer(deviceName) {
     const server = new McpServer({
         name: "zhihand",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhihand/mcp",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "private": false,
   "type": "module",
   "description": "ZhiHand MCP Server — phone control tools for Claude Code, Codex, Gemini CLI, and OpenClaw",