Codex Desktop 26.707.71524: Browser and Chrome plugins fail with `Cannot redefine property: process`

same here

Independent reproduction confirmed on macOS (Darwin 25.5.0, arm64).

Environment:

• Codex Desktop: 26.707.71524 (Build 5263)
• Bundled Browser plugin: 26.707.71524
• Bundled Chrome plugin: 26.707.71524
• The two installed browser-client.mjs files are byte-identical (same SHA-256)

Observed result:

• Import fails before browser discovery, extension handshake, page attachment, or authentication.
• Exact exception: TypeError: Cannot redefine property: process
• Stack points to browser-client.mjs:33:22, at globalThis.process = processShim.
• Both Browser and Chrome integrations fail identically.

Troubleshooting confirmed:

• Restarting Codex does not help.
• Reinstalling Browser/Chrome installs the same 26.707.71524 bundle and does not help.
• The failure is independent of the target website or login state.

Impact: all workflows that require the in-app browser or the user's signed-in Chrome session are blocked in this build.

I've noticed this happened in the latest release just few hours ago.

Feedback ID: 019f5e63-f4d0-7c40-bc96-8cfa8ba629bd

I hit the same issue on macOS with ChatGPT/Codex Desktop 26.707.71524 (Build 5263):

TypeError: Cannot redefine property: process

Both the Chrome plugin and the built-in Browser plugin were affected.

Root cause

The generated browser-client.mjs attempts to overwrite globalThis.process:

globalThis.process = processShim;
globalThis.global = globalThis.global ?? globalThis;
globalThis.global.process = processShim;

In the current Codex Node REPL runtime, process is protected/non-configurable, so the plugin fails during initialization.

Simply removing those assignments is not enough. That gets past the first error, but bundled dependencies later fail with:

global.process.on is not a function

Temporary local patch

I asked Codex/AI to patch the two cached plugin files:

~/.codex/plugins/cache/openai-bundled/chrome/<version>/scripts/browser-client.mjs
~/.codex/plugins/cache/openai-bundled/browser/<version>/scripts/browser-client.mjs

For me, <version> was 26.707.71524.

First, make backups of both files. Then replace:

globalThis.process = processShim;
globalThis.global = globalThis.global ?? globalThis;
globalThis.global.process = processShim;

with:

const process = processShim;
const global = Object.create(globalThis, {
  process: {
    value: processShim,
    writable: true,
    configurable: true,
  },
});

This keeps process and global module-scoped and gives bundled dependencies the expected process shim without attempting to redefine the protected globalThis.process.

Prompt you can give to Codex/AI

The Chrome and Browser plugins fail with:

TypeError: Cannot redefine property: process

Please inspect the current cached browser-client.mjs files under:

~/.codex/plugins/cache/openai-bundled/chrome/
~/.codex/plugins/cache/openai-bundled/browser/

Do not modify /Applications/ChatGPT.app, the Chrome extension, my projects,
Codex configuration, or any unrelated files.

Before making changes:

1. Locate the active plugin version.
2. Back up both browser-client.mjs files with a timestamped .bak suffix.
3. Confirm both original files have the same relevant process shim code.
4. Patch only the startup shim.

Replace:

globalThis.process = processShim;
globalThis.global = globalThis.global ?? globalThis;
globalThis.global.process = processShim;

with:

const process = processShim;
const global = Object.create(globalThis, {
  process: { value: processShim, writable: true, configurable: true },
});

After patching:

1. Run `node --check` on both files.
2. Confirm the two patched files are identical if their originals were identical.
3. Reset the Node REPL/browser runtime.
4. Load the Chrome plugin and connect to the existing Chrome extension.
5. Open https://www.google.com/ in a new tab.
6. Verify the resulting page title and URL.
7. If plugin initialization still fails, restore both backups immediately.
8. Report every modified file and the rollback path.

Do not use a naive patch that merely deletes the globalThis.process assignment,
because dependencies may then fail with `global.process.on is not a function`.

Verification

After applying the patch, I verified:

• Both files pass node --check.
• The Chrome plugin initializes successfully.
• Codex connects to the Chrome extension.
• A new Chrome tab opens Google successfully.
• The resulting page is https://www.google.com/ with the title Google.

Impact and risks

This is an unsupported local workaround, not an upstream fix.

It only changes cached browser plugin bootstrap files. It does not modify:

• The signed /Applications/ChatGPT.app bundle
• Core Codex code
• The Chrome extension
• Project repositories
• Codex configuration

Normal Codex functionality should therefore remain unaffected, but the Chrome/Browser plugins should still be tested after applying it.

A future ChatGPT/Codex update or plugin cache refresh may overwrite the patched files. That is expected and is preferable to permanently modifying the application bundle. After an update:

1. Test the plugin before doing anything—the upstream issue may already be fixed.
2. Do not blindly reapply the old patch.
3. If the same error remains, ask AI to inspect the new generated file and verify that the same code pattern and failure still exist.
4. Reapply only if the new bundle has the same compatibility issue.
5. Keep backups so the patch can be rolled back easily.

Downgrading the entire application was not necessary in my case. This cache-only patch restored Chrome control while keeping the application bundle untouched.

---

I ran into this after updating as well. It completely broke Chrome usage.

Additional reproduction with a useful version/OS control:

• macOS 26.5.2 (Build 25F84; Darwin 25.5.0, arm64)
• Codex Desktop / bundled Chrome plugin: 26.707.71524 (Build 5263)
• Google Chrome: 150.0.7871.115
• Codex Chrome extension: 1.2.27203.26575_0

Checks completed:

• Chrome is installed and running.
• The Codex Chrome extension is installed and enabled in the Default profile.
• The native messaging host manifest exists, uses the expected host name/origin, and points to an existing host.
• Reinstalling the bundled plugin installs the same 26.707.71524 files and does not change the failure.
• Import still fails immediately at browser-client.mjs:33:22 on globalThis.process = processShim, before any Chrome/native-messaging handshake or macOS accessibility interaction.

Regression control:

• The older bundled plugin 26.707.62119 imported and reached browser setup on this same Mac before the Codex/plugin update.
• The new 26.707.71524 bundle fails deterministically during module evaluation.

