@hypothesi/tauri-mcp-server 0.11.1 → 0.12.0

package/README.md

@@ -44,10 +44,10 @@ fn main() {
 
 ### 2. Configure Your AI Assistant
 
-Use [install-mcp](https://www.npmjs.com/package/install-mcp) to add the server to your AI assistant:
+Use [aix](https://aix.a1st.dev/cli/add/#aix-add-mcp) to add the server to your AI assistant:
 
 ```bash
-npx -y install-mcp @hypothesi/tauri-mcp-server --client claude-code
+npx -y @a1st/aix add mcp tauri --command 'npx @hypothesi/tauri-mcp-server' --user
 ```
 
 Supported clients: `claude-code`, `cursor`, `windsurf`, `vscode`, `cline`, `roo-cline`, `claude`, `zed`, `goose`, `warp`, `codex`

package/dist/config.d.ts

@@ -25,6 +25,20 @@ export declare function getDefaultHost(): string;
  * 2. 9223 (default)
  */
 export declare function getDefaultPort(): number;
+/**
+ * Gets the CWD hint used to route tool calls to the right Tauri instance
+ * when multiple are connected at once.
+ *
+ * Resolution priority:
+ * 1. MCP_BRIDGE_CWD environment variable (explicit override; useful when a
+ *    wrapper script wants to pin routing to a specific worktree regardless
+ *    of where the TS server happened to be launched from)
+ * 2. process.cwd() (natural inheritance from the calling shell / IDE)
+ *
+ * Returns null only when both are unavailable, which is extremely rare:
+ * process.cwd() is set on every healthy POSIX process.
+ */
+export declare function getCwdHint(): string | null;
 /**
  * Gets the full bridge configuration from environment variables.
  */

package/dist/config.js

@@ -28,6 +28,32 @@ export function getDefaultPort() {
     const port = process.env.MCP_BRIDGE_PORT;
     return port ? parseInt(port, 10) : 9223;
 }
+/**
+ * Gets the CWD hint used to route tool calls to the right Tauri instance
+ * when multiple are connected at once.
+ *
+ * Resolution priority:
+ * 1. MCP_BRIDGE_CWD environment variable (explicit override; useful when a
+ *    wrapper script wants to pin routing to a specific worktree regardless
+ *    of where the TS server happened to be launched from)
+ * 2. process.cwd() (natural inheritance from the calling shell / IDE)
+ *
+ * Returns null only when both are unavailable, which is extremely rare:
+ * process.cwd() is set on every healthy POSIX process.
+ */
+export function getCwdHint() {
+    // eslint-disable-next-line no-process-env
+    const override = process.env.MCP_BRIDGE_CWD;
+    if (override && override.length > 0) {
+        return override;
+    }
+    try {
+        return process.cwd();
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Gets the full bridge configuration from environment variables.
  */

package/dist/driver/element-picker.d.ts

@@ -17,9 +17,9 @@ export declare const SelectElementSchema: z.ZodObject<{
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
 }, {
+    timeout?: number | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
-    timeout?: number | undefined;
 }>;
 export declare const GetPointedElementSchema: z.ZodObject<{
     windowId: z.ZodOptional<z.ZodString>;

package/dist/driver/protocol.d.ts

@@ -110,6 +110,13 @@ export interface BackendState {
         visible: boolean;
     }>;
     window_count: number;
+    /**
+     * Working directory of the host Tauri process. Optional for backward
+     * compat with plugin versions before this field was added. Used by the
+     * TS server to disambiguate concurrent Tauri instances (e.g. moss
+     * running from multiple worktrees) that share the same bundle id.
+     */
+    cwd?: string | null;
     timestamp: number;
 }
 /** Console log entry */

package/dist/driver/session-manager.d.ts

@@ -30,6 +30,13 @@ export declare const ManageDriverSessionSchema: z.ZodObject<{
 export interface SessionInfo {
     name: string;
     identifier: string | null;
+    /**
+     * Working directory of the host Tauri process at session-start time.
+     * `null` when the plugin is too old to advertise it (pre-v0.11) or
+     * when the lookup failed; in that case CWD-based routing skips this
+     * session and falls back to default behavior.
+     */
+    cwd: string | null;
     host: string;
     port: number;
     client: PluginClient;
@@ -52,9 +59,40 @@ export declare function getDefaultSession(): SessionInfo | null;
  * Get all active sessions.
  */
 export declare function getAllSessions(): SessionInfo[];
+/**
+ * Find the session whose `cwd` best matches `hintCwd`.
+ *
+ * Used to disambiguate multiple concurrent Tauri instances when the caller
+ * did not pass an explicit appIdentifier. The "best match" is the longest
+ * shared prefix between the hint and a session's CWD, in either direction:
+ *
+ *   - `session.cwd === hintCwd` (exact)
+ *   - `hintCwd.startsWith(session.cwd + '/')` (TS server runs inside a
+ *     subdirectory of the host process's CWD; rare)
+ *   - `session.cwd.startsWith(hintCwd + '/')` (host process runs inside
+ *     the workspace the TS server was launched from; the common case
+ *     when VSCode opens a parent dir and moss runs from a worktree)
+ *
+ * Sessions whose `cwd` is null (older plugin without CWD support) are
+ * skipped — they cannot be matched and stay eligible for the existing
+ * "use default app" fallback in `resolveTargetApp`.
+ *
+ * Pure function (takes `sessions` as a parameter) so it can be unit-tested
+ * without touching module state.
+ *
+ * @returns The best-matching session, or null if no session matches.
+ */
+export declare function findSessionByCwd(sessions: Iterable<SessionInfo>, hintCwd: string | null): SessionInfo | null;
 /**
  * Resolve target app from port or identifier.
  * Returns the appropriate session based on the routing logic.
+ *
+ * Order of precedence:
+ * 1. Explicit `portOrIdentifier` (port number or bundle id)
+ * 2. CWD match via `findSessionByCwd` against `MCP_BRIDGE_CWD` or
+ *    `process.cwd()` — lets each MCP client target the Tauri instance
+ *    running in its own workspace/worktree without manual routing
+ * 3. The default app (most-recently-connected)
  */
 export declare function resolveTargetApp(portOrIdentifier?: string | number): SessionInfo;
 /**

package/dist/driver/session-manager.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { getDefaultHost, getDefaultPort } from '../config.js';
+import { getCwdHint, getDefaultHost, getDefaultPort } from '../config.js';
 import { AppDiscovery } from './app-discovery.js';
 import { PluginClient } from './plugin-client.js';
 import { resetInitialization } from './webview-executor.js';
@@ -69,9 +69,65 @@ function getAppDiscovery(host) {
     }
     return appDiscovery;
 }
+/**
+ * Find the session whose `cwd` best matches `hintCwd`.
+ *
+ * Used to disambiguate multiple concurrent Tauri instances when the caller
+ * did not pass an explicit appIdentifier. The "best match" is the longest
+ * shared prefix between the hint and a session's CWD, in either direction:
+ *
+ *   - `session.cwd === hintCwd` (exact)
+ *   - `hintCwd.startsWith(session.cwd + '/')` (TS server runs inside a
+ *     subdirectory of the host process's CWD; rare)
+ *   - `session.cwd.startsWith(hintCwd + '/')` (host process runs inside
+ *     the workspace the TS server was launched from; the common case
+ *     when VSCode opens a parent dir and moss runs from a worktree)
+ *
+ * Sessions whose `cwd` is null (older plugin without CWD support) are
+ * skipped — they cannot be matched and stay eligible for the existing
+ * "use default app" fallback in `resolveTargetApp`.
+ *
+ * Pure function (takes `sessions` as a parameter) so it can be unit-tested
+ * without touching module state.
+ *
+ * @returns The best-matching session, or null if no session matches.
+ */
+export function findSessionByCwd(sessions, hintCwd) {
+    if (!hintCwd) {
+        return null;
+    }
+    let best = null, bestScore = -1;
+    for (const session of sessions) {
+        if (!session.cwd) {
+            continue;
+        }
+        let score = -1;
+        if (session.cwd === hintCwd) {
+            score = session.cwd.length;
+        }
+        else if (hintCwd.startsWith(session.cwd + '/')) {
+            score = session.cwd.length;
+        }
+        else if (session.cwd.startsWith(hintCwd + '/')) {
+            score = hintCwd.length;
+        }
+        if (score > bestScore) {
+            best = session;
+            bestScore = score;
+        }
+    }
+    return best;
+}
 /**
  * Resolve target app from port or identifier.
  * Returns the appropriate session based on the routing logic.
+ *
+ * Order of precedence:
+ * 1. Explicit `portOrIdentifier` (port number or bundle id)
+ * 2. CWD match via `findSessionByCwd` against `MCP_BRIDGE_CWD` or
+ *    `process.cwd()` — lets each MCP client target the Tauri instance
+ *    running in its own workspace/worktree without manual routing
+ * 3. The default app (most-recently-connected)
  */
 export function resolveTargetApp(portOrIdentifier) {
     if (activeSessions.size === 0) {
@@ -105,6 +161,12 @@ export function resolveTargetApp(portOrIdentifier) {
         }
         throw new Error(formatAppNotFoundError(portOrIdentifier));
     }
+    // No explicit identifier: try CWD-based routing before falling back to
+    // "default app". If no session matches, behave as before.
+    const cwdMatch = findSessionByCwd(activeSessions.values(), getCwdHint());
+    if (cwdMatch) {
+        return cwdMatch;
+    }
     // Use default app
     if (defaultPort !== null && activeSessions.has(defaultPort)) {
         const session = activeSessions.get(defaultPort);
@@ -174,6 +236,7 @@ async function handleStatusAction() {
             connected: true,
             app: session.name,
             identifier: session.identifier,
+            cwd: session.cwd,
             host: session.host,
             port: session.port,
         });
@@ -182,6 +245,7 @@ async function handleStatusAction() {
         return {
             name: session.name,
             identifier: session.identifier,
+            cwd: session.cwd,
             host: session.host,
             port: session.port,
             isDefault: session.port === defaultPort,
@@ -232,12 +296,16 @@ async function handleStartAction(host, port) {
     if (!connectedSession) {
         return `Session start failed - no Tauri app found at localhost or ${configuredHost}:${configuredPort}`;
     }
+    if (activeSessions.has(connectedSession.port)) {
+        return `Already connected to app on port ${connectedSession.port}`;
+    }
     const client = new PluginClient(connectedSession.host, connectedSession.port);
     await client.connect();
-    const identifier = await fetchAppIdentifier(client);
+    const { identifier, cwd } = await fetchAppMetadata(client);
     const sessionInfo = {
         name: connectedSession.name,
         identifier,
+        cwd,
         host: connectedSession.host,
         port: connectedSession.port,
         client,
@@ -292,27 +360,32 @@ async function tryConnect(host, port) {
  * Must be called after a PluginClient is connected.
  *
  * @param client - The PluginClient to query
- * @returns The app identifier (bundle ID) or null if not available. Returns null when:
- *          - The plugin doesn't support the identifier field (older versions)
+ * @returns `{ identifier, cwd }`. Each field is null when:
+ *          - The plugin is too old to advertise it
  *          - The backend state request fails
- *          - The identifier field is missing from the response
+ *          - The field is missing from the response
+ *
+ *          Older plugins (pre-identifier) return `{ identifier: null, cwd: null }`.
+ *          Newer plugins without the cwd field return a real identifier and a null cwd.
+ *          Routing degrades gracefully in either case.
  */
-async function fetchAppIdentifier(client) {
+async function fetchAppMetadata(client) {
     try {
         const response = await client.sendCommand({
             command: 'invoke_tauri',
             args: { command: 'plugin:mcp-bridge|get_backend_state', args: {} },
         });
         if (!response.success || !response.data) {
-            return null;
+            return { identifier: null, cwd: null };
         }
         const state = response.data;
-        // Return null if identifier is not present (backward compat with older plugins)
-        return state.app?.identifier ?? null;
+        return {
+            identifier: state.app?.identifier ?? null,
+            cwd: typeof state.cwd === 'string' && state.cwd.length > 0 ? state.cwd : null,
+        };
     }
     catch {
-        // Return null on any error (e.g., older plugin version that doesn't support this)
-        return null;
+        return { identifier: null, cwd: null };
     }
 }
 /**

package/dist/driver/webview-interactions.d.ts

@@ -124,17 +124,17 @@ export declare const WaitForSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     value: string;
     type: "text" | "selector" | "ipc-event";
-    strategy: "css" | "text" | "xpath";
     timeout: number;
+    strategy: "css" | "text" | "xpath";
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
 }, {
     value: string;
     type: "text" | "selector" | "ipc-event";
+    timeout?: number | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     strategy?: "css" | "text" | "xpath" | undefined;
-    timeout?: number | undefined;
 }>;
 export declare const GetStylesSchema: z.ZodObject<{
     windowId: z.ZodOptional<z.ZodString>;

package/dist/manager/mobile.js

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { execa } from 'execa';
 export const ListDevicesSchema = z.object({});
+const DEVICE_LIST_TIMEOUT_MS = 5000;
 async function getAndroidDevices() {
     try {
-        const { stdout } = await execa('adb', ['devices', '-l']);
+        const { stdout } = await execa('adb', ['devices', '-l'], { timeout: DEVICE_LIST_TIMEOUT_MS });
         return stdout
             .split('\n')
             .slice(1)
@@ -20,7 +21,7 @@ async function getIOSSimulators() {
         return [];
     }
     try {
-        const { stdout } = await execa('xcrun', ['simctl', 'list', 'devices', 'booted']);
+        const { stdout } = await execa('xcrun', ['simctl', 'list', 'devices', 'booted'], { timeout: DEVICE_LIST_TIMEOUT_MS });
         return stdout
             .split('\n')
             .filter((line) => { return line.trim().length > 0 && !line.includes('== Devices =='); });

package/dist/prompts-registry.js

@@ -74,11 +74,18 @@ export const PROMPTS = [
         name: 'select',
         description: 'Visually select an element in the running Tauri app. ' +
             'Activates a picker overlay — click an element to send its metadata and an annotated screenshot to the agent. ' +
-            'Optionally include a message describing what you want to do with the element.',
+            'Optionally include a message describing what you want to do with the element. ' +
+            'Note for Claude Code users: due to upstream bugs ' +
+            '(anthropics/claude-code#5597, #14210), Claude Code requires at least one ' +
+            'character of input and only forwards the first word of the `message` argument. ' +
+            'Type your full message in regular chat before or after invoking the prompt instead.',
         arguments: [
             {
                 name: 'message',
-                description: 'What you want to discuss or do with the selected element (e.g. "this button should be green instead of blue")',
+                description: 'What you want to discuss or do with the selected element ' +
+                    '(e.g. "this button should be green instead of blue"). ' +
+                    'In Claude Code, only the first word reaches the server (anthropics/claude-code#14210) — ' +
+                    'put your full message in chat instead.',
                 required: false,
             },
         ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypothesi/tauri-mcp-server",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "mcpName": "io.github.hypothesi/mcp-server-tauri",
   "description": "A Model Context Protocol server for use with Tauri v2 applications",
   "type": "module",