codexgpt 1.0.0

package/scripts/windows-process-host.ps1

@@ -0,0 +1,59 @@
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+$scriptRoot = [System.IO.Path]::GetFullPath($PSScriptRoot)
+$sourcePath = [System.IO.Path]::Combine($scriptRoot, 'windows-process-host.cs')
+$protocolPath = [System.IO.Path]::Combine($scriptRoot, 'windows-process-host-protocol-v1.json')
+$workerPath = [System.IO.Path]::Combine($scriptRoot, 'windows-conpty-worker.ps1')
+$probePath = [System.IO.Path]::Combine($scriptRoot, 'windows-conpty-probe-child.mjs')
+$manifestPath = [System.IO.Path]::Combine($scriptRoot, 'windows-process-host-manifest.json')
+
+if (-not [System.IO.File]::Exists($sourcePath)) {
+    [Console]::Error.WriteLine('HOST_SOURCE_MISSING')
+    exit 2
+}
+if (-not [System.IO.File]::Exists($protocolPath)) {
+    [Console]::Error.WriteLine('HOST_PROTOCOL_MISSING')
+    exit 2
+}
+if (-not [System.IO.File]::Exists($workerPath)) {
+    [Console]::Error.WriteLine('HOST_CONPTY_WORKER_MISSING')
+    exit 2
+}
+if (-not [System.IO.File]::Exists($probePath)) {
+    [Console]::Error.WriteLine('HOST_CONPTY_PROBE_MISSING')
+    exit 2
+}
+if (-not [System.IO.File]::Exists($manifestPath)) {
+    [Console]::Error.WriteLine('HOST_MANIFEST_MISSING')
+    exit 2
+}
+
+$protocol = [System.IO.File]::ReadAllText($protocolPath, [System.Text.Encoding]::UTF8) | ConvertFrom-Json
+if ($protocol.name -ne 'CXP4' -or $protocol.version -ne 1 -or $protocol.headerLength -ne 64 -or $protocol.maxFramePayloadBytes -ne 65536) {
+    [Console]::Error.WriteLine('HOST_PROTOCOL_CONSTANT_MISMATCH')
+    exit 2
+}
+$manifest = [System.IO.File]::ReadAllText($manifestPath, [System.Text.Encoding]::UTF8) | ConvertFrom-Json
+$sourceDigest = (Get-FileHash -LiteralPath $sourcePath -Algorithm SHA256).Hash.ToLowerInvariant()
+$protocolDigest = (Get-FileHash -LiteralPath $protocolPath -Algorithm SHA256).Hash.ToLowerInvariant()
+$workerDigest = (Get-FileHash -LiteralPath $workerPath -Algorithm SHA256).Hash.ToLowerInvariant()
+$probeDigest = (Get-FileHash -LiteralPath $probePath -Algorithm SHA256).Hash.ToLowerInvariant()
+if ($manifest.protocolName -ne 'CXP4' -or $manifest.protocolVersion -ne 1 -or $manifest.headerLength -ne 64 -or
+    $manifest.conPtyWorker -ne 'scripts/windows-conpty-worker.ps1' -or
+    $manifest.conPtyProbeChild -ne 'scripts/windows-conpty-probe-child.mjs' -or
+    $manifest.productionCSharpSha256 -ne $sourceDigest -or
+    $manifest.conPtyWorkerSha256 -ne $workerDigest -or
+    $manifest.conPtyProbeChildSha256 -ne $probeDigest -or
+    $manifest.protocolSha256 -ne $protocolDigest) {
+    [Console]::Error.WriteLine('HOST_MANIFEST_IDENTITY_MISMATCH')
+    exit 2
+}
+
+try {
+    Add-Type -Path $sourcePath -ReferencedAssemblies @('System.Web.Extensions') -ErrorAction Stop | Out-Null
+} catch {
+    [Console]::Error.WriteLine('HOST_COMPILE_FAILED')
+    exit 2
+}
+[CodexGPT.Phase4.ProcessHost]::Run()

