@zhihand/mcp 0.22.0 → 0.23.0

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,7 +5,7 @@ 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 MAX_OUTPUT_BYTES = 100 * 1024; // 100KB (for one-shot backends)
 const MAX_HISTORY_TURNS = 20; // keep last N exchanges in conversation history
@@ -208,7 +208,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,
                 });
@@ -539,7 +539,13 @@ async function dispatchClaudeWithHistory(prompt, startTime, log, model) {
     const claudePath = resolveClaude();
     log(`[claude] One-shot dispatch (history: ${conversationHistory.length} turns)`);
     // Pass prompt via stdin (-p -) to avoid ARG_MAX limit with long conversation history
-    const child = spawn(claudePath, ["-p", "-", "--model", model, "--output-format", "json"], {
+    // --permission-mode bypassPermissions: auto-approve all tool calls (like gemini's --approval-mode yolo)
+    const child = spawn(claudePath, [
+        "-p", "-",
+        "--model", model,
+        "--output-format", "json",
+        "--permission-mode", "bypassPermissions",
+    ], {
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"],
         detached: false,

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.0";
+export declare const PACKAGE_VERSION = "0.23.0";
 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.0";
+export const PACKAGE_VERSION = "0.23.0";
 export function createServer(deviceName) {
     const server = new McpServer({
         name: "zhihand",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhihand/mcp",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "private": false,
   "type": "module",
   "description": "ZhiHand MCP Server — phone control tools for Claude Code, Codex, Gemini CLI, and OpenClaw",
@@ -22,7 +22,8 @@
   "files": [
     "README.md",
     "bin/",
-    "dist/"
+    "dist/",
+    "scripts/"
   ],
   "publishConfig": {
     "access": "public"

package/scripts/pty-wrap.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Thin PTY wrapper — runs argv[1:] inside a pseudo-terminal so that tools
+requiring isatty(stdin)==True (e.g. ``gemini -i``) work from a daemon.
+
+Output is forwarded to this process's stdout in real time.
+Stdin from the parent process is forwarded to the child's PTY input,
+enabling persistent interactive sessions (send new prompts after startup).
+Exit code matches the child's exit code.
+
+Signals (SIGTERM, SIGINT) are forwarded to the child process group so that
+killing this wrapper also kills the tool underneath — no orphaned processes.
+
+Usage:  python3 pty-wrap.py gemini --approval-mode yolo --model flash -i "prompt"
+"""
+
+import os
+import pty
+import select
+import signal
+import subprocess
+import sys
+import time
+
+SHUTDOWN_GRACE_SECONDS = 3
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        sys.stderr.write("usage: pty-wrap.py COMMAND [ARGS...]\n")
+        return 1
+
+    master_fd, slave_fd = pty.openpty()
+
+    try:
+        proc = subprocess.Popen(
+            sys.argv[1:],
+            stdin=slave_fd,
+            stdout=slave_fd,
+            stderr=slave_fd,
+            start_new_session=True,
+            close_fds=True,
+        )
+    except OSError as exc:
+        os.close(master_fd)
+        os.close(slave_fd)
+        sys.stderr.write(f"pty-wrap: exec failed: {exc}\n")
+        return 127
+
+    os.close(slave_fd)
+    os.set_blocking(master_fd, False)
+
+    # Set up stdin forwarding (parent → PTY master → child stdin)
+    stdin_fd = sys.stdin.fileno()
+    stdin_open = True
+    try:
+        os.set_blocking(stdin_fd, False)
+    except OSError:
+        stdin_open = False
+
+    # Forward SIGTERM/SIGINT to the child's process group
+    def _forward_signal(signum: int, _frame: object) -> None:
+        try:
+            os.killpg(proc.pid, signum)
+        except OSError:
+            pass
+
+    signal.signal(signal.SIGTERM, _forward_signal)
+    signal.signal(signal.SIGINT, _forward_signal)
+
+    # Drain PTY master while child is alive, forward stdin to child
+    while proc.poll() is None:
+        fds = [master_fd]
+        if stdin_open:
+            fds.append(stdin_fd)
+        try:
+            ready, _, _ = select.select(fds, [], [], 1.0)
+        except (OSError, InterruptedError):
+            break
+
+        if master_fd in ready:
+            try:
+                data = os.read(master_fd, 8192)
+                if data:
+                    sys.stdout.buffer.write(data)
+                    sys.stdout.buffer.flush()
+            except OSError:
+                break
+
+        if stdin_open and stdin_fd in ready:
+            try:
+                data = os.read(stdin_fd, 8192)
+                if data:
+                    # Write all bytes, handling partial writes
+                    offset = 0
+                    while offset < len(data):
+                        try:
+                            written = os.write(master_fd, data[offset:])
+                            offset += written
+                        except BlockingIOError:
+                            # PTY buffer full — wait briefly and retry
+                            time.sleep(0.01)
+                else:
+                    stdin_open = False  # EOF on stdin
+            except BlockingIOError:
+                # read() got EAGAIN — no data yet, not an error
+                pass
+            except OSError:
+                stdin_open = False
+
+    # Final drain after child exits
+    try:
+        while True:
+            data = os.read(master_fd, 8192)
+            if not data:
+                break
+            sys.stdout.buffer.write(data)
+            sys.stdout.buffer.flush()
+    except OSError:
+        pass
+
+    os.close(master_fd)
+
+    # Ensure the entire process group is dead
+    if proc.poll() is None:
+        try:
+            os.killpg(proc.pid, signal.SIGTERM)
+        except OSError:
+            pass
+        deadline = time.monotonic() + SHUTDOWN_GRACE_SECONDS
+        while proc.poll() is None and time.monotonic() < deadline:
+            time.sleep(0.1)
+        if proc.poll() is None:
+            try:
+                os.killpg(proc.pid, signal.SIGKILL)
+            except OSError:
+                pass
+            proc.wait(timeout=2)
+
+    return proc.returncode or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())