Merge 2ba7120 into c4d7a9e

Author: Mkassabov

alchemy/package.json

@@ -146,6 +146,7 @@
     "libsodium-wrappers": "^0.7.15",
     "turndown": "^7.0.0",
     "unenv": "2.0.0-rc.15",
+    "ws": "^8.18.2",
     "yaml": "^2.0.0"
   },
   "peerDependencies": {
@@ -189,6 +190,7 @@
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "latest",
     "@types/turndown": "^5.0.5",
+    "@types/ws": "^8.18.1",
     "ai": "^4.1.16",
     "alchemy": "^0.37.1",
     "arktype": "^2.1.16",

alchemy/src/alchemy.ts

@@ -394,6 +394,12 @@ export interface AlchemyOptions {
    * If not provided, the default fallback logger will be used.
    */
   logger?: LoggerApi;
+  /**
+   * Whether to persist runtime logs to a file.
+   *
+   * @default true
+   */
+  persistLogs?: boolean;
 }
 
 export interface ScopeOptions extends AlchemyOptions {

alchemy/src/cloudflare/worker.ts

@@ -334,6 +334,12 @@ export interface BaseWorkerProps<
          * Port to use for local development
          */
         port?: number;
+        /**
+         * Whether to log to the console.
+         *
+         * @default true
+         */
+        logToConsole?: boolean;
         /**
          * EXPERIMENTAL: Whether to run the worker remotely instead of locally.
          *
@@ -1035,6 +1041,10 @@ export const _Worker = Resource(
         compatibilityFlags,
         bindings: props.bindings ?? ({} as B),
         port: typeof props.dev === "object" ? props.dev.port : undefined,
+        logToConsole:
+          typeof props.dev === "object"
+            ? (props.dev?.logToConsole ?? true)
+            : true,
       };
 
       let url: string;

alchemy/src/cloudflare/worker/miniflare-worker-options.ts

@@ -20,6 +20,7 @@ export type MiniflareWorkerOptions = Pick<
   name: string;
   script: string;
   port?: number;
+  logToConsole: boolean;
 };
 
 type BindingType = Exclude<Binding, string | Self>["type"];
@@ -225,6 +226,7 @@ export function buildMiniflareWorkerOptions({
     compatibilityDate,
     compatibilityFlags,
     unsafeDirectSockets: [{ entrypoint: undefined, proxy: true }],
+    unsafeInspectorProxy: true,
     containerEngine: {
       localDocker: {
         socketPath:

alchemy/src/cloudflare/worker/miniflare.ts

@@ -6,6 +6,7 @@ import {
   type WorkerOptions,
 } from "miniflare";
 import path from "node:path";
+import { InspectorProxy } from "../../util/chrome-devtools/inspector-proxy.ts";
 import { findOpenPort } from "../../util/find-open-port.ts";
 import { logger } from "../../util/logger.ts";
 import {
@@ -25,6 +26,8 @@ class MiniflareServer {
   workers = new Map<string, WorkerOptions>();
   servers = new Map<string, HTTPServer>();
   mixedModeProxies = new Map<string, MixedModeProxy>();
+  inspectorPort?: number;
+  inspectorProxies: Map<string, InspectorProxy> = new Map();
 
   stream = new WritableStream<{
     worker: MiniflareWorkerOptions;
@@ -70,6 +73,10 @@ class MiniflareServer {
       await withErrorRewrite(
         this.miniflare.setOptions(await this.miniflareOptions()),
       );
+      const inspectorProxy = this.inspectorProxies.get(worker.name);
+      if (inspectorProxy) {
+        await inspectorProxy.reconnect();
+      }
     } else {
       const { Miniflare } = await import("miniflare").catch(() => {
         throw new Error(
@@ -95,6 +102,15 @@ class MiniflareServer {
       port: worker.port ?? (await findOpenPort()),
       fetch: this.createRequestHandler(worker.name as string),
     });
+    const inspectorProxy = new InspectorProxy(
+      server.server,
+      `ws://localhost:${this.inspectorPort}/${worker.name}`,
+      {
+        consoleIdentifier: worker.logToConsole ? worker.name : undefined,
+      },
+    );
+    this.inspectorProxies.set(worker.name, inspectorProxy);
+
     this.servers.set(worker.name, server);
     await server.ready;
     return server;
@@ -139,6 +155,23 @@ class MiniflareServer {
   private createRequestHandler(name: string) {
     return async (req: Request) => {
       try {
+        const url = new URL(req.url);
+        const subdomain = url.hostname.split(".")[0];
+        if (subdomain === "inspect") {
+          if (url.pathname === "/" && url.searchParams.get("ws") == null) {
+            return Response.redirect(
+              `http://inspect.localhost:${url.port}?ws=localhost:${url.port}`,
+              302,
+            );
+          }
+          const app = await fetch(
+            `http://devtools.devprod.cloudflare.dev/${url.pathname === "/" ? "js_app" : url.pathname}`,
+          );
+          app.headers.delete("content-encoding");
+          app.headers.delete("content-length");
+          return app;
+        }
+
         if (!this.miniflare) {
           return new Response(
             "[Alchemy] Miniflare is not initialized. Please try again.",
@@ -177,7 +210,8 @@ class MiniflareServer {
 
   private async miniflareOptions(): Promise<MiniflareOptions> {
     const { getDefaultDevRegistryPath } = await import("miniflare");
-    return {
+    this.inspectorPort = this.inspectorPort ?? (await findOpenPort());
+    const options = {
       workers: Array.from(this.workers.values()),
       defaultPersistRoot: path.join(process.cwd(), ".alchemy/miniflare"),
       unsafeDevRegistryPath: getDefaultDevRegistryPath(),
@@ -189,7 +223,10 @@ class MiniflareServer {
       r2Persist: true,
       secretsStorePersist: true,
       workflowsPersist: true,
+      inspectorPort: this.inspectorPort,
+      handleRuntimeStdio: () => {},
     };
+    return options;
   }
 }
 

alchemy/src/scope.ts

@@ -41,6 +41,7 @@ export interface ScopeOptions {
   dev?: boolean;
   telemetryClient?: ITelemetryClient;
   logger?: LoggerApi;
+  persistLogs?: boolean;
 }
 
 export type PendingDeletions = Array<{
@@ -111,6 +112,7 @@ export class Scope {
   public readonly logger: LoggerApi;
   public readonly telemetryClient: ITelemetryClient;
   public readonly dataMutex: AsyncMutex;
+  public readonly persistLogs: boolean;
 
   private isErrored = false;
   private finalized = false;
@@ -184,6 +186,7 @@ export class Scope {
     this.telemetryClient =
       options.telemetryClient ?? this.parent?.telemetryClient!;
     this.dataMutex = new AsyncMutex();
+    this.persistLogs = options.persistLogs ?? this.parent?.persistLogs ?? true;
   }
 
   public get root(): Scope {

alchemy/src/test/vitest.ts

@@ -145,6 +145,7 @@ export function test(
     phase: "up",
     telemetryClient: new NoopTelemetryClient(),
     quiet: defaultOptions.quiet,
+    persistLogs: false,
   });
 
   test.beforeAll = (fn: (scope: Scope) => Promise<void>) => {