Because the exception occurs before browser discovery or OS permission checks, this reproduction strongly points to a bundled browser-client / Node REPL compatibility regression rather than a Chrome extension, native-host, or macOS privacy-permission failure.

I can reproduce the same regression on Windows.

Environment:

• OS: Windows x64
• Codex Desktop package: OpenAI.Codex_26.707.9564.0_x64
• Bundled Chrome plugin: 26.707.71524
• Bundled Browser plugin: 26.707.71524
• Both plugins are reported as installed and enabled by codex plugin list
• Node REPL itself accepts basic JS tool calls

Failure:

• Importing the current bundled chrome/.../scripts/browser-client.mjs fails immediately with:

Cannot redefine property: process

• The failure occurs before agent.browsers.get("extension"), tab discovery, extension handshake, navigation, or authentication.
• Therefore Codex cannot open, inspect, or control any Chrome tab. Browser-dependent work is completely blocked.

Regression evidence:

• Bundled Chrome plugin version 26.707.62119 worked earlier in the same environment.
• After the bundled cache updated to 26.707.71524, the old version directory was removed and the new version began failing with this exception.
• The current cache and latest junction both point to 26.707.71524.

Troubleshooting attempted without improvement:

• Fully restarted Codex Desktop.
• Fully restarted Chrome.
• Reinstalled the Codex Chrome extension in Chrome.
• Confirmed the bundled Chrome and Browser plugins remain installed/enabled.
• The Codex plugin UI does not allow the bundled Chrome plugin to be disabled or removed.
• Retested after the above steps; the same exception occurs.

This appears to be a cross-platform compatibility regression in the generated browser client/process shim rather than a Chrome extension, tab, login, or native-host problem. On Windows it prevents all Chrome-backed Codex workflows, so no browser work can proceed.

Could an OpenAI maintainer please confirm whether this is a known regression in 26.707.71524, and advise whether there is a supported workaround, rollback path, or fixed plugin/app version available? This currently blocks all Chrome-dependent work on the affected Windows installation, so a response or recommended recovery procedure would be greatly appreciated.

Independent reproduction on macOS arm64 with Codex Desktop 26.707.71524 (build 5263).

• Importing the app-bundled Chrome client alone fails before browser discovery, extension handshake, or navigation:

/Applications/ChatGPT.app/Contents/Resources/plugins/openai-bundled/plugins/chrome/scripts/browser-client.mjs:33:22
TypeError: Cannot redefine property: process

• The currently cached Chrome client also fails at the same source line. The cached Browser and Chrome clients are byte-identical, so the in-app browser path is affected too.
• This persists with Chrome running and after restarting Chrome, Codex, and the machine.
• A direct assignment to globalThis.process in the ordinary REPL succeeds; the failure appears specifically while the imported module is evaluated in SourceTextModule. That points to a compatibility change in the module sandbox/runtime interaction, rather than Chrome or extension state.

The app-bundled client reproducing the fault means a stale plugin cache alone is not a workaround.

Additional reproduction details from a Chrome-extension setup:

• Codex Desktop: 26.707.71524 (Build 5263)
• Bundled Chrome plugin: 26.707.71524
• Official ChatGPT Chrome extension: 1.2.27203.26575
• Chrome extension is installed, enabled, and registered in the selected Default profile
• Native messaging host manifest is present and matches com.openai.codexextension and the expected extension origin
• Chrome is running

The Chrome plugin still fails during browser-client.mjs import with:

TypeError: Cannot redefine property: process

The failure occurs before agent.browsers.get("extension"), tab enumeration, or any page interaction.

The error persists after:

• fully quitting and reopening Chrome and Codex Desktop
• reinstalling the official Chrome extension
• reinstalling the bundled Chrome plugin
• resetting the Node REPL session

No browsing history, page URL, or authenticated-site state is involved in reproducing the failure.

+1
---
https://chromewebstore.google.com/detail/hehggadaopoacecdllhhajmbjkdcmajg
cannot open it

Independent reproduction on macOS with the same desktop/plugin build.

• ChatGPT Desktop: 26.707.71524
• Bundled Codex CLI: codex-cli 0.144.2
• Chrome plugin: chrome@26.707.71524
• Exact failure: TypeError: Cannot redefine property: process
• Stack location: scripts/browser-client.mjs:33:22

The error occurs during the documented module import, before setupBrowserRuntime, Chrome discovery, extension communication, permission checks, or CDP access.

Also reproduced after:

• Fully restarting ChatGPT Desktop
• Moving the Chrome plugin cache aside and allowing the app to rebuild/restore it
• Retrying in a clean Node REPL session
• Confirming the desktop app reports itself as the latest version

A separate report was initially opened as #32934 before this exact existing issue was found; it is being closed as a duplicate.

downgrading to 26.707.62119 fixes it https://persistent.oaistatic.com/codex-app-prod/ChatGPT-darwin-arm64-26.707.62119.zip

Additional reproduction and root-cause evidence from Codex Desktop / Browser plugin 26.707.71524:

• The import fails consistently at browser-client.mjs:33:22 on the unconditional globalThis.process = processShim assignment.
• Original cached bundle SHA-256: 57ee77a283eb230c6c6d47353af13a25cec4c331b511868c8fbf7ccd3dd1b2f6.
• A minimal experiment that only guards the global assignment moves the failure deeper into the bundle:
• TypeError: Cannot read properties of undefined (reading 'node') from code expecting process.versions.node.
• Providing a module-scoped processShim then exposes TypeError: global.process.on is not a function in the bundled monitoring integration.
• This confirms the Node REPL trusted-module host process is intentionally metadata-only/frozen and cannot safely replace the bundle's full process shim.

Suggested source-level fix:

1. Keep the full process shim module-scoped.
2. Provide a module-scoped CommonJS-compatible global facade whose process points to that shim.
3. Do not mutate globalThis.process or the Node REPL host global.
4. Add a smoke test that imports the built client inside the Node REPL trusted-module context, calls setupBrowserRuntime, and performs in-app browser discovery.

