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

@@ -63,7 +63,9 @@ pub(crate) async fn execute<R: Runtime>(
     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)
+        let script_json = serde_json::to_string(&request.script)
+            .map_err(|e| crate::Error::SerializationError(format!("Failed to serialize script: {}", e)))?;
+        format!("(function() {{ const __wdio_args = {}; return ({}); }})()", args_json, script_json)
     } else {
         request.script.clone()
     };

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);

packages/tauri-service/src/service.ts

@@ -318,6 +318,8 @@ export default class TauriWorkerService {
       script: string | ((...args: InnerArguments) => ReturnValue),
       ...args: InnerArguments
     ): Promise<ReturnValue> {
+      // For functions: use .toString() - produces valid JS function source
+      // For strings: pass as-is (wrapper template wraps in parentheses to make callable)
       const scriptString = typeof script === 'function' ? script.toString() : script;
 
       if (isEmbedded) {
@@ -327,9 +329,12 @@ export default class TauriWorkerService {
       }
 
       // For tauri-driver: use sync execute with console wrapper
+      // Note: scriptString is passed as-is - wrap in IIFE to make both strings and functions callable
+      // For string scripts: "return x" -> "(() => return x)()" - wraps statement as expression
+      // For function scripts: "(a,b) => a+b" -> "((a,b) => a+b)()" - works as IIFE
       const wrappedScript = `
             ${CONSOLE_WRAPPER_SCRIPT}
-            return (${scriptString}).apply(null, arguments);
+            return ((${scriptString})()).apply(null, arguments);
           `;
 
       return originalExecute(wrappedScript, ...args) as Promise<ReturnValue>;

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

@@ -189,7 +189,7 @@ describe('execute', () => {
       expect(secondCall[3]).toBe(2);
     });
 
-    it('should pass strings as-is', async () => {
+    it('should pass strings as-is to the plugin', async () => {
       const mockExecute = vi.fn();
       mockExecute.mockResolvedValueOnce(true);
       mockExecute.mockResolvedValueOnce(JSON.stringify({ __wdio_value__: 'hello' }));
@@ -294,9 +294,7 @@ describe('execute', () => {
       browser = createMockBrowser();
       (browser.execute as ReturnType<typeof vi.fn>).mockImplementation(mockExecute);
 
-      await expect(() => execute<string, []>(browser, '() => "fail"')).rejects.toThrow(
-        /Failed to parse execute result:.*something went wrong/,
-      );
+      await expect(() => execute<string, []>(browser, '() => "fail"')).rejects.toThrow('something went wrong');
     });
 
     it('should throw for window undefined error', async () => {