@zhihand/mcp 0.32.4 → 0.33.0

package/bin/zhihand

@@ -30,7 +30,7 @@ import { fetchUserCredentials } from "../dist/core/ws.js";
 import { configureMCP, displayName } from "../dist/cli/mcp-config.js";
 
 const DEFAULT_ENDPOINT = "https://api.zhihand.com";
-const VERSION = "0.32.4";
+const VERSION = "0.33.0";
 
 const CLI_TOOL_MAP = {
   claude: "claudecode",
@@ -555,8 +555,7 @@ switch (command) {
   }
 
   case "test": {
-    const { createControlCommand, createSystemCommand, enqueueCommand } = await import("../dist/core/command.js");
-    const { waitForCommandAck } = await import("../dist/core/ws.js");
+    const { createControlCommand, createSystemCommand } = await import("../dist/core/command.js");
     const { fetchScreenshot, getSnapshotStaleThresholdMs } = await import("../dist/core/screenshot.js");
     const { fetchDeviceProfileOnce, extractStatic, computeCapabilities, formatDeviceStatus } = await import("../dist/core/device.js");
 
@@ -630,6 +629,34 @@ switch (command) {
       process.exit(1);
     }
 
+    // Require daemon to be running (provides WS connections for command ACK)
+    const DAEMON_PORT = parseInt(process.env.ZHIHAND_PORT ?? "", 10) || 18686;
+    const DAEMON_BASE = `http://127.0.0.1:${DAEMON_PORT}`;
+    let daemonOk = false;
+    try {
+      const resp = await fetch(`${DAEMON_BASE}/internal/status`, { signal: AbortSignal.timeout(2000) });
+      daemonOk = resp.ok;
+    } catch { /* daemon not reachable */ }
+    if (!daemonOk) {
+      console.error("❌ Daemon is not running. Start it first: zhihand start");
+      process.exit(1);
+    }
+
+    // Execute command via daemon's /internal/exec endpoint
+    async function execViaDaemon(command, timeoutMs = 10_000) {
+      const resp = await fetch(`${DAEMON_BASE}/internal/exec`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ command, credentialId: testConfig.credentialId, timeoutMs }),
+        signal: AbortSignal.timeout(timeoutMs + 5000),
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`Daemon exec failed: ${resp.status} ${body}`);
+      }
+      return resp.json();
+    }
+
     const forceRun = values.force === true;
     let selectedIds = null;
     let includeUnsafe = false;
@@ -652,7 +679,7 @@ switch (command) {
       }
     }
 
-    console.log("ZhiHand Device Test");
+    console.log("🔧 ZhiHand Device Test");
     console.log(`   Device: ${testConfig.credentialId}`);
     console.log(`   Endpoint: ${testConfig.controlPlaneEndpoint}\n`);
 
@@ -672,18 +699,18 @@ switch (command) {
     } catch { /* non-fatal */ }
     const getDevicePlatform = () => currentProfile?.platform ?? "unknown";
 
-    console.log("   -- Capability readiness --");
+    console.log("   ── Capability readiness ──");
     if (!currentCaps) {
-      console.log("   [!] Device profile not loaded — all capability gates will allow tests through.");
+      console.log("   ⚠️  Device profile not loaded — all capability gates will allow tests through.");
     } else {
-      const fmt = (name, cap) => `   ${cap.ready ? "[ok]" : "[!]"} ${name.padEnd(14)} ${cap.ready ? "ready" : "NOT ready"}  — ${cap.reason}`;
+      const fmt = (name, cap) => `   ${cap.ready ? "✅" : "⚠️"} ${name.padEnd(16)} ${cap.ready ? "ready" : "NOT ready"}  — ${cap.reason}`;
       console.log(fmt("screen_sharing", currentCaps.screen_sharing));
       console.log(fmt("hid", currentCaps.hid));
       console.log(fmt("live_session", currentCaps.live_session));
       const ageStr = currentCaps.profile.age_ms >= 0 ? `${(currentCaps.profile.age_ms / 1000).toFixed(1)}s` : "unknown";
-      console.log(`   ${currentCaps.profile.stale ? "[!]" : "[ok]"} profile        age=${ageStr}${currentCaps.profile.stale ? " (STALE)" : ""}`);
+      console.log(`   ${currentCaps.profile.stale ? "⚠️" : "✅"} profile          age=${ageStr}${currentCaps.profile.stale ? " (STALE)" : ""}`);
       if (forceRun) {
-        console.log("   --force passed: capability gates disabled.");
+        console.log("   ⚡ --force passed: capability gates disabled.");
       }
     }
     console.log("");
