@frockbot/cloudflare 0.0.0 → 0.7.291

package/src/working-context-cleanup.ts

@@ -0,0 +1,96 @@
+// Projects the working context for Sessions whose event log predates it.
+//
+// The working-context head arrived after these logs were written, and an
+// append to a log with events but no head is refused as a gap, so every Turn
+// on such a Session failed before its first event. Rebuilding is an archive
+// read, which ordinary startup never does; the receipt makes it once per
+// object. A log this process cannot read or project gets an empty context
+// that starts after it, so the Bot answers without that history rather than
+// not at all.
+
+import { emptyConversationHeadV1 } from "@frockbot/core/contracts";
+import {
+  SESSION_EVENT_LOG_INDEX_PREFIX,
+  SessionEventLog,
+  workingContextHeadKeyV1,
+  type WorkingContextStorageV1,
+} from "@frockbot/core/durable";
+import { replaceWorkingContextV1 } from "@frockbot/app/shell/working-context-store";
+
+const RECEIPT = "maintenance:working-context-head:2026-09-23";
+const PAGE = 50;
+
+interface CleanupStorage extends WorkingContextStorageV1 {
+  transaction<T>(body: (tx: WorkingContextStorageV1) => Promise<T>): Promise<T>;
+}
+
+export async function projectUnprojectedSessionsV1(
+  storage: CleanupStorage,
+): Promise<void> {
+  if (await storage.get(RECEIPT)) return;
+  const sessions: { sessionId: string; eventCount: number }[] = [];
+  let start: string | undefined;
+  for (;;) {
+    const listed = await storage.list<{ eventCount?: number }>({
+      prefix: SESSION_EVENT_LOG_INDEX_PREFIX,
+      limit: PAGE,
+      ...(start ? { start } : {}),
+    });
+    for (const [key, index] of listed) {
+      const eventCount = index?.eventCount;
+      if (!Number.isSafeInteger(eventCount) || eventCount! <= 0) continue;
+      sessions.push({
+        sessionId: decodeURIComponent(
+          key.slice(SESSION_EVENT_LOG_INDEX_PREFIX.length),
+        ),
+        eventCount: eventCount!,
+      });
+    }
+    if (listed.size < PAGE) break;
+    start = `${[...listed.keys()].at(-1)}\0`;
+  }
+  const rebuilt: { sessionId: string; events: number; from: string }[] = [];
+  for (const { sessionId, eventCount } of sessions) {
+    if (await storage.get(workingContextHeadKeyV1(sessionId))) continue;
+    // Display fidelity leaves each model request as its bounded projection;
+    // the reducer never reads one back.
+    const events = await new SessionEventLog(storage)
+      .readDisplayRange(sessionId, 0, eventCount)
+      .catch(() => undefined);
+    let from: "log" | "empty" = "log";
+    if (events) {
+      try {
+        await storage.transaction(async (tx) => {
+          if (await tx.get(workingContextHeadKeyV1(sessionId))) return;
+          await replaceWorkingContextV1(tx, sessionId, events);
+        });
+      } catch {
+        from = "empty";
+      }
+    } else {
+      from = "empty";
+    }
+    if (from === "empty") {
+      // A throw here would reset the object on every wake, so the fallback is
+      // a plain write. Every Turn writes at least one event, so no earlier
+      // Turn number reaches past the event count.
+      if (!(await storage.get(workingContextHeadKeyV1(sessionId)))) {
+        await storage.put(workingContextHeadKeyV1(sessionId), {
+          ...emptyConversationHeadV1(sessionId),
+          nextSeq: eventCount,
+          projectedThroughSeq: eventCount,
+          nextTurn: eventCount + 1,
+        });
+      }
+    }
+    rebuilt.push({
+      sessionId,
+      events: eventCount,
+      from,
+    });
+  }
+  await storage.put(RECEIPT, { schemaVersion: 1, rebuilt });
+  if (rebuilt.length) {
+    console.info({ event: "working-context-cleanup", rebuilt });
+  }
+}

package/src/workspace.ts