All experimental edits to the cached generated bundle were reverted after diagnosis.

Reproduced in a ChatGPT desktop/Codex task on macOS while trying to use the bundled Browser plugin with an already open Azure session.

Following the documented Browser setup, the runtime fails immediately with:

Cannot redefine property: process

A subsequent check showed no initialized browser binding (hasAgent: false, hasBrowsers: false, browser: false). The failure occurs before browser discovery, tab access, authentication, or navigation, so it blocks browser-assisted work that depends on an existing session. No credentials, cookies, or page contents were inspected.

Impact: unable to help the user access or manage Azure through their open browser session. Please prioritize a compatibility fix between the bundled Browser client and the Node REPL runtime.

Windows reproduction of the same issue:

• Windows 11 Pro (build 26200), codex-cli 0.144.3 installed via npm (latest on the registry as of 2026-07-13).
• Plugin runtime: internal Node v24.14.0 (.cache/codex-runtimes/codex-primary-runtime); system Node v26.4.0 is not involved.
• chrome@openai-bundled auto-updated from 26.707.62119 → 26.707.71524 on 2026-07-13 (~17:41–19:58 local). 26.707.62119 had completed a full browser session successfully on the same machine minutes before the update.
• Since then, every skill load fails during ESM import, before any extension handshake or Chrome interaction:

``
TypeError: Cannot redefine property: process
at ~/.codex/plugins/cache/openai-bundled/chrome/26.707.71524/scripts/browser-client.mjs:33:22
``

Line 33 is globalThis.process = processShim; (line 35 globalThis.global.process = processShim;).

• Tried without success: plugin reinstall, codex update (already latest), fresh processes.
• Not corruption: the versioned and latest cached copies are byte-identical, and the bundle SHA256 matches the trusted hash list (NODE_REPL_TRUSTED_BROWSER_CLIENT_SHA256S) in the local config.
• browser@openai-bundled and computer-use@openai-bundled also jumped to 26.707.71524 in the same auto-update.

Independent reproduction on macOS:

• Codex Desktop: 26.707.71524 (Build 5263)
• Browser and Chrome plugins: 26.707.71524
• Both browser-client.mjs files are byte-identical
• SHA-256: 57ee77a283eb230c6c6d47353af13a25cec4c331b511868c8fbf7ccd3dd1b2f6
• Exact failure: TypeError: Cannot redefine property: process
• Stack location: scripts/browser-client.mjs:33:22

Reproduces after fully restarting Codex, resetting the Node REPL kernel, retrying in the same and fresh runtime state, and testing both the in-app Browser and Chrome integrations. The failure occurs during module import, before browser discovery or extension communication. Codex reports itself as the latest available version.

Independent reproduction from another macOS team:

• Two separate users reproduce the regression with bundled Browser and Chrome plugin 26.707.71524.
• Both integrations fail at browser-client.mjs:33:22 with TypeError: Cannot redefine property: process.
• Fully restarting Codex and retrying from a fresh browser runtime does not help.
• The failure occurs before browser discovery, tab attachment, extension handshake, or authentication, so it is independent of the target website.

Impact: all workflows requiring the in-app browser or an existing signed-in Chrome session are blocked. No cookies, credentials, page content, project names, or target URLs were accessed or included in this reproduction.

was just about to file same bug, yeah crazy that this bug is in release. can't use Codex in Chrome plugin without a patch

Independent Windows reproduction and verified workaround:

• Windows 11 Home, 64-bit, build 26200
• Codex Desktop: 26.707.9564.0
• Chrome plugin bundle: 26.707.71524
• Codex CLI: 0.144.2
• Bundled runtime: Node v24.14.0
• Chrome extension: 1.2.27203.26575
• Original browser-client.mjs SHA-256: 57ee77a283eb230c6c6d47353af13a25cec4c331b511868c8fbf7ccd3dd1b2f6

The import failed consistently at browser-client.mjs:33:22 with TypeError: Cannot redefine property: process. Windows Repair, app restart, and plugin remove/re-add attempts did not change the failure.

A cache-only patch that keeps the shim module-local instead of assigning to protected runtime globals restored initialization:

const process = processShim;
const global = { process: processShim };

After resetting the browser runtime, the Chrome extension connection succeeded and reported connected: true; existing tabs were discoverable. This confirms the failure is in the bundled bootstrap/global collision rather than the Chrome extension handshake or website state.

No account identifiers, local usernames, task IDs, URLs, credentials, cookies, or browsing data are included.

Independent reproduction on Codex app 26.707.71524 / bundled Chrome plugin 26.707.71524:

• Previous bundled version 26.707.62119 worked in the same workflow.
• Current module fails at ESM evaluation on globalThis.process = processShim.
• Exact error: TypeError: Cannot redefine property: process.
• Reproduces after browser runtime reset and in a fresh Codex JavaScript runtime.
• Failure occurs before setupBrowserRuntime, browser discovery, extension/native-host communication, tab inspection, authentication, or prompt submission.
• Reinstalling the same bundled version is unlikely to change the result because the cached source contains the same unconditional assignment.
• No vendor source was modified and no alternate browser automation was used.

I initially filed #32946 before discovering this report; #32946 has been closed as a duplicate so tracking remains consolidated here.

Independent macOS reproduction — please prioritize a signed fix or rollback.

• ChatGPT/Codex Desktop: 26.707.71524, build 5263.
• Chrome and Browser control fail at browser-client.mjs:33 when the client assigns to globalThis.process. The failure occurs before tab discovery, extension/native-host handshake, authentication, or website access.
• The previous 26.707.62119 release reached browser-backend ready on the same Mac. Restarting or reinstalling reloads the same incompatible 26.707.71524 artifact.
• A cache-only lexical-shim workaround restores Chrome control, confirming the regression is in the shipped browser-client and Node REPL integration, not the Chrome extension.

This blocks paid users signed-in Chrome workflows. Please ship a signed compatible fix or rollback; end users should not need to patch bundled cache files.

Independent reproduction confirmed on macOS.

Environment:

• macOS: 26.5 (25F71)
• ChatGPT Desktop: 26.707.71524 (Build 5263)
• Google Chrome: 150.0.7871.114
• Bundled Chrome plugin: 26.707.71524
• Bundled Browser plugin: 26.707.71524

Both bundled browser-client.mjs files are byte-identical:

SHA-256: 57ee77a283eb230c6c6d47353af13a25cec4c331b511868c8fbf7ccd3dd1b2f6

Exact failure:

TypeError: Cannot redefine property: process
    at browser-client.mjs:33:22

Observed behavior:

• Both the Chrome plugin and the built-in Browser plugin fail during module initialization.
• The failure occurs before browser discovery, tab attachment, extension communication, page navigation, or authentication.
• Google Chrome is running, and the ChatGPT Chrome Extension is installed and enabled in the selected profile.
• Fully restarting ChatGPT/Codex, reinstalling the plugin, and retrying from a clean JavaScript runtime do not resolve the issue.
• The same browser workflows worked before the 26.707.71524 update.

Additional diagnostic:

• The same browser-client.mjs imports successfully under ordinary Node.js v22.14.0.
• It fails only inside the current Codex runtime, where process is protected/non-configurable while the bundled browser client attempts to overwrite it.

Impact:
All workflows requiring the signed-in Chrome session or the built-in Browser are blocked.

I have not modified the bundled plugin files or applied the unofficial cache patch.

Reproduced this on macOS arm64 with Node v22.22.0, using the cached bundle at ~/.codex/plugins/cache/openai-bundled/browser/26.707.71524/scripts/browser-client.mjs.

Root cause: the bundle has a prelude (before the minified code) that unconditionally overwrites the process global at import time:

globalThis.process = processShim;
globalThis.global = globalThis.global ?? globalThis;
globalThis.global.process = processShim;

What I observed:

• In plain node, the import succeeds but silently replaces the real process — after import, process.pid is 0, process.env is empty, and process.version reports "v20.0.0". So it corrupts the runtime even where it doesn't throw.
• If process is read-only on the global, import throws TypeError: Cannot assign to read only property 'process'.
• In a vm/contextify sandbox with a non-configurable process (which matches the Codex Desktop REPL), running the prelude throws the exact error from this issue: TypeError: Cannot redefine property: process.

This looks like a browser-platform process polyfill banner applied to a Node-targeted build. Guarding it with if (typeof globalThis.process === "undefined") { ... } (or dropping the shim for the Node target) should fix it.

Local workaround until then: edit the cached browser-client.mjs and wrap the three assignment lines above in that same guard.

I can reproduce this regression on macOS.

On the same machine, Chrome plugin 26.707.31428 initialized successfully on 2026-07-10. After updating to 26.707.71524 (ChatGPT/Codex Desktop build 5263), the import fails at browser-client.mjs:33:22 with:

TypeError: Cannot redefine property: process

The failure happens before setupBrowserRuntime, browser discovery, or the Chrome extension/native-host handshake. This confirms a regression in the bundled browser-client / Node REPL integration rather than Chrome profile or extension state.

A source-level fix should keep the full process shim module-scoped, provide bundled CommonJS dependencies with a module-scoped global.process facade, and avoid mutating the protected host globalThis.process. A regression test should import the built client inside the trusted Node REPL module context and verify that setupBrowserRuntime reaches browser discovery.

I'm willing to contribute the source-level fix and regression test. If an external contribution would be useful, please point me to the relevant source location and explicitly invite a PR.

Adding a Windows reproduction of this exact regression.

Environment:

• Windows 11 x64
• Codex desktop Microsoft Store package: OpenAI.Codex 26.707.9564.0
• Bundled Chrome plugin: 26.707.71524
• ChatGPT Chrome extension: 1.2.27203.26575
• Google Chrome, signed-in work profile

Observed failure:

TypeError: Cannot redefine property: process

The exception occurs while importing the bundled scripts/browser-client.mjs, before setupBrowserRuntime, Chrome tab discovery, or website interaction.

Chrome-side verification completed successfully:

• ChatGPT extension installed and enabled
• Extension pinned to the toolbar
• Site access set to On all sites
• Permission to communicate with cooperating native applications present
• Chrome running in the intended profile

Troubleshooting completed with no change:

1. Restarted Windows, Chrome, and Codex multiple times.
2. Stopped the Chrome extension-host.exe native helper.
3. Removed the entire cached openai-bundled/chrome plugin directory while the native host was stopped.
4. Restarted Codex and confirmed it downloaded a clean copy of plugin 26.707.71524.
5. Retried from a fresh JavaScript kernel.
6. The newly downloaded copy immediately produced the same Cannot redefine property: process error.

This confirms the failure is reproducible on Windows and is not caused by Chrome permissions, profile state, website authentication, or a stale plugin cache. The generated client attempts to install its process shim into a runtime where process is already protected/non-configurable.

Confirmed on Windows x64 as well.

Environment

• Codex Desktop package: OpenAI.Codex_26.707.9564.0_x64
• Browser plugin: 26.707.71524
• Windows: 25H2, build 26200.8655, x64
• browser-client.mjs SHA-256: 57EE77A283EB230C6C6D47353AF13A25CEC4C331B511868C8FBF7CCD3DD1B2F6

Minimal reproduction

1. Reset the Node REPL kernel to a clean state.
2. Before import, Object.getOwnPropertyDescriptor(globalThis, "process") returns undefined, and globalThis.agent?.browsers is absent.
3. Import the bundled client from:

%USERPROFILE%\.codex\plugins\cache\openai-bundled\browser\26.707.71524\scripts\browser-client.mjs

1. The module import immediately fails:

TypeError: Cannot redefine property: process
    at ...\browser-client.mjs:33:22
    at SourceTextModule.evaluate (node:internal/vm/module:233:26)

The local bundle's line 33 is:

globalThis.process = processShim;

The Node REPL itself is healthy: minimal JavaScript calls succeed. Resetting the kernel and retrying from a clean state reproduces the same error. The failure happens before setupBrowserRuntime, browser discovery, URL navigation, or application code. Standalone Playwright against the same local target works normally.