package/scripts/windows-realpath-shim.cjs

@@ -0,0 +1,78 @@
+const childProcess = require('node:child_process');
+const fs = require('node:fs');
+const { syncBuiltinESMExports } = require('node:module');
+const path = require('node:path');
+
+if (process.platform === 'win32' && fs.realpathSync?.native) {
+  const nativeRealpathSync = fs.realpathSync.native.bind(fs.realpathSync);
+  nativeRealpathSync.native = fs.realpathSync.native;
+  fs.realpathSync = nativeRealpathSync;
+
+  const originalSpawn = childProcess.spawn;
+  const originalSpawnSync = childProcess.spawnSync;
+  const inspectNodeScript = (candidate) => {
+    try {
+      if (!fs.statSync(candidate).isFile()) return '';
+      if (/\.(?:c?js|mjs)$/i.test(candidate)) return candidate;
+      return fs.readFileSync(candidate, 'utf8').slice(0, 64).includes('/usr/bin/env node') ? candidate : '';
+    } catch {
+      return '';
+    }
+  };
+  const resolveCommandPath = (command, options) => {
+    if (typeof command !== 'string') return '';
+    if (fs.existsSync(command)) return command;
+    if (command.includes('/') || command.includes('\\')) return '';
+    const env = options?.env ?? process.env;
+    const searchPath = env.PATH ?? env.Path ?? process.env.PATH ?? '';
+    const extensions = (env.PATHEXT ?? process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+      .split(';')
+      .filter(Boolean);
+    for (const directory of searchPath.split(path.delimiter).filter(Boolean)) {
+      const exact = path.join(directory, command);
+      if (fs.existsSync(exact)) return exact;
+      if (!path.extname(command)) {
+        for (const extension of extensions) {
+          const candidate = `${exact}${extension.toLowerCase()}`;
+          if (fs.existsSync(candidate)) return candidate;
+          const upperCandidate = `${exact}${extension.toUpperCase()}`;
+          if (fs.existsSync(upperCandidate)) return upperCandidate;
+        }
+      }
+    }
+    return '';
+  };
+  const quoteCmdArg = (value) => `"${String(value).replace(/"/g, '""')}"`;
+  const batchInvocation = (command, args, options) => ({
+    command: options?.env?.ComSpec ?? process.env.ComSpec ?? 'cmd.exe',
+    args: ['/d', '/s', '/c', ['call', quoteCmdArg(command), ...args.map(quoteCmdArg)].join(' ')],
+    options: { ...options, windowsVerbatimArguments: true }
+  });
+
+  childProcess.spawn = (command, args = [], options) => {
+    const resolved = resolveCommandPath(command, options);
+    const script = resolved ? inspectNodeScript(resolved) : '';
+    if (script) return originalSpawn(process.execPath, [script, ...args], options);
+    if (/\.(?:bat|cmd)$/i.test(resolved)) {
+      const invocation = batchInvocation(resolved, args, options);
+      return originalSpawn(invocation.command, invocation.args, invocation.options);
+    }
+    return originalSpawn(command, args, options);
+  };
+  childProcess.spawnSync = (command, args = [], options) => {
+    const resolved = resolveCommandPath(command, options);
+    const script = resolved ? inspectNodeScript(resolved) : '';
+    if (script) return originalSpawnSync(process.execPath, [script, ...args], options);
+    if (/\.(?:bat|cmd)$/i.test(resolved)) {
+      const invocation = batchInvocation(resolved, args, options);
+      return originalSpawnSync(invocation.command, invocation.args, invocation.options);
+    }
+    return originalSpawnSync(command, args, options);
+  };
+  syncBuiltinESMExports();
+}
+
+const previousNodeOptions = process.env.CODEXGPT_REALPATH_PREVIOUS_NODE_OPTIONS;
+if (previousNodeOptions) process.env.NODE_OPTIONS = previousNodeOptions;
+else delete process.env.NODE_OPTIONS;
+delete process.env.CODEXGPT_REALPATH_PREVIOUS_NODE_OPTIONS;