@bitkyc08/opencodex 2.84.0 → 2.86.0

package/src/codex/desktop-compatibility/usage-sse-controller.ts

@@ -0,0 +1,86 @@
+type Rewrite = (text: string) => Promise<string | null>;
+
+async function rewriteRecord(bytes: Buffer, first: boolean, rewrite: Rewrite): Promise<Buffer> {
+  let text: string;
+  try { text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes); }
+  catch { return Buffer.from(bytes); }
+  const lines = [...text.matchAll(/([^\r\n]*)(\r\n|\r|\n|$)/g)].filter(m => m[0].length > 0);
+  const data: string[] = [], indexes = new Set<number>(); let event = '';
+  lines.forEach((line, i) => {
+    const content = first && i === 0 ? line[1]!.replace(/^\uFEFF/, '') : line[1]!;
+    if (content.startsWith(':')) return;
+    const colon = content.indexOf(':');
+    const key = colon < 0 ? content : content.slice(0, colon);
+    const value = colon < 0 ? '' : content.slice(colon + 1).replace(/^ /, '');
+    if (key === 'event') event = value;
+    if (key === 'data') { data.push(value); indexes.add(i); }
+  });
+  if (event !== 'usage.snapshot' || !data.length) return Buffer.from(bytes);
+  const changed = await rewrite(data.join('\n'));
+  if (changed === null) return Buffer.from(bytes);
+  let written = false;
+  return Buffer.from(lines.map((line, i) => {
+    if (!indexes.has(i)) return line[0];
+    if (written) return '';
+    written = true;
+    const bom = first && i === 0 && line[1]!.startsWith('\uFEFF') ? '\uFEFF' : '';
+    return `${bom}data: ${changed}${line[2]}`;
+  }).join(''));
+}
+
+/** Byte-bounded SSE framing; never fabricates events or changes stream sequence numbers. */
+export function controlledUsageSse(rewrite: Rewrite, cap = 262144): TransformStream<Uint8Array, Uint8Array> {
+  if (!Number.isSafeInteger(cap) || cap < 1 || cap > 1048576) throw new Error('Invalid record limit');
+  const buffer = Buffer.alloc(cap);
+  let used = 0, lineHasBytes = false, pendingCR = false, first = true, passthrough = false;
+  return new TransformStream({
+    async transform(chunk, controller) {
+      let rawStart = passthrough ? 0 : -1;
+      const enterPassthrough = (start: number) => {
+        controller.enqueue(Buffer.from(buffer.subarray(0, used)));
+        used = 0; passthrough = true; rawStart = start;
+      };
+      const endRecord = async (rawEnd: number) => {
+        if (passthrough) {
+          if (rawEnd > rawStart) controller.enqueue(chunk.subarray(rawStart, rawEnd));
+          passthrough = false; rawStart = -1;
+        } else {
+          controller.enqueue(await rewriteRecord(buffer.subarray(0, used), first, rewrite));
+        }
+        first = false; used = 0; lineHasBytes = false;
+      };
+      for (let i = 0; i < chunk.length; i++) {
+        const byte = chunk[i]!;
+        if (pendingCR) {
+          pendingCR = false;
+          if (byte !== 10) {
+            if (!lineHasBytes) await endRecord(i);
+            lineHasBytes = false;
+          }
+          else {
+            if (!passthrough && used === cap) enterPassthrough(i);
+            if (!passthrough) buffer[used++] = byte;
+            const blankLine = !lineHasBytes;
+            lineHasBytes = false;
+            if (blankLine) await endRecord(i + 1);
+            continue;
+          }
+        }
+        if (!passthrough && used === cap) enterPassthrough(i);
+        if (!passthrough) buffer[used++] = byte;
+        if (byte === 13) pendingCR = true;
+        else if (byte === 10) {
+          const blankLine = !lineHasBytes;
+          lineHasBytes = false;
+          if (blankLine) await endRecord(i + 1);
+        } else lineHasBytes = true;
+      }
+      if (passthrough && rawStart < chunk.length) controller.enqueue(chunk.subarray(rawStart));
+    },
+    async flush(controller) {
+      if (passthrough) return;
+      if (pendingCR && !lineHasBytes) { controller.enqueue(await rewriteRecord(buffer.subarray(0, used), first, rewrite)); used = 0; }
+      if (used > 0) controller.enqueue(Buffer.from(buffer.subarray(0, used)));
+    },
+  });
+}

