@hypothesi/tauri-mcp-server 0.11.2 → 0.13.0

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

@@ -30,10 +30,18 @@ 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;
     connected: boolean;
+    pluginVersion: string | null;
 }
 /**
  * Check if any session is currently active.
@@ -52,9 +60,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,9 +1,10 @@
 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';
 import { createMcpLogger } from '../logger.js';
+import { PLUGIN_VERSION_FULL, describeVersionSkew } from '../version.js';
 const sessionLogger = createMcpLogger('SESSION');
 /**
  * Session Manager - Native IPC-based session management
@@ -69,9 +70,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 +162,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);
@@ -149,6 +212,30 @@ function promoteNextDefault() {
         defaultPort = null;
     }
 }
+/**
+ * Return whether a cached session is responsive, removing it when stale.
+ */
+async function keepResponsiveSession(port) {
+    const session = activeSessions.get(port);
+    if (!session) {
+        return false;
+    }
+    try {
+        if (await session.client.checkConnection()) {
+            return true;
+        }
+    }
+    catch {
+        // Treat probe errors like missed pongs and replace the stale client below.
+    }
+    session.client.disconnect();
+    activeSessions.delete(port);
+    if (port === defaultPort) {
+        promoteNextDefault();
+    }
+    sessionLogger.info(`Removed stale session: ${session.name} (${session.host}:${session.port})`);
+    return false;
+}
 async function handleStatusAction() {
     if (activeSessions.size === 0) {
         return JSON.stringify({
@@ -157,6 +244,9 @@ async function handleStatusAction() {
             identifier: null,
             host: null,
             port: null,
+            pluginVersion: null,
+            serverVersion: PLUGIN_VERSION_FULL,
+            versionWarning: describeVersionSkew(null),
         });
     }
     if (activeSessions.size === 1) {
@@ -168,22 +258,35 @@ async function handleStatusAction() {
                 identifier: null,
                 host: null,
                 port: null,
+                pluginVersion: null,
+                serverVersion: PLUGIN_VERSION_FULL,
+                versionWarning: describeVersionSkew(null),
             });
         }
+        const versionWarning = describeVersionSkew(session.pluginVersion);
         return JSON.stringify({
             connected: true,
             app: session.name,
             identifier: session.identifier,
+            cwd: session.cwd,
             host: session.host,
             port: session.port,
+            pluginVersion: session.pluginVersion,
+            serverVersion: PLUGIN_VERSION_FULL,
+            versionWarning,
         });
     }
     const apps = Array.from(activeSessions.values()).map((session) => {
+        const versionWarning = describeVersionSkew(session.pluginVersion);
         return {
             name: session.name,
             identifier: session.identifier,
+            cwd: session.cwd,
             host: session.host,
             port: session.port,
+            pluginVersion: session.pluginVersion,
+            serverVersion: PLUGIN_VERSION_FULL,
+            versionWarning,
             isDefault: session.port === defaultPort,
         };
     });
