@hypothesi/tauri-mcp-server 0.2.2 → 0.3.0

package/README.md

@@ -13,10 +13,8 @@ A **Model Context Protocol (MCP) server** that enables AI assistants like Claude
 |----------|-------------|
 | 🎯 **UI Automation** | Screenshots, clicks, typing, scrolling, element finding |
 | 🔍 **IPC Monitoring** | Capture and inspect Tauri IPC calls in real-time |
-| 📱 **Mobile Dev** | Manage Android emulators & iOS simulators |
-| 🛠️ **CLI Integration** | Run any Tauri command (`init`, `dev`, `build`, etc.) |
-| ⚙️ **Configuration** | Read/write Tauri config files with validation |
-| 📋 **Logs** | Stream Android logcat, iOS device logs, system logs |
+| 📱 **Mobile Dev** | List Android emulators & iOS simulators |
+| 📋 **Logs** | Stream console, Android logcat, iOS, and system logs |
 
 ## Quick Start
 
@@ -54,51 +52,38 @@ npx -y install-mcp @hypothesi/tauri-mcp-server --client claude-code
 
 Supported clients: `claude-code`, `cursor`, `windsurf`, `vscode`, `cline`, `roo-cline`, `claude`, `zed`, `goose`, `warp`, `codex`
 
-## Available Tools
+## Available Tools (16 total)
 
 ### UI Automation
 
 | Tool | Description |
 |------|-------------|
-| `tauri_webview_screenshot` | Capture webview screenshots |
-| `tauri_list_windows` | List all open webview windows |
+| `tauri_driver_session` | Start/stop/status automation session |
 | `tauri_webview_find_element` | Find elements by selector |
-| `tauri_webview_interact` | Click, scroll, swipe, long-press |
+| `tauri_read_logs` | Read console, Android, iOS, or system logs |
+| `tauri_webview_interact` | Click, scroll, swipe, focus, long-press |
+| `tauri_webview_screenshot` | Capture webview screenshots |
 | `tauri_webview_keyboard` | Type text or send key events |
 | `tauri_webview_wait_for` | Wait for elements, text, or events |
 | `tauri_webview_get_styles` | Get computed CSS styles |
 | `tauri_webview_execute_js` | Execute JavaScript in webview |
-| `tauri_webview_focus_element` | Focus on elements |
-| `tauri_driver_get_console_logs` | Get browser console logs |
-| `tauri_read_platform_logs` | Read Android/iOS/system logs |
-| `tauri_driver_session` | Start/stop automation session |
+| `tauri_list_windows` | List all open webview windows |
 
 ### IPC & Plugin
 
 | Tool | Description |
 |------|-------------|
-| `tauri_plugin_execute_ipc` | Execute Tauri IPC commands |
-| `tauri_plugin_get_window_info` | Get window information |
-| `tauri_plugin_get_backend_state` | Get app metadata and state |
-| `tauri_plugin_ipc_monitor` | Start/stop IPC monitoring |
-| `tauri_plugin_ipc_get_events` | Get captured IPC events |
-| `tauri_plugin_emit_event` | Emit custom events |
+| `tauri_ipc_execute_command` | Execute Tauri IPC commands |
+| `tauri_ipc_get_backend_state` | Get app metadata and state |
+| `tauri_ipc_monitor` | Start/stop IPC monitoring |
+| `tauri_ipc_get_captured` | Get captured IPC traffic |
+| `tauri_ipc_emit_event` | Emit custom events |
 
 ### Mobile Development
 
 | Tool | Description |
 |------|-------------|
 | `tauri_list_devices` | List Android devices and iOS simulators |
-| `tauri_launch_emulator` | Launch Android AVD or iOS Simulator |
-
-### Project Management
-
-| Tool | Description |
-|------|-------------|
-| `tauri_run_command` | Run any Tauri CLI command |
-| `tauri_read_config` | Read Tauri config files |
-| `tauri_write_config` | Write config files with validation |
-| `tauri_get_docs` | Fetch Tauri documentation |
 
 ## Links
 

package/dist/driver/plugin-commands.js