package/src/codex/desktop-compatibility/windows-activation-source.ts

@@ -0,0 +1,44 @@
+// Kept inline so source and standalone Bun distributions carry the same COM adapter.
+export const WINDOWS_ACTIVATION_SOURCE = String.raw`using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+// Windows.Launch preserves package identity and forwards explicit application arguments.
+public static class OpenCodexPackageActivation {
+    [ComImport, Guid("2E941141-7F97-4756-BA1D-9DECDE894A3D"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IApplicationActivationManager {
+        [PreserveSig] int ActivateApplication([MarshalAs(UnmanagedType.LPWStr)] string appId, [MarshalAs(UnmanagedType.LPWStr)] string arguments, uint options, out uint processId);
+        [PreserveSig] int ActivateForFile([MarshalAs(UnmanagedType.LPWStr)] string appId, IntPtr items, [MarshalAs(UnmanagedType.LPWStr)] string verb, out uint processId);
+        [PreserveSig] int ActivateForProtocol([MarshalAs(UnmanagedType.LPWStr)] string appId, IntPtr items, out uint processId);
+    }
+    [DllImport("ole32.dll", PreserveSig=true)]
+    private static extern int CoCreateInstance(ref Guid clsid, IntPtr outer, uint context, ref Guid iid, [MarshalAs(UnmanagedType.Interface)] out IApplicationActivationManager manager);
+    [DllImport("kernel32.dll", SetLastError=true)] private static extern IntPtr OpenProcess(uint access, bool inherit, uint pid);
+    [DllImport("kernel32.dll")] private static extern bool CloseHandle(IntPtr handle);
+    [DllImport("kernel32.dll", CharSet=CharSet.Unicode)] private static extern int GetPackageFullName(IntPtr process, ref uint length, StringBuilder name);
+    private static IApplicationActivationManager Manager() {
+        var clsid=new Guid("45BA127D-10A8-46EA-8AB7-56EA9078943C");
+        var iid=new Guid("2E941141-7F97-4756-BA1D-9DECDE894A3D");
+        IApplicationActivationManager manager;
+        // LOCAL_SERVER preserves activation argument lifetime after the short launcher exits.
+        Marshal.ThrowExceptionForHR(CoCreateInstance(ref clsid,IntPtr.Zero,4,ref iid,out manager));
+        return manager;
+    }
+    public static void ValidateActivationService() {var manager=Manager();Marshal.FinalReleaseComObject(manager);}
+    public static uint Activate(string appId,string arguments) {
+        var manager=Manager();
+        try {uint pid;Marshal.ThrowExceptionForHR(manager.ActivateApplication(appId,arguments,0,out pid));return pid;}
+        finally {Marshal.FinalReleaseComObject(manager);}
+    }
+    public static string PackageOf(uint pid) {
+        var handle=OpenProcess(0x1000,false,pid);
+        if(handle==IntPtr.Zero)throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
+        try {uint length=0;int status=GetPackageFullName(handle,ref length,null);
+            if(status==15700)return null;
+            if(status!=122)throw new System.ComponentModel.Win32Exception(status);
+            var value=new StringBuilder((int)length);status=GetPackageFullName(handle,ref length,value);
+            if(status!=0)throw new System.ComponentModel.Win32Exception(status);
+            return value.ToString();
+        }finally{CloseHandle(handle);}
+    }
+}`;

package/src/codex/desktop-compatibility/windows-certificate-trust.ts