This confirms the 26.707.71524 plugin/runtime compatibility regression is cross-platform and is not the older Windows sandbox/helper-binary failure family.

Independent reproduction on macOS with the bundled Chrome plugin 26.707.71524.

The supported bootstrap import fails immediately with:

TypeError: Cannot redefine property: process
    at ~/.codex/plugins/cache/openai-bundled/chrome/26.707.71524/scripts/browser-client.mjs:33:22

This occurs before browser discovery, extension handshake, tab inspection, or any target-site interaction. The same task previously worked with the earlier bundled plugin version 26.707.62119.

Recovery attempts made with no change:

• reset the managed JavaScript kernel
• fully restart Codex Desktop
• reinstall/re-enable the Chrome integration
• retry from a fresh task
• repeat the exact supported setupBrowserRuntime({ globals: globalThis }) bootstrap

The open Chrome tab and its signed-in state remain intact, but Codex cannot attach to it. No account identifiers, URLs, cookies, authentication details, or payment information are included in this reproduction.

Seeing the same issue with both the built-in Browser and Chrome plugins on Windows.

• Windows 11 Pro 24H2, build 26100.3775, x64
• Codex Desktop 26.707.71524
• Browser plugin 26.707.71524
• Chrome plugin 26.707.71524
• Bundled Codex CLI 0.144.2

Importing the bundled client fails immediately:
TypeError: Cannot redefine property: process
at browser-client.mjs:33:22
at SourceTextModule.evaluate (node:internal/vm/module:233:26)

The desktop logs show browser_use_iab_backend_startup_ready before the Browser import fails, so the in-app browser backend is running. The failure happens while loading browser-client.mjs, before setupBrowserRuntime, browser discovery, extension communication, or navigation.

Resetting the JavaScript kernel and trying again gives the same result with both plugins. Their browser-client.mjs files are byte-identical and have the same SHA-256:
57EE77A283EB230C6C6D47353AF13A25CEC4C331B511868C8FBF7CCD3DD1B2F6

macOS: 26.5.2 (25F84)
ChatGPT: 26.707.71524
Chrome: 150.0.7871.115 (Official Build) (arm64)
Extension: 1.2.27203.26575

too

Independent reproduction with one additional diagnostic that may help narrow the fix.

Environment

• macOS 26.5.2 (build 25F84), Apple Silicon / arm64
• ChatGPT/Codex Desktop 26.707.71524 (build 5263)
• Bundled Browser plugin 26.707.71524
• browser-client.mjs SHA-256: 57ee77a283eb230c6c6d47353af13a25cec4c331b511868c8fbf7ccd3dd1b2f6

Result
The supported Browser bootstrap fails with:

Cannot redefine property: process

I reproduced it in both:

1. The normal managed node_repl runtime.
2. The runtime's documented node_repl --disable-sandbox direct-kernel diagnostic mode.

The direct-kernel mode reaches the same failure, so the additional sandbox launcher is not the cause. Restarting, changing the agent model, and using a fresh ephemeral task do not change the result.

Read-only inspection shows the bundled runtime installs its trusted process facade using a non-writable, non-configurable property, while the bundled Browser client then attempts:

globalThis.process = processShim;
globalThis.global = globalThis.global ?? globalThis;
globalThis.global.process = processShim;

This fails before an in-app Browser binding can be established or any page can be opened. No target website, login state, cookies, or application data are involved.

No local patch or trusted-hash change was applied because that would weaken the intended trusted Browser boundary. An upstream bundle/runtime compatibility fix is required.

Reproduced on Codex Desktop 26.707.9564.0 (Windows x64) with the bundled Chrome controller 26.707.71524.

The supported bootstrap fails consistently, including in a clean runtime, before Chrome discovery:

Cannot redefine property: process

Chrome is running, the extension is enabled, and the native-host checks pass.

Feedback ID: 019f5f72-e552-7a80-b2a0-703576341be1

Additional macOS reproduction (2026-07-14):

This reproduces on a separate Apple Silicon Mac before any Chrome tab, site, login, or extension handshake is accessed.

Environment (redacted of serials/account data):

• ChatGPT/Codex Desktop: 26.707.71524 (build 5263)
• Bundled Chrome plugin: 26.707.71524
• macOS 15.6.1 (Darwin 24.6.0, arm64), Apple M4 Pro, 48 GB RAM
• Google Chrome: 150.0.7871.115
• Node REPL runtime: v22.16.0

Fresh Node REPL reproduction:

await import("~/.codex/plugins/cache/openai-bundled/chrome/26.707.71524/scripts/browser-client.mjs");

Result:

TypeError: Cannot redefine property: process
    at ~/.codex/plugins/cache/openai-bundled/chrome/26.707.71524/scripts/browser-client.mjs:33:22
    at SourceTextModule.evaluate (node:internal/vm/module:233:26)
    at importResolved (.../kernel.js:905:27)
    at process.processTicksAndRejections (node:internal/process/task_queues:104:5)

Resetting the JS kernel and repeating the import produces the same result. This blocks Chrome Use entirely; the browser is never selected and no Jimeng/website action is attempted.

Separate user-impact note: after recent desktop updates, the user reports Chrome Use and Computer Use becoming unavailable frequently. I do not have a matching Computer Use stack trace in this report, so please treat that as a correlated reliability report rather than evidence of the same root cause. The reproducible Chrome bootstrap regression above is confirmed.

Product feedback / request for regression coverage:

Recent desktop updates have repeatedly made Chrome Use and Computer Use unavailable or unreliable in normal workflows. In this report, the Chrome failure is directly reproducible at bootstrap; separately, the user frequently experiences Computer Use failures after updates as well.

Please strengthen release-gating regression coverage across both surfaces, especially:

1. Fresh-task bootstrap for the bundled Chrome plugin and the in-app Browser/Computer Use runtime on macOS Apple Silicon and Windows.
2. A protected/non-configurable globalThis.process case in the Node REPL, so generated browser clients cannot fail before backend discovery.
3. End-to-end smoke tests that verify Chrome extension discovery, tab claim, basic read action, click/type, and local-file upload permission handling.
4. Computer Use smoke tests that verify the desktop-control session remains available after an app update and can complete a minimal visible interaction.
5. Upgrade-to-upgrade compatibility tests: an existing installation with an enabled plugin/extension should keep working after the desktop app updates, rather than only clean-install coverage.
6. Clear diagnostics that distinguish bootstrap/runtime regressions from login, website permission, extension, or user-profile failures.