@@ -24,21 +24,6 @@ export async function executeIPCCommand(command, args = {}) {
         return JSON.stringify({ success: false, error: message });
     }
 }
-export const GetWindowInfoSchema = z.object({});
-export async function getWindowInfo() {
-    try {
-        const result = await executeIPCCommand('plugin:mcp-bridge|get_window_info');
-        const parsed = JSON.parse(result);
-        if (!parsed.success) {
-            throw new Error(parsed.error || 'Unknown error');
-        }
-        return JSON.stringify(parsed.result);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to get window info: ${message}`);
-    }
-}
 // Combined schema for managing IPC monitoring
 export const ManageIPCMonitoringSchema = z.object({
     action: z.enum(['start', 'stop']).describe('Action to perform: start or stop IPC monitoring'),

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 } from './plugin-client.js';
+import { resetPluginClient, getPluginClient } from './plugin-client.js';
 import { resetInitialization } from './webview-executor.js';
 /**
  * Session Manager - Native IPC-based session management
@@ -18,7 +18,7 @@ import { resetInitialization } from './webview-executor.js';
 // Schemas
 // ============================================================================
 export const ManageDriverSessionSchema = z.object({
-    action: z.enum(['start', 'stop']).describe('Action to perform: start or stop the session'),
+    action: z.enum(['start', 'stop', 'status']).describe('Action to perform: start or stop the session, or check status'),
     host: z.string().optional().describe('Host address to connect to (e.g., 192.168.1.100). Falls back to MCP_BRIDGE_HOST or TAURI_DEV_HOST env vars'),
     port: z.number().optional().describe('Port to connect to (default: 9223)'),
 });
@@ -26,7 +26,8 @@ export const ManageDriverSessionSchema = z.object({
 // Module State
 // ============================================================================
 // AppDiscovery instance - recreated when host changes
-let appDiscovery = null;
+// Track current session info
+let appDiscovery = null, currentSession = null;
 function getAppDiscovery(host) {
     if (!appDiscovery || appDiscovery.host !== host) {
         appDiscovery = new AppDiscovery(host);
@@ -63,6 +64,24 @@ async function tryConnect(host, port) {
  * @param port - Optional port number (defaults to 9223)
  */
 export async function manageDriverSession(action, host, port) {
+    // Handle status action
+    if (action === 'status') {
+        const client = getPluginClient();
+        if (client.isConnected() && currentSession) {
+            return JSON.stringify({
+                connected: true,
+                app: currentSession.name,
+                host: currentSession.host,
+                port: currentSession.port,
+            });
+        }
+        return JSON.stringify({
+            connected: false,
+            app: null,
+            host: null,
+            port: null,
+        });
+    }
     if (action === 'start') {
         // Reset any existing plugin client to ensure fresh connection
         resetPluginClient();
@@ -72,6 +91,7 @@ export async function manageDriverSession(action, host, port) {
         if (configuredHost !== 'localhost' && configuredHost !== '127.0.0.1') {
             try {
                 const session = await tryConnect('localhost', configuredPort);
+                currentSession = session;
                 return `Session started with app: ${session.name} (localhost:${session.port})`;
             }
             catch {
@@ -81,6 +101,7 @@ export async function manageDriverSession(action, host, port) {
         // Strategy 2: Try the configured/provided host
         try {
             const session = await tryConnect(configuredHost, configuredPort);
+            currentSession = session;
             return `Session started with app: ${session.name} (${session.host}:${session.port})`;
         }
         catch {
@@ -94,6 +115,7 @@ export async function manageDriverSession(action, host, port) {
                 // Reset client again to connect to discovered port
                 resetPluginClient();
                 const session = await tryConnect('localhost', firstApp.port);
+                currentSession = session;
                 return `Session started with app: ${session.name} (localhost:${session.port})`;
             }
             catch {
@@ -104,10 +126,12 @@ export async function manageDriverSession(action, host, port) {
         try {
             resetPluginClient();
             const session = await tryConnect(configuredHost, configuredPort);
+            currentSession = session;
             return `Session started with app: ${session.name} (${session.host}:${session.port})`;
         }
         catch {
             // All attempts failed
+            currentSession = null;
             return `Session started (native IPC mode - no Tauri app found at localhost or ${configuredHost}:${configuredPort})`;
         }
     }
@@ -117,5 +141,6 @@ export async function manageDriverSession(action, host, port) {
     }
     resetPluginClient();
     resetInitialization();
+    currentSession = null;
     return 'Session stopped';
 }

package/dist/driver/webview-executor.js

@@ -206,16 +206,41 @@ export async function clearConsoleLogs() {
    `;
     return executeInWebview(script);
 }
-function formatScreenshotResponse(dataUrl, windowContext) {
-    let result = 'Webview screenshot captured (native)';
+/**
+ * Parse a data URL to extract the base64 data and mime type.
+ */
+function parseDataUrl(dataUrl) {
+    const match = dataUrl.match(/^data:(image\/(?:png|jpeg));base64,(.+)$/);
+    if (!match) {
+        return null;
+    }
+    return { mimeType: match[1], data: match[2] };
+}
+/**
+ * Build screenshot result with image content and optional text context.
+ */
+function buildScreenshotResult(dataUrl, method, windowContext) {
+    const parsed = parseDataUrl(dataUrl);
+    if (!parsed) {
+        throw new Error(`Invalid data URL format: ${dataUrl.substring(0, 50)}...`);
+    }
+    const content = [];
+    // Add context text if there's window info or warnings
+    let contextText = `Screenshot captured via ${method}`;
     if (windowContext) {
-        result += ` in window "${windowContext.windowLabel}"`;
+        contextText += ` in window "${windowContext.windowLabel}"`;
         if (windowContext.warning) {
-            result += `\n\n⚠️ ${windowContext.warning}`;
+            contextText += `\n\n⚠️ ${windowContext.warning}`;
         }
     }
-    result += `:\n\n![Screenshot](${dataUrl})`;
-    return result;
+    content.push({ type: 'text', text: contextText });
+    // Add the image content
+    content.push({
+        type: 'image',
+        data: parsed.data,
+        mimeType: parsed.mimeType,
+    });
+    return { content };
 }
 /**
  * Prepares the html2canvas script for screenshot capture.
@@ -242,7 +267,7 @@ async function prepareHtml2canvasScript(format, quality) {
  * Capture a screenshot of the entire webview.
  *
  * @param options - Screenshot options (format, quality, windowId)
- * @returns Base64-encoded image data URL
+ * @returns Screenshot result with image content
  */
 export async function captureScreenshot(options = {}) {
     const { format = 'png', quality = 90, windowId } = options;
@@ -272,7 +297,7 @@ export async function captureScreenshot(options = {}) {
             throw new Error('Native screenshot returned invalid data');
         }
         // Build response with window context
-        return formatScreenshotResponse(dataUrl, response.windowContext);
+        return buildScreenshotResult(dataUrl, 'native API', response.windowContext);
     }
     catch (nativeError) {
         // Log the native error for debugging, then fall back
@@ -343,7 +368,7 @@ export async function captureScreenshot(options = {}) {
         const result = await executeAsyncInWebview(html2canvasScript, undefined, 10000); // Longer timeout for library loading
         // Validate that we got a real data URL, not 'null' or empty
         if (result && result !== 'null' && result.startsWith('data:image/')) {
-            return `Webview screenshot captured:\n\n![Screenshot](${result})`;
+            return buildScreenshotResult(result, 'html2canvas');
         }
         throw new Error(`html2canvas returned invalid result: ${result?.substring(0, 100) || 'null'}`);
     }
@@ -353,7 +378,7 @@ export async function captureScreenshot(options = {}) {
             const result = await executeAsyncInWebview(screenCaptureScript);
             // Validate that we got a real data URL
             if (result && result.startsWith('data:image/')) {
-                return `Webview screenshot captured (via Screen Capture API):\n\n![Screenshot](${result})`;
+                return buildScreenshotResult(result, 'Screen Capture API');
             }
             throw new Error(`Screen Capture API returned invalid result: ${result?.substring(0, 50) || 'null'}`);
         }

package/dist/driver/webview-interactions.js

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { executeInWebview, executeInWebviewWithContext, captureScreenshot, getConsoleLogs as getConsoleLogsFromCapture, } from './webview-executor.js';
 import { SCRIPTS, buildScript, buildTypeScript, buildKeyEventScript } from './scripts/index.js';
 // ============================================================================
@@ -15,7 +17,7 @@ export const WindowTargetSchema = z.object({
 // Schemas
 // ============================================================================
 export const InteractSchema = WindowTargetSchema.extend({
-    action: z.enum(['click', 'double-click', 'long-press', 'scroll', 'swipe'])
+    action: z.enum(['click', 'double-click', 'long-press', 'scroll', 'swipe', 'focus'])
         .describe('Type of interaction to perform'),
     selector: z.string().optional().describe('CSS selector for the element to interact with'),
     x: z.number().optional().describe('X coordinate for direct coordinate interaction'),
@@ -32,6 +34,7 @@ export const InteractSchema = WindowTargetSchema.extend({
 export const ScreenshotSchema = WindowTargetSchema.extend({
     format: z.enum(['png', 'jpeg']).optional().default('png').describe('Image format'),
     quality: z.number().min(0).max(100).optional().describe('JPEG quality (0-100, only for jpeg format)'),
+    filePath: z.string().optional().describe('File path to save the screenshot to instead of returning as base64'),
 });
 export const KeyboardSchema = WindowTargetSchema.extend({
     action: z.enum(['type', 'press', 'down', 'up'])
@@ -76,6 +79,13 @@ export async function interact(options) {
     if (action === 'swipe') {
         return performSwipe({ fromX, fromY, toX, toY, duration, windowId });
     }
+    // Handle focus action
+    if (action === 'focus') {
+        if (!selector) {
+            throw new Error('Focus action requires a selector');
+        }
+        return focusElement({ selector, windowId });
+    }
     const script = buildScript(SCRIPTS.interact, {
         action,
         selector: selector ?? null,
@@ -108,9 +118,23 @@ async function performSwipe(options) {
     }
 }
 export async function screenshot(options = {}) {
-    const { quality, format = 'png', windowId } = options;
+    const { quality, format = 'png', windowId, filePath } = options;
     // Use the native screenshot function from webview-executor
-    return captureScreenshot({ format, quality, windowId });
+    const result = await captureScreenshot({ format, quality, windowId });
+    // If filePath is provided, write to file instead of returning base64
+    if (filePath) {
+        // Find the image content in the result
+        const imageContent = result.content.find((c) => { return c.type === 'image'; });
+        if (!imageContent || imageContent.type !== 'image') {
+            throw new Error('Screenshot capture failed: no image data');
+        }
+        // Decode base64 and write to file
+        const buffer = Buffer.from(imageContent.data, 'base64');
+        const resolvedPath = resolve(filePath);
+        await writeFile(resolvedPath, buffer);
+        return { filePath: resolvedPath, format };
+    }
+    return result;
 }
 export async function keyboard(options) {
     const { action, selectorOrKey, textOrModifiers, modifiers, windowId } = options;

package/dist/index.js

@@ -52,6 +52,32 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         }),
     };
 });
+/**
+ * Convert a ToolResult to MCP content array.
+ * Handles string (legacy), single content, and content arrays.
+ */
+function toolResultToContent(result) {
+    // Legacy string result - convert to text content
+    if (typeof result === 'string') {
+        return [{ type: 'text', text: result }];
+    }
+    // Array of content items
+    if (Array.isArray(result)) {
+        return result.map(contentToMcp);
+    }
+    // Single content item
+    return [contentToMcp(result)];
+}
+/**
+ * Convert a single ToolContent to MCP format.
+ */
+function contentToMcp(content) {
+    if (content.type === 'text') {
+        return { type: 'text', text: content.text };
+    }
+    // Image content
+    return { type: 'image', data: content.data, mimeType: content.mimeType };
+}
 // Tool call handler - generated from registry
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
@@ -60,7 +86,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             throw new Error(`Unknown tool: ${request.params.name}`);
         }
         const output = await tool.handler(request.params.arguments);
-        return { content: [{ type: 'text', text: output }] };
+        return { content: toolResultToContent(output) };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/manager/mobile.js

@@ -37,47 +37,3 @@ export async function listDevices() {
     ]);
     return { android, ios };
 }
-export const LaunchEmulatorSchema = z.object({
-    platform: z.enum(['android', 'ios']),
-    name: z.string().describe('Name of the AVD or Simulator'),
-});
-export async function launchEmulator(platform, name) {
-    if (platform === 'android') {
-        try {
-            // Launch Android Emulator - Try to spawn, but immediately await to catch ENOENT
-            await execa('emulator', ['-avd', name], {
-                detached: true,
-                stdio: 'ignore',
-                timeout: 1000, // Just check if it spawns
-            });
-            return `Launching Android AVD: ${name}`;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to launch Android emulator: ${message}`);
-        }
-    }
-    else if (platform === 'ios') {
-        // Check if we're on macOS first
-        if (process.platform !== 'darwin') {
-            throw new Error('iOS simulators are only available on macOS');
-        }
-        try {
-            // Launch iOS Simulator
-            await execa('xcrun', ['simctl', 'boot', name]);
-            await execa('open', ['-a', 'Simulator']);
-            return `Booted iOS Simulator: ${name}`;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            // Provide more helpful error messages
-            if (message.includes('xcrun: error')) {
-                throw new Error('Xcode is not installed. Please install Xcode from the App Store to use iOS simulators.');
-            }
-            throw new Error(`Failed to launch iOS simulator: ${message}`);
-        }
-    }
-    else {
-        throw new Error(`Unsupported platform: ${platform}. Use 'android' or 'ios'.`);
-    }
-}

package/dist/monitor/logs.js

@@ -1,15 +1,27 @@
 import { z } from 'zod';
 import { execa } from 'execa';
+import { getConsoleLogs } from '../driver/webview-interactions.js';
 export const ReadLogsSchema = z.object({
-    source: z.enum(['android', 'ios', 'system']),
+    source: z.enum(['console', 'android', 'ios', 'system'])
+        .describe('Log source: "console" for webview JS logs, "android" for logcat, "ios" for simulator, "system" for desktop'),
     lines: z.number().default(50),
     filter: z.string().optional().describe('Regex or keyword to filter logs'),
     since: z.string().optional().describe('ISO timestamp to filter logs since (e.g. 2023-10-27T10:00:00Z)'),
+    windowId: z.string().optional().describe('Window label for console logs (defaults to "main")'),
 });
-export async function readLogs(source, lines, filter, since) {
+export async function readLogs(options) {
+    const { source, lines = 50, filter, since, windowId } = options;
     try {
         let output = '';
+        // Handle console logs (webview JS logs)
+        if (source === 'console') {
+            return await getConsoleLogs({ filter, since, windowId });
+        }
         if (source === 'android') {
+            // Find adb - check ANDROID_HOME first, then fall back to PATH
+            // eslint-disable-next-line no-process-env
+            const androidHome = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+            const adbPath = androidHome ? `${androidHome}/platform-tools/adb` : 'adb';
             const args = ['logcat', '-d'];
             if (since) {
                 // adb logcat -T expects "MM-DD HH:MM:SS.mmm"
@@ -26,7 +38,7 @@ export async function readLogs(source, lines, filter, since) {
             else {
                 args.push('-t', lines.toString());
             }
-            const { stdout } = await execa('logcat', ['-d', '-t', lines.toString()], { timeout: 5000 });
+            const { stdout } = await execa(adbPath, args, { timeout: 10000 });
             output = stdout;
         }
         else if (source === 'ios') {

package/dist/prompts-registry.js

@@ -8,7 +8,7 @@ Please follow these steps:
 
 1. **Start a session** - Use \`tauri_driver_session\` with action "start" to connect to the running Tauri app
 
-2. **Get console logs** - Use \`tauri_driver_get_console_logs\` to retrieve any JavaScript errors or warnings from the webview console
+2. **Get console logs** - Use \`tauri_read_logs\` with source "console" to retrieve JavaScript errors or warnings
 
 3. **Analyze the errors** - Look at the error messages, stack traces, and identify:
    - What type of error it is (TypeError, ReferenceError, SyntaxError, etc.)
@@ -24,6 +24,96 @@ Please follow these steps:
 If no errors are found, let me know the app is running cleanly.
 
 If the session fails to start, help me troubleshoot the connection (is the app running? is the MCP bridge plugin installed?).`;
+const SETUP_PROMPT = `Help me set up the MCP Bridge plugin in my Tauri project so I can use these AI development tools.
+
+## Prerequisites
+
+- This is a **Tauri v2** project (check for \`src-tauri/\` directory and \`tauri.conf.json\`)
+- If this is NOT a Tauri project, stop and let the user know this setup only applies to Tauri apps
+
+## Setup Steps
+
+### Step 1: Add the Rust Plugin
+
+Add the plugin to \`src-tauri/Cargo.toml\` dependencies:
+
+\`\`\`toml
+[dependencies]
+tauri-plugin-mcp-bridge = "0.2"
+\`\`\`
+
+Or run from the \`src-tauri\` directory:
+\`\`\`bash
+cargo add tauri-plugin-mcp-bridge
+\`\`\`
+
+### Step 2: Register the Plugin
+
+In the Tauri app's entry point (usually \`src-tauri/src/lib.rs\` or \`src-tauri/src/main.rs\`), register the plugin.
+
+Find the \`tauri::Builder\` and add the plugin (only in debug builds):
+
+\`\`\`rust
+let mut builder = tauri::Builder::default();
+// ... existing plugins ...
+
+#[cfg(debug_assertions)]
+{
+    builder = builder.plugin(tauri_plugin_mcp_bridge::init());
+}
+
+builder
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
+\`\`\`
+
+### Step 3: Enable Global Tauri (REQUIRED)
+
+In \`src-tauri/tauri.conf.json\`, ensure \`withGlobalTauri\` is enabled:
+
+\`\`\`json
+{
+  "app": {
+    "withGlobalTauri": true
+  }
+}
+\`\`\`
+
+**This is required** - without it, the MCP bridge cannot communicate with the webview.
+
+### Step 4: Add Plugin Permissions
+
+Add the plugin permission to \`src-tauri/capabilities/default.json\` (create the file if it doesn't exist):
+
+\`\`\`json
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "Default capabilities",
+  "windows": ["main"],
+  "permissions": [
+    "mcp-bridge:default"
+  ]
+}
+\`\`\`
+
+If the file already exists, just add \`"mcp-bridge:default"\` to the existing permissions array.
+
+## Verification
+
+After setup:
+1. Run the Tauri app in development mode (\`cargo tauri dev\` or \`npm run tauri dev\`)
+2. The MCP bridge will start a WebSocket server on port 9223
+3. Use \`tauri_driver_session\` with action "start" to connect
+4. Use \`tauri_driver_session\` with action "status" to verify the connection
+
+## Notes
+
+- The plugin only runs in debug builds (\`#[cfg(debug_assertions)]\`) so it won't affect production
+- The WebSocket server binds to \`0.0.0.0\` by default to support mobile device testing
+- For localhost-only access, use \`Builder::new().bind_address("127.0.0.1").build()\` instead of \`init()\`
+
+Please examine the project structure and make the necessary changes to set up the MCP bridge plugin.`;
 /**
  * Complete registry of all available prompts
  */
@@ -47,6 +137,24 @@ export const PROMPTS = [
             ];
         },
     },
+    {
+        name: 'setup',
+        description: 'Set up the MCP Bridge plugin in a Tauri project. ' +
+            'Guides through adding the Rust crate, registering the plugin, enabling withGlobalTauri, ' +
+            'and adding permissions. Use this when starting with a new Tauri project.',
+        arguments: [],
+        handler: () => {
+            return [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: SETUP_PROMPT,
+                    },
+                },
+            ];
+        },
+    },
 ];
 /**
  * Create a Map for fast prompt lookup by name