@@ -0,0 +1,81 @@
+import { execFile } from "node:child_process";
+import { X509Certificate } from "node:crypto";
+import { resolveTrustedWindowsPowerShellExe } from "../../lib/windows-elevation";
+import type { StoredDesktopAuthority } from "./certificate-store";
+import { isTestHomeGuardArmed } from "../../lib/test-home-guard";
+import { isServerAuthOnlyCertificate } from "../../claude/intercept/local-ca";
+
+export type DesktopCertificateTrust = "trusted" | "not-trusted" | "unknown";
+export type TrustOperation = "inspect" | "trust" | "remove";
+export type CertificateTrustRunner = (operation: TrustOperation, certificateDer: string, fingerprint: string) => Promise<DesktopCertificateTrust>;
+
+const SCRIPT = [
+  "$ErrorActionPreference='Stop'",
+  "$inputData=[Console]::In.ReadToEnd()|ConvertFrom-Json",
+  "$bytes=[Convert]::FromBase64String($inputData.certificate)",
+  "$cert=[Security.Cryptography.X509Certificates.X509Certificate2]::new($bytes)",
+  "$sha=[Security.Cryptography.SHA256]::Create()",
+  "try {$fingerprint=([BitConverter]::ToString($sha.ComputeHash($bytes))).Replace('-','')}finally{$sha.Dispose()}",
+  "if($fingerprint -cne $inputData.fingerprint){throw 'Certificate changed'}",
+  "$store=[Security.Cryptography.X509Certificates.X509Store]::new('Root','CurrentUser')",
+  "$mode=if($inputData.operation -eq 'inspect'){[Security.Cryptography.X509Certificates.OpenFlags]::ReadOnly}else{[Security.Cryptography.X509Certificates.OpenFlags]::ReadWrite}",
+  "try {",
+  " $store.Open($mode)",
+  " $foundCertificates=@($store.Certificates.Find([Security.Cryptography.X509Certificates.X509FindType]::FindByThumbprint,$cert.Thumbprint,$false))",
+  " foreach($certificateMatch in $foundCertificates){if([Convert]::ToBase64String($certificateMatch.RawData) -cne [Convert]::ToBase64String($bytes)){throw 'Certificate mismatch'}}",
+  " if($inputData.operation -eq 'trust'){if($foundCertificates.Count -eq 0){$store.Add($cert)}}",
+  " elseif($inputData.operation -eq 'remove'){foreach($certificateMatch in $foundCertificates){$store.Remove($certificateMatch)}}",
+  " elseif($inputData.operation -ne 'inspect'){throw 'Unknown operation'}",
+  " $present=@($store.Certificates.Find([Security.Cryptography.X509Certificates.X509FindType]::FindByThumbprint,$cert.Thumbprint,$false)).Count -gt 0",
+  " if($present){[Console]::Out.Write('trusted')}else{[Console]::Out.Write('not-trusted')}",
+  "}finally{$store.Close();$store.Dispose();$cert.Dispose()}",
+].join("\n");
+
+const run: CertificateTrustRunner = (operation, certificateDer, fingerprint) => {
+  if (process.platform !== "win32") return Promise.resolve("unknown");
+  if (operation !== "inspect" && isTestHomeGuardArmed()) return Promise.resolve("unknown");
+  return new Promise(resolve => {
+    const child = execFile(resolveTrustedWindowsPowerShellExe(), ["-NoProfile", "-NonInteractive", "-Command", SCRIPT], {
+      timeout: operation === "inspect" ? 10_000 : 120_000, maxBuffer: 4096, windowsHide: true, encoding: "utf8",
+    }, (error, stdout) => resolve(!error && (stdout.trim() === "trusted" || stdout.trim() === "not-trusted")
+      ? stdout.trim() as DesktopCertificateTrust : "unknown"));
+    child.stdin?.on("error", () => { /* completion and readback decide the result */ });
+    child.stdin?.end(JSON.stringify({ operation, certificate: certificateDer, fingerprint }));
+  });
+};
+
+/** Public status cannot create a certificate, decrypt a key or alter OS trust. */
+export async function inspectWindowsCertificateTrust(certPem: string, expectedFingerprint: string, runner: CertificateTrustRunner = run): Promise<DesktopCertificateTrust> {
+  const certificate = new X509Certificate(certPem);
+  const fingerprint = certificate.fingerprint256.replaceAll(":", "");
+  if (!certificate.ca || fingerprint !== expectedFingerprint || !/^[A-F0-9]{64}$/.test(expectedFingerprint)) {
+    throw new Error("desktop_compatibility_certificate_mismatch");
+  }
+  return runner("inspect", certificate.raw.toString("base64"), fingerprint).catch(() => "unknown" as const);
+}
+
+/** Mutations require the store-validated private key, not unverified public status metadata. */
+export function createWindowsCertificateTrust(authority: StoredDesktopAuthority, expectedFingerprint: string, runner: CertificateTrustRunner = run) {
+  const certificate = new X509Certificate(authority.authority.certPem);
+  const fingerprint = certificate.fingerprint256.replaceAll(":", "");
+  if (fingerprint !== expectedFingerprint || !certificate.ca || !certificate.checkPrivateKey(authority.authority.privateKey)
+    || !certificate.verify(authority.authority.publicKey) || !/^OpenCodex Codex Desktop [0-9a-f-]{36}$/.test(authority.commonName)
+    || !certificate.subject.split("\n").includes(`CN=${authority.commonName}`)) throw new Error("desktop_compatibility_certificate_mismatch");
+  const encoded = certificate.raw.toString("base64");
+  const inspect = () => runner("inspect", encoded, fingerprint).catch(() => "unknown" as const);
+  let pending: Promise<DesktopCertificateTrust> | null = null;
+  const change = (operation: "trust" | "remove") => {
+    if (pending) return Promise.reject(new Error("desktop_compatibility_trust_busy"));
+    if (operation === "trust" && Date.parse(certificate.validTo) <= Date.now()) return Promise.reject(new Error("desktop_compatibility_authority_expired"));
+    if (operation === "trust" && !isServerAuthOnlyCertificate(certificate)) return Promise.reject(new Error("desktop_compatibility_authority_renewal_required"));
+    pending = (async () => {
+      const before = await inspect();
+      if (before === "unknown") return before;
+      if (before === (operation === "trust" ? "trusted" : "not-trusted")) return before;
+      try { await runner(operation, encoded, fingerprint); } catch { /* read the exact store after an uncertain action */ }
+      return inspect();
+    })().finally(() => { pending = null; });
+    return pending;
+  };
+  return { inspect, trust: () => change("trust"), remove: () => change("remove") };
+}

