@hypothesi/tauri-mcp-server 0.5.0 → 0.5.1

package/dist/driver/plugin-client.js

@@ -174,14 +174,33 @@ export class PluginClient extends EventEmitter {
 }
 // Singleton instance
 let pluginClient = null;
+/**
+ * Gets the existing singleton PluginClient without creating or modifying it.
+ * Use this for status checks where you don't want to affect the current connection.
+ *
+ * @returns The existing PluginClient or null if none exists
+ */
+export function getExistingPluginClient() {
+    return pluginClient;
+}
 /**
  * Gets or creates a singleton PluginClient.
+ *
+ * If host/port are provided and differ from the existing client's configuration,
+ * the existing client is disconnected and a new one is created. This ensures
+ * that session start with a specific port always uses that port.
+ *
  * @param host Optional host override
  * @param port Optional port override
  */
 export function getPluginClient(host, port) {
     const resolvedHost = host ?? getDefaultHost();
     const resolvedPort = port ?? getDefaultPort();
+    // If singleton exists but host/port don't match, reset it
+    if (pluginClient && (pluginClient.host !== resolvedHost || pluginClient.port !== resolvedPort)) {
+        pluginClient.disconnect();
+        pluginClient = null;
+    }
     if (!pluginClient) {
         pluginClient = new PluginClient(resolvedHost, resolvedPort);
     }
@@ -202,6 +221,25 @@ export async function connectPlugin(host, port) {
         await client.connect();
     }
 }