@@ -712,25 +739,24 @@ switch (command) {
       process.stdout.write(`   ${String(t.id).padStart(2)}. ${t.label}... `);
       const t0 = Date.now();
       try {
-        const queued = await enqueueCommand(testConfig, command);
-        const ack = await waitForCommandAck(testConfig, { commandId: queued.id, timeoutMs: 10_000 });
+        const result = await execViaDaemon(command);
         const ms = Date.now() - t0;
-        if (ack.acked) {
-          const ackStatus = ack.command?.ack_status ?? "ok";
-          const resultInfo = ack.command?.ack_result ? ` ${JSON.stringify(ack.command.ack_result)}` : "";
+        if (result.acked) {
+          const ackStatus = result.command?.ack_status ?? "ok";
+          const resultInfo = result.command?.ack_result ? ` ${JSON.stringify(result.command.ack_result)}` : "";
           if (ackStatus === "ok") {
-            console.log(`[PASS] (${ms}ms)${resultInfo}`);
+            console.log(`✅ (${ms}ms)${resultInfo}`);
             passed++;
           } else {
-            console.log(`[FAIL] [${ackStatus}] (${ms}ms)${resultInfo}`);
+            console.log(`❌ [${ackStatus}] (${ms}ms)${resultInfo}`);
             failed++;
           }
         } else {
-          console.log(`[TIMEOUT] (${ms}ms)`);
+          console.log(`⏱️  timeout (${ms}ms)`);
           failed++;
         }
       } catch (err) {
-        console.log(`[FAIL] ${err.message} (${Date.now() - t0}ms)`);
+        console.log(`❌ ${err.message} (${Date.now() - t0}ms)`);
         failed++;
       }
     }
@@ -739,7 +765,7 @@ switch (command) {
       const currentPlatform = getDevicePlatform();
       if (t.platform && t.platform !== currentPlatform) {
         totalSteps++; skipped++;
-        console.log(`   ${String(t.id).padStart(2)}. ${t.label}... [SKIP] (${t.platform}-only, device is ${currentPlatform})`);
+        console.log(`   ${String(t.id).padStart(2)}. ${t.label}... ⏭️  (${t.platform}-only, device is ${currentPlatform})`);
         return;
       }
       if (!forceRun && currentCaps) {
@@ -748,7 +774,7 @@ switch (command) {
           const gate = requiredCap === "screen" ? currentCaps.screen_sharing : currentCaps.hid;
           if (!gate.ready) {
             totalSteps++; skipped++;
-            console.log(`   ${String(t.id).padStart(2)}. ${t.label}... [SKIP] (${requiredCap} not ready: ${gate.reason})`);
+            console.log(`   ${String(t.id).padStart(2)}. ${t.label}... ⏭️  (${requiredCap} not ready: ${gate.reason})`);
             return;
           }
         }
@@ -768,14 +794,14 @@ switch (command) {
               currentProfile = extractStatic(currentRawAttrs);
               currentCaps = computeCapabilities(currentRawAttrs, profileReceivedAtMs);
               const s = currentProfile;
-              console.log(`[PASS] ${s.platform} ${s.model}, ${s.osVersion}, ${s.screenWidthPx}x${s.screenHeightPx} (${ms}ms)`);
+              console.log(`✅ ${s.platform} ${s.model}, ${s.osVersion}, ${s.screenWidthPx}x${s.screenHeightPx} (${ms}ms)`);
               passed++;
             } else {
-              console.log(`[!] Loaded but empty (${ms}ms)`);
+              console.log(`⚠️  loaded but empty (${ms}ms)`);
               failed++;
             }
           } catch (err) {
-            console.log(`[FAIL] ${err.message} (${Date.now() - t0}ms)`);
+            console.log(`❌ ${err.message} (${Date.now() - t0}ms)`);
             failed++;
           }
           break;
@@ -805,12 +831,12 @@ switch (command) {
             const capReadySummary = ["screen_sharing", "hid", "live_session"]
               .map((k) => `${k}=${caps[k]?.ready ? "ready" : "not-ready"}`)
               .join(", ");
-            console.log(`[PASS] ${topLevel.length} curated + ${rawKeys.length} raw attributes; ${capReadySummary}`);
+            console.log(`✅ ${topLevel.length} curated + ${rawKeys.length} raw attributes; ${capReadySummary}`);
             console.log(`      curated: ${topLevel.join(", ")}`);
             console.log(`      raw:     ${rawKeys.join(", ")}`);
             passed++;
           } catch (err) {
-            console.log(`[FAIL] ${err.message}`);
+            console.log(`❌ ${err.message}`);
             failed++;
           }
           break;
@@ -821,10 +847,9 @@ switch (command) {
           const t0 = Date.now();
           try {
             const cmd = createControlCommand({ action: "screenshot" });
-            const queued = await enqueueCommand(testConfig, cmd);
-            const ack = await waitForCommandAck(testConfig, { commandId: queued.id, timeoutMs: 10_000 });
-            if (!ack.acked) {
-              console.log(`[TIMEOUT] (${Date.now() - t0}ms)`);
+            const result = await execViaDaemon(cmd);
+            if (!result.acked) {
+              console.log(`⏱️  timeout (${Date.now() - t0}ms)`);
               failed++;
               break;
             }
@@ -833,14 +858,14 @@ switch (command) {
             const ms = Date.now() - t0;
             if (shot.stale) {
               const threshold = getSnapshotStaleThresholdMs();
-              console.log(`[FAIL] Stale (${kb}KB, age=${(shot.ageMs / 1000).toFixed(1)}s > ${(threshold / 1000).toFixed(1)}s) ${shot.width}x${shot.height} seq=${shot.sequence} — phone may not be screen-sharing (${ms}ms)`);
+              console.log(`❌ stale (${kb}KB, age=${(shot.ageMs / 1000).toFixed(1)}s > ${(threshold / 1000).toFixed(1)}s) ${shot.width}x${shot.height} seq=${shot.sequence} — phone may not be screen-sharing (${ms}ms)`);
               failed++;
             } else {
-              console.log(`[PASS] ${kb}KB, ${shot.width}x${shot.height}, age=${shot.ageMs >= 0 ? `${shot.ageMs}ms` : "?"}, seq=${shot.sequence} (${ms}ms)`);
+              console.log(`✅ ${kb}KB, ${shot.width}x${shot.height}, age=${shot.ageMs >= 0 ? `${shot.ageMs}ms` : "?"}, seq=${shot.sequence} (${ms}ms)`);
               passed++;
             }
           } catch (err) {
-            console.log(`[FAIL] ${err.message} (${Date.now() - t0}ms)`);
+            console.log(`❌ ${err.message} (${Date.now() - t0}ms)`);
             failed++;
           }
           break;
@@ -873,23 +898,24 @@ switch (command) {
     if (selectedIds) {
       const foundIds = new Set(toRun.map((t) => t.id));
       const missing = [...selectedIds].filter((id) => !foundIds.has(id));
-      if (missing.length) console.warn(`[!] Unknown test IDs: ${missing.join(", ")}`);
+      if (missing.length) console.warn(`   ⚠️  Unknown test IDs: ${missing.join(", ")}`);
     }
 
     let currentPhase = "";
     for (let i = 0; i < toRun.length; i++) {
       const t = toRun[i];
       if (t.phase !== currentPhase) {
-        console.log(`   -- ${t.phase} --`);
+        console.log(`\n   ── ${t.phase} ──`);
         currentPhase = t.phase;
       }
       await runSingleTest(t);
       if (i < toRun.length - 1) await pause();
     }
 
-    console.log(`\n   Result: ${passed}/${totalSteps} passed, ${failed} failed, ${skipped} skipped`);
-    if (failed === 0) console.log("   All tests passed! Device is fully responsive.");
-    else console.log(`   ${failed} test(s) failed. Check phone connectivity.`);
+    console.log(`\n   ── Result ──`);
+    console.log(`   ${passed}/${totalSteps} passed, ${failed} failed, ${skipped} skipped`);
+    if (failed === 0) console.log("   🎉 All tests passed! Device is fully responsive.");
+    else console.log(`   ⚠️  ${failed} test(s) failed. Check phone connectivity.`);
     process.exit(failed > 0 ? 1 : 0);
   }
 

package/dist/core/command.d.ts

@@ -43,5 +43,4 @@ export interface SystemParams {
 }
 export declare function createSystemCommand(params: SystemParams, platform?: string): QueuedControlCommand;
 export declare function enqueueCommand(config: ZhiHandRuntimeConfig, command: QueuedControlCommand): Promise<QueuedCommandRecord>;
-export declare function getCommand(config: ZhiHandRuntimeConfig, commandId: string): Promise<QueuedCommandRecord>;
 export declare function formatAckSummary(action: string, result: WaitForCommandAckResult): string;

package/dist/core/command.js

@@ -170,21 +170,6 @@ export async function enqueueCommand(config, command) {
     dbg(`[cmd] Enqueued: id=${payload.command.id}, status=${payload.command.status}`);
     return payload.command;
 }
-export async function getCommand(config, commandId) {
-    const url = `${config.controlPlaneEndpoint}/v1/credentials/${encodeURIComponent(config.credentialId)}/commands/${encodeURIComponent(commandId)}`;
-    dbg(`[cmd] GET ${url}`);
-    const response = await fetch(url, {
-        headers: { "Authorization": `Bearer ${config.controllerToken}` },
-    });
-    if (!response.ok) {
-        dbg(`[cmd] Get failed: ${response.status}`);
-        throw new Error(`Get command failed: ${response.status}`);
-    }
-    const payload = (await response.json());
-    const cmd = payload.command;
-    dbg(`[cmd] Got: id=${cmd.id}, status=${cmd.status}, acked=${!!cmd.acked_at}, ack_status=${cmd.ack_status ?? "-"}, ack_result=${JSON.stringify(cmd.ack_result ?? null)}`);
-    return payload.command;
-}
 export function formatAckSummary(action, result) {
     if (!result.acked) {
         return `Sent ${action}, waiting for ACK (timed out).`;

package/dist/core/ws.d.ts

@@ -85,9 +85,9 @@ export interface CredentialResponse {
 export declare function fetchUserCredentials(endpoint: string, userId: string, controllerToken: string, onlineFilter?: boolean): Promise<CredentialResponse[]>;
 /**
  * Wait for command ACK via WS push (which should already be connected by the
- * registry). Falls back to polling.
+ * registry). WS-only — no polling fallback.
  */
-export declare function waitForCommandAck(config: ZhiHandRuntimeConfig, options: {
+export declare function waitForCommandAck(_config: ZhiHandRuntimeConfig, options: {
     commandId: string;
     timeoutMs?: number;
     signal?: AbortSignal;

package/dist/core/ws.js

@@ -9,7 +9,6 @@
  *   - fetchUserCredentials: HTTP REST helper (unchanged from sse.ts).
  */
 import WebSocket from "ws";
-import { getCommand } from "./command.js";
 import { log } from "./logger.js";
 // ── Shared reconnecting base ─────────────────────────────
 const BACKOFF_INITIAL_MS = 1000;
@@ -279,59 +278,27 @@ export async function fetchUserCredentials(endpoint, userId, controllerToken, on
 }
 /**
  * Wait for command ACK via WS push (which should already be connected by the
- * registry). Falls back to polling.
+ * registry). WS-only — no polling fallback.
  */
-export async function waitForCommandAck(config, options) {
+export async function waitForCommandAck(_config, options) {
     const timeoutMs = options.timeoutMs ?? 15_000;
     log.debug(`[ws-cmd] Waiting for ACK: commandId=${options.commandId}, timeout=${timeoutMs}ms`);
     return new Promise((resolve, reject) => {
-        let resolved = false;
-        let pollInterval;
         const timeout = setTimeout(() => {
             cleanup();
             resolve({ acked: false });
         }, timeoutMs);
         const unsubscribe = subscribeToCommandAck(options.commandId, (ackedCommand) => {
-            if (resolved)
-                return;
-            resolved = true;
             cleanup();
             resolve({ acked: true, command: ackedCommand });
         });
-        // Delay polling startup by 2s so WS push ACK normally wins in the
-        // registry-connected path. CLI (zhihand test) still resolves via polling
-        // after the initial delay.
-        const POLL_START_DELAY_MS = 2000;
-        const POLL_INTERVAL_MS = 500;
-        const startPolling = setTimeout(() => {
-            if (resolved)
-                return;
-            pollInterval = setInterval(async () => {
-                if (resolved)
-                    return;
-                try {
-                    const cmd = await getCommand(config, options.commandId);
-                    if (cmd.acked_at) {
-                        resolved = true;
-                        cleanup();
-                        resolve({ acked: true, command: cmd });
-                    }
-                }
-                catch {
-                    // non-fatal
-                }
-            }, POLL_INTERVAL_MS);
-        }, POLL_START_DELAY_MS);
         options.signal?.addEventListener("abort", () => {
             cleanup();
             reject(new Error("The operation was aborted"));
         }, { once: true });
         function cleanup() {
             clearTimeout(timeout);
-            clearTimeout(startPolling);
             unsubscribe();
-            if (pollInterval)
-                clearInterval(pollInterval);
         }
     });
 }

package/dist/daemon/index.js

@@ -12,6 +12,8 @@ import { PromptListener } from "./prompt-listener.js";
 import { dispatchToCLI, postReply, killActiveChild } from "./dispatcher.js";
 import { setDebugEnabled, dbg } from "./logger.js";
 import { registry } from "../core/registry.js";
+import { enqueueCommand } from "../core/command.js";
+import { waitForCommandAck } from "../core/ws.js";
 const DEFAULT_PORT = 18686;
 const PID_FILE = "daemon.pid";
 // ── State ────────���─────────────────────────────────────────
@@ -102,6 +104,39 @@ function handleInternalAPI(req, res) {
         });
         return true;
     }
+    // Execute command via daemon's WS (used by zhihand test)
+    if (url === "/internal/exec" && req.method === "POST") {
+        dbg(`[api] POST /internal/exec`);
+        let body = "";
+        const MAX_BODY = 10 * 1024;
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+            if (body.length > MAX_BODY) {
+                res.writeHead(413, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Payload too large" }));
+                req.destroy();
+            }
+        });
+        req.on("end", async () => {
+            try {
+                const { command, credentialId, timeoutMs } = JSON.parse(body);
+                const cfg = resolveConfig(credentialId);
+                const effectiveTimeout = timeoutMs ?? 10_000;
+                const queued = await enqueueCommand(cfg, command);
+                const ack = await waitForCommandAck(cfg, {
+                    commandId: queued.id,
+                    timeoutMs: effectiveTimeout,
+                });
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ id: queued.id, ...ack }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+        });
+        return true;
+    }
     if (url === "/internal/status" && req.method === "GET") {
         dbg(`[api] GET /internal/status`);
         const effectiveModel = activeBackend ? (activeModel ?? DEFAULT_MODELS[activeBackend]) : null;

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

@@ -17,8 +17,6 @@ export declare class PromptListener {
     private log;
     private processedIds;
     private rws;
-    private pollTimer;
-    private wsConnected;
     private stopped;
     constructor(config: ZhiHandConfig, handler: PromptHandler, log: (msg: string) => void);
     start(): void;
@@ -27,9 +25,5 @@ export declare class PromptListener {
     private connectWS;
     private handleWSMessage;
     private handleEvent;
-    private startPolling;
-    private schedulePoll;
-    private stopPolling;
-    private poll;
 }
 export {};

package/dist/daemon/prompt-listener.js

@@ -1,14 +1,11 @@
 import { ReconnectingWebSocket } from "../core/ws.js";
 import { dbg } from "./logger.js";
-const POLL_INTERVAL = 2_000;
 export class PromptListener {
     config;
     handler;
     log;
     processedIds = new Set();
     rws = null;
-    pollTimer = null;
-    wsConnected = false;
     stopped = false;
     constructor(config, handler, log) {
         this.config = config;
@@ -23,8 +20,6 @@ export class PromptListener {
         this.stopped = true;
         this.rws?.stop();
         this.rws = null;
-        this.wsConnected = false;
-        this.stopPolling();
     }
     dispatchPrompt(prompt) {
         if (this.processedIds.has(prompt.id)) {
@@ -60,11 +55,7 @@ export class PromptListener {
                 // onConnected deferred until auth_ok is received (see handleWSMessage)
             },
             onClose: (_code, _reason) => {
-                if (this.wsConnected) {
-                    this.wsConnected = false;
-                    this.log("[ws] Disconnected. Falling back to polling.");
-                    this.startPolling();
-                }
+                dbg("[ws] Disconnected. ReconnectingWebSocket will retry.");
             },
             onMessage: (data) => {
                 this.handleWSMessage(data);
@@ -79,8 +70,6 @@ export class PromptListener {
         const msg = data;
         // Auth responses
         if (msg.type === "auth_ok") {
-            this.wsConnected = true;
-            this.stopPolling();
             this.log("[ws] Connected to prompt stream.");
             return;
         }
@@ -88,8 +77,6 @@ export class PromptListener {
             this.log(`[ws] Auth failed: ${msg.error}`);
             this.rws?.stop();
             this.rws = null;
-            this.wsConnected = false;
-            this.startPolling();
             return;
         }
         // Application-level ping (if server sends these alongside protocol pings)
@@ -119,50 +106,4 @@ export class PromptListener {
             this.log("[device] device_profile.updated event received on prompts stream (ignored; registry handles it)");
         }
     }
-    startPolling() {
-        if (this.pollTimer || this.stopped)
-            return;
-        this.schedulePoll();
-    }
-    schedulePoll() {
-        if (this.pollTimer)
-            return;
-        this.pollTimer = setTimeout(async () => {
-            this.pollTimer = null;
-            await this.poll();
-            if (!this.wsConnected && !this.stopped) {
-                this.schedulePoll();
-            }
-        }, POLL_INTERVAL);
-    }
-    stopPolling() {
-        if (this.pollTimer) {
-            clearTimeout(this.pollTimer);
-            this.pollTimer = null;
-        }
-    }
-    async poll() {
-        try {
-            const url = `${this.config.controlPlaneEndpoint}/v1/credentials/${encodeURIComponent(this.config.credentialId)}/prompts?limit=5`;
-            dbg(`[poll] GET ${url}`);
-            const response = await fetch(url, {
-                headers: { "Authorization": `Bearer ${this.config.controllerToken}` },
-                signal: AbortSignal.timeout(10_000),
-            });
-            if (!response.ok) {
-                dbg(`[poll] Response: ${response.status}`);
-                return;
-            }
-            const data = (await response.json());
-            dbg(`[poll] Got ${data.items?.length ?? 0} prompt(s)`);
-            if (this.stopped)
-                return; // Guard against late responses after stop()
-            for (const prompt of data.items ?? []) {
-                this.dispatchPrompt(prompt);
-            }
-        }
-        catch (err) {
-            dbg(`[poll] Error: ${err.message}`);
-        }
-    }
 }

package/dist/index.d.ts

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

package/dist/index.js

@@ -8,7 +8,7 @@ import { handlePair } from "./tools/pair.js";
 import { resolveTargetDevice } from "./tools/resolve.js";
 import { buildControlToolDescription, buildSystemToolDescription, buildScreenshotToolDescription, formatDeviceStatus, extractDynamic, } from "./core/device.js";
 import { registry } from "./core/registry.js";
-export const PACKAGE_VERSION = "0.32.4";
+export const PACKAGE_VERSION = "0.33.0";
 function errorResult(message) {
     return { content: [{ type: "text", text: message }], isError: true };
 }

package/package.json

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