package/src/codex/desktop-compatibility/windows-key-protection.ts

@@ -0,0 +1,59 @@
+import { execFile } from "node:child_process";
+import { resolveTrustedWindowsPowerShellExe } from "../../lib/windows-elevation";
+
+const MAX_INPUT = 65_536;
+const MAX_OUTPUT = 131_072;
+const PURPOSE = "opencodex/codex-desktop-compatibility/authority/v1";
+// A cold Windows PowerShell that must also load System.Security has been measured past 10s on a
+// loaded machine (Windows CI run 38591626343). The call is async and off the request path, so a
+// wider bound costs nothing while healthy and turns a slow start into success instead of a refusal.
+const DPAPI_TIMEOUT_MS = 20_000;
+const SCRIPT = [
+  "$ErrorActionPreference='Stop'",
+  "Add-Type -AssemblyName System.Security",
+  "$r=[Console]::In.ReadToEnd()|ConvertFrom-Json",
+  "$data=[Convert]::FromBase64String($r.data)",
+  `if($data.Length -eq 0 -or $data.Length -gt ${MAX_INPUT}){throw 'Invalid data size'}`,
+  `$entropy=[Text.Encoding]::UTF8.GetBytes('${PURPOSE}')`,
+  "$scope=[Security.Cryptography.DataProtectionScope]::CurrentUser",
+  "if($r.operation -eq 'protect'){",
+  " $out=[Security.Cryptography.ProtectedData]::Protect($data,$entropy,$scope)",
+  "}elseif($r.operation -eq 'unprotect'){",
+  " $out=[Security.Cryptography.ProtectedData]::Unprotect($data,$entropy,$scope)",
+  "}else{throw 'Invalid operation'}",
+  "[Console]::Out.Write([Convert]::ToBase64String($out))",
+].join("\n");
+
+export interface AuthorityKeyProtection {
+  protect(cleartext: Uint8Array): Promise<Uint8Array>;
+  unprotect(ciphertext: Uint8Array): Promise<Uint8Array>;
+}
+
+/** The payload travels on stdin, never in process arguments, environment or logs. */
+function runDpapi(operation: "protect" | "unprotect", data: Uint8Array): Promise<Uint8Array> {
+  if (process.platform !== "win32") return Promise.reject(new Error("desktop_compatibility_windows_required"));
+  if (data.byteLength === 0 || data.byteLength > MAX_INPUT) return Promise.reject(new Error("desktop_compatibility_key_size"));
+  return new Promise((resolve, reject) => {
+    const child = execFile(resolveTrustedWindowsPowerShellExe(), ["-NoProfile", "-NonInteractive", "-Command", SCRIPT], {
+      timeout: DPAPI_TIMEOUT_MS, maxBuffer: MAX_OUTPUT, windowsHide: true, encoding: "utf8",
+    }, (error, stdout) => {
+      // Do not include PowerShell stderr, command output or the input in a propagated error.
+      if (error || !/^[A-Za-z0-9+/]+={0,2}$/.test(stdout.trim())) {
+        reject(new Error("desktop_compatibility_key_protection_failed")); return;
+      }
+      const bytes = Buffer.from(stdout.trim(), "base64");
+      if (bytes.length === 0 || bytes.length > MAX_INPUT) {
+        reject(new Error("desktop_compatibility_key_size")); return;
+      }
+      resolve(bytes);
+    });
+    child.stdin?.on("error", () => { /* execFile's completion reports the failed child. */ });
+    child.stdin?.end(JSON.stringify({ operation, data: Buffer.from(data).toString("base64") }));
+  });
+}
+
+/** CurrentUser protects against other OS identities, not other processes of the same user. */
+export const windowsAuthorityKeyProtection: AuthorityKeyProtection = {
+  protect: bytes => runDpapi("protect", bytes),
+  unprotect: bytes => runDpapi("unprotect", bytes),
+};

