@zhihand/mcp 0.18.2 → 0.19.1

package/bin/zhihand

@@ -131,17 +131,29 @@ switch (command) {
   case "relay": {
     if (values.detach) {
       const { spawn: spawnChild } = await import("node:child_process");
+      const fsSync = await import("node:fs");
+      const pathMod = await import("node:path");
+      const osMod = await import("node:os");
+
       const args = [process.argv[1], "start"];
       if (values.port) args.push("--port", values.port);
       if (values.device) args.push("--device", values.device);
 
+      // Write daemon logs to ~/.zhihand/daemon.log
+      const zhihandDir = pathMod.default.join(osMod.default.homedir(), ".zhihand");
+      fsSync.default.mkdirSync(zhihandDir, { recursive: true });
+      const logPath = pathMod.default.join(zhihandDir, "daemon.log");
+      const logFd = fsSync.default.openSync(logPath, "a");
+
       const child = spawnChild(process.execPath, args, {
         detached: true,
-        stdio: "ignore",
+        stdio: ["ignore", logFd, logFd],
         env: { ...process.env },
       });
       child.unref();
+      fsSync.default.closeSync(logFd);
       console.log(`Daemon starting in background (PID ${child.pid}).`);
+      console.log(`Logs: ${logPath}`);
       process.exit(0);
     }
     const port = values.port ? parseInt(values.port, 10) : undefined;

package/dist/cli/detect.d.ts

@@ -1,6 +1,7 @@
 export interface CLITool {
     name: "claudecode" | "codex" | "gemini" | "openclaw";
     command: string;
+    resolvedPath: string;
     version: string;
     loggedIn: boolean;
     priority: number;

package/dist/cli/detect.js

@@ -1,4 +1,5 @@
 import { execSync } from "node:child_process";
+import { resolveExecutable, resolveGemini, resolveClaude, resolveCodex } from "../core/resolve-path.js";
 function tryExec(cmd) {
     try {
         return execSync(cmd, { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
@@ -7,41 +8,39 @@ function tryExec(cmd) {
         return null;
     }
 }
-function isCommandAvailable(cmd) {
-    return tryExec(`which ${cmd}`) !== null;
-}
 async function detectClaudeCode() {
-    if (!isCommandAvailable("claude"))
-        return null;
-    const version = tryExec("claude --version") ?? "unknown";
-    // Check login: claude has config in ~/.claude/
+    const resolved = resolveClaude();
+    if (resolved === "claude")
+        return null; // bare name = not found
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = tryExec("ls ~/.claude/settings.json") !== null;
-    return { name: "claudecode", command: "claude", version, loggedIn, priority: 1 };
+    return { name: "claudecode", command: "claude", resolvedPath: resolved, version, loggedIn, priority: 1 };
 }
 async function detectCodex() {
-    if (!isCommandAvailable("codex"))
+    const resolved = resolveCodex();
+    if (resolved === "codex")
         return null;
-    const version = tryExec("codex --version") ?? "unknown";
-    // Check login: OPENAI_API_KEY env var or config
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = !!process.env.OPENAI_API_KEY || tryExec("ls ~/.codex/") !== null;
-    return { name: "codex", command: "codex", version, loggedIn, priority: 2 };
+    return { name: "codex", command: "codex", resolvedPath: resolved, version, loggedIn, priority: 2 };
 }
 async function detectGemini() {
-    if (!isCommandAvailable("gemini"))
+    const resolved = resolveGemini();
+    if (resolved === "gemini")
         return null;
-    const version = tryExec("gemini --version") ?? "unknown";
-    // Check login: oauth_creds.json or GOOGLE_API_KEY env var
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = !!process.env.GOOGLE_API_KEY
         || !!process.env.GEMINI_API_KEY
         || tryExec("ls ~/.gemini/oauth_creds.json") !== null;
-    return { name: "gemini", command: "gemini", version, loggedIn, priority: 3 };
+    return { name: "gemini", command: "gemini", resolvedPath: resolved, version, loggedIn, priority: 3 };
 }
 async function detectOpenClaw() {
-    if (!isCommandAvailable("openclaw"))
+    const resolved = resolveExecutable("openclaw", []);
+    if (resolved === "openclaw")
         return null;
-    const version = tryExec("openclaw --version") ?? "unknown";
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = tryExec("ls ~/.openclaw/openclaw.json") !== null;
-    return { name: "openclaw", command: "openclaw", version, loggedIn, priority: 4 };
+    return { name: "openclaw", command: "openclaw", resolvedPath: resolved, version, loggedIn, priority: 4 };
 }
 export async function detectCLITools() {
     const results = await Promise.allSettled([

package/dist/cli/mcp-config.js

@@ -1,21 +1,26 @@
 import { execSync } from "node:child_process";
+import { resolveClaude, resolveCodex, resolveGemini } from "../core/resolve-path.js";
 const DEFAULT_PORT = 18686;
 function mcpUrl() {
     const port = parseInt(process.env.ZHIHAND_PORT ?? "", 10) || DEFAULT_PORT;
     return `http://localhost:${port}/mcp`;
 }
+/** Quote a path for shell execution (handles spaces in paths) */
+function q(p) {
+    return `"${p}"`;
+}
 const MCP_COMMANDS = {
     claudecode: {
-        add: () => `claude mcp add --transport http zhihand ${mcpUrl()}`,
-        remove: "claude mcp remove zhihand",
+        add: () => `${q(resolveClaude())} mcp add --transport http zhihand ${mcpUrl()}`,
+        remove: () => `${q(resolveClaude())} mcp remove zhihand`,
     },
     codex: {
-        add: () => `codex mcp add zhihand --url ${mcpUrl()}`,
-        remove: "codex mcp remove zhihand",
+        add: () => `${q(resolveCodex())} mcp add zhihand --url ${mcpUrl()}`,
+        remove: () => `${q(resolveCodex())} mcp remove zhihand`,
     },
     gemini: {
-        add: () => `gemini mcp add --transport http --scope user zhihand ${mcpUrl()}`,
-        remove: "gemini mcp remove --scope user zhihand",
+        add: () => `${q(resolveGemini())} mcp add --transport http --scope user zhihand ${mcpUrl()}`,
+        remove: () => `${q(resolveGemini())} mcp remove --scope user zhihand`,
     },
 };
 const DISPLAY_NAMES = {
@@ -44,7 +49,7 @@ export function configureMCP(backend, previousBackend) {
         const cmds = MCP_COMMANDS[previousBackend];
         if (cmds) {
             console.log(`  Removing MCP config from ${DISPLAY_NAMES[previousBackend]}...`);
-            removed = tryRun(cmds.remove);
+            removed = tryRun(cmds.remove());
         }
     }
     // Add to new backend

package/dist/core/resolve-path.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolve an executable by name: first try `which`, then check fallback paths.
+ * Supports a single `*` glob segment in fallback paths (for version directories).
+ * Returns the full path, or the bare name as last resort.
+ */
+export declare function resolveExecutable(name: string, fallbackPaths: string[]): string;
+/** Platform-specific fallback paths for gemini */
+export declare function resolveGemini(): string;
+/** Platform-specific fallback paths for claude */
+export declare function resolveClaude(): string;
+/** Platform-specific fallback paths for codex */
+export declare function resolveCodex(): string;

package/dist/core/resolve-path.js

@@ -0,0 +1,99 @@
+/**
+ * Platform-aware executable path resolution.
+ * Shared by both the CLI detection layer and the daemon dispatcher.
+ */
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+/** Cache of resolved executable paths to avoid repeated lookups */
+const cache = new Map();
+/**
+ * Resolve an executable by name: first try `which`, then check fallback paths.
+ * Supports a single `*` glob segment in fallback paths (for version directories).
+ * Returns the full path, or the bare name as last resort.
+ */
+export function resolveExecutable(name, fallbackPaths) {
+    const cached = cache.get(name);
+    if (cached)
+        return cached;
+    // Try `which` first (works when the binary is in PATH)
+    try {
+        const resolved = execSync(`which ${name}`, { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
+        if (resolved) {
+            cache.set(name, resolved);
+            return resolved;
+        }
+    }
+    catch {
+        // Not in PATH, try fallback locations
+    }
+    for (const candidate of fallbackPaths) {
+        if (candidate.includes("*")) {
+            // Expand one level of wildcard
+            try {
+                const parts = candidate.split("*");
+                if (parts.length === 2) {
+                    const parentDir = parts[0].replace(/\/$/, "");
+                    const suffix = parts[1];
+                    if (fs.existsSync(parentDir)) {
+                        const entries = fs.readdirSync(parentDir, { withFileTypes: true });
+                        // Sort descending to prefer latest version
+                        const dirs = entries
+                            .filter(e => e.isDirectory())
+                            .map(e => e.name)
+                            .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+                        for (const d of dirs) {
+                            const full = parentDir + "/" + d + suffix;
+                            if (fs.existsSync(full)) {
+                                cache.set(name, full);
+                                return full;
+                            }
+                        }
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+        else {
+            if (fs.existsSync(candidate)) {
+                cache.set(name, candidate);
+                return candidate;
+            }
+        }
+    }
+    // Last resort: return bare name and let spawn fail with a clear error
+    return name;
+}
+/** Platform-specific fallback paths for gemini */
+export function resolveGemini() {
+    return resolveExecutable("gemini", [
+        "/opt/homebrew/bin/gemini",
+        "/usr/local/bin/gemini",
+        path.join(os.homedir(), ".local/bin/gemini"),
+        path.join(os.homedir(), "bin/gemini"),
+    ]);
+}
+/** Platform-specific fallback paths for claude */
+export function resolveClaude() {
+    const home = os.homedir();
+    const fallbacks = [];
+    if (process.platform === "darwin") {
+        fallbacks.push(path.join(home, "Library/Application Support/Claude/claude-code/*/claude.app/Contents/MacOS/claude"), "/usr/local/bin/claude", "/opt/homebrew/bin/claude");
+    }
+    else if (process.platform === "linux") {
+        fallbacks.push("/usr/local/bin/claude", path.join(home, ".local/bin/claude"), "/snap/bin/claude");
+    }
+    else if (process.platform === "win32") {
+        fallbacks.push(path.join(process.env.LOCALAPPDATA ?? "", "Programs/Claude/claude.exe"), path.join(process.env.APPDATA ?? "", "npm/claude.cmd"));
+    }
+    return resolveExecutable("claude", fallbacks);
+}
+/** Platform-specific fallback paths for codex */
+export function resolveCodex() {
+    return resolveExecutable("codex", [
+        "/opt/homebrew/bin/codex",
+        "/usr/local/bin/codex",
+        path.join(os.homedir(), ".local/bin/codex"),
+    ]);
+}

package/dist/daemon/dispatcher.js

@@ -3,6 +3,7 @@ import fsp from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
+import { resolveGemini, resolveClaude, resolveCodex } from "../core/resolve-path.js";
 const CLI_TIMEOUT = 120_000; // 120s
 const SIGKILL_DELAY = 2_000; // 2s after SIGTERM
 const MAX_OUTPUT_BYTES = 100 * 1024; // 100KB
@@ -396,7 +397,8 @@ function dispatchGemini(prompt, startTime, log, model) {
         COLORTERM: "truecolor",
     };
     // Wrap with PTY so gemini sees isatty()==true
-    const child = spawn("python3", [PTY_WRAP_SCRIPT, "gemini", ...cliArgs], {
+    const geminiPath = resolveGemini();
+    const child = spawn("python3", [PTY_WRAP_SCRIPT, geminiPath, ...cliArgs], {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false,
@@ -417,7 +419,8 @@ function dispatchCodex(prompt, startTime, model) {
         args.push("-m", codexModel);
     }
     args.push(prompt);
-    const child = spawn("codex", args, {
+    const codexPath = resolveCodex();
+    const child = spawn(codexPath, args, {
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false,
@@ -427,7 +430,8 @@ function dispatchCodex(prompt, startTime, model) {
 }
 // ── Claude Dispatch ────────────────────────────────────────
 function dispatchClaude(prompt, startTime, model) {
-    const child = spawn("claude", ["-p", prompt, "--output-format", "json"], {
+    const claudePath = resolveClaude();
+    const child = spawn(claudePath, ["-p", prompt, "--output-format", "json"], {
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false,

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

package/package.json

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