fix: improve script handling in execute commands for better serialization

[goosewobbler]

No description provided.

[github-actions]

Release Preview — no release

No bump label detected.
Note: Add bump:patch, bump:minor, or bump:major to trigger a release.

---

Updated automatically by ReleaseKit

[greptile-apps]

Greptile Summary

This PR substantially refactors the execute command pipeline across the Electron and Tauri services to fix serialization and cross-platform (WebKit/macOS) compatibility issues. The core change is that patchBrowserExecute in service.ts now always routes through executeAsync with an explicit done callback — using arrow-function .then() handlers to correctly close over arguments — for both function and string scripts, addressing the previously-flagged WebKit Promise-serialisation and arguments-shadowing bugs.

• Two related P1 issues remain in both guest-js/index.ts (line 234) and commands.rs (line 215): multi-statement string scripts that do not begin with a control-flow keyword (e.g. someFn(); anotherFn(); return result) bypass the statement-keyword heuristic, causing a spurious return to be prepended and the trailing statements to become unreachable dead code. The electron-service already ships a hasSemicolonOutsideQuotes helper that handles this correctly; the same guard should be applied in both locations.

Confidence Score: 3/5

Safe to merge on the happy path; two P1 edge cases around multi-statement scripts without keyword prefixes can produce silently-wrong results at runtime

The vast majority of issues from the previous review round have been resolved: executeAsync is used everywhere, arguments shadowing is fixed, word-boundary checks are in place for async/function/return, and double-encoding is gone. Two genuine P1 logic gaps remain (semicolons-outside-quotes not checked in guest-js and commands.rs), lowering the score from 5.

packages/tauri-plugin/guest-js/index.ts (line 234) and packages/tauri-plugin/src/commands.rs (lines 215-230) — both need a semicolon-outside-quotes scan to complement the existing keyword-prefix check

Important Files Changed

Filename	Overview
packages/tauri-service/src/service.ts	patchBrowserExecute now always uses executeAsync with arrow-function callbacks and wdio_error unwrapping — the critical WebKit/macOS issues from the prior review are addressed; minor edge cases remain around multi-statement scripts without keyword prefixes
packages/tauri-plugin/guest-js/index.ts	Function classification uses hasTopLevelArrow and proper regex word-boundary checks; string scripts are wrapped in async IIFEs with statement keyword detection; async[\s(] check correctly avoids false positives like asyncData
packages/tauri-plugin/src/commands.rs	Function detection uses has_keyword_prefix (word-boundary aware), has_arrow_outside_parens (depth-tracking), and single_param_arrow; string branch has_return check uses strip_prefix+char check to avoid returnData-style false positives; string+args returns an explicit error
packages/tauri-service/src/commands/execute.ts	Plugin availability check uses an arrow function (safe through patchedExecute); executeWithinTauri serializes results as JSON to survive the WebDriver protocol boundary; argsJson forwarded correctly to guest-js
packages/electron-service/src/commands/execute.ts	wrapStringScript now produces sync IIFEs (not async) which is correct for the Electron native handler; hasSemicolonOutsideQuotes uses consecutive-backslash counting; isFunctionLike uses hasTopLevelArrow to avoid parenthesized-expression false positives
packages/electron-service/src/commands/executeCdp.ts	hasSemicolonOutsideQuotes updated with the same consecutive-backslash-counting fix as execute.ts; wrapStringScriptForCdp produces async function expressions (not IIFEs) suitable for Runtime.callFunctionOn with awaitPromise:true
packages/tauri-service/test/service.spec.ts	Tests updated to assert executeAsync is called for both function and string scripts on all providers; asserts done-callback pattern (.then() + wdio_error) and expression-return prepending
.github/workflows/_ci-e2e-tauri-all-providers.reusable.yml	Adds cleanup of test-runner-backend and tauri-driver processes before/after CrabNebula provider tests to prevent stale process interference

Sequence Diagram

sequenceDiagram
    participant Test as Test Code
    participant TS as tauri-service/execute.ts
    participant PE as patchedExecute (service.ts)
    participant WD as WebDriver executeAsync
    participant BW as Browser / WebKit
    participant GJ as guest-js index.ts
    participant RS as commands.rs (Rust)

    Test->>TS: browser.tauri.execute(fn, ...args)
    TS->>PE: browser.execute(executeWithinTauri, scriptStr, opts, argsJson)
    PE->>PE: typeof script === function → function path
    PE->>WD: originalExecuteAsync(wrappedScript, scriptStr, opts, argsJson)
    WD->>BW: eval wrappedScript (with done callback as last arg)
    BW->>BW: Promise.resolve(executeWithinTauri.apply(null, args_without_done)).then(arrow→done(r))
    BW->>GJ: window.wdioTauri.execute(scriptStr, opts, argsJson)
    GJ->>GJ: classify script (isFunctionLike?)
    GJ->>GJ: build scriptToSend with Tauri API injection and __wdio_args
    GJ->>RS: invoke plugin:wdio|execute { script: scriptToSend, args: [] }
    RS->>RS: detect is_function / string branch
    RS->>BW: window.eval(script_with_result)
    BW->>BW: await user script, emit wdio-result-uuid event
    RS-->>GJ: event result via Tauri event system
    GJ-->>BW: resolve with result
    BW->>WD: done(JSON.stringify({__wdio_value__: result}))
    WD-->>PE: asyncResult
    PE->>PE: check __wdio_error__, return value
    PE-->>TS: ReturnValue
    TS-->>Test: result

Loading

_{Reviews (54): Last reviewed commit: "refactor(electron-service): simplify IIF..." | Re-trigger Greptile}

[greptile-apps]

Multi-statement string scripts without a keyword prefix lose the trailing statements

hasStatementKeyword only matches scripts whose first token is a control-flow keyword. A script like someFn(); anotherFn(); return result starts with someFn — no keyword match — so return is prepended, producing return someFn(); anotherFn(); return result. The anotherFn() call and the explicit return are unreachable. The electron-service already has a hasSemicolonOutsideQuotes helper that detects this correctly; the same approach should be applied here so semicolons outside string literals also set the "has statement" flag.