package/src/codex/desktop-compatibility/windows-package-command.ts

@@ -0,0 +1,86 @@
+import type { DesktopAppInstall, DesktopExec, DesktopProcess } from "../desktop-app/types";
+import { resolveTrustedWindowsPowerShellExe } from "../../lib/windows-elevation";
+import { WINDOWS_ACTIVATION_SOURCE } from "./windows-activation-source";
+import { readDesktopCompatibilityLaunch } from "./runtime-ownership";
+
+/** Only the feature's loopback PAC endpoint may become a launch argument. */
+export function validatedCompatibilityPacUrl(value: string): string {
+  let url: URL;
+  try { url = new URL(value); } catch { throw new Error("desktop_compatibility_invalid_pac_url"); }
+  if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || !url.port || Number(url.port) < 1
+    || url.username || url.password || url.search || url.hash
+    || !/^\/[a-zA-Z0-9-]{16,80}\/proxy\.pac$/.test(url.pathname)
+    || value !== url.href) throw new Error("desktop_compatibility_invalid_pac_url");
+  return url.href;
+}
+
+function literal(value: string): string { return `'${value.replaceAll("'", "''")}'`; }
+
+export function compatibilityActivationScript(install: DesktopAppInstall, pacUrl: string): string {
+  const pac = validatedCompatibilityPacUrl(pacUrl);
+  if (!/^OpenAI\.Codex(?:Beta)?_[A-Za-z0-9]+$/.test(install.id) || install.relaunch !== `${install.id}!App`) {
+    throw new Error("desktop_compatibility_invalid_package");
+  }
+  return [
+    "$ErrorActionPreference='Stop'",
+    `$family=${literal(install.id)}; $root=${literal(install.root)}; $pac=${literal(pac)}`,
+    `$p=Get-AppxPackage -Name ${literal(install.id.split("_")[0]!)}`,
+    "$p=@($p|Where-Object {$_.PackageFamilyName -eq $family -and $_.InstallLocation -ieq $root})",
+    "if($p.Count -ne 1){throw 'Package changed'}; $p=$p[0]",
+    "$manifest=Get-AppxPackageManifest -Package $p.PackageFullName",
+    "$entry=@($manifest.Package.Applications.Application|Where-Object {$_.Id -eq 'App' -and $_.Executable.Replace('/','\\') -ieq 'app\\ChatGPT.exe'})",
+    "if($entry.Count -ne 1){throw 'Application entry changed'}",
+    "Add-Type -TypeDefinition @'", WINDOWS_ACTIVATION_SOURCE, "'@",
+    "$pidValue=[OpenCodexPackageActivation]::Activate($family+'!App','--proxy-pac-url='+$pac)",
+    "if([OpenCodexPackageActivation]::PackageOf($pidValue) -ne $p.PackageFullName){throw 'Package identity missing'}",
+    "$running=Get-CimInstance Win32_Process -Filter ('ProcessId='+$pidValue)",
+    "$expected=Join-Path $p.InstallLocation 'app\\ChatGPT.exe'",
+    "if(-not $running -or $running.ExecutablePath -ine $expected -or $running.CommandLine -notmatch ('(?:^|[\\s\"])--proxy-pac-url='+[regex]::Escape($pac)+'(?:$|[\\s\"])')){throw 'Launch arguments not observed'}",
+    "[pscustomobject]@{pid=[int]$pidValue;packageFullName=$p.PackageFullName;verified=$true}|ConvertTo-Json -Compress",
+  ].join("\n");
+}
+
+
+/** Preserve only the current runtime's PAC and lifetime, never trust a URL shape alone. */
+export function captureWindowsCompatibilityContext(processes: readonly DesktopProcess[]): Record<string, string> {
+  const members = new Set(processes.map(entry => entry.pid));
+  const urls = new Set<string>();
+  for (const entry of processes.filter(value => !members.has(value.parentPid))) {
+    if (entry.commandLine !== undefined && entry.commandLine.trim() === "") {
+      throw new Error("desktop_compatibility_launch_context_unavailable");
+    }
+    for (const match of (entry.commandLine ?? "").matchAll(/(?:^|\s)"?--proxy-pac-url=([^"\s]+)"?/g)) {
+      const url = match[1]!;
+      if (url.startsWith("http://127.0.0.1:")) urls.add(validatedCompatibilityPacUrl(url));
+    }
+  }
+  if (urls.size > 1) throw new Error("desktop_compatibility_conflicting_launch_context");
+  if (urls.size === 0) return {};
+  const pacUrl = [...urls][0]!, owner = readDesktopCompatibilityLaunch();
+  if (!owner || owner.pacUrl !== pacUrl) throw new Error("desktop_compatibility_launch_owner_unverified");
+  return { codexCompatibilityPacUrl: pacUrl, codexCompatibilityGeneration: owner.generation };
+}
+
+/** Recheck after the asynchronous stop ladder: identical endpoints can belong to a new runtime. */
+export function assertWindowsCompatibilityContext(context: Record<string, string>): void {
+  const owner = readDesktopCompatibilityLaunch();
+  if (!owner || owner.pacUrl !== context.codexCompatibilityPacUrl || owner.generation !== context.codexCompatibilityGeneration) {
+    throw new Error("desktop_compatibility_launch_owner_unverified");
+  }
+}
+
+export function activateWindowsCodexCompatibility(exec: DesktopExec, install: DesktopAppInstall, pacUrl: string): { pid: number; packageFullName: string } {
+  const script = compatibilityActivationScript(install, pacUrl);
+  let text: string;
+  try { text = exec(resolveTrustedWindowsPowerShellExe(), ["-NoProfile", "-NonInteractive", "-Command", script], { timeout: 15_000, windowsHide: true }); }
+  catch { throw new Error("desktop_compatibility_activation_unverified"); }
+  let result: unknown;
+  try { result = JSON.parse(text.trim().split(/\r?\n/).at(-1) ?? ""); }
+  catch { throw new Error("desktop_compatibility_activation_unverified"); }
+  if (!result || typeof result !== "object" || Array.isArray(result)) throw new Error("desktop_compatibility_activation_unverified");
+  const value = result as Record<string, unknown>;
+  if (value.verified !== true || !Number.isSafeInteger(value.pid) || Number(value.pid) <= 0
+    || typeof value.packageFullName !== "string" || !value.packageFullName.startsWith(install.id.split("_")[0]! + "_")
+    || !value.packageFullName.endsWith("_" + install.id.split("_")[1]!)) throw new Error("desktop_compatibility_activation_unverified");
+  return { pid: Number(value.pid), packageFullName: value.packageFullName };
+}

