fix: improve script handling in execute commands for better serialization

docs/tauri-playwright-improvements-plan.md

@@ -7,14 +7,14 @@
 
 ## Improvement Summary
 
-| # | Improvement | Applies To | Effort | Impact |
-|---|-------------|------------|--------|--------|
-| 1 | Browser-only test mode with mocked native IPC | Tauri + Electron | Large | High |
-| 2 | Direct WebView eval channel (supplement WebDriver) | Tauri (embedded) | Large | High |
-| 3 | Multi-window label configuration | Tauri | Small | Medium |
-| 4 | Native screenshot capture | Tauri + Electron | Medium | Low |
-| 5 | Audit JS string interpolation / escaping | Tauri + Electron | Small | Medium |
-| 6 | IPC mock serialization pattern | Tauri + Electron | Medium | Medium |
+| # | Improvement | Applies To | Effort | Impact | Status |
+|---|-------------|------------|--------|--------|--------|
+| 1 | Browser-only test mode with mocked native IPC | Tauri + Electron | Large | High | Pending |
+| 2 | Direct WebView eval channel (supplement WebDriver) | Tauri (embedded) | Large | High | Pending |
+| 3 | Multi-window label configuration | Tauri | Small | Medium | Pending |
+| 4 | Native screenshot capture | Tauri + Electron | Medium | Low | Pending |
+| 5 | Audit JS string interpolation / escaping | Tauri + Electron | Small | Medium | **Done** |
+| 6 | IPC mock serialization pattern | Tauri + Electron | Medium | Medium | Pending |
 
 ---
 

packages/electron-service/src/commands/execute.ts

@@ -14,11 +14,13 @@ export async function execute<ReturnValue, InnerArguments extends unknown[]>(
     throw new Error('WDIO browser is not yet initialised');
   }
 
+  const scriptString = typeof script === 'function' ? script.toString() : script;
+
   const returnValue = await browser.execute(
     function executeWithinElectron(script: string, ...args) {
       return window.wdioElectron.execute(script, args);
     },
-    `${script}`,
+    scriptString,
     ...args,
   );
 

packages/electron-service/test/commands/execute.spec.ts

@@ -47,4 +47,34 @@ describe('execute Command', () => {
     expect(globalThis.browser.execute).toHaveBeenCalledWith(expect.any(Function), '() => 1 + 2 + 3');
     expect(globalThis.wdioElectron.execute).toHaveBeenCalledWith('() => 1 + 2 + 3', []);
   });
+
+  it('should handle scripts with quotes', async () => {
+    const scriptWithQuotes = '() => "He said \\"hello\\""';
+    await execute(globalThis.browser, scriptWithQuotes);
+    expect(globalThis.browser.execute).toHaveBeenCalledWith(expect.any(Function), scriptWithQuotes);
+  });
+
+  it('should handle scripts with newlines', async () => {
+    const scriptWithNewlines = '() => "line1\\nline2"';
+    await execute(globalThis.browser, scriptWithNewlines);
+    expect(globalThis.browser.execute).toHaveBeenCalledWith(expect.any(Function), scriptWithNewlines);
+  });
+
+  it('should handle scripts with unicode', async () => {
+    const scriptWithUnicode = '() => "Hello 世界"';
+    await execute(globalThis.browser, scriptWithUnicode);
+    expect(globalThis.browser.execute).toHaveBeenCalledWith(expect.any(Function), scriptWithUnicode);
+  });
+
+  it('should handle scripts with backslashes', async () => {
+    const scriptWithBackslashes = '() => "C:\\\\path\\\\file"';
+    await execute(globalThis.browser, scriptWithBackslashes);
+    expect(globalThis.browser.execute).toHaveBeenCalledWith(expect.any(Function), scriptWithBackslashes);
+  });
+
+  it('should handle mixed special characters', async () => {
+    const script = '() => "Test \\n \\t \\u001b and \\\\ backslash"';
+    await execute(globalThis.browser, script);
+    expect(globalThis.browser.execute).toHaveBeenCalledWith(expect.any(Function), script);
+  });
 });

packages/tauri-plugin/src/commands.rs

