fix: restore upstream Chrome host compatibility (#71)

Author: cau1k

runtime/webstrap/server.mjs

@@ -536,6 +536,7 @@ const appHostMain = {
   services: {
     appUpdates: {
       setSparkleQueryParams() {},
+      checkForUpdates() {},
       installUpdate() {},
       stateChanged(callback) {
         appUpdateSubscribers.add(callback);
@@ -546,6 +547,14 @@ const appHostMain = {
           appUpdateSubscribers.delete(callback);
         };
       }
+    },
+    // The browser shell has no desktop auto-resolution scheduler. Upstream
+    // still reports renderer presentation/activity state through this service.
+    requestUserInputAutoResolution: {
+      setDisabled() {},
+      snooze() {},
+      setConversationPresented() {},
+      recordConversationActivity() {}
     }
   }
 };

scripts/lib/chrome-extension-patches.mjs

@@ -4,22 +4,23 @@ import { CHROME_EXTENSION_HOST_CONTENT_VARIANT } from "./chrome-extension-consta
 
 const contractName = "Chrome plugin content-variant";
 const materializerSignals = [
-  ".browserSkillVariant",
-  ".computerUseSkillVariant",
-  ".pluginRoot",
-  ".codex-plugin"
+  ".codex-plugin",
+  "plugin.json"
 ];
 
 export const linuxChromeExtensionHostContentVariantContract = {
   name: "linux-chrome-extension-host-content-variant",
   find: findContentVariantContract,
   assertBefore(source) {
     const match = findContentVariantContract(source);
-    if (match.status !== "patch") throw new Error("Linux Chrome content variant is already present");
+    if (match.status !== "patch") {
+      throw new Error("Linux Chrome content variant does not require patching");
+    }
   },
   apply: patchLinuxChromeExtensionHostContentVariant,
   assertAfter(source) {
-    if (!hasLinuxChromeExtensionHostContentVariant(source)) {
+    const match = findContentVariantContract(source);
+    if (!["patched", "absent"].includes(match.status)) {
       throw new Error("Linux Chrome content variant was not applied");
     }
   }
@@ -29,7 +30,7 @@ function findContentVariantContract(source) {
   if (hasLinuxChromeExtensionHostContentVariant(source)) {
     return { status: "patched" };
   }
-  return { status: "patch", ...findContentVariantMaterializer(source) };
+  return findContentVariantMaterializer(source);
 }
 
 /**
@@ -42,6 +43,10 @@ export function patchLinuxChromeExtensionHostContentVariant(source) {
 
   try {
     const match = findContentVariantMaterializer(source);
+    // Newer upstream builds materialize only computer-use and visualize here.
+    // Chrome's manifest is stamped directly in chrome-plugin-patches.mjs.
+    if (match.status === "absent") return source;
+
     const variantName = source.slice(match.property.value.start, match.property.value.end);
     const replacement =
       `${match.pluginParameter}.pluginName===\`chrome\`?` +
@@ -84,9 +89,20 @@ function findContentVariantMaterializer(source) {
     if (!fn || pluginParameter?.type !== "Identifier") return;
 
     const functionSource = source.slice(fn.start, fn.end);
-    if (!materializerSignals.every(signal => functionSource.includes(signal))) return;
+    const pluginParameterSignals = [
+      `${pluginParameter.name}.pluginName`,
+      `${pluginParameter.name}.pluginRoot`
+    ];
+    if (
+      ![...materializerSignals, ...pluginParameterSignals].every(signal =>
+        functionSource.includes(signal)
+      )
+    ) {
+      return;
+    }
 
     matches.push({
+      functionSource,
       property: node,
       pluginParameter: pluginParameter.name
     });
@@ -96,7 +112,50 @@ function findContentVariantMaterializer(source) {
     throw contractError(`expected one runtime materializer, found ${matches.length}`);
   }
 
-  return matches[0];
+  const [match] = matches;
+  if (
+    referencesParameterProperty(
+      match.functionSource,
+      match.pluginParameter,
+      "browserSkillVariant"
+    ) ||
+    hasPluginNameBranch(match.functionSource, match.pluginParameter, "chrome")
+  ) {
+    return { status: "patch", ...match };
+  }
+
+  if (isKnownNonChromeMaterializer(match.functionSource, match.pluginParameter)) {
+    return { status: "absent", ...match };
+  }
+
+  throw contractError("runtime materializer does not prove whether Chrome is handled");
+}
+
+function isKnownNonChromeMaterializer(functionSource, pluginParameter) {
+  return (
+    referencesParameterProperty(
+      functionSource,
+      pluginParameter,
+      "computerUseSkillVariant"
+    ) &&
+    referencesParameterProperty(
+      functionSource,
+      pluginParameter,
+      "liveVisualizationSkillVariant"
+    ) &&
+    hasPluginNameBranch(functionSource, pluginParameter, "computer-use") &&
+    hasPluginNameBranch(functionSource, pluginParameter, "visualize")
+  );
+}
+
+function referencesParameterProperty(source, parameterName, propertyName) {
+  return source.includes(`${parameterName}.${propertyName}`);
+}
+
+function hasPluginNameBranch(source, parameterName, pluginName) {
+  return ["`", '"', "'"].some(quote =>
+    source.includes(`${parameterName}.pluginName===${quote}${pluginName}${quote}`)
+  );
 }
 
 function isBundledContentVariantProperty(node) {

scripts/lib/chrome-extension-smoke.mjs

@@ -3,7 +3,10 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { CHROME_EXTENSION_HOST_ARCH } from "./chrome-extension-constants.mjs";
+import {
+  CHROME_EXTENSION_HOST_ARCH,
+  CHROME_EXTENSION_HOST_CONTENT_VARIANT
+} from "./chrome-extension-constants.mjs";
 import { chromePluginRoot } from "./chrome-extension-host.mjs";
 import { projectRoot } from "./config.mjs";
 
@@ -22,18 +25,28 @@ export async function assertLinuxChromeExtensionHost(resourcesDir, channelName)
     CHROME_EXTENSION_HOST_ARCH,
     "extension-host"
   );
+  const pluginManifestPath = path.join(pluginRoot, ".codex-plugin", "plugin.json");
 
   await fs.access(hostPath).catch(error => {
     throw new Error(`Missing Chrome extension host: ${hostPath}`, { cause: error });
   });
-  const [stat, fileType] = await Promise.all([
+  const [stat, fileType, pluginManifestSource] = await Promise.all([
     fs.stat(hostPath),
-    runFileType(hostPath)
+    runFileType(hostPath),
+    fs.readFile(pluginManifestPath, "utf8")
   ]);
   const artifact = evaluateLinuxChromeExtensionHostArtifact({
     fileType,
     mode: stat.mode & 0o777
   });
+  let pluginManifest;
+  try {
+    pluginManifest = evaluateLinuxChromePluginManifest(JSON.parse(pluginManifestSource));
+  } catch (error) {
+    throw new Error(`Invalid packaged Chrome plugin manifest: ${pluginManifestPath}`, {
+      cause: error
+    });
+  }
   const protocol = await smokeLinuxChromeExtensionHostProtocol({
     channelName,
     hostPath,
@@ -44,10 +57,24 @@ export async function assertLinuxChromeExtensionHost(resourcesDir, channelName)
   return {
     path: path.relative(resourcesDir, hostPath),
     ...artifact,
+    ...pluginManifest,
     ...protocol
   };
 }
 
+export function evaluateLinuxChromePluginManifest(manifest) {
+  if (
+    manifest?.name !== "chrome" ||
+    manifest?.bundledContentVariant !== CHROME_EXTENSION_HOST_CONTENT_VARIANT
+  ) {
+    throw new Error(
+      `Chrome plugin must declare bundledContentVariant ${CHROME_EXTENSION_HOST_CONTENT_VARIANT}`
+    );
+  }
+
+  return { contentVariant: manifest.bundledContentVariant };
+}
+
 export function evaluateLinuxChromeExtensionHostArtifact({ fileType, mode }) {
   if ((mode & 0o111) === 0) {
     throw new Error(`Chrome extension host must be executable (mode ${mode.toString(8)})`);

scripts/lib/chrome-plugin-patches.mjs

@@ -2,12 +2,15 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { parse } from "acorn";
 
+import { CHROME_EXTENSION_HOST_CONTENT_VARIANT } from "./chrome-extension-constants.mjs";
 import { chromePluginRoot } from "./chrome-extension-host.mjs";
 
 const nativeManifestContract = "Linux native-host manifest diagnostics";
+const pluginManifestVariantContract = "Linux Chrome plugin manifest variant";
 
 export async function patchLinuxChromePluginResources(resourcesDir) {
-  const scriptsDir = path.join(chromePluginRoot(resourcesDir), "scripts");
+  const pluginRoot = chromePluginRoot(resourcesDir);
+  const scriptsDir = path.join(pluginRoot, "scripts");
   // browser-client.mjs is SHA-pinned by the desktop runtime. Keep its bytes
   // intact; changing its profile metadata would disable the trusted Node REPL.
   const manifestCheckPath = path.join(scriptsDir, "check-native-host-manifest.js");
@@ -18,6 +21,36 @@ export async function patchLinuxChromePluginResources(resourcesDir) {
   });
   const patched = patchLinuxNativeHostManifestCheckSource(source);
   if (patched !== source) await fs.writeFile(manifestCheckPath, patched);
+
+  const pluginManifestPath = path.join(pluginRoot, ".codex-plugin", "plugin.json");
+  const pluginManifestSource = await fs.readFile(pluginManifestPath, "utf8").catch(error => {
+    throw new Error(`Required Chrome plugin manifest is missing: ${pluginManifestPath}`, {
+      cause: error
+    });
+  });
+  const patchedPluginManifest = patchLinuxChromePluginManifestSource(pluginManifestSource);
+  if (patchedPluginManifest !== pluginManifestSource) {
+    await fs.writeFile(pluginManifestPath, patchedPluginManifest);
+  }
+}
+
+/** Stamp the Linux host revision into the cache identity used by upstream. */
+export function patchLinuxChromePluginManifestSource(source) {
+  try {
+    const manifest = JSON.parse(source);
+    if (manifest?.name !== "chrome") throw new Error("expected the Chrome plugin manifest");
+
+    const currentVariant = manifest.bundledContentVariant;
+    if (currentVariant === CHROME_EXTENSION_HOST_CONTENT_VARIANT) return source;
+    if (currentVariant !== undefined) {
+      throw new Error(`unexpected bundledContentVariant ${JSON.stringify(currentVariant)}`);
+    }
+
+    manifest.bundledContentVariant = CHROME_EXTENSION_HOST_CONTENT_VARIANT;
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+  } catch (error) {
+    throw contractError(pluginManifestVariantContract, error);
+  }
 }
 
 export function patchLinuxNativeHostManifestCheckSource(source) {
@@ -64,11 +97,27 @@ export function patchLinuxNativeHostManifestCheckSource(source) {
 }
 
 function hasLinuxNativeHostManifestCheck(source) {
-  return (
-    source.includes('process.platform === "linux"') &&
-    source.includes('"NativeMessagingHosts"') &&
-    source.includes("supports macOS, Linux, and Windows")
-  );
+  try {
+    const fn = findNamedFunction(source, "getNativeHostManifestLocation");
+    const functionSource = source.slice(fn.start, fn.end);
+    const locationShape = [
+      'process.platform === "linux"',
+      "manifestPath:",
+      "registryKey: null",
+      "registryManifestPath: null",
+      "registryKeyExists: null"
+    ];
+    const resolvesManifestPath =
+      functionSource.includes('"NativeMessagingHosts"') ||
+      functionSource.includes("resolveLinuxNativeMessagingManifestPath(");
+
+    return (
+      resolvesManifestPath &&
+      locationShape.every(signal => functionSource.includes(signal))
+    );
+  } catch {
+    return false;
+  }
 }
 
 function findNamedFunction(source, name) {

test/chrome-extension-patches.test.mjs

@@ -17,6 +17,15 @@ const upstreamMaterializer = [
   "}"
 ].join("");
 
+const upstreamMaterializerWithoutChrome = [
+  "async function ol(e){",
+  "let t,n=[];",
+  "if(e.pluginName===`computer-use`?(t=e.computerUseSkillVariant):e.pluginName===`visualize`&&(t=e.liveVisualizationSkillVariant),t==null)return;",
+  "let r=join(e.pluginRoot,`.codex-plugin`,`plugin.json`),i=await schema.parseAsync(JSON.parse(await fs.readFile(r,`utf8`)));",
+  "await fs.writeFile(r,`${JSON.stringify({...i,bundledContentVariant:t},null,2)}\\n`,`utf8`)",
+  "}"
+].join("");
+
 test("patchLinuxChromeExtensionHostContentVariant revises only the Chrome cache identity", () => {
   const patched = patchLinuxChromeExtensionHostContentVariant(upstreamMaterializer);
 
@@ -45,6 +54,16 @@ test("content-variant contract runner accepts an already patched bundle", () =>
   );
 });
 
+test("content-variant contract accepts a materializer without Chrome", () => {
+  assert.equal(
+    applyUpstreamPatchContract(
+      upstreamMaterializerWithoutChrome,
+      linuxChromeExtensionHostContentVariantContract
+    ),
+    upstreamMaterializerWithoutChrome
+  );
+});
+
 test("patchLinuxChromeExtensionHostContentVariant fails on upstream contract drift", () => {
   assert.throws(
     () => patchLinuxChromeExtensionHostContentVariant("async function unrelated(){}"),