package/src/codex/desktop-compatibility/windows-package-launch.ts

@@ -0,0 +1,28 @@
+import { windowsDefaultExec, windowsDesktopAppAdapter } from "../desktop-app/windows";
+import type { DesktopExec } from "../desktop-app/types";
+import { activateWindowsCodexCompatibility, validatedCompatibilityPacUrl } from "./windows-package-command";
+export { compatibilityActivationScript, validatedCompatibilityPacUrl } from "./windows-package-command";
+
+export interface CompatibilityLaunchIo {
+  exec?: DesktopExec;
+  platform?: string;
+}
+export type CompatibilityLaunchResult =
+  | { status: "started"; pid: number; packageFullName: string }
+  | { status: "refused"; reason: "unsupported_platform" | "test_environment" | "package_unavailable" | "app_running" | "process_probe_failed" | "activation_failed" };
+
+/** Never quits an app, launches the raw EXE, changes login or installs a watcher. */
+export function launchWindowsCodexCompatibility(pacUrl: string, io: CompatibilityLaunchIo = {}): CompatibilityLaunchResult {
+  validatedCompatibilityPacUrl(pacUrl);
+  if ((io.platform ?? process.platform) !== "win32") return { status: "refused", reason: "unsupported_platform" };
+  if (process.env.OCX_TEST_HOME_GUARD === "1" && !io.exec) return { status: "refused", reason: "test_environment" };
+  const exec = io.exec ?? windowsDefaultExec;
+  const install = windowsDesktopAppAdapter.discover(exec);
+  if (!install) return { status: "refused", reason: "package_unavailable" };
+  const processes = windowsDesktopAppAdapter.listProcesses(exec, install);
+  if (processes === null) return { status: "refused", reason: "process_probe_failed" };
+  if (processes.length > 0) return { status: "refused", reason: "app_running" };
+  try {
+    return { status: "started", ...activateWindowsCodexCompatibility(exec, install, pacUrl) };
+  } catch { return { status: "refused", reason: "activation_failed" }; }
+}

