fix: dynamic import `ws` to prevent Electron ESM startup crash (#88)

The `ws` package uses CJS `require('events')` internally. When esbuild
bundles the server as ESM for Electron, these dynamic requires fail at
startup with "Dynamic require of 'events' is not supported".

Switch to lazy dynamic `import("ws")` so the CJS dependency chain is
only resolved at first WebSocket use, not at module load time.

Also lazy-import `https-proxy-agent` for the same reason.

Closes #87

Co-authored-by: icebear0828 <icebear0828@users.noreply.github.com>

src/proxy/ws-transport.ts

@@ -7,12 +7,27 @@
  * regardless of whether HTTP SSE or WebSocket was used.
  *
  * Used when `previous_response_id` is present — HTTP SSE does not support it.
+ *
+ * The `ws` package is loaded lazily via dynamic import to avoid
+ * "Dynamic require of 'events' is not supported" errors when the
+ * backend is bundled as ESM for Electron (esbuild cannot convert
+ * ws's CJS require chain to ESM statics).
  */
 
-import WebSocket from "ws";
-import { HttpsProxyAgent } from "https-proxy-agent";
 import type { CodexInputItem } from "./codex-api.js";
 
+/** Cached ws module — loaded once on first use. */
+let _WS: typeof import("ws").default | undefined;
+
+/** Lazily load the `ws` package. */
+async function getWS(): Promise<typeof import("ws").default> {
+  if (!_WS) {
+    const mod = await import("ws");
+    _WS = mod.default;
+  }
+  return _WS;
+}
+
 /** Flat WebSocket message format expected by the Codex backend. */
 export interface WsCreateRequest {
   type: "response.create";
@@ -42,24 +57,29 @@ export interface WsCreateRequest {
  * The SSE format matches what parseStream() expects:
  *   event: <type>\ndata: <json>\n\n
  */
-export function createWebSocketResponse(
+export async function createWebSocketResponse(
   wsUrl: string,
   headers: Record<string, string>,
   request: WsCreateRequest,
   signal?: AbortSignal,
   proxyUrl?: string | null,
 ): Promise<Response> {
+  const WS = await getWS();
+
+  // Lazy-import proxy agent only when needed
+  const wsOpts: ConstructorParameters<typeof WS>[2] = { headers };
+  if (proxyUrl) {
+    const { HttpsProxyAgent } = await import("https-proxy-agent");
+    wsOpts.agent = new HttpsProxyAgent(proxyUrl);
+  }
+
   return new Promise<Response>((resolve, reject) => {
     if (signal?.aborted) {
       reject(new Error("Aborted before WebSocket connect"));
       return;
     }
 
-    const wsOpts: WebSocket.ClientOptions = { headers };
-    if (proxyUrl) {
-      wsOpts.agent = new HttpsProxyAgent(proxyUrl);
-    }
-    const ws = new WebSocket(wsUrl, wsOpts);
+    const ws = new WS(wsUrl, wsOpts);
     const encoder = new TextEncoder();
     let controller: ReadableStreamDefaultController<Uint8Array> | null = null;
     let streamClosed = false;