@@ -192,12 +295,13 @@ async function handleStatusAction() {
         apps,
         totalCount: apps.length,
         defaultPort,
+        serverVersion: PLUGIN_VERSION_FULL,
     });
 }
 async function handleStartAction(host, port) {
     const configuredHost = host ?? getDefaultHost();
     const configuredPort = port ?? getDefaultPort();
-    if (activeSessions.has(configuredPort)) {
+    if (await keepResponsiveSession(configuredPort)) {
         return `Already connected to app on port ${configuredPort}`;
     }
     let connectedSession = null;
@@ -232,21 +336,31 @@ async function handleStartAction(host, port) {
     if (!connectedSession) {
         return `Session start failed - no Tauri app found at localhost or ${configuredHost}:${configuredPort}`;
     }
+    if (await keepResponsiveSession(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, pluginVersion } = await fetchAppMetadata(client);
     const sessionInfo = {
         name: connectedSession.name,
         identifier,
+        cwd,
         host: connectedSession.host,
         port: connectedSession.port,
         client,
         connected: true,
+        pluginVersion,
     };
     activeSessions.set(connectedSession.port, sessionInfo);
     defaultPort = connectedSession.port;
     sessionLogger.info(`Session started: ${sessionInfo.name} (${sessionInfo.host}:${sessionInfo.port}) [DEFAULT]`);
-    return `Session started with app: ${sessionInfo.name} (${sessionInfo.host}:${sessionInfo.port}) [DEFAULT]`;
+    let result = `Session started with app: ${sessionInfo.name} (${sessionInfo.host}:${sessionInfo.port}) [DEFAULT]`;
+    const versionWarning = describeVersionSkew(sessionInfo.pluginVersion);
+    if (versionWarning) {
+        result = `${versionWarning}\n\n${result}`;
+    }
+    return result;
 }
 async function handleStopAction(appIdentifier) {
     if (appIdentifier !== undefined) {
@@ -292,27 +406,33 @@ 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, pluginVersion: 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,
+            pluginVersion: state.bridge?.pluginVersion ?? null,
+        };
     }
     catch {
-        // Return null on any error (e.g., older plugin version that doesn't support this)
-        return null;
+        return { identifier: null, cwd: null, pluginVersion: null };
     }
 }
 /**

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

@@ -28,18 +28,20 @@ export interface ExecuteInWebviewResult {
  * @param script - JavaScript code to execute in the webview context
  * @param windowId - Optional window label to target (defaults to "main")
  * @param appIdentifier - Optional app identifier to target specific app
+ * @param timeoutMs - Optional timeout in milliseconds
  * @returns Result of the script execution with window context
  */
-export declare function executeInWebview(script: string, windowId?: string, appIdentifier?: string | number): Promise<string>;
+export declare function executeInWebview(script: string, windowId?: string, appIdentifier?: string | number, timeoutMs?: number): Promise<string>;
 /**
  * Execute JavaScript in the Tauri webview and return window context.
  *
  * @param script - JavaScript code to execute in the webview context
  * @param windowId - Optional window label to target (defaults to "main")
  * @param appIdentifier - Optional app identifier to target specific app
+ * @param timeoutMs - Optional timeout in milliseconds
  * @returns Result of the script execution with window context
  */
-export declare function executeInWebviewWithContext(script: string, windowId?: string, appIdentifier?: string | number): Promise<ExecuteInWebviewResult>;
+export declare function executeInWebviewWithContext(script: string, windowId?: string, appIdentifier?: string | number, timeoutMs?: number, isRetry?: boolean): Promise<ExecuteInWebviewResult>;
 /**
  * Execute async JavaScript in the webview with timeout support.
  *
@@ -61,13 +63,19 @@ export declare function initializeConsoleCapture(): Promise<string>;
 /**
  * Retrieve captured console logs with optional filtering.
  *
- * @param filter - Optional regex pattern to filter log messages
- * @param since - Optional ISO timestamp to filter logs after this time
- * @param windowId - Optional window label to target (defaults to "main")
- * @param appIdentifier - Optional app identifier to target specific app
+ * @param options - Filtering and formatting options
  * @returns Formatted console logs as string
  */
-export declare function getConsoleLogs(filter?: string, since?: string, windowId?: string, appIdentifier?: string | number): Promise<string>;
+export declare function getConsoleLogs(options?: {
+    filter?: string;
+    since?: string;
+    lines?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+    level?: string;
+    maxChars?: number;
+    maxCharsPerEntry?: number;
+}): Promise<string>;
 /**
  * Clear all captured console logs.
  */
@@ -85,9 +93,10 @@ export interface CaptureScreenshotOptions {
     windowId?: string;
     appIdentifier?: string | number;
     maxWidth?: number;
+    allowScreenCapture?: boolean;
 }
 /**
- * Capture a screenshot of the entire webview.
+ * Capture a screenshot of the visible webview viewport.
  *
  * @param options - Screenshot options (format, quality, windowId, appIdentifier, etc.)
  * @returns Screenshot result with image content
@@ -113,10 +122,13 @@ export declare const GetConsoleLogsSchema: z.ZodObject<{
 export declare const CaptureScreenshotSchema: z.ZodObject<{
     format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>>;
     quality: z.ZodOptional<z.ZodNumber>;
+    allowScreenCapture: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     format: "png" | "jpeg";
+    allowScreenCapture: boolean;
     quality?: number | undefined;
 }, {
     format?: "png" | "jpeg" | undefined;
     quality?: number | undefined;
+    allowScreenCapture?: boolean | undefined;
 }>;