fix: resolve editor proxy WebSocket handshake timeout

Replace .resolve() with .derive() for passing request URL to WebSocket
handlers — resolve can fail to deliver data to ws handlers in Elysia,
causing wsOpen to throw silently and never creating the upstream
connection. Add fallback URL reconstruction from params/query, wrap
wsOpen in try-catch, add upstream connection timeout, and log WS events
for diagnostics.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Remote Agent

packages/api/src/routes/editor-proxy.routes.ts

@@ -154,63 +154,102 @@ for (const path of paths) {
 const upstreamSockets = new WeakMap<object, WebSocket>();
 const messageBuffers = new WeakMap<object, (string | ArrayBuffer)[]>();
 
-function wsOpen(ws: any) {
-  const { params, requestUrl } = ws.data;
-  const editorId = params.editorId;
-
-  const editor = codeEditorService.getEditor(editorId);
-  if (!editor || (editor.status !== 'running' && editor.status !== 'starting')) {
-    ws.close();
-    return;
+function buildUpstreamWsUrl(ws: any, editorId: string, port: number): string {
+  // Primary: use requestUrl captured by derive()
+  const requestUrl: string | undefined = ws.data.requestUrl;
+  if (requestUrl) {
+    const url = new URL(requestUrl);
+    const strippedPath = stripProxyPrefix(url.pathname, editorId);
+    return `ws://127.0.0.1:${port}${strippedPath}${url.search}`;
   }
 
-  const url = new URL(requestUrl);
-  const strippedPath = stripProxyPrefix(url.pathname, editorId);
-  const targetUrl = `ws://127.0.0.1:${editor.port}${strippedPath}${url.search}`;
-
-  // Forward Sec-WebSocket-Protocol if the client sent one
-  const protocolHeader: string | undefined = ws.data.headers?.['sec-websocket-protocol'];
-  const protocols = protocolHeader
-    ? protocolHeader.split(',').map((p: string) => p.trim())
-    : undefined;
+  // Fallback: reconstruct from route params and query
+  console.warn('[EditorProxy] WS: requestUrl missing from context, reconstructing from params/query');
+  const wildcardPath = ws.data.params['*'] || '';
+  const forwardPath = wildcardPath ? `/${wildcardPath}` : '/';
+  const queryObj = ws.data.query || {};
+  const qs = new URLSearchParams(queryObj as Record<string, string>).toString();
+  return `ws://127.0.0.1:${port}${forwardPath}${qs ? '?' + qs : ''}`;
+}
 
-  const upstream = new WebSocket(targetUrl, protocols);
-  upstream.binaryType = 'arraybuffer';
-  upstreamSockets.set(ws, upstream);
+function wsOpen(ws: any) {
+  const editorId = ws.data.params.editorId;
 
-  const buffer: (string | ArrayBuffer)[] = [];
-  messageBuffers.set(ws, buffer);
+  try {
+    const editor = codeEditorService.getEditor(editorId);
+    if (!editor || (editor.status !== 'running' && editor.status !== 'starting')) {
+      console.warn(`[EditorProxy] WS: Editor ${editorId} not available (status: ${editor?.status ?? 'not found'})`);
+      ws.close();
+      return;
+    }
 
-  upstream.addEventListener('open', () => {
-    for (const msg of buffer) upstream.send(msg);
-    buffer.length = 0;
-  });
+    const targetUrl = buildUpstreamWsUrl(ws, editorId, editor.port);
+    console.log(`[EditorProxy] WS open: editor=${editorId} → ${targetUrl}`);
+
+    // Forward Sec-WebSocket-Protocol if the client sent one
+    const headers = ws.data.headers || {};
+    const protocolHeader: string | undefined = headers['sec-websocket-protocol'];
+    const protocols = protocolHeader
+      ? protocolHeader.split(',').map((p: string) => p.trim())
+      : undefined;
+
+    const upstream = protocols?.length
+      ? new WebSocket(targetUrl, protocols)
+      : new WebSocket(targetUrl);
+    upstream.binaryType = 'arraybuffer';
+    upstreamSockets.set(ws, upstream);
+
+    const buffer: (string | ArrayBuffer)[] = [];
+    messageBuffers.set(ws, buffer);
+
+    upstream.addEventListener('open', () => {
+      console.log(`[EditorProxy] WS upstream connected: editor=${editorId}`);
+      for (const msg of buffer) upstream.send(msg);
+      buffer.length = 0;
+    });
 
-  upstream.addEventListener('message', (event: MessageEvent) => {
-    try {
-      if (typeof event.data === 'string') {
-        ws.send(event.data);
-      } else {
-        // Must use ws.raw.send() for binary data — Elysia's ws.send()
-        // JSON-stringifies objects (including Uint8Array), corrupting binary frames.
-        ws.raw.send(new Uint8Array(event.data as ArrayBuffer));
+    upstream.addEventListener('message', (event: MessageEvent) => {
+      try {
+        if (typeof event.data === 'string') {
+          ws.send(event.data);
+        } else {
+          // Must use ws.raw.send() for binary data — Elysia's ws.send()
+          // JSON-stringifies objects (including Uint8Array), corrupting binary frames.
+          ws.raw.send(new Uint8Array(event.data as ArrayBuffer));
+        }
+      } catch {
+        // Client already disconnected
       }
-    } catch {
-      // Client already disconnected
-    }
-  });
+    });
 
-  upstream.addEventListener('close', () => {
-    upstreamSockets.delete(ws);
-    messageBuffers.delete(ws);
-    try { ws.close(); } catch {}
-  });
+    upstream.addEventListener('close', (event: CloseEvent) => {
+      console.log(`[EditorProxy] WS upstream closed: editor=${editorId} code=${event.code}`);
+      upstreamSockets.delete(ws);
+      messageBuffers.delete(ws);
+      try { ws.close(); } catch {}
+    });
 
-  upstream.addEventListener('error', () => {
-    upstreamSockets.delete(ws);
-    messageBuffers.delete(ws);
+    upstream.addEventListener('error', (event: Event) => {
+      console.error(`[EditorProxy] WS upstream error: editor=${editorId}`, event);
+      upstreamSockets.delete(ws);
+      messageBuffers.delete(ws);
+      try { ws.close(); } catch {}
+    });
+
+    // Safety timeout: if upstream never connects, clean up
+    setTimeout(() => {
+      if (upstream.readyState === WebSocket.CONNECTING) {
+        console.error(`[EditorProxy] WS upstream connect timeout (10s): editor=${editorId}`);
+        upstream.close();
+        upstreamSockets.delete(ws);
+        messageBuffers.delete(ws);
+        try { ws.close(); } catch {}
+      }
+    }, 10_000);
+  } catch (err) {
+    console.error(`[EditorProxy] WS open error: editor=${editorId}`, err);
     try { ws.close(); } catch {}
-  });
+  }
 }
 
 function wsMessage(ws: any, message: string | Buffer) {
@@ -247,10 +286,11 @@ function wsClose(ws: any) {
 
 const wsHandler = { open: wsOpen, message: wsMessage, close: wsClose };
 
-// .resolve() captures request URL and headers for the ws open handler (runs before upgrade).
-base.resolve(({ request }) => ({
+// derive() captures the raw request URL for the ws open handler.
+// Using derive (not resolve) because resolve can fail to pass data to ws handlers in Elysia.
+// We only store requestUrl — Elysia's default ws.data.headers already has request headers.
+base.derive(({ request }) => ({
   requestUrl: request.url,
-  headers: Object.fromEntries(request.headers.entries()),
 }));
 
 for (const path of paths) {