+/**
+ * Ensures a session is active and connects to the plugin using session config.
+ * This should be used by all tools that require a connected Tauri app.
+ *
+ * @throws Error if no session is active
+ */
+export async function ensureSessionAndConnect() {
+    // Import dynamically to avoid circular dependency
+    const { hasActiveSession, getCurrentSession } = await import('./session-manager.js');
+    if (!hasActiveSession()) {
+        throw new Error('No active session. Call tauri_driver_session with action "start" first to connect to a Tauri app.');
+    }
+    const session = getCurrentSession();
+    if (!session) {
+        throw new Error('Session state is inconsistent. Please restart the session.');
+    }
+    await connectPlugin(session.host, session.port);
+    return getPluginClient(session.host, session.port);
+}
 export async function disconnectPlugin() {
     const client = getPluginClient();
     client.disconnect();

package/dist/driver/plugin-commands.js

@@ -1,14 +1,13 @@
 import { z } from 'zod';
-import { getPluginClient, connectPlugin } from './plugin-client.js';
+import { ensureSessionAndConnect, getExistingPluginClient } from './plugin-client.js';
 export const ExecuteIPCCommandSchema = z.object({
     command: z.string(),
     args: z.unknown().optional(),
 });
 export async function executeIPCCommand(command, args = {}) {
     try {
-        // Ensure we're connected to the plugin
-        await connectPlugin();
-        const client = getPluginClient();
+        // Ensure we have an active session and are connected
+        const client = await ensureSessionAndConnect();
         // Send IPC command via WebSocket to the mcp-bridge plugin
         const response = await client.sendCommand({
             command: 'invoke_tauri',
@@ -126,8 +125,34 @@ export async function getWindowInfo() {
     }
 }
 export const GetBackendStateSchema = z.object({});
-export async function getBackendState() {
+/**
+ * Get backend state from the connected Tauri app.
+ *
+ * This function can work in two modes:
+ * 1. Normal mode: Requires an active session (for MCP tool calls)
+ * 2. Setup mode: Uses existing connected client (for session setup)
+ *
+ * @param useExistingClient If true, uses the existing connected client without
+ *        session validation. Used during session setup before currentSession is set.
+ */
+export async function getBackendState(useExistingClient = false) {
     try {
+        if (useExistingClient) {
+            // During session setup, use the already-connected client directly
+            const client = getExistingPluginClient();
+            if (!client || !client.isConnected()) {
+                throw new Error('No connected client available');
+            }
+            const response = await client.sendCommand({
+                command: 'invoke_tauri',
+                args: { command: 'plugin:mcp-bridge|get_backend_state', args: {} },
+            });
+            if (!response.success) {
+                throw new Error(response.error || 'Unknown error');
+            }
+            return JSON.stringify(response.data);
+        }
+        // Normal mode: use executeIPCCommand which validates session
         const result = await executeIPCCommand('plugin:mcp-bridge|get_backend_state');
         const parsed = JSON.parse(result);
         if (!parsed.success) {
@@ -149,8 +174,7 @@ export const ListWindowsSchema = z.object({});
  */
 export async function listWindows() {
     try {
-        await connectPlugin();
-        const client = getPluginClient();
+        const client = await ensureSessionAndConnect();
         const response = await client.sendCommand({
             command: 'list_windows',
         });
@@ -184,8 +208,7 @@ export const ResizeWindowSchema = z.object({
  */
 export async function resizeWindow(options) {
     try {
-        await connectPlugin();
-        const client = getPluginClient();
+        const client = await ensureSessionAndConnect();
         const response = await client.sendCommand({
             command: 'resize_window',
             args: {
@@ -236,8 +259,7 @@ export async function manageWindow(options) {
         }
         case 'info': {
             try {
-                await connectPlugin();
-                const client = getPluginClient();
+                const client = await ensureSessionAndConnect();
                 const response = await client.sendCommand({
                     command: 'get_window_info',
                     args: { windowId },

package/dist/driver/script-manager.js

@@ -6,7 +6,7 @@
  *
  * @internal This module is for internal use only and is not exposed as MCP tools.
  */
-import { getPluginClient, connectPlugin } from './plugin-client.js';
+import { ensureSessionAndConnect } from './plugin-client.js';
 /**
  * Registers a script to be injected into the webview.
  *
@@ -20,8 +20,7 @@ import { getPluginClient, connectPlugin } from './plugin-client.js';
  * @returns Promise resolving to registration result
  */
 export async function registerScript(id, type, content, windowLabel) {
-    await connectPlugin();
-    const client = getPluginClient();
+    const client = await ensureSessionAndConnect();
     const response = await client.sendCommand({
         command: 'register_script',
         args: { id, type, content, windowLabel },
@@ -39,8 +38,7 @@ export async function registerScript(id, type, content, windowLabel) {
  * @returns Promise resolving to removal result
  */
 export async function removeScript(id, windowLabel) {
-    await connectPlugin();
-    const client = getPluginClient();
+    const client = await ensureSessionAndConnect();
     const response = await client.sendCommand({
         command: 'remove_script',
         args: { id, windowLabel },
@@ -57,8 +55,7 @@ export async function removeScript(id, windowLabel) {
  * @returns Promise resolving to the number of scripts cleared
  */
 export async function clearScripts(windowLabel) {
-    await connectPlugin();
-    const client = getPluginClient();
+    const client = await ensureSessionAndConnect();
     const response = await client.sendCommand({
         command: 'clear_scripts',
         args: { windowLabel },
@@ -74,8 +71,7 @@ export async function clearScripts(windowLabel) {
  * @returns Promise resolving to the list of registered scripts
  */
 export async function getScripts() {
-    await connectPlugin();
-    const client = getPluginClient();
+    const client = await ensureSessionAndConnect();
     const response = await client.sendCommand({
         command: 'get_scripts',
         args: {},

package/dist/driver/session-manager.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { getDefaultHost, getDefaultPort } from '../config.js';
 import { AppDiscovery } from './app-discovery.js';
-import { resetPluginClient, getPluginClient, connectPlugin } from './plugin-client.js';
+import { resetPluginClient, getExistingPluginClient, connectPlugin } from './plugin-client.js';
 import { getBackendState } from './plugin-commands.js';
 import { resetInitialization } from './webview-executor.js';
 /**
@@ -29,6 +29,19 @@ export const ManageDriverSessionSchema = z.object({
 // AppDiscovery instance - recreated when host changes
 // Track current session info including app identifier for session reuse
 let appDiscovery = null, currentSession = null;
+/**
+ * Check if a session is currently active.
+ * @returns true if a session has been started and not stopped
+ */
+export function hasActiveSession() {
+    return currentSession !== null;
+}
+/**
+ * Get the current session info, or null if no session is active.
+ */
+export function getCurrentSession() {
+    return currentSession;
+}
 function getAppDiscovery(host) {
     if (!appDiscovery || appDiscovery.host !== host) {
         appDiscovery = new AppDiscovery(host);
@@ -62,7 +75,8 @@ async function tryConnect(host, port) {
  */
 async function fetchAppIdentifier() {
     try {
-        const stateJson = await getBackendState();
+        // Use existing client - called during session setup before currentSession is set
+        const stateJson = await getBackendState(true);
         const state = JSON.parse(stateJson);
         // Return null if identifier is not present (backward compat with older plugins)
         return state.app?.identifier ?? null;
@@ -95,8 +109,8 @@ async function fetchAppIdentifier() {
 export async function manageDriverSession(action, host, port) {
     // Handle status action
     if (action === 'status') {
-        const client = getPluginClient();
-        if (client.isConnected() && currentSession) {
+        const client = getExistingPluginClient();
+        if (client?.isConnected() && currentSession) {
             return JSON.stringify({
                 connected: true,
                 app: currentSession.name,

package/dist/driver/webview-executor.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { getPluginClient, connectPlugin } from './plugin-client.js';
+import { hasActiveSession, getCurrentSession } from './session-manager.js';
 import { createMcpLogger } from '../logger.js';
 import { buildScreenshotScript, buildScreenshotCaptureScript, getHtml2CanvasSource, HTML2CANVAS_SCRIPT_ID, } from './scripts/html2canvas-loader.js';
 import { registerScript, isScriptRegistered } from './script-manager.js';
@@ -22,17 +23,27 @@ const driverLogger = createMcpLogger('DRIVER');
  * This is called automatically by all tool functions.
  *
  * Initialization includes:
- * - Connecting to the plugin WebSocket
+ * - Verifying an active session exists (via tauri_driver_session)
+ * - Connecting to the plugin WebSocket using session config
  * - Console capture is already initialized by bridge.js in the Tauri app
  *
  * This function is idempotent - calling it multiple times is safe.
+ *
+ * @throws Error if no session is active (tauri_driver_session must be called first)
  */
 export async function ensureReady() {
     if (isInitialized) {
         return;
     }
-    // Connect to the plugin
-    await connectPlugin();
+    // Require an active session to prevent connecting to wrong app
+    if (!hasActiveSession()) {
+        throw new Error('No active session. Call tauri_driver_session with action "start" first to connect to a Tauri app.');
+    }
+    // Get session config and connect with explicit host/port
+    const session = getCurrentSession();
+    if (session) {
+        await connectPlugin(session.host, session.port);
+    }
     isInitialized = true;
 }
 /**
@@ -63,7 +74,12 @@ export async function executeInWebviewWithContext(script, windowId) {
     try {
         // Ensure we're fully initialized
         await ensureReady();
-        const client = getPluginClient();
+        // Get session config to use correct host/port
+        const session = getCurrentSession();
+        if (!session) {
+            throw new Error('No active session');
+        }
+        const client = getPluginClient(session.host, session.port);
         // Send script directly - Rust handles wrapping and IPC callbacks.
         // Use 7s timeout (longer than Rust's 5s) so errors return before Node times out.
         const response = await client.sendCommand({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypothesi/tauri-mcp-server",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "A Model Context Protocol server for Tauri v2 development",
   "type": "module",
   "bin": {