The current issue is a high-impact regression because it blocks the only approved workflow for signed-in Chrome tasks before any browser action can begin.

Independent reproduction on macOS 26.5.1 (Build 25F80), arm64.

• ChatGPT/Codex Desktop: 26.707.71524 (Build 5263)
• Bundled Browser plugin: 26.707.71524
• Error: TypeError: Cannot redefine property: process
• Location: browser-client.mjs:33:22

The failure occurs before in-app browser discovery or page attachment. Restarting Codex, confirming the app is up to date, moving the Browser plugin cache aside, and allowing it to regenerate did not resolve the issue. The regenerated bundle remains version 26.707.71524 and fails identically.

Confirming this regression on Windows.

• Codex app package: 26.707.9564.0
• Chrome plugin: 26.707.71524
• Codex CLI: 0.144.2

The import fails at browser-client.mjs:33:

globalThis.process = processShim;

Codex’s trusted runtime already defines process as non-writable and non-configurable, so this assignment throws:

TypeError: Cannot redefine property: process

The error occurs before any Chrome-extension handshake and persists after restarting Codex, restarting Windows, and resetting the JavaScript kernel.

Confirmed on Windows x64.

My ChatGPT/Codex Desktop app version is 26.707.9564, and the bundled Chrome/Browser plugin version is 26.707.71524.

Both the Chrome plugin and the in-app Browser fail before any browser connection or tab discovery with:

TypeError: Cannot redefine property: process

The failure occurs when importing the bundled browser-client.mjs, so this is not caused by a Chrome profile, extension permissions, or a website.

I reproduced it after:

• restarting Codex and Chrome;
• rebooting Windows;
• reinstalling/reconnecting the Chrome plugin;
• reinstalling the Chrome extension;
• starting a fresh Codex task.

Independent macOS reproduction with a minimized runtime comparison.

Environment

• ChatGPT/Codex Desktop: 26.707.71524 (Build 5263)
• Bundled Codex CLI: 0.144.2
• macOS 27.0 (Build 26A5378n), Apple Silicon / arm64
• Bundled Browser and Chrome plugins: 26.707.71524
• Both browser-client.mjs files are byte-identical:

57ee77a283eb230c6c6d47353af13a25cec4c331b511868c8fbf7ccd3dd1b2f6

Observed failure

The supported import fails deterministically before browser discovery:

TypeError: Cannot redefine property: process
    at .../browser-client.mjs:33:22
    at SourceTextModule.evaluate (node:internal/vm/module:233:26)

The failing statement is:

globalThis.process = processShim;

This occurs before setupBrowserRuntime, agent.browsers.get(...), Chrome-extension/native-host handshake, tab inspection, navigation, or any website/login state.

Controls and recovery attempts

• Chrome is running.
• The ChatGPT Chrome Extension is installed and enabled in the selected Default profile.
• The native-host manifest exists and matches the expected extension origin.
• Fully quit and restarted the app.
• Reinstalled the Chrome plugin.
• Reset the managed JavaScript runtime.
• Opened a fresh blank Chrome window and retried.
• The failure remained unchanged.

A useful differential: the same bundled file imports successfully under standalone system Node v26.0.0, but fails in Codex's trusted SourceTextModule context. Read-only inspection shows that the trusted Codex runtime installs its process facade as non-writable and non-configurable, while the generated browser client unconditionally tries to replace it. This confirms the failure is at the bundled client/runtime boundary, not in Chrome or the target website.

No local source patch, trusted-hash change, account data, cookies, or target-site information was used or included.

Adding another Windows reproduction with an exact Microsoft Store upgrade boundary and target-isolation check.

Environment

• Windows x64
• Current Microsoft Store package: OpenAI.Codex_26.707.9564.0_x64__2p2nqsd0c76g0
• Previous package: OpenAI.Codex_26.707.8479.0_x64__2p2nqsd0c76g0
• Bundled in-app Browser plugin: 26.707.71524
• Affected surface: ChatGPT/Codex built-in Browser, not Chrome

Verified upgrade boundary

Windows deployment logs record the following package transition on July 14, 2026:

• 26.707.8479.0 was removed.
• 26.707.9564.0 was registered immediately afterward.

Built-in Browser control worked before the update and failed afterward.

Current failure

Importing the unmodified bundled Browser client from a fresh runtime fails immediately:

TypeError: Cannot redefine property: process
    at %USERPROFILE%\.codex\plugins\cache\openai-bundled\browser\26.707.71524\scripts\browser-client.mjs:33:22
    at SourceTextModule.evaluate

The failing source line is:

globalThis.process = processShim;

The failure occurs before setupBrowserRuntime, Browser discovery, tab creation or navigation. Repeating from a clean runtime produces the same error.

Target-isolation check

The intended local application at http://127.0.0.1:4173/ independently returns HTTP 200.

The Browser crashes before accessing that URL or any other URL. Therefore, the failure is not caused by the website, localhost permissions, page authentication or application code.

No Browser plugin files were modified, and no unsupported package rollback was attempted.

Expected result

The trusted bundled Browser client should load without replacing the runtime’s protected process value, then proceed to in-app Browser discovery and tab control.

This regression currently blocks required end-to-end Browser QA on Windows.

Additional Windows reproduction with an RDP/session differential and a clean-runtime control.

Environment:

• Windows x64, build 10.0.26200
• Codex App: 26.707.9564.0
• bundled Chrome plugin: 26.707.71524
• bundled Node: v24.14.0
• browser-client.mjs SHA-256: 57ee77a283eb230c6c6d47353af13a25cec4c331b511868c8fbf7ccd3dd1b2f6

Controls:

• Codex, helper, Chrome, extension host, and node_repl were all in the same active RDP session (WTSActive, protocol 2, WinSta0\\Default). The physical console had a different SessionId, which is normal for RDP and was not used as a readiness criterion.
• A full Codex App relaunch recreated node_repl. A single minimal JS smoke call then passed in 160 ms, proving the MCP transport and Node kernel were healthy.
• The first and only supported Chrome bootstrap still failed during module import, before setupBrowserRuntime, extension binding, tab discovery, or any website action:

TypeError: Cannot redefine property: process
at browser-client.mjs:33:22

The official skill call is correct:

const { setupBrowserRuntime } = await import("<plugin>/scripts/browser-client.mjs");
await setupBrowserRuntime({ globals: globalThis });

Static and isolated-process checks:

• line 33 unconditionally executes globalThis.process = processShim;
• the standalone bundled Node exposes globalThis.process as a configurable getter and imports the file;
• an isolated protected-getter realm reproduces the failure at exactly line 33;
• latest and the installed skill both resolve to 26.707.71524, so reinstalling the same version cannot change the result.

This confirms the failure is at the generated browser-client/trusted-runtime boundary, independent of RDP, Chrome permissions, login state, or target URL. A regression test should cover importing the generated client when globalThis.process is protected. The client should keep the shim lexical or conditionally preserve the runtime-owned property instead of overwriting it. No local bundle patch was applied in this reproduction.

<img width="480" height="455" alt="Image" src="https://github.com/user-attachments/assets/3931db82-5810-4693-8011-96d342a72e4b" />

this new update fix this issue

Still reproducible on a newer ChatGPT desktop build:

• ChatGPT app: 26.707.72221 (build 5307)
• Bundled Codex CLI: 0.144.2
• macOS / Apple Silicon
• Cached Chrome browser client: ~/.codex/plugins/cache/openai-bundled/chrome/26.707.51957/scripts/browser-client.mjs

The in-app browser itself opens http://127.0.0.1:8000/ and renders correctly when operated manually. Agent control fails before browser discovery while importing the bundled client:

TypeError: Cannot redefine property: process
    at .../scripts/browser-client.mjs:33:22
    at SourceTextModule.evaluate (node:internal/vm/module:233:26)

The failing module lines assign the process shim through both globalThis.process and globalThis.global.process. Resetting the Node-backed JavaScript kernel and retrying produces the same error. This confirms the regression affects agent-to-browser control, not the browser UI or target localhost app.

Thanks for the bug reports. We've published an updated version (26.707.72221) that addresses this problem.

This issue is closed, but I am still experiencing the same issues on

• ChatGPT app: 26.707.72221
• Bundled Codex CLI: 0.144.2
• macOS / Apple Silicon

If you're still seeing this with 26.707.72221, you may need to quit and restart the app to update the plugin.

I uninstalled and re-installed the plugins, rebooted... no avail.

If you're able to share /feedback, we can take a look and see what might be wrong

Done, 019f61b9-e2c3-7463-84b1-8ef83806f1e3

Thank you

Looking into why this may have happened to you, but in the meantime, deleting (or asking codex to delete) ~/.codex/plugins/cache/openai-bundled/browser/26.623.141536/ and restarting codex should help -- looks like an outdated browser plugin sticking around

Feedback ID: 019f5e36-bb0a-78f3-9128-f5a04e1f6312

Still reproducible on macOS / Apple Silicon after the ChatGPT app reports 26.707.72221 (build 5307) as the newest available.

The app-bundled Chrome client now works when loaded explicitly, but the normal openai-bundled marketplace snapshot still advertises only chrome@26.707.51957. Deleting its cache directory causes Codex to recreate that same version; a clean standard bootstrap of the recreated cached client still fails at browser-client.mjs:33 with Cannot redefine property: process.

This appears to be a stale bundled-marketplace snapshot rather than a browser, extension, or app-update problem.

I can confirm it is fixed, at least it can control Chrome now.

Btw, because of this issue, I tried to have the model review the .mjs file: Review the .mjs file from your "Chrome Control/Browser Use" skill., but it was blocked by the security policy (It thinks I'm conducting cybersecurity research but I'm just an end user).

I only want to review a file that already exists on my local machine, as a user, to check whether it poses any supply chain security risks, or any other bugs. I'm not sure I understand why this is being blocked.

Codex Chrome Plugin Repair Guide

Overview

This document summarizes a successful repair of the bundled Chrome plugin in the Codex desktop application. The failure occurred when newly created tasks could not load the Chrome control skill, even though the Chrome extension itself was installed and enabled.

The main lesson is that a damaged plugin cache may be only a symptom. Codex can repeatedly rebuild that cache from an outdated bundled marketplace copy, so the entire plugin loading chain must be inspected.

Observed Symptoms

• Newly created tasks did not include the chrome:control-chrome skill.
• Only generic tools such as node_repl were available.
• Reloading bundled plugins did not resolve the issue.
• Restarting Codex did not initially resolve the issue.
• The Chrome extension appeared installed and enabled.

Root Cause

Several Codex plugin layers were out of sync:

• The current Codex application bundled Chrome plugin version was 26.707.72221.
• The temporary bundled marketplace still contained version 26.707.62119.
• The installed plugin cache was therefore repeatedly rebuilt as version 26.707.62119.
• The latest directory junction continued to point to the old cache directory.
• An old extension-host process remained alive across a Codex restart and continued using the old path.

The original cache had also been incomplete and was missing a valid .codex-plugin/plugin.json. Repairing that file alone was insufficient because Codex continued sourcing the plugin from the stale marketplace copy.

Component Model

The relevant loading chain is:

Codex task
  -> chrome:control-chrome skill
  -> node_repl
  -> browser-client.mjs
  -> extension-host
  -> Chrome native messaging
  -> Chrome extension

Each layer must reference a compatible and current plugin installation.

Modern versions of the bundled Chrome plugin may use a skill plus node_repl rather than exposing a separate Chrome MCP server. Therefore, the absence of a server_name=chrome entry is not sufficient evidence of failure. The decisive signal is whether a newly created task receives the chrome:control-chrome skill and can establish a real browser connection.

Diagnostic Procedure

1. Verify the Chrome extension

Confirm that:

