feat(codex): support GPT-5.5 responses websocket (#1573)

Integrated into release/v3.7.0

scripts/pack-artifact-policy.ts

@@ -32,8 +32,10 @@ export const APP_STAGING_ALLOWED_EXACT_PATHS: string[] = [
   "docs/openapi.yaml",
   "open-sse/mcp-server/server.js",
   "package.json",
+  "responses-ws-proxy.mjs",
   "scripts/sync-env.mjs",
   "server.js",
+  "server-ws.mjs",
 ];
 
 export const APP_STAGING_ALLOWED_PATH_PREFIXES: string[] = [
@@ -74,6 +76,7 @@ export const PACK_ARTIFACT_ROOT_ALLOWED_EXACT_PATHS: string[] = [
   "scripts/native-binary-compat.mjs",
   "scripts/postinstall.mjs",
   "scripts/postinstallSupport.mjs",
+  "scripts/responses-ws-proxy.mjs",
   "scripts/sync-env.mjs",
   "src/shared/utils/nodeRuntimeSupport.ts",
 ];
@@ -86,6 +89,8 @@ export const PACK_ARTIFACT_ROOT_ALLOWED_PATH_PREFIXES: string[] = [
 
 export const PACK_ARTIFACT_REQUIRED_PATHS: string[] = [
   "app/server.js",
+  "app/server-ws.mjs",
+  "app/responses-ws-proxy.mjs",
   "bin/mcp-server.mjs",
   "bin/nodeRuntimeSupport.mjs",
   "bin/omniroute.mjs",

scripts/prepublish.ts

@@ -195,6 +195,17 @@ console.log("  📋 Copying standalone build to app/...");
 mkdirSync(APP_DIR, { recursive: true });
 cpSync(standaloneDir, APP_DIR, { recursive: true });
 
+const standaloneWsSrc = join(ROOT, "scripts", "standalone-server-ws.mjs");
+const responsesWsProxySrc = join(ROOT, "scripts", "responses-ws-proxy.mjs");
+if (existsSync(standaloneWsSrc) && existsSync(responsesWsProxySrc)) {
+  console.log("  📋 Adding Responses WebSocket standalone wrapper...");
+  cpSync(standaloneWsSrc, join(APP_DIR, "server-ws.mjs"));
+  writeFileSync(
+    join(APP_DIR, "responses-ws-proxy.mjs"),
+    'export * from "../scripts/responses-ws-proxy.mjs";\n'
+  );
+}
+
 // ── Next.js Turbopack Standalone Tracer Fix ───────────────
 // Workaround for Next.js 15+ standalone mode missing Turbopack chunks
 const staticChunksSrc = join(ROOT, ".next", "server", "chunks");

scripts/responses-ws-proxy.mjs

@@ -0,0 +1,597 @@
+import { createHash, randomUUID } from "node:crypto";
+import { STATUS_CODES } from "node:http";
+import { websocket } from "wreq-js";
+
+export const RESPONSES_WS_PUBLIC_PATHS = new Set([
+  "/responses",
+  "/v1/responses",
+  "/api/v1/responses",
+]);
+
+const INTERNAL_ROUTE = "/api/internal/codex-responses-ws";
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+const WS_QUERY_TOKEN_KEYS = ["api_key", "token", "access_token"];
+const textDecoder = new TextDecoder();
+
+function isText(value) {
+  return typeof value === "string" && value.length > 0;
+}
+
+function jsonStringifySafe(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return JSON.stringify({
+      type: "response.failed",
+      response: {
+        status: "failed",
+        error: {
+          code: "serialization_failed",
+          message: "Failed to serialize WebSocket payload",
+        },
+      },
+    });
+  }
+}
+
+export function isResponsesWsPath(pathname) {
+  return RESPONSES_WS_PUBLIC_PATHS.has(pathname);
+}
+
+export function encodeWsFrame(opcode, payload = Buffer.alloc(0)) {
+  const payloadBuffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+  const length = payloadBuffer.length;
+
+  let header;
+  if (length < 126) {
+    header = Buffer.allocUnsafe(2);
+    header[1] = length;
+  } else if (length <= 0xffff) {
+    header = Buffer.allocUnsafe(4);
+    header[1] = 126;
+    header.writeUInt16BE(length, 2);
+  } else {
+    header = Buffer.allocUnsafe(10);
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(length), 2);
+  }
+
+  header[0] = 0x80 | (opcode & 0x0f);
+  return Buffer.concat([header, payloadBuffer]);
+}
+
+export function decodeClientFrames(buffer) {
+  const frames = [];
+  let offset = 0;
+
+  while (buffer.length - offset >= 2) {
+    const byte1 = buffer[offset];
+    const byte2 = buffer[offset + 1];
+    const fin = (byte1 & 0x80) !== 0;
+    const opcode = byte1 & 0x0f;
+    const masked = (byte2 & 0x80) !== 0;
+    let payloadLength = byte2 & 0x7f;
+    let headerLength = 2;
+
+    if (!masked) {
+      throw new Error("Client WebSocket frames must be masked");
+    }
+
+    if (payloadLength === 126) {
+      if (buffer.length - offset < 4) break;
+      payloadLength = buffer.readUInt16BE(offset + 2);
+      headerLength = 4;
+    } else if (payloadLength === 127) {
+      if (buffer.length - offset < 10) break;
+      const bigLength = buffer.readBigUInt64BE(offset + 2);
+      if (bigLength > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("WebSocket payload too large");
+      }
+      payloadLength = Number(bigLength);
+      headerLength = 10;
+    }
+
+    const totalLength = headerLength + 4 + payloadLength;
+    if (buffer.length - offset < totalLength) break;
+
+    const mask = buffer.subarray(offset + headerLength, offset + headerLength + 4);
+    const payload = Buffer.from(buffer.subarray(offset + headerLength + 4, offset + totalLength));
+    for (let index = 0; index < payload.length; index += 1) {
+      payload[index] ^= mask[index % 4];
+    }
+
+    frames.push({ fin, opcode, payload });
+    offset += totalLength;
+  }
+
+  return {
+    frames,
+    remaining: buffer.subarray(offset),
+  };
+}
+
+function writeHttpError(socket, status, body, headers = {}) {
+  if (!socket.writable || socket.destroyed) return;
+
+  const bodyBuffer = Buffer.from(body || "", "utf8");
+  const statusText = STATUS_CODES[status] || "Error";
+  const responseHeaders = {
+    Connection: "close",
+    "Content-Length": String(bodyBuffer.length),
+    "Content-Type": "application/json; charset=utf-8",
+    ...headers,
+  };
+
+  const head = [
+    `HTTP/1.1 ${status} ${statusText}`,
+    ...Object.entries(responseHeaders).map(([name, value]) => `${name}: ${value}`),
+    "",
+    "",
+  ].join("\r\n");
+
+  socket.write(head);
+  socket.end(bodyBuffer);
+}
+
+function getAuthHeaders(requestUrl, requestHeaders) {
+  const headers = {};
+  if (isText(requestHeaders.authorization)) {
+    headers.authorization = requestHeaders.authorization;
+  } else {
+    const url = new URL(requestUrl, "http://omniroute.local");
+    for (const key of WS_QUERY_TOKEN_KEYS) {
+      const value = url.searchParams.get(key);
+      if (isText(value)) {
+        headers.authorization = `Bearer ${value.trim()}`;
+        break;
+      }
+    }
+  }
+
+  if (isText(requestHeaders.cookie)) headers.cookie = requestHeaders.cookie;
+  if (isText(requestHeaders.origin)) headers.origin = requestHeaders.origin;
+  if (isText(requestHeaders["x-forwarded-for"])) {
+    headers["x-forwarded-for"] = requestHeaders["x-forwarded-for"];
+  }
+  return headers;
+}
+
+function getResponseCreatePayload(message) {
+  if (!message || typeof message !== "object" || Array.isArray(message)) return null;
+  if (message.type !== "response.create") return null;
+  if (
+    message.response &&
+    typeof message.response === "object" &&
+    !Array.isArray(message.response)
+  ) {
+    return message.response;
+  }
+  if (message.body && typeof message.body === "object" && !Array.isArray(message.body)) {
+    return message.body;
+  }
+  if (message.payload && typeof message.payload === "object" && !Array.isArray(message.payload)) {
+    return message.payload;
+  }
+  const { type, ...payload } = message;
+  return payload;
+}
+
+function withPreparedResponseCreate(message, preparedBody) {
+  const next = { ...message };
+  if (
+    message.response &&
+    typeof message.response === "object" &&
+    !Array.isArray(message.response)
+  ) {
+    next.response = preparedBody;
+  } else if (message.body && typeof message.body === "object" && !Array.isArray(message.body)) {
+    next.body = preparedBody;
+  } else if (
+    message.payload &&
+    typeof message.payload === "object" &&
+    !Array.isArray(message.payload)
+  ) {
+    next.payload = preparedBody;
+  } else {
+    return { type: "response.create", ...preparedBody };
+  }
+  return next;
+}
+
+async function callInternal(fetchImpl, baseUrl, bridgeSecret, action, payload) {
+  const response = await fetchImpl(new URL(INTERNAL_ROUTE, baseUrl), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-omniroute-ws-bridge-secret": bridgeSecret,
+    },
+    body: JSON.stringify({ action, ...payload }),
+  });
+  const text = await response.text();
+  let json = null;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = null;
+  }
+  return { ok: response.ok, status: response.status, text, json, headers: response.headers };
+}
+
+class ResponsesWsSession {
+  constructor({
+    baseUrl,
+    bridgeSecret,
+    fetchImpl,
+    socket,
+    requestHeaders,
+    requestUrl,
+    wsFactory,
+    pingIntervalMs,
+    idleTimeoutMs,
+  }) {
+    this.baseUrl = baseUrl;
+    this.bridgeSecret = bridgeSecret;
+    this.fetchImpl = fetchImpl;
+    this.socket = socket;
+    this.requestHeaders = requestHeaders;
+    this.requestUrl = requestUrl;
+    this.wsFactory = wsFactory;
+    this.pingIntervalMs = pingIntervalMs;
+    this.idleTimeoutMs = idleTimeoutMs;
+    this.sessionId = randomUUID();
+    this.closed = false;
+    this.buffer = Buffer.alloc(0);
+    this.fragmentOpcode = null;
+    this.fragmentParts = [];
+    this.upstream = null;
+    this.upstreamReady = null;
+    this.lastSeenAt = Date.now();
+
+    this.pingTimer = setInterval(() => {
+      if (this.closed) return;
+      const idleForMs = Date.now() - this.lastSeenAt;
+      if (idleForMs >= this.idleTimeoutMs) {
+        this.close(1001, "idle_timeout");
+        return;
+      }
+      this.sendFrame(0x9);
+    }, this.pingIntervalMs);
+
+    this.socket.setNoDelay(true);
+    this.socket.on("data", (chunk) => {
+      this.onData(chunk).catch((error) => {
+        this.sendFailure(
+          "frame_decode_failed",
+          error instanceof Error ? error.message : String(error)
+        );
+        this.close(1011, "frame_decode_failed");
+      });
+    });
+    this.socket.on("close", () => this.dispose());
+    this.socket.on("end", () => this.dispose());
+    this.socket.on("error", () => this.dispose());
+  }
+
+  sendFrame(opcode, payload) {
+    if (this.closed || this.socket.destroyed) return;
+    this.socket.write(encodeWsFrame(opcode, payload));
+  }
+
+  sendJson(payload) {
+    this.sendFrame(0x1, Buffer.from(jsonStringifySafe(payload), "utf8"));
+  }
+
+  sendFailure(code, message) {
+    this.sendJson({
+      type: "response.failed",
+      response: {
+        id: null,
+        status: "failed",
+        error: {
+          code,
+          message,
+        },
+      },
+    });
+  }
+
+  async onData(chunk) {
+    this.lastSeenAt = Date.now();
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const parsed = decodeClientFrames(this.buffer);
+    this.buffer = parsed.remaining;
+
+    for (const frame of parsed.frames) {
+      await this.handleFrame(frame);
+    }
+  }
+
+  async handleFrame(frame) {
+    switch (frame.opcode) {
+      case 0x0:
+        if (this.fragmentOpcode === null) {
+          this.sendFailure("unexpected_continuation", "Unexpected continuation frame");
+          return;
+        }
+        this.fragmentParts.push(frame.payload);
+        if (frame.fin) {
+          const payload = Buffer.concat(this.fragmentParts);
+          const opcode = this.fragmentOpcode;
+          this.fragmentOpcode = null;
+          this.fragmentParts = [];
+          await this.handleDataFrame(opcode, payload);
+        }
+        return;
+      case 0x1:
+      case 0x2:
+        if (!frame.fin) {
+          this.fragmentOpcode = frame.opcode;
+          this.fragmentParts = [frame.payload];
+          return;
+        }
+        await this.handleDataFrame(frame.opcode, frame.payload);
+        return;
+      case 0x8:
+        this.close();
+        return;
+      case 0x9:
+        this.sendFrame(0xa, frame.payload);
+        return;
+      case 0xa:
+        this.lastSeenAt = Date.now();
+        return;
+      default:
+        this.sendFailure("unsupported_opcode", `Unsupported opcode ${frame.opcode}`);
+    }
+  }
+
+  async handleDataFrame(opcode, payload) {
+    if (opcode !== 0x1) {
+      this.sendFailure("unsupported_payload", "Only UTF-8 text messages are supported");
+      return;
+    }
+
+    const raw = textDecoder.decode(payload);
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      this.sendFailure("invalid_json", "WebSocket message must be valid JSON");
+      return;
+    }
+
+    await this.forwardClientMessage(message);
+  }
+
+  async ensureUpstream(firstMessage) {
+    if (this.upstreamReady) return this.upstreamReady;
+
+    this.upstreamReady = (async () => {
+      const responseBody = getResponseCreatePayload(firstMessage);
+      if (responseBody === null) {
+        throw new Error("First Responses WebSocket message must be response.create");
+      }
+
+      const prepared = await callInternal(
+        this.fetchImpl,
+        this.baseUrl,
+        this.bridgeSecret,
+        "prepare",
+        {
+          requestUrl: this.requestUrl,
+          headers: getAuthHeaders(this.requestUrl, this.requestHeaders),
+          message: firstMessage,
+          response: responseBody,
+        }
+      );
+
+      if (!prepared.ok) {
+        const message =
+          prepared.json?.error?.message ||
+          prepared.json?.message ||
+          prepared.text ||
+          "Codex WS prepare failed";
+        const code = prepared.json?.error?.code || "codex_ws_prepare_failed";
+        const error = new Error(message);
+        error.code = code;
+        throw error;
+      }
+
+      const upstream = await this.wsFactory(prepared.json.upstreamUrl, {
+        browser: prepared.json.browser || "chrome_142",
+        os: prepared.json.os || "windows",
+        headers: prepared.json.headers || {},
+      });
+
+      upstream.onmessage = (event) => {
+        if (this.closed) return;
+        const data =
+          typeof event.data === "string" ? event.data : Buffer.from(event.data).toString("utf8");
+        this.sendFrame(0x1, Buffer.from(data, "utf8"));
+      };
+      upstream.onerror = (event) => {
+        if (this.closed) return;
+        this.sendFailure(
+          "upstream_websocket_error",
+          event.message || "Codex upstream WebSocket error"
+        );
+      };
+      upstream.onclose = (event) => {
+        if (this.closed) return;
+        this.close(event.code || 1000, event.reason || "upstream_closed");
+      };
+
+      this.upstream = upstream;
+      return {
+        upstream,
+        firstMessage: withPreparedResponseCreate(firstMessage, prepared.json.response),
+      };
+    })();
+
+    return this.upstreamReady;
+  }
+
+  async forwardClientMessage(message) {
+    try {
+      if (!this.upstream) {
+        const { upstream, firstMessage } = await this.ensureUpstream(message);
+        upstream.send(jsonStringifySafe(firstMessage));
+        return;
+      }
+      this.upstream.send(jsonStringifySafe(message));
+    } catch (error) {
+      const code = error?.code || "upstream_websocket_connect_failed";
+      const messageText = error instanceof Error ? error.message : String(error);
+      this.sendFailure(code, messageText);
+      this.close(1011, "upstream_connect_failed");
+    }
+  }
+
+  close(code = 1000, reason = "normal_closure") {
+    if (this.closed) return;
+    this.closed = true;
+
+    clearInterval(this.pingTimer);
+    try {
+      this.upstream?.close?.(code, reason);
+    } catch {
+      // ignore close races
+    }
+
+    const reasonBuffer = Buffer.from(reason, "utf8");
+    const payload = Buffer.allocUnsafe(2 + reasonBuffer.length);
+    payload.writeUInt16BE(code, 0);
+    reasonBuffer.copy(payload, 2);
+    this.sendFrame(0x8, payload);
+    this.socket.end();
+    setTimeout(() => {
+      if (!this.socket.destroyed) {
+        this.socket.destroy();
+      }
+    }, 50).unref?.();
+  }
+
+  dispose() {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.pingTimer);
+    try {
+      this.upstream?.close?.(1000, "downstream_closed");
+    } catch {
+      // ignore close races
+    }
+  }
+}
+
+export function createResponsesWsProxy({
+  baseUrl,
+  bridgeSecret,
+  fetchImpl = fetch,
+  wsFactory = websocket,
+  pingIntervalMs = 25000,
+  idleTimeoutMs = 90000,
+} = {}) {
+  if (!isText(baseUrl)) {
+    throw new Error("createResponsesWsProxy requires a baseUrl");
+  }
+  if (!isText(bridgeSecret)) {
+    throw new Error("createResponsesWsProxy requires a bridgeSecret");
+  }
+
+  return {
+    isResponsesWsPath,
+    async handleUpgrade(req, socket, head) {
+      const pathname = new URL(req.url || "/", baseUrl).pathname;
+      if (!isResponsesWsPath(pathname)) {
+        return false;
+      }
+
+      const upgradeHeader = String(req.headers.upgrade || "").toLowerCase();
+      if (upgradeHeader !== "websocket") {
+        writeHttpError(
+          socket,
+          426,
+          JSON.stringify({
+            error: {
+              message: "Upgrade Required",
+              code: "upgrade_required",
+            },
+          }),
+          { Upgrade: "websocket" }
+        );
+        return true;
+      }
+
+      try {
+        const auth = await callInternal(fetchImpl, baseUrl, bridgeSecret, "authenticate", {
+          requestUrl: req.url || pathname,
+          headers: getAuthHeaders(req.url || pathname, req.headers),
+        });
+        if (!auth.ok) {
+          writeHttpError(
+            socket,
+            auth.status,
+            auth.text || "{}",
+            Object.fromEntries(auth.headers.entries())
+          );
+          return true;
+        }
+
+        const wsKey = req.headers["sec-websocket-key"];
+        if (!isText(wsKey)) {
+          writeHttpError(
+            socket,
+            400,
+            JSON.stringify({
+              error: {
+                message: "Missing sec-websocket-key header",
+                code: "bad_websocket_handshake",
+              },
+            })
+          );
+          return true;
+        }
+
+        const acceptKey = createHash("sha1").update(`${wsKey}${WS_GUID}`).digest("base64");
+        const headers = [
+          "HTTP/1.1 101 Switching Protocols",
+          "Upgrade: websocket",
+          "Connection: Upgrade",
+          `Sec-WebSocket-Accept: ${acceptKey}`,
+          "",
+          "",
+        ].join("\r\n");
+
+        socket.write(headers);
+        if (head && head.length > 0) {
+          socket.unshift(head);
+        }
+
+        new ResponsesWsSession({
+          baseUrl,
+          bridgeSecret,
+          fetchImpl,
+          socket,
+          requestUrl: req.url || pathname,
+          requestHeaders: req.headers,
+          wsFactory,
+          pingIntervalMs,
+          idleTimeoutMs,
+        });
+        return true;
+      } catch (error) {
+        writeHttpError(
+          socket,
+          500,
+          JSON.stringify({
+            error: {
+              message: error instanceof Error ? error.message : String(error),
+              code: "responses_websocket_proxy_failed",
+            },
+          })
+        );
+        return true;
+      }
+    },
+  };
+}