package/src/codex/history-provider.ts

@@ -1831,7 +1831,7 @@ export function countPendingOpencodexHistory(
       : { pendingRows: 0, backupEntries };
   }
   try {
-    const db = new Database(stateDbPath, { readonly: true });
+    const db = openCodexStateForPreflight(stateDbPath);
     try {
       db.exec("PRAGMA busy_timeout = 100");
       // Prove the expected history schema is readable without counting unowned routed rows.

package/src/codex/inject/config-write-section.ts

@@ -1,7 +1,7 @@
 import type { AtomicWriteHooks } from "../../config/atomic-write";
 import { existsSync, readFileSync } from "node:fs";
 import { withConfigMutationLockSync } from "../../config";
-import { ConfigWriteLockRefusal, assertConfigWriteDestination, publishConfigWriteTarget, watchConfigWriteTargets, withConfigWriteLockHeld, type LockHandle } from "../config-write-lock";
+import { ConfigWriteLockRefusal, assertConfigWriteDestination, publishConfigWriteTarget, removeConfigWriteEntry, watchConfigWriteTargets, withConfigWriteLockHeld, type LockHandle } from "../config-write-lock";
 import { CODEX_CONFIG_PATH, CODEX_PROFILE_PATH } from "../paths";
 import { getCodexHome } from "../paths";
 import { codexHomeIsAbsent } from "../codex-home-owner";
@@ -16,6 +16,9 @@ export function publishCodexArtifact<T>(path: string, held: LockHandle | undefin
   if (!held) throw new Error("Codex artifact publication requires a held configuration lock");
   return publishConfigWriteTarget(CODEX_CONFIG_PATH, held, path, run);
 }
+export function removeCodexProfileEntry(held: LockHandle): void {
+  removeConfigWriteEntry(CODEX_CONFIG_PATH, held, CODEX_PROFILE_PATH);
+}
 /** Courtesy cleanup re-reads provider ownership inside the same config section. */
 export function cleanExternalProviderJournal(beforeClientWrite?: () => void): void {
   if (codexHomeIsAbsent(getCodexHome())) return;

package/src/codex/inject/remove.ts

@@ -1,8 +1,8 @@
-import { beginCodexWriteSection, publishCodexArtifact } from "./config-write-section";
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { beginCodexWriteSection, publishCodexArtifact, removeCodexProfileEntry } from "./config-write-section";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { normalizeStructuralWhitespace, rootAssignmentKey, rootSourceLines, sourceAssignment, sourceText } from "../toml-source-lines";
 import { atomicWriteFile } from "../../config";
-import { ConfigWriteLockRefusal, configWriteLockFailureMessage, withConfigWriteLockHeld } from "../config-write-lock";
+import { ConfigWriteLockRefusal, configWriteLockFailureMessage, withConfigWriteLockHeld, withConfigWriteRecovery } from "../config-write-lock";
 import type { LockHandle } from "../config-write-lock";
 import {
   REALTIME_WS_BASE_URL_KEY,
@@ -206,15 +206,26 @@ export function removeCodexConfig(
   }
   const locked = withConfigWriteLockHeld(CODEX_CONFIG_PATH, options.heldConfigWriteLock, held => {
   beginCodexWriteSection(held);
+  if (!options.preserveProfile) {
+    try {
+      if (lstatSync(CODEX_PROFILE_PATH).isSymbolicLink()) {
+        return { success: false, message: "Codex profile is a symbolic link; configuration and recovery evidence were preserved." };
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
   if (!existsSync(CODEX_CONFIG_PATH)) {
     if (!options.preserveProfile && existsSync(CODEX_PROFILE_PATH))
-      publishCodexArtifact(CODEX_PROFILE_PATH, held, (path, hooks) => { hooks.validateBeforeRename?.(path); unlinkSync(path); hooks.afterRename?.(path); });
+      removeCodexProfileEntry(held);
     return {
       success: true,
       message: `Codex config not found; no native restore was needed${options.preserveProfile ? "." : ", and the opencodex profile was removed if present."}`,
     };
   }
-  const rawContent = readFileSync(CODEX_CONFIG_PATH, "utf-8");
+  const preimage = readFileSync(CODEX_CONFIG_PATH);
+  return withConfigWriteRecovery(CODEX_CONFIG_PATH, held, () => {
+  const rawContent = preimage.toString("utf-8");
   // Same EOL boundary as inject: strip in LF space, write back in the file's own ending.
   // The unchanged fast path compares in LF space so an untouched file is never rewritten.
   const eol = dominantEol(rawContent);
@@ -248,7 +259,7 @@ export function removeCodexConfig(
     publishCodexArtifact(CODEX_CONFIG_PATH, held, (path, hooks) => atomicWriteFile(path, applyEol(finalContent, eol), undefined, hooks));
   }
   if (!options.preserveProfile && existsSync(CODEX_PROFILE_PATH))
-    publishCodexArtifact(CODEX_PROFILE_PATH, held, (path, hooks) => { hooks.validateBeforeRename?.(path); unlinkSync(path); hooks.afterRename?.(path); });
+    removeCodexProfileEntry(held);
   const retainedNote = retainedBlock === null
     ? ""
     : " Kept [model_providers.opencodex] so conversations already tagged opencodex still open;"
@@ -272,6 +283,7 @@ export function removeCodexConfig(
     message: removedMessage,
     ...(retainedBlock === null ? {} : { retainedProviderTable: retainedBlock.replace(/\n+$/, "").split("\n") }),
   };
+  }, { preimage, requireMatchingPreimage: true });
   });
   if (!locked.ok) return { success: false, retryable: locked.error === "locked", message: configWriteLockFailureMessage(locked) };
   return locked.value;

package/src/codex/journal.ts

@@ -1,7 +1,7 @@
 import { beginCodexWriteSection, publishCodexArtifact } from "./inject/config-write-section";
 import { createHash } from "node:crypto";
 import type { AtomicWriteHooks } from "../config/atomic-write";
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteFile } from "../config";
 import { assertCodexHomeOwner, codexHomeIsAbsent, CODEX_HOME_JOURNAL_FILE, CodexHomeOwnerRefusal, opencodexHomeForInjection, readCodexHomeJournal, type CodexHomeOwnerRefusalReason } from "./codex-home-owner";
@@ -347,6 +347,21 @@ export function restoreJournalState(
     };
   }
 
+  // A matching byte hash does not authorize following a newly substituted profile link.
+  // Refuse the complete pair before restoring config or deleting its recovery journal.
+  let profileIsSymlink = false;
+  if (profileUnchanged && (!comparison.profileAlreadyOriginal || comparison.originalProfile === null)) {
+    try { profileIsSymlink = lstatSync(CODEX_PROFILE_PATH).isSymbolicLink(); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+  }
+  if (profileIsSymlink) {
+    return {
+      configRestored: comparison.configAlreadyOriginal, profileRestored: false,
+      configRewritten: false, profileRewritten: false,
+      configChanged: !configUnchanged, profileChanged: false,
+      complete: false, unverified: false, profileRestoreFailed: true as const,
+    };
+  }
   assertCodexHomeOwner(CODEX_HOME);
   let configRestored = comparison.configAlreadyOriginal;
   let profileRestored = comparison.profileAlreadyOriginal;