@@ -0,0 +1,201 @@
+// The `WORKSPACE_FILES` seam, bound in production.
+//
+// `app/shell/backend-skills.ts` reads one property off the Bot
+// Durable Object's environment: a `WorkspaceFilesV1`. Until now nothing bound
+// it, so the Skills Package was never mounted and no deployed Turn could load
+// a Skill. This module is the binding: `WorkspaceFilesV1` over R2, with every
+// generation recorded in the Bot Durable Object that owns the root.
+//
+// It wakes no Computer. "The Agent loop, Memory, Skills, Package composition,
+// and Routines function correctly while the Computer is hibernated and do not
+// wake it" — a read here is an R2 read and a Durable Object storage read, and
+// nothing on this path can reach a Computer provider.
+//
+// The R2 types stop here: "Electron, Cloudflare, provider SDK, and Computer
+// implementation types remain inside their adapters", so `@frockbot/workspace-
+// store` sees only the structural `ObjectBucketV1` this file supplies.
+import type {
+  WorkspaceFilesV1,
+  WorkspaceGenerationsV1,
+} from "@frockbot/core/contracts";
+import {
+  createObjectWorkspaceFilesV1,
+  workspaceObjectPrefixV1,
+  type ObjectBucketV1,
+  type ObjectHeadV1,
+  type WorkspaceGenerationPublicationV1,
+  type WorkspaceStoreSurfaceV1,
+} from "@frockbot/core/workspace-store";
+
+function head(object: R2Object): ObjectHeadV1 {
+  return {
+    key: object.key,
+    etag: object.etag,
+    size: object.size,
+    uploaded: object.uploaded,
+    ...(object.customMetadata ? { customMetadata: object.customMetadata } : {}),
+  };
+}
+
+/** The structural object store, over one R2 bucket. */
+export function createR2ObjectBucketV1(bucket: R2Bucket): ObjectBucketV1 {
+  return {
+    get: async (key) => {
+      const object = await bucket.get(key);
+      if (!object) return null;
+      return {
+        ...head(object),
+        bytes: async () => new Uint8Array(await object.arrayBuffer()),
+      };
+    },
+    head: async (key) => {
+      const object = await bucket.head(key);
+      return object ? head(object) : null;
+    },
+    put: async (key, bytes, options) => {
+      const onlyIf = options?.onlyIf;
+      // `If-None-Match: *` is "create only if absent". `uploadedBefore` at the
+      // epoch says the same thing in a second way, and is sent alongside so
+      // the precondition holds even where a wildcard etag is compared
+      // literally. A create that silently overwrote would be
+      // last-writer-wins, which is forbidden outright.
+      const conditional: R2Conditional | undefined =
+        onlyIf === undefined
+          ? undefined
+          : onlyIf.etagDoesNotMatch === "*"
+            ? { etagDoesNotMatch: "*", uploadedBefore: new Date(0) }
+            : onlyIf;
+      const written = await bucket.put(key, bytes as ArrayBufferView, {
+        ...(conditional ? { onlyIf: conditional } : {}),
+        ...(options?.customMetadata
+          ? { customMetadata: options.customMetadata }
+          : {}),
+        ...(options?.contentType
+          ? { httpMetadata: { contentType: options.contentType } }
+          : {}),
+      });
+      return written ? head(written) : null;
+    },
+    delete: (key) => bucket.delete(key),
+    list: async (request) => {
+      const page = await bucket.list({
+        ...(request.prefix ? { prefix: request.prefix } : {}),
+        ...(request.cursor ? { cursor: request.cursor } : {}),
+        ...(request.limit ? { limit: request.limit } : {}),
+        include: ["customMetadata"],
+      });
+      return {
+        objects: page.objects.map(head),
+        truncated: page.truncated,
+        ...(page.truncated ? { cursor: page.cursor } : {}),
+      };
+    },
+  };
+}
+
+/** The bucket binding that backs durable roots. Optional: absence is a state. */
+export interface WorkspaceStoreEnv {
+  MEMORY_FILES?: R2Bucket;
+}
+
+/**
+ * The Workspace file surface one Durable Object serves, or `undefined` when no
+ * bucket is bound — in which case the Skills Package is simply not mounted,
+ * visibly, rather than reading instructions from a store it invented.
+ */
+export function createDurableWorkspaceFilesV1(
+  env: WorkspaceStoreEnv,
+  options: {
+    /**
+     * The generation ledger these roots record in. Required, and passed in
+     * rather than constructed here: a ledger caches the minting cursor while
+     * it is resident, so two instances on one Durable Object can read one
+     * cursor and mint one id twice. The object that owns the roots holds
+     * exactly one.
+     */
+    generations: WorkspaceGenerationsV1;
+    surface?: WorkspaceStoreSurfaceV1;
+    /**
+     * The User whose durable roots this store serves. Passed as soon as the
+     * Durable Object knows it — a Bot object learns its User on the RPC that
+     * addresses it — so a root belonging to another User is refused at the
+     * store rather than reaching object storage.
+     */
+    owner?: { userId: string };
+    onInstructionPublication?: (
+      event: WorkspaceGenerationPublicationV1,
+    ) => Promise<void>;
+  },
+): WorkspaceFilesV1 | undefined {
+  const bucket = env.MEMORY_FILES;
+  if (!bucket) return undefined;
+  return createObjectWorkspaceFilesV1({
+    bucket: createR2ObjectBucketV1(bucket),
+    generations: options.generations,
+    ...(options.owner ? { owner: options.owner } : {}),
+    ...(options.surface ? { surface: options.surface } : {}),
+    ...(options.onInstructionPublication
+      ? { onInstructionPublication: options.onInstructionPublication }
+      : {}),
+  });
+}
+
+/** Removes every object under one prefix, a page at a time. Idempotent. */
+async function deleteObjectPrefixV1(
+  store: ObjectBucketV1,
+  prefix: string,
+): Promise<number> {
+  let removed = 0;
+  let cursor: string | undefined;
+  do {
+    const page = await store.list({
+      prefix,
+      ...(cursor === undefined ? {} : { cursor }),
+      limit: 1_000,
+    });
+    for (const object of page.objects) {
+      await store.delete(object.key);
+      removed += 1;
+    }
+    cursor = page.truncated ? page.cursor : undefined;
+  } while (cursor !== undefined);
+  return removed;
+}
+
+/**
+ * Every object of the two durable roots one Bot owns, removed from the bucket.
+ *
+ * A Bot owns exactly two roots — `bot-instructions` and `bot-memory` — and
+ * both are keyed by `<kind>:<userId>:<botId>`, so a prefix listing names this
+ * Bot's objects and nobody else's. The User's own Skills root, User Memory,
+ * and every `package-declared` root are User-scoped and are deliberately left
+ * alone: another Bot of the same User still reads them.
+ *
+ * This is a bulk removal rather than `WorkspaceStore.delete`, which is
+ * generation-fenced per file and leaves a tombstone marker. A deleted Bot has
+ * no generation ledger left to fence against and nothing to preserve a losing
+ * write for, so the bytes go. Conflict objects live under the same prefix and
+ * go with them.
+ *
+ * Idempotent: a second call over an empty prefix removes nothing.
+ */
+export async function deleteBotWorkspaceRootsV1(
+  env: WorkspaceStoreEnv,
+  identity: { userId: string; botId: string },
+): Promise<number> {
+  const bucket = env.MEMORY_FILES;
+  if (!bucket) return 0;
+  const store = createR2ObjectBucketV1(bucket);
+  let removed = 0;
+  for (const kind of ["bot-instructions", "bot-memory"] as const) {
+    removed += await deleteObjectPrefixV1(
+      store,
+      workspaceObjectPrefixV1({
+        kind,
+        userId: identity.userId,
+        botId: identity.botId,
+      }),
+    );
+  }
+  return removed;
+}