scripts/run-next.mjs

@@ -7,6 +7,8 @@ import next from "next";
 import { bootstrapEnv } from "./bootstrap-env.mjs";
 import { resolveRuntimePorts, withRuntimePortEnv } from "./runtime-env.mjs";
 import { createOmnirouteWsBridge } from "./v1-ws-bridge.mjs";
+import { createResponsesWsProxy } from "./responses-ws-proxy.mjs";
+import { randomUUID } from "node:crypto";
 
 // Add check for conflicting app/ directory (Issue #1206)
 const rootAppDir = path.join(process.cwd(), "app");
@@ -35,6 +37,7 @@ for (const [key, value] of Object.entries(mergedEnv)) {
 const { dashboardPort } = runtimePorts;
 const hostname = process.env.HOST || "0.0.0.0";
 const useTurbopack = dev && mergedEnv.OMNIROUTE_USE_TURBOPACK === "1";
+process.env.OMNIROUTE_WS_BRIDGE_SECRET ||= randomUUID();
 
 const nextApp = next({
   dev,
@@ -50,6 +53,10 @@ async function start() {
 
   const requestHandler = nextApp.getRequestHandler();
   const upgradeHandler = nextApp.getUpgradeHandler();
+  const responsesWsProxy = createResponsesWsProxy({
+    baseUrl: `http://127.0.0.1:${dashboardPort}`,
+    bridgeSecret: process.env.OMNIROUTE_WS_BRIDGE_SECRET,
+  });
   const wsBridge = createOmnirouteWsBridge({
     baseUrl: `http://127.0.0.1:${dashboardPort}`,
   });
@@ -57,6 +64,8 @@ async function start() {
   const server = http.createServer((req, res) => requestHandler(req, res));
   server.on("upgrade", async (req, socket, head) => {
     try {
+      const responsesWsHandled = await responsesWsProxy.handleUpgrade(req, socket, head);
+      if (responsesWsHandled) return;
       const handled = await wsBridge.handleUpgrade(req, socket, head);
       if (handled) return;
       await upgradeHandler(req, socket, head);

scripts/standalone-server-ws.mjs

@@ -0,0 +1,70 @@
+import http from "node:http";
+import { randomUUID } from "node:crypto";
+import { createResponsesWsProxy } from "./responses-ws-proxy.mjs";
+
+const originalCreateServer = http.createServer.bind(http);
+const proxiesByPort = new Map();
+
+process.env.OMNIROUTE_WS_BRIDGE_SECRET ||= randomUUID();
+
+function getPort(server) {
+  const address = server.address?.();
+  if (address && typeof address === "object" && typeof address.port === "number") {
+    return address.port;
+  }
+  const rawPort = process.env.PORT || process.env.DASHBOARD_PORT || "3000";
+  const parsed = Number.parseInt(rawPort, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 3000;
+}
+
+function getProxy(server) {
+  const port = getPort(server);
+  const existing = proxiesByPort.get(port);
+  if (existing) return existing;
+
+  const proxy = createResponsesWsProxy({
+    baseUrl: `http://127.0.0.1:${port}`,
+    bridgeSecret: process.env.OMNIROUTE_WS_BRIDGE_SECRET,
+  });
+  proxiesByPort.set(port, proxy);
+  return proxy;
+}
+
+function wrapUpgradeListener(server, listener) {
+  return async function responsesWsAwareUpgrade(req, socket, head) {
+    try {
+      const handled = await getProxy(server).handleUpgrade(req, socket, head);
+      if (handled) return;
+      return listener.call(this, req, socket, head);
+    } catch (error) {
+      if (!socket.destroyed) {
+        socket.destroy(error instanceof Error ? error : undefined);
+      }
+      console.error("[Responses WS] Upgrade handling failed:", error);
+    }
+  };
+}
+
+http.createServer = function createServerWithResponsesWs(...args) {
+  const server = originalCreateServer(...args);
+  const originalOn = server.on.bind(server);
+  const originalAddListener = server.addListener.bind(server);
+
+  server.on = function patchedOn(eventName, listener) {
+    if (eventName === "upgrade" && typeof listener === "function") {
+      return originalOn(eventName, wrapUpgradeListener(server, listener));
+    }
+    return originalOn(eventName, listener);
+  };
+
+  server.addListener = function patchedAddListener(eventName, listener) {
+    if (eventName === "upgrade" && typeof listener === "function") {
+      return originalAddListener(eventName, wrapUpgradeListener(server, listener));
+    }
+    return originalAddListener(eventName, listener);
+  };
+
+  return server;
+};
+
+await import("./server.js");

scripts/validate-pack-artifact.ts

@@ -18,13 +18,27 @@ const ROOT: string = join(__dirname, "..");
 const npmCommand: string = process.platform === "win32" ? "npm.cmd" : "npm";
 
 function runPackDryRun(): any {
-  const output = execFileSync(npmCommand, ["pack", "--dry-run", "--json", "--ignore-scripts"], {
+  const npmExecPath = process.env.npm_execpath;
+  const command = npmExecPath ? process.execPath : npmCommand;
+  const args = [
+    ...(npmExecPath ? [npmExecPath] : []),
+    "pack",
+    "--dry-run",
+    "--json",
+    "--ignore-scripts",
+  ];
+
+  const output = execFileSync(command, args, {
     cwd: ROOT,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
   });
 
-  const parsed = JSON.parse(output);
+  const jsonStart = output.indexOf("[");
+  const jsonEnd = output.lastIndexOf("]");
+  const jsonPayload =
+    jsonStart >= 0 && jsonEnd > jsonStart ? output.slice(jsonStart, jsonEnd + 1) : output;
+  const parsed = JSON.parse(jsonPayload);
   const packReport = Array.isArray(parsed) ? parsed[0] : null;
 
   if (!packReport || !Array.isArray(packReport.files)) {