alchemy 2.0.0-beta.34 → 2.0.0-beta.35

package/src/Cloudflare/CloudflareEnvironment.ts

@@ -4,7 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { getAuthProvider } from "../Auth/AuthProvider.ts";
-import { ALCHEMY_PROFILE, loadOrConfigure } from "../Auth/Profile.ts";
+import { ALCHEMY_PROFILE, Profile } from "../Auth/Profile.ts";
 import {
   CLOUDFLARE_AUTH_PROVIDER_NAME,
   type CloudflareAuthConfig,
@@ -34,6 +34,7 @@ export const fromProfile = () =>
   Layer.effect(
     CloudflareEnvironment,
     Effect.gen(function* () {
+      const profile = yield* Profile;
       const auth = yield* getAuthProvider<
         CloudflareAuthConfig,
         CloudflareResolvedCredentials
@@ -43,7 +44,7 @@ export const fromProfile = () =>
       // `loadOrConfigure` reads the persisted config under the canonical
       // provider name (`Cloudflare`); only runs `configure` (and persists the
       // result) if no stored config exists.
-      const config = yield* loadOrConfigure(auth, profileName, { ci });
+      const config = yield* profile.loadOrConfigure(auth, profileName, { ci });
       return yield* auth.read(profileName, config as CloudflareAuthConfig);
     }),
   );

package/src/Cloudflare/Credentials.ts

@@ -11,7 +11,7 @@ import * as Layer from "effect/Layer";
 import * as Match from "effect/Match";
 import * as Redacted from "effect/Redacted";
 import { getAuthProvider } from "../Auth/AuthProvider.ts";
-import { ALCHEMY_PROFILE, loadOrConfigure } from "../Auth/Profile.ts";
+import { ALCHEMY_PROFILE, Profile } from "../Auth/Profile.ts";
 import {
   CLOUDFLARE_AUTH_PROVIDER_NAME,
   type CloudflareAuthConfig,
@@ -29,15 +29,15 @@ export const fromAuthProvider = () =>
   Layer.effect(
     Credentials,
     Effect.gen(function* () {
+      const profile = yield* Profile;
       const auth = yield* getAuthProvider<
         CloudflareAuthConfig,
         CloudflareResolvedCredentials
       >(CLOUDFLARE_AUTH_PROVIDER_NAME);
       const profileName = yield* ALCHEMY_PROFILE;
       const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
-      const ctx = yield* Effect.context<never>();
 
-      return loadOrConfigure(auth, profileName, { ci }).pipe(
+      return profile.loadOrConfigure(auth, profileName, { ci }).pipe(
         Effect.flatMap((config) =>
           auth.read(profileName, config as CloudflareAuthConfig),
         ),
@@ -69,7 +69,6 @@ export const fromAuthProvider = () =>
               message: `Failed to resolve Cloudflare credentials for profile '${profileName}': ${(e as { message?: string }).message ?? String(e)}`,
             }),
         ),
-        Effect.provide(ctx),
       );
     }),
   );

package/src/Cloudflare/Local/Sidecar.ts

@@ -1,7 +1,4 @@
-import {
-  ServeError,
-  type ServeResult,
-} from "@distilled.cloud/cloudflare-runtime/Server";
+import { RuntimeError } from "@distilled.cloud/cloudflare-runtime/RuntimeError";
 import * as Worker from "@distilled.cloud/cloudflare-runtime/Worker";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
@@ -22,13 +19,19 @@ export interface ServeOptions extends WorkerBundleOptions {
   durableObjectNamespaces: Worker.DurableObjectNamespace[];
 }
 
+export const ServeResult = Schema.Struct({
+  name: Schema.String,
+  address: Schema.String,
+});
+export type ServeResult = typeof ServeResult.Type;
+
+export const ServeError = Schema.Union([RuntimeError, BundleError]);
+export type ServeError = typeof ServeError.Type;
+
 export const SidecarSchema = defineSchema<Sidecar["Service"]>({
   serve: {
-    success: Schema.Struct({
-      name: Schema.String,
-      address: Schema.String,
-    }),
-    error: Schema.Union([ServeError, BundleError]),
+    success: ServeResult,
+    error: ServeError,
   },
   stop: { success: Schema.Void, error: Schema.Never },
 });
@@ -38,7 +41,7 @@ export class Sidecar extends RpcClient.RpcClientService<
   {
     readonly serve: (
       options: ServeOptions,
-    ) => Effect.Effect<ServeResult, ServeError | BundleError>;
+    ) => Effect.Effect<ServeResult, ServeError>;
     readonly stop: (name: string) => Effect.Effect<void>;
   }
 >()("Sidecar") {}

package/src/Cloudflare/Local/SidecarHandlers.ts