package/wrangler.jsonc

@@ -0,0 +1,385 @@
+// Bindings, migrations, and the environments `wrangler dev` and the test
+// harnesses run. No deployment identity: the account, the Worker names, the
+// routes, the resource names and the identity vars belong to
+// `deployments/<profile>.json`, and `bun run deployment:config` joins the
+// two into the config `wrangler deploy -c` takes (ADR 0028).
+{
+  "$schema": "./node_modules/wrangler/config-schema.json",
+  "name": "frockbot-cloudflare",
+  "main": "src/index.ts",
+  "compatibility_date": "2026-08-27",
+  "compatibility_flags": ["nodejs_compat"],
+  // The Flutter client, staged by `build-flutter-web.ts` under
+  // `_flutter/<buildHash>/`. It is uploaded with the deploy and answered by
+  // the asset router before this Worker runs, which is why the payload
+  // needs no route, no bucket and no seeding step: the same `wrangler dev`
+  // that runs the Worker locally serves it from the same directory.
+  //
+  // `html_handling` and `not_found_handling` are both off. The document is
+  // rendered per account by the application artifact, so an asset
+  // directory that answered `/` or invented an index would answer for it.
+  "assets": {
+    "directory": "./dist/web",
+    "html_handling": "none",
+    "not_found_handling": "none",
+  },
+  "worker_loaders": [
+    {
+      "binding": "USER_APPLICATIONS",
+    },
+    // Bot-authored Package isolates, loaded from the Bot Durable Object with
+    // `globalOutbound` disabled (plan Step 4 / decision D2). A separate binding
+    // so Bot Packages and user applications never share a loader namespace.
+    {
+      "binding": "BOT_PACKAGES",
+    },
+  ],
+  // Wrangler's validator refuses a service with no target and a Vectorize
+  // binding with no index, even in a config it never deploys, so both carry
+  // `named-by-deployment-config` here. The generator writes the deployment's
+  // own names; nothing reads these.
+  "services": [
+    // The shared Computer host (ADR 0004). It holds SPRITES_TOKEN and the
+    // Sprites SDK; this Worker sends only an opaque credential reference.
+    {
+      "binding": "COMPUTER_HOST",
+      "service": "named-by-deployment-config",
+    },
+    // The plugin build service. It type-checks, lints, bundles
+    // and boots a plugin's source and returns the artifacts; it holds no
+    // storage, so this Worker stays the only thing that writes R2 and the only
+    // thing that hash-verifies what came back.
+    {
+      "binding": "APPLET_BUILD",
+      "service": "named-by-deployment-config",
+    },
+  ],
+  "r2_buckets": [
+    {
+      "binding": "APPLICATION_ARTIFACTS",
+    },
+    {
+      "binding": "MEMORY_FILES",
+    },
+  ],
+  "d1_databases": [
+    {
+      "binding": "AUTH_DB",
+      "migrations_dir": "migrations",
+    },
+  ],
+  "vectorize": [
+    {
+      "binding": "MEMORY_INDEX",
+      "index_name": "named-by-deployment-config",
+    },
+  ],
+  "ai": {
+    "binding": "AI",
+  },
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "BOT_STATES",
+        "class_name": "BotState",
+      },
+      {
+        "name": "USER_CONFIGURATIONS",
+        "class_name": "UserConfiguration",
+      },
+      {
+        "name": "DEPLOYMENT_POLICY",
+        "class_name": "DeploymentPolicy",
+      },
+      // The account-wide voice session, one object per User (docs/voice.md).
+      // A Cloudflare Agents SDK class; the Bot runtime stays hand-rolled.
+      {
+        "name": "VOICE_ASSISTANTS",
+        "class_name": "VoiceAssistant",
+      },
+      // One object per Group Chat: its thread, read cursor and member Turns.
+      {
+        "name": "GROUP_CHATS",
+        "class_name": "GroupChat",
+      },
+    ],
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": ["BotState"],
+    },
+    {
+      "tag": "v2",
+      "new_sqlite_classes": ["UserConfiguration"],
+    },
+    {
+      "tag": "v3",
+      "new_sqlite_classes": ["DeploymentPolicy"],
+    },
+    {
+      "tag": "v4",
+      "new_sqlite_classes": ["AppletState"],
+    },
+    {
+      "tag": "v5",
+      "new_sqlite_classes": ["VoiceSession"],
+    },
+    // `v5` is immutable once applied, so the class it created is retired by a
+    // later tag rather than by editing it away.
+    {
+      "tag": "v6",
+      "deleted_classes": ["VoiceSession"],
+    },
+    // A new class under a new name: the retired `VoiceSession` above cannot be
+    // revived, and this one is an Agents SDK object with SQLite storage.
+    {
+      "tag": "v7",
+      "new_sqlite_classes": ["VoiceAssistant"],
+    },
+    {
+      "tag": "v8",
+      "deleted_classes": ["AppletState"],
+    },
+    {
+      "tag": "v9",
+      "new_sqlite_classes": ["GroupChat"],
+    },
+  ],
+  "vars": {
+    "DEFAULT_APPLICATION_HASH": "foundation-v1",
+  },
+  "env": {
+    "development": {
+      // Never deployed, and without an empty list `wrangler dev` inherits the
+      // top-level custom domain and rewrites every request URL to
+      // bot.frockbot.com — which the native auth origin check then refuses.
+      "routes": [],
+      // The Flutter client, staged by `build-flutter-web.ts` under
+      // `_flutter/<buildHash>/`. It is uploaded with the deploy and answered by
+      // the asset router before this Worker runs, which is why the payload
+      // needs no route, no bucket and no seeding step: the same `wrangler dev`
+      // that runs the Worker locally serves it from the same directory.
+      //
+      // `html_handling` and `not_found_handling` are both off. The document is
+      // rendered per account by the application artifact, so an asset
+      // directory that answered `/` or invented an index would answer for it.
+      "assets": {
+        "directory": "./dist/web",
+        "html_handling": "none",
+        "not_found_handling": "none",
+      },
+      "worker_loaders": [
+        {
+          "binding": "USER_APPLICATIONS",
+        },
+        {
+          "binding": "BOT_PACKAGES",
+        },
+      ],
+      "services": [
+        {
+          "binding": "COMPUTER_HOST",
+          "service": "frockbot-computer-host",
+        },
+        {
+          "binding": "APPLET_BUILD",
+          "service": "frockbot-applet-build",
+        },
+      ],
+      "r2_buckets": [
+        {
+          "binding": "APPLICATION_ARTIFACTS",
+          "bucket_name": "frockbot-application-artifacts",
+          "remote": false,
+        },
+        {
+          "binding": "MEMORY_FILES",
+          "bucket_name": "frockbot-memory-files-development",
+          "remote": true,
+        },
+      ],
+      "d1_databases": [
+        {
+          "binding": "AUTH_DB",
+          "database_name": "frockbot-auth-development",
+          "database_id": "00000000-0000-0000-0000-000000000000",
+          "migrations_dir": "migrations",
+          "remote": false,
+        },
+      ],
+      "vectorize": [
+        {
+          "binding": "MEMORY_INDEX",
+          "index_name": "frockbot-memory-development",
+          "remote": true,
+        },
+      ],
+      "ai": {
+        "binding": "AI",
+        "remote": true,
+      },
+      "durable_objects": {
+        "bindings": [
+          {
+            "name": "BOT_STATES",
+            "class_name": "BotState",
+          },
+          {
+            "name": "USER_CONFIGURATIONS",
+            "class_name": "UserConfiguration",
+          },
+          {
+            "name": "DEPLOYMENT_POLICY",
+            "class_name": "DeploymentPolicy",
+          },
+          {
+            "name": "VOICE_ASSISTANTS",
+            "class_name": "VoiceAssistant",
+          },
+          {
+            "name": "GROUP_CHATS",
+            "class_name": "GroupChat",
+          },
+        ],
+      },
+      "vars": {
+        "DEFAULT_APPLICATION_HASH": "foundation-v1",
+        "FROCK_AI_GATEWAY_ID": "flock",
+        // Enables the compat HTTP transport, which is the only one that
+        // accepts a `dynamic/<route>` model (cloudflare/ai#617). Pairs
+        // with the FROCK_AI_GATEWAY_TOKEN secret.
+        "FROCK_AI_ACCOUNT_ID": "374784ce2915a597adcecf9bcb2c5ee6",
+        "FROCK_AI_AUTO_ROUTE": "flock-auto",
+        // Placeholder only. Production supplies this as a secret.
+        "FROCKBOT_ADMIN_EMAILS": "owner@example.com",
+      },
+    },
+    // The browser end-to-end harness (`apps/cloudflare/e2e/harness.ts`) runs
+    // `src/index.ts` — the deployed Worker, unmodified — under `wrangler dev`.
+    // It cannot use `development`: that environment marks `MEMORY_FILES`,
+    // `MEMORY_INDEX` and `AI` remote, and a remote binding makes `wrangler dev`
+    // open a proxy session against the Cloudflare API, which fails without a
+    // `CLOUDFLARE_API_TOKEN` and so cannot run on a pull request.
+    //
+    // Only binding locality differs. `main`, `compatibility_date`,
+    // `compatibility_flags`, `migrations` and the Durable Object classes are
+    // the top-level production ones, and every var is the production value.
+    // `MEMORY_INDEX` is omitted because workerd has no local Vectorize
+    // simulator. `AI` is a local RPC service under this environment: the e2e
+    // harness starts its auxiliary Worker in a second local Wrangler process,
+    // which the dev service registry connects at the same `run(model, input)`
+    // seam without spending account credits or requiring a Cloudflare token.
+    "e2e": {
+      // This environment is never deployed. Without an empty list it would
+      // inherit the top-level custom domain and a stray `wrangler deploy --env
+      // e2e` would reassign bot.frockbot.com to it.
+      "routes": [],
+      // The Flutter client, staged by `build-flutter-web.ts` under
+      // `_flutter/<buildHash>/`. It is uploaded with the deploy and answered by
+      // the asset router before this Worker runs, which is why the payload
+      // needs no route, no bucket and no seeding step: the same `wrangler dev`
+      // that runs the Worker locally serves it from the same directory.
+      //
+      // `html_handling` and `not_found_handling` are both off. The document is
+      // rendered per account by the application artifact, so an asset
+      // directory that answered `/` or invented an index would answer for it.
+      "assets": {
+        "directory": "./dist/web",
+        "html_handling": "none",
+        "not_found_handling": "none",
+      },
+      "worker_loaders": [
+        {
+          "binding": "USER_APPLICATIONS",
+        },
+        {
+          "binding": "BOT_PACKAGES",
+        },
+      ],
+      // Declared as production declares them. The Computer host does not run
+      // beside the harness, so `COMPUTER_HOST` reports "not connected" and no
+      // spec uses a Computer; a binding that is declared but unreachable is
+      // what production looks like when a dependency is down. The plugin build
+      // service runs beside it — `e2e/harness.ts` starts `apps/applet-build`
+      // under its own `wrangler dev` in the dev service registry.
+      "services": [
+        {
+          "binding": "COMPUTER_HOST",
+          "service": "frockbot-computer-host",
+        },
+        {
+          "binding": "APPLET_BUILD",
+          "service": "frockbot-applet-build",
+        },
+        {
+          "binding": "AI",
+          // The deployed e2e stand-in Worker; its Cloudflare name still reads
+          // `flock`, and renaming the service is a separate manual step.
+          "service": "frockbot-flock-ai-e2e",
+          "entrypoint": "FrockAiFake",
+        },
+      ],
+      "r2_buckets": [
+        {
+          "binding": "APPLICATION_ARTIFACTS",
+          "bucket_name": "frockbot-application-artifacts",
+          "remote": false,
+        },
+        {
+          "binding": "MEMORY_FILES",
+          "bucket_name": "frockbot-memory-files-e2e",
+          "remote": false,
+        },
+      ],
+      "d1_databases": [
+        {
+          "binding": "AUTH_DB",
+          "database_name": "frockbot-auth-e2e",
+          "database_id": "00000000-0000-0000-0000-000000000000",
+          "migrations_dir": "migrations",
+          "remote": false,
+        },
+      ],
+      "durable_objects": {
+        "bindings": [
+          {
+            "name": "BOT_STATES",
+            "class_name": "BotState",
+          },
+          {
+            "name": "USER_CONFIGURATIONS",
+            "class_name": "UserConfiguration",
+          },
+          {
+            "name": "DEPLOYMENT_POLICY",
+            "class_name": "DeploymentPolicy",
+          },
+          {
+            "name": "VOICE_ASSISTANTS",
+            "class_name": "VoiceAssistant",
+          },
+          {
+            "name": "GROUP_CHATS",
+            "class_name": "GroupChat",
+          },
+        ],
+      },
+      "vars": {
+        "DEFAULT_APPLICATION_HASH": "foundation-v1",
+        "FROCK_AI_GATEWAY_ID": "flock",
+        // Enables the compat HTTP transport, which is the only one that
+        // accepts a `dynamic/<route>` model (cloudflare/ai#617). Pairs
+        // with the FROCK_AI_GATEWAY_TOKEN secret.
+        "FROCK_AI_ACCOUNT_ID": "374784ce2915a597adcecf9bcb2c5ee6",
+        "FROCK_AI_AUTO_ROUTE": "flock-auto",
+        // The canonical `development` identity is admin in this environment;
+        // this placeholder also proves the configured-allowlist rule.
+        "FROCKBOT_ADMIN_EMAILS": "owner@example.com",
+      },
+    },
+  },
+  "observability": {
+    "enabled": true,
+  },
+}

package/README.md

@@ -1,3 +0,0 @@
-# @frockbot/cloudflare
-
-Placeholder reserving this name. See https://github.com/timoconnellaus/frockbot.