@@ -60,11 +60,17 @@ pub(crate) async fn execute<R: Runtime>(
     let tx = Arc::new(Mutex::new(Some(tx)));
 
     // Build the script with args if offered
+    // For args: inject Tauri APIs as first param, then pass user args
+    // For no-args: preserve the script expression and evaluate it below
     let script = if !request.args.is_empty() {
         let args_json = serde_json::to_string(&request.args)
             .map_err(|e| crate::Error::SerializationError(format!("Failed to serialize args: {}", e)))?;
-        format!("(function() {{ const __wdio_args = {}; return ({}); }})()", args_json, request.script)
+        format!(
+            "(function() {{ const __wdio_fn = ({}); const __wdio_args = {}; return __wdio_fn({{ core: window.__TAURI__?.core, event: window.__TAURI__?.event, log: window.__TAURI__?.log }}, ...__wdio_args); }})()",
+            request.script, args_json
+        )
     } else {
+        // No args - preserve the script expression and evaluate it below
         request.script.clone()
     };
 
@@ -122,8 +128,13 @@ pub(crate) async fn execute<R: Runtime>(
                     throw new Error('window.__TAURI__.core.invoke not available after timeout');
                 }}
 
-                // Execute the user's script
-                const result = await ({});
+                // Execute the user's script.
+                // If expression resolves to a function, call it with Tauri APIs.
+                // Otherwise, await the value directly.
+                const __wdio_script = ({});
+                const result = typeof __wdio_script === 'function'
+                    ? await __wdio_script({{ core: window.__TAURI__?.core, event: window.__TAURI__?.event }})
+                    : await __wdio_script;
 
                 // Emit the result using the current window's event emitter
                 // This ensures the event goes to the same window where we're listening

packages/tauri-service/src/commands/execute.ts

@@ -65,7 +65,9 @@ export async function execute<ReturnValue, InnerArguments extends unknown[]>(
     log.debug('Plugin availability cached, skipping check');
   }
 
-  // Convert function to string - keep parameters intact, plugin will inject tauri as first arg
+  // Convert function to string - keep parameters intact, plugin will handle escaping
+  // For functions: use .toString() (produces valid JS function source)
+  // For strings: send as-is (Rust handles proper escaping when args present)
   const scriptString = typeof script === 'function' ? script.toString() : script;
 
   // Execute via plugin's execute command with better error handling
@@ -111,21 +113,25 @@ export async function execute<ReturnValue, InnerArguments extends unknown[]>(
   );
 
   // Extract result or error from wrapped response
-  try {
-    if (result && typeof result === 'string') {
-      const parsed = JSON.parse(result) as { __wdio_error__?: string; __wdio_value__?: unknown };
-      if (parsed.__wdio_error__) {
-        throw new Error(parsed.__wdio_error__);
-      }
-      if (parsed.__wdio_value__ !== undefined) {
-        log.debug(`Execute result:`, parsed.__wdio_value__);
-        return parsed.__wdio_value__ as ReturnValue;
-      }
+  let parsed: { __wdio_error__?: string; __wdio_value__?: unknown } | undefined;
+  if (result && typeof result === 'string') {
+    try {
+      parsed = JSON.parse(result) as { __wdio_error__?: string; __wdio_value__?: unknown };
+    } catch (parseError) {
+      throw new Error(
+        `Failed to parse execute result: ${parseError instanceof Error ? parseError.message : String(parseError)}, raw result: ${result}`,
+      );
     }
-  } catch (parseError) {
-    throw new Error(
-      `Failed to parse execute result: ${parseError instanceof Error ? parseError.message : String(parseError)}, raw result: ${result}`,
-    );
+  }
+
+  // Check for script errors AFTER parsing (outside try/catch to avoid re-wrapping)
+  if (parsed?.__wdio_error__) {
+    throw new Error(parsed.__wdio_error__);
+  }
+
+  if (parsed?.__wdio_value__ !== undefined) {
+    log.debug(`Execute result:`, parsed.__wdio_value__);
+    return parsed.__wdio_value__ as ReturnValue;
   }
 
   log.debug(`Execute result:`, result);