feat(cloudflare): debugging support for cf workers

alchemy-web/src/content/docs/guides/planetscale-drizzle.mdx

@@ -261,4 +261,4 @@ This guide shows how to create and manage [PlanetScale](https://planetscale.com/
      </TabItem>
    </Tabs>
 
-</Steps>
+</Steps>

alchemy/bin/services/cdp-manager/cdp-proxy.ts

@@ -1,37 +1,64 @@
-import type { WebSocket as WsWebSocket } from "ws";
-import { CDPServer } from "./server.ts";
+import { WebSocket } from "ws";
+import {
+  CDPServer,
+  type ClientCDPMessage,
+  type ServerCDPMessage,
+} from "./server.ts";
 
 export class CDPProxy extends CDPServer {
   private inspectorUrl: string;
   private inspectorWs?: WebSocket;
-  private onStartMessageQueue: Array<string>;
+  private onStartMessageQueue: Array<ClientCDPMessage>;
+  private enabledDomains: Set<string> = new Set();
+  private debuggerId?: string;
 
   constructor(
     inspectorUrl: string,
     options: ConstructorParameters<typeof CDPServer>[0] & {
       connect?: boolean;
+      hotDomains?: Array<string>;
     },
   ) {
     super(options);
     this.inspectorUrl = inspectorUrl;
     this.onStartMessageQueue = [];
+    for (const domain of options.hotDomains ?? []) {
+      this.onStartMessageQueue.push({
+        id: ++this.internalMessageId,
+        method: `${domain}.enable`,
+        params: {},
+      });
+    }
     if (options.connect ?? true) {
       this.start();
     }
   }
 
   public async start(): Promise<void> {
-    this.inspectorWs = new WebSocket(this.inspectorUrl);
+    if (this.inspectorWs != null) {
+      this.inspectorWs.close();
+    }
+    this.inspectorWs = new WebSocket(this.inspectorUrl, {
+      headers: {
+        Origin: "http://localhost",
+      },
+    });
+
+    this.inspectorWs.onmessage = async (event) => {
+      const json = JSON.parse(event.data.toString()) as ServerCDPMessage;
+      if (json.id != null && json?.result?.debuggerId != null) {
+        this.debuggerId = json?.result?.debuggerId;
+      }
+      await this.handleInspectorMessage(
+        JSON.parse(event.data.toString()) as ServerCDPMessage,
+      );
+    };
 
-    this.inspectorWs.addEventListener("open", async () => {
+    this.inspectorWs.onopen = async () => {
       await new Promise((resolve) => setTimeout(resolve, 1000));
       for (const message of this.onStartMessageQueue) {
-        this.internalHandleClientMessage(message);
+        this.handleClientMessage(undefined, message);
       }
-    });
-
-    this.inspectorWs.onmessage = async (event) => {
-      await this.handleInspectorMessage(event.data.toString());
     };
 
     this.inspectorWs.onclose = () => {
@@ -43,7 +70,10 @@ export class CDPProxy extends CDPServer {
     };
   }
 
-  async handleClientMessage(_ws: WsWebSocket, data: string): Promise<void> {
+  async handleClientMessage(
+    clientId: string | undefined,
+    data: ClientCDPMessage,
+  ): Promise<void> {
     if (
       this.inspectorWs == null ||
       this.inspectorWs.readyState !== WebSocket.OPEN
@@ -54,16 +84,57 @@ export class CDPProxy extends CDPServer {
       this.onStartMessageQueue.push(data);
       return;
     } else {
-      this.internalHandleClientMessage(data);
+      this.internalHandleClientMessage(clientId, data);
     }
   }
 
-  private async internalHandleClientMessage(data: string): Promise<void> {
-    const message = JSON.parse(data);
-    const messageDomain = message.method?.split(".")?.[0];
-    if (messageDomain != null && !this.domains.has(messageDomain)) {
-      return;
+  private async internalHandleClientMessage(
+    clientId: string | undefined,
+    data: ClientCDPMessage,
+  ): Promise<void> {
+    const messageDomain = data.method?.split(".")?.[0];
+
+    if (data.method?.endsWith(".enable") && messageDomain) {
+      if (this.enabledDomains.has(messageDomain)) {
+        if (clientId != null) {
+          const client = this.getClientById(clientId);
+          if (client != null) {
+            //* handle some special cases where enabling isn't properly reported
+            switch (data.method) {
+              case "Runtime.enable": {
+                client.send(
+                  JSON.stringify({
+                    id: data.id,
+                    result: {},
+                  }),
+                );
+                break;
+              }
+              case "Debugger.enable": {
+                if (this.debuggerId != null) {
+                  client.send(
+                    JSON.stringify({
+                      id: data.id,
+                      result: {
+                        debuggerId: this.debuggerId,
+                      },
+                    }),
+                  );
+                  break;
+                }
+              }
+            }
+          }
+        }
+        return;
+      }
+      this.enabledDomains.add(messageDomain);
+
+      if (data.id != null) {
+        data.id = ++this.internalMessageId;
+      }
     }
-    this.inspectorWs!.send(data);
+
+    this.inspectorWs!.send(JSON.stringify(data));
   }
 }