@@ -12,7 +12,12 @@ import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { WorkerBundle } from "../Workers/WorkerBundle.ts";
-import { Sidecar, type ServeOptions } from "./Sidecar.ts";
+import {
+  Sidecar,
+  type ServeError,
+  type ServeOptions,
+  type ServeResult,
+} from "./Sidecar.ts";
 
 export const SidecarHandlers = Layer.effect(
   Sidecar,
@@ -29,10 +34,6 @@ export const SidecarHandlers = Layer.effect(
     ) {
       const scope = yield* Effect.flatMap(Effect.scope, Scope.fork);
       const result = yield* server
-        // The published @distilled.cloud/cloudflare-runtime types don't yet
-        // declare `hyperdrives` on the serve options, but the runtime
-        // accepts it. Cast through any so dev-mode local DB wiring works
-        // until the type is shipped upstream.
         .serve({
           name: worker.id.toLowerCase(),
           compatibilityDate: worker.compatibility.date,
@@ -55,19 +56,13 @@ export const SidecarHandlers = Layer.effect(
       string,
       {
         hash: number;
-        fiber: Fiber.Fiber<
-          Server.ServeResult,
-          Server.ServeError | Bundle.BundleError
-        >;
+        fiber: Fiber.Fiber<ServeResult, ServeError>;
         scope: Scope.Closeable;
       }
     >();
 
     const serveFiber = Effect.fnUntraced(function* (worker: ServeOptions) {
-      const result = yield* Deferred.make<
-        Server.ServeResult,
-        Server.ServeError | Bundle.BundleError
-      >();
+      const result = yield* Deferred.make<ServeResult, ServeError>();
       let start = Date.now();
       yield* bundle.watch(worker).pipe(
         Stream.mapEffect((event) =>

package/src/Cloudflare/Local/SidecarServer.ts

@@ -5,7 +5,10 @@ import * as Path from "effect/Path";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import * as AlchemyContext from "../../AlchemyContext.ts";
 import { AuthProviders } from "../../Auth/AuthProvider.ts";
+import { CredentialsStoreLive } from "../../Auth/Credentials.ts";
+import { ProfileLive } from "../../Auth/Profile.ts";
 import * as RpcServer from "../../Sidecar/RpcServer.ts";
+import * as RpcServices from "../../Sidecar/RpcServices.ts";
 import {
   httpServer,
   PlatformServices,
@@ -23,6 +26,8 @@ const apiServices = Layer.merge(
 ).pipe(
   Layer.provide(CloudflareAuth),
   Layer.provide(Layer.succeed(AuthProviders, {})),
+  Layer.provide(ProfileLive),
+  Layer.provide(CredentialsStoreLive),
 );
 
 const runtimeServices = SidecarHandlers.pipe(
@@ -46,7 +51,7 @@ const runtimeServices = SidecarHandlers.pipe(
 );
 
 const services = Layer.provideMerge(
-  Layer.provideMerge(runtimeServices, RpcServer.layerServices(import.meta.url)),
+  Layer.provideMerge(runtimeServices, RpcServices.layer(import.meta.url)),
   PlatformServices,
 );
 

package/src/Cloudflare/Logs.ts

@@ -1,6 +1,10 @@
 import * as workers from "@distilled.cloud/cloudflare/workers";
+import type * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Schedule from "effect/Schedule";
 import * as Stream from "effect/Stream";
+import * as Socket from "effect/unstable/socket/Socket";
 import type { LogLine, LogsInput } from "../Provider.ts";
 
 const DEFAULT_LOOKBACK_MS = 1 * 60 * 60 * 1000;
@@ -23,6 +27,33 @@ export interface TelemetryFilter {
   value?: string | number | boolean;
 }
 
+interface TailEventMessage {
+  eventTimestamp?: number;
+  wallTime: number;
+  cpuTime: number;
+  truncated: boolean;
+  outcome: string;
+  scriptName: string;
+  exceptions: {
+    name: string;
+    message: string;
+    stack: string;
+    timestamp: string;
+  }[];
+  logs: {
+    message: string[];
+    level: string;
+    timestamp: string;
+  }[];
+  event:
+    | {
+        request: { method: string; url: string };
+        response?: { status: number };
+      }
+    | null
+    | undefined;
+}
+
 const parseEvents = (
   response: workers.QueryObservabilityTelemetryResponse,
 ): LogLine[] => {
@@ -44,6 +75,8 @@ const parseEvents = (
 
 export const CloudflareLogs = Effect.gen(function* () {
   const queryTelemetry = yield* workers.queryObservabilityTelemetry;
+  const createScriptTail = yield* workers.createScriptTail;
+  const deleteScriptTail = yield* workers.deleteScriptTail;
 
   const queryLogs = (opts: {
     accountId: string;
@@ -83,6 +116,87 @@ export const CloudflareLogs = Effect.gen(function* () {
       return parseEvents(response);
     });
 
+  /**
+   * Open a real-time Workers tail session against `scriptName` and
+   * surface its messages as a {@link LogLine} stream. The websocket is
+   * automatically reconnected (with `Stream.repeat`) when Cloudflare
+   * closes it after its idle window.
+   */
+  const tailScript = (opts: { accountId: string; scriptName: string }) => {
+    const runTailSession = Effect.gen(function* () {
+      const { id: tailId, url } = yield* createScriptTail({
+        scriptName: opts.scriptName,
+        accountId: opts.accountId,
+        body: { filters: [] },
+      });
+
+      const socket = yield* Socket.makeWebSocket(url, {
+        protocols: ["trace-v1"],
+      });
+
+      const queue = yield* Queue.make<LogLine, Cause.Done>();
+
+      yield* socket
+        .runRaw((raw) => {
+          const text =
+            typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+          const data: TailEventMessage = JSON.parse(text);
+          const eventTs = new Date(data.eventTimestamp ?? Date.now());
+
+          if (data.event && "request" in data.event) {
+            const reqEvent = data.event;
+            const pathname = (() => {
+              try {
+                return new URL(reqEvent.request.url).pathname;
+              } catch {
+                return reqEvent.request.url;
+              }
+            })();
+            const status = reqEvent.response?.status ?? 500;
+            Queue.offerUnsafe(queue, {
+              timestamp: eventTs,
+              message: `${reqEvent.request.method} ${pathname} > ${status} (cpu: ${Math.round(data.cpuTime)}ms, wall: ${Math.round(data.wallTime)}ms)`,
+            });
+          }
+
+          for (const log of data.logs) {
+            const msg = log.message.join(" ");
+            Queue.offerUnsafe(queue, {
+              timestamp: new Date(log.timestamp),
+              message: log.level === "log" ? msg : `${log.level}: ${msg}`,
+            });
+          }
+
+          for (const exception of data.exceptions) {
+            Queue.offerUnsafe(queue, {
+              timestamp: new Date(exception.timestamp),
+              message: `${exception.name} ${exception.message}\n${exception.stack}`,
+            });
+          }
+        })
+        .pipe(
+          Effect.ensuring(
+            Effect.all([
+              deleteScriptTail({
+                scriptName: opts.scriptName,
+                id: tailId,
+                accountId: opts.accountId,
+              }).pipe(Effect.ignore),
+              Queue.end(queue),
+            ]),
+          ),
+          Effect.ignore,
+          Effect.forkChild(),
+        );
+
+      return Stream.fromQueue(queue);
+    });
+
+    return Stream.unwrap(runTailSession).pipe(
+      Stream.repeat(Schedule.spaced("1 second")),
+    );
+  };
+
   const tailStream = (opts: {
     accountId: string;
     filters: TelemetryFilter[];
@@ -118,5 +232,5 @@ export const CloudflareLogs = Effect.gen(function* () {
     return poll(Date.now());
   };
 
-  return { queryLogs, tailStream };
+  return { queryLogs, tailScript, tailStream };
 });

package/src/Cloudflare/Providers.ts

@@ -8,6 +8,8 @@ import * as Schedule from "effect/Schedule";
 import { Command } from "../Build/Command.ts";
 import * as Build from "../Build/index.ts";
 import * as Provider from "../Provider.ts";
+import { CredentialsStoreLive } from "../Auth/Credentials.ts";
+import { ProfileLive } from "../Auth/Profile.ts";
 import { Random, RandomProvider } from "../Random.ts";
 import * as Access from "./Access.ts";
 import * as AiGateway from "./AiGateway/index.ts";
@@ -59,6 +61,7 @@ export const providers = () =>
       Queue.Queue,
       Queue.QueueBindingPolicy,
       Queue.QueueConsumer,
+      Queue.QueueEventSourcePolicy,
       R2.R2Bucket,
       R2.R2BucketBindingPolicy,
       SecretsStore.SecretBindingPolicy,
@@ -88,6 +91,7 @@ export const providers = () =>
         KV.KVNamespaceBindingPolicyLive,
         KV.KVNamespaceProvider(),
         Queue.QueueBindingPolicyLive,
+        Queue.QueueEventSourcePolicyLive,
         Queue.QueueProvider(),
         Queue.QueueConsumerProvider(),
         R2.R2BucketBindingPolicyLive,
@@ -110,6 +114,8 @@ export const providers = () =>
     Layer.provideMerge(CloudflareEnvironment.fromProfile()),
     Layer.provideMerge(CloudflareAuth),
     Layer.provideMerge(Access.AccessLive),
+    Layer.provideMerge(ProfileLive),
+    Layer.provideMerge(CredentialsStoreLive),
     // Apply a blanket retry policy to every Cloudflare API call. Extends
     // `Retry.makeDefault`'s transient detection (throttling / 5xx /
     // network) with one Cloudflare-specific misleadingly-tagged

package/src/Cloudflare/Queue/Queue.ts

@@ -67,7 +67,7 @@ export type Queue = Resource<
  *
  * export default Cloudflare.Worker(
  *   "Worker",
- *   { main: import.meta.path },
+ *   { main: import.meta.filename },
  *   Effect.gen(function* () {
  *     const queue = yield* Cloudflare.QueueBinding.bind(Queue);
  *