@zhihand/mcp 0.22.0 → 0.22.1

package/dist/daemon/dispatcher.js

@@ -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/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.22.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.0";
+export const PACKAGE_VERSION = "0.22.1";
 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.22.1",
   "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())