• The expected extension ID is installed.
• The extension is enabled in the intended Chrome profile.
• Chrome preferences contain the extension registration.
• The installed extension version is visible.

If these checks pass, do not assume the browser extension is the source of the problem.

2. Verify native messaging

Check both:

• The Windows registry entry under Chrome native messaging hosts.
• The corresponding native messaging manifest file.

The manifest should contain:

• The correct native host name.
• The expected extension origin.
• A path to extension-host.exe through the plugin's latest directory.

3. Inspect Codex plugin loader logs

Look for messages such as:

failed to load plugin: missing or invalid plugin.json

Record the exact plugin ID and cache path shown in the log. This establishes which cache directory Codex is actually trying to load.

4. Compare all plugin versions

Compare the manifests in these locations:

Codex application resources
Codex temporary bundled marketplace
Codex plugin cache
Codex plugin cache latest junction

The application resource version is the reference version. If the temporary marketplace is older, cache reloads will continue reproducing the old installation.

5. Inspect the running extension host

Check whether extension-host is still running and determine which plugin path it uses. A surviving old process can keep the old junction or binaries in use even after Codex restarts.

Repair Procedure

1. Preserve rollback copies

Before changing plugin state, back up:

• The damaged plugin cache.
• The stale temporary marketplace plugin directories.

Keep these backups until an end-to-end browser test succeeds.

2. Replace stale marketplace content

Replace the outdated temporary marketplace copies of the affected bundled plugins with the versions shipped in the current Codex application resources.

The related components may include:

• browser
• chrome
• computer-use

This corrects the source from which Codex rebuilds its cache.

3. Restart Codex

Fully exit and reopen Codex after replacing the stale marketplace content. Then verify that Codex creates a cache directory matching the current bundled plugin version.

4. Stop the old extension host

If an old extension-host process is still running, stop it before changing the latest directory junction.

5. Update the latest junction

Point the plugin's latest junction to the current version directory.

On Windows PowerShell 5.1, Remove-Item may fail when removing a directory junction and can produce a null-reference error. A safe alternative is to remove only the junction with the .NET directory API, after validating the absolute path and confirming that the target is a junction:

[System.IO.Directory]::Delete($latest, $false)

The second argument must remain false so that the operation removes the junction itself rather than recursively deleting the target directory.

6. Reinstall the native host manifest

Run the current plugin's official installManifest.mjs script with the active Codex, Node.js, and Node REPL runtime paths.

This updates:

• The native messaging manifest.
• The Windows registry entry.
• extension-host-config.json.

7. Run the bundled verification scripts

Use the plugin's official checks to confirm:

• The Chrome extension is installed and enabled.
• The native host registry entry exists.
• The manifest path is correct.
• The allowed extension origin is correct.

End-to-End Verification

File and registry checks are necessary but not sufficient. The final test must reproduce the original user workflow:

1. Create a completely new Codex task.
2. Explicitly select or reference the bundled Chrome plugin.
3. Confirm that the task loads chrome:control-chrome from the current version directory.
4. Establish a real Chrome session.
5. Open a harmless test page.
6. Read the actual page title and URL.

The issue is resolved only when this complete workflow succeeds. A repaired directory tree alone does not prove that task-level plugin injection is working.

What Did Not Solve the Problem

The following actions were insufficient by themselves:

• Restarting Chrome.
• Restarting Codex before correcting the stale marketplace copy.
• Reinstalling or verifying only the Chrome extension.
• Restoring the missing plugin manifest in the old cache.
• Reloading bundled plugins while the bundled marketplace source remained outdated.
• Creating a new latest junction before correcting the source version and stopping the old extension host.

Operational Lessons

1. Trace the complete data flow instead of repairing only the first broken file.
2. Treat the bundled marketplace as the cache source of truth used by Codex during reconciliation.
3. Compare explicit version numbers at every layer.
4. Check for long-lived helper processes after application restarts.
5. Do not use MCP server count alone to determine Chrome skill availability.
6. Keep rollback backups until an end-to-end task succeeds.
7. Verify the original user-visible behavior before declaring the repair complete.
8. Delete repair backups only after the current version has passed a real browser-control test.

Quick Troubleshooting Checklist

• [ ] Chrome extension is installed and enabled.
• [ ] Native messaging registry entry exists.
• [ ] Native messaging manifest is correct.
• [ ] .codex-plugin/plugin.json exists and is valid.
• [ ] Application resource version is identified.
• [ ] Temporary bundled marketplace version matches the application version.
• [ ] Plugin cache contains the current version.
• [ ] latest points to the current version directory.
• [ ] No old extension-host process remains active.
• [ ] Official manifest installation completes successfully.
• [ ] Official extension and native-host checks pass.
• [ ] A newly created task loads chrome:control-chrome.
• [ ] A real Chrome navigation test succeeds.

This is still a problem. MacOS, ChatGPT/Codex Desktop 26.715.31925. After removing both Chrome/Browser plugins/directories and reinstalling I get version 26.707.51957 of Chrome/Browser plugin. I patched the code as described above and then it works.

This is still reproducible on Windows with a newer Codex Desktop build.

Environment:

• Windows x64
• Codex Desktop: 26.715.4045.0
• Installed bundled Chrome/Browser plugin: 26.623.141536
• chrome/latest still resolves to 26.623.141536

From a fresh browser-control runtime, importing the bundled client fails immediately with:

TypeError: Cannot redefine property: process
at browser-client.mjs:33:22

The failing statement is:

globalThis.process = processShim;

Resetting the browser-control runtime and retrying produces the same result. The failure occurs before the in-app Browser can enumerate or access any tabs.

Although this issue was marked completed after 26.707.72221, the newer desktop app is still resolving an outdated bundled plugin. This may be related to the stale managed marketplace/cache behavior reported in #33738:

https://github.com/openai/codex/issues/33738

Could this issue be reopened, or could you point us to the current tracking issue for the stale bundled-plugin update problem?

Update: I submitted in-app feedback with the conversation diagnostics.

Feedback ID: 019f7748-53cb-78f3-80e0-ec9225d47b9b

Please associate this feedback with the issue.