@frockbot/cloudflare 0.0.0 → 0.7.291

package/src/project-cleanup.ts

@@ -0,0 +1,123 @@
+// Disposable cleanup for what Projects left in the User Durable Object.
+//
+// Group Chats replaced Projects. The Project catalogue and each Bot's joined
+// list go, with the generation records of the Project Memory roots and their
+// files in object storage. Memory kept a Project's facts in its shared
+// `groupChat` scope under the Project's slug; a Group Chat's scope is keyed
+// by the group's id, so every such scope not keyed by one is a Project's and
+// is purged. Object storage is paged, so a large root finishes over several
+// wakes; the receipt carries the cursor until it is done.
+
+import { isGroupIdV1 } from "@frockbot/app/groups/shared";
+import {
+  WORKSPACE_CONFLICT_PREFIX,
+  WORKSPACE_GENERATION_PREFIX,
+} from "@frockbot/core/durable";
+import { WORKSPACE_OBJECT_PREFIX } from "@frockbot/core/workspace-store";
+import type { MemoryEngineV1 } from "@frockbot/app/memory/engine";
+import { decodeMemoryScopeKeyV1 } from "@frockbot/app/memory/records";
+
+const RECEIPT = "maintenance:project-removal:2026-09-23";
+const RETIRED_KEY = "memory:projects";
+const RETIRED_ROOT = "project-memory:";
+const PAGE = 50;
+const OBJECT_PAGES = 4;
+
+interface CleanupStorage {
+  get(key: string): Promise<unknown>;
+  put(key: string, value: unknown): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  list(options: {
+    prefix: string;
+    limit: number;
+    start?: string;
+  }): Promise<Map<string, unknown>>;
+}
+
+interface CleanupBucket {
+  list(options: {
+    prefix: string;
+    limit: number;
+    cursor?: string;
+  }): Promise<{ keys: string[]; cursor?: string; truncated: boolean }>;
+  delete(key: string): Promise<void>;
+}
+
+async function deletePrefix(
+  storage: CleanupStorage,
+  prefix: string,
+): Promise<number> {
+  let deleted = 0;
+  for (;;) {
+    const listed = await storage.list({ prefix, limit: PAGE });
+    for (const key of listed.keys()) {
+      await storage.delete(key);
+      deleted += 1;
+    }
+    if (listed.size < PAGE) return deleted;
+  }
+}
+
+export async function cleanRetiredProjectsV1(
+  storage: CleanupStorage,
+  options: {
+    userId?: string;
+    bucket?: CleanupBucket;
+    engine?: Pick<MemoryEngineV1, "scopeKeysOfKind" | "purgeScope">;
+  },
+): Promise<void> {
+  const stored = await storage.get(RECEIPT);
+  const receipt =
+    stored && typeof stored === "object"
+      ? (stored as { done?: boolean; cursor?: string })
+      : undefined;
+  if (receipt?.done) return;
+  let keys = (await storage.delete(RETIRED_KEY)) ? 1 : 0;
+  keys += await deletePrefix(storage, `${RETIRED_KEY}:`);
+  keys += await deletePrefix(
+    storage,
+    `${WORKSPACE_GENERATION_PREFIX}${RETIRED_ROOT}`,
+  );
+  keys += await deletePrefix(
+    storage,
+    `${WORKSPACE_CONFLICT_PREFIX}${RETIRED_ROOT}`,
+  );
+  let scopes = 0;
+  for (const scopeKey of options.engine?.scopeKeysOfKind("groupChat") ?? []) {
+    if (isGroupIdV1(decodeMemoryScopeKeyV1(scopeKey).groupChatId)) continue;
+    options.engine!.purgeScope(scopeKey);
+    scopes += 1;
+  }
+  let cursor = receipt?.cursor;
+  let objects = 0;
+  let done = true;
+  if (options.userId && options.bucket) {
+    const prefix = `${WORKSPACE_OBJECT_PREFIX}/${RETIRED_ROOT}${encodeURIComponent(options.userId)}:`;
+    done = false;
+    for (let page = 0; page < OBJECT_PAGES; page += 1) {
+      const listed = await options.bucket.list({
+        prefix,
+        limit: PAGE,
+        ...(cursor ? { cursor } : {}),
+      });
+      for (const key of listed.keys) {
+        if (!key.startsWith(prefix)) continue;
+        await options.bucket.delete(key);
+        objects += 1;
+      }
+      if (!listed.truncated) {
+        done = true;
+        break;
+      }
+      cursor = listed.cursor;
+    }
+  }
+  await storage.put(RECEIPT, {
+    schemaVersion: 1,
+    done,
+    ...(done || !cursor ? {} : { cursor }),
+    keys,
+    scopes,
+    objects,
+  });
+}

package/src/project-events-cleanup.ts

@@ -0,0 +1,152 @@
+// Disposable cleanup for the Session events Projects left behind.
+//
+// Group Chats replaced Projects. A Memory event's `project` scope reads as
+// `group` now, and its `projectId` as `groupId`: Memory already kept a
+// Project's facts in its shared `groupChat` scope under that id, so the
+// record stays true. The two Project membership events become the Memory
+// Package's call and result they were, so no event is dropped and no
+// sequence number moves. Each Session is rewritten in its own transaction;
+// the walk is once per Bot.
+
+import {
+  LATEST_EVENTS_KEY,
+  SESSION_EVENT_LOG_INDEX_PREFIX,
+  SessionEventLog,
+  type SessionEventLogStorage,
+} from "@frockbot/core/durable";
+
+const RECEIPT = "maintenance:project-events:2026-09-23";
+const PAGE = 50;
+
+interface CleanupStorage extends SessionEventLogStorage {
+  transaction<T>(body: (tx: SessionEventLogStorage) => Promise<T>): Promise<T>;
+}
+
+type Stored = Record<string, unknown>;
+
+function scoped(entry: unknown): unknown {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    return entry;
+  }
+  const { projectId, ...rest } = entry as Stored;
+  const scope = rest.scope === "project" ? "group" : rest.scope;
+  return projectId === undefined
+    ? { ...rest, scope }
+    : { ...rest, scope, groupId: projectId };
+}
+
+function each(value: unknown): unknown {
+  return Array.isArray(value) ? value.map(scoped) : value;
+}
+
+/** The replacement for one stored event, or `undefined` to keep it. */
+export function withoutProjectShapesV1(event: Stored): Stored | undefined {
+  const replaced = replacement(event);
+  // An event already in today's shape is left alone, so a second walk after
+  // an interrupted one writes nothing it already wrote.
+  return replaced && JSON.stringify(replaced) !== JSON.stringify(event)
+    ? replaced
+    : undefined;
+}
+
+function replacement(event: Stored): Stored | undefined {
+  const common = { seq: event.seq, timestamp: event.timestamp };
+  switch (event.type) {
+    case "memory/injected":
+      return {
+        ...event,
+        sources: each(event.sources),
+        facts: each(event.facts),
+        omissions: each(event.omissions),
+        ...(Object.hasOwn(event, "faded") ? { faded: each(event.faded) } : {}),
+      };
+    case "memory/write-intent":
+    case "memory/written":
+      return scoped(event) as Stored;
+    case "memory/project-intent":
+      return {
+        type: "package/tool-call",
+        ...common,
+        turn: event.turn,
+        step: event.step,
+        effectId: event.effectId,
+        packageId: "memory",
+        callId: event.effectId,
+        name: `project_${String(event.action)}`,
+        input: { project: event.projectId },
+      };
+    case "memory/project-changed": {
+      const projects = Array.isArray(event.projects) ? event.projects : [];
+      return {
+        type: "package/tool-result",
+        ...common,
+        turn: event.turn,
+        step: event.step,
+        effectId: event.effectId,
+        packageId: "memory",
+        callId: event.effectId,
+        name: `project_${String(event.action)}`,
+        content: `Projects: ${projects.join(", ") || "none"}`,
+        isError: false,
+      };
+    }
+    default:
+      return undefined;
+  }
+}
+
+export async function cleanProjectEventsV1(
+  storage: CleanupStorage,
+): Promise<void> {
+  if (await storage.get(RECEIPT)) return;
+  const sessions: string[] = [];
+  let start: string | undefined;
+  for (;;) {
+    const listed = await storage.list({
+      prefix: SESSION_EVENT_LOG_INDEX_PREFIX,
+      limit: PAGE,
+      ...(start ? { start } : {}),
+    });
+    for (const key of listed.keys()) {
+      sessions.push(
+        decodeURIComponent(key.slice(SESSION_EVENT_LOG_INDEX_PREFIX.length)),
+      );
+    }
+    if (listed.size < PAGE) break;
+    start = `${[...listed.keys()].at(-1)}\0`;
+  }
+  let events = 0;
+  const unreadable: string[] = [];
+  for (const sessionId of sessions) {
+    try {
+      events += await storage.transaction((tx) =>
+        new SessionEventLog(tx).repairStoredEvents(
+          sessionId,
+          withoutProjectShapesV1,
+        ),
+      );
+    } catch {
+      // A throw here would reset the object on every wake. A log this cannot
+      // read was unreadable before it ran, and is left as it was.
+      unreadable.push(sessionId);
+    }
+  }
+  // The pre-paging log, if a Bot still has one, is read the same way.
+  const legacy = await storage.get<unknown[]>(LATEST_EVENTS_KEY);
+  if (Array.isArray(legacy)) {
+    let changed = false;
+    const repaired = legacy.map((event) => {
+      if (!event || typeof event !== "object") return event;
+      const replacement = withoutProjectShapesV1(event as Stored);
+      if (replacement) changed = true;
+      return replacement ?? event;
+    });
+    if (changed) await storage.put(LATEST_EVENTS_KEY, repaired);
+  }
+  await storage.put(RECEIPT, {
+    schemaVersion: 1,
+    sessions: sessions.length,
+    events,
+    unreadable,
+  });
+}

package/src/publication-state-cleanup.ts

@@ -0,0 +1,92 @@
+// Disposable cleanup for the S3 invalidation log and pending stubs S5
+// replaced with PublicationHead / ConversationUpdate records.
+//
+// Old channel events cannot be replayed as typed updates, and a pending
+// marker without a kind is not a recoverable obligation. Live S5 pending
+// records (with kind, entityId, revision) stay: they still need a drain.
+
+import {
+  PUBLICATION_CURSOR_KEY,
+  PUBLICATION_PENDING_PREFIX,
+  RETIRED_CHANNEL_EVENT_PREFIX_V1,
+  RETIRED_CHANNEL_META_KEY_V1,
+} from "@frockbot/core/durable";
+
+const RECEIPT = "maintenance:publication:s5:2026-09-22";
+const PAGE = 50;
+
+interface CleanupStorage {
+  get(key: string): Promise<unknown>;
+  put(key: string, value: unknown): Promise<void>;
+  delete(key: string): Promise<boolean | void>;
+  list(options: {
+    prefix?: string;
+    limit?: number;
+    start?: string;
+  }): Promise<Map<string, unknown>>;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+function isLivePending(value: unknown): boolean {
+  const stored = record(value);
+  return (
+    stored !== undefined &&
+    stored.schemaVersion === 1 &&
+    typeof stored.kind === "string" &&
+    typeof stored.entityId === "string" &&
+    Number.isSafeInteger(stored.cursor) &&
+    Number.isSafeInteger(stored.revision)
+  );
+}
+
+async function page(
+  storage: CleanupStorage,
+  prefix: string,
+  visit: (key: string, value: unknown) => Promise<void>,
+): Promise<void> {
+  let start: string | undefined;
+  for (;;) {
+    const listed = await storage.list({
+      prefix,
+      limit: PAGE,
+      ...(start ? { start } : {}),
+    });
+    if (listed.size === 0) return;
+    let last = "";
+    for (const [key, value] of listed) {
+      last = key;
+      if (start !== undefined && key === start) continue;
+      await visit(key, value);
+    }
+    if (listed.size < PAGE) return;
+    start = `${last}\0`;
+  }
+}
+
+export async function cleanRetiredPublicationStateV1(
+  storage: CleanupStorage,
+): Promise<void> {
+  if (await storage.get(RECEIPT)) return;
+  let removed = 0;
+  if (await storage.delete(RETIRED_CHANNEL_META_KEY_V1)) removed += 1;
+  if (await storage.delete(PUBLICATION_CURSOR_KEY)) removed += 1;
+  await page(storage, RETIRED_CHANNEL_EVENT_PREFIX_V1, async (key) => {
+    await storage.delete(key);
+    removed += 1;
+  });
+  await page(storage, PUBLICATION_PENDING_PREFIX, async (key, value) => {
+    if (isLivePending(value)) return;
+    await storage.delete(key);
+    removed += 1;
+  });
+  await storage.put(RECEIPT, {
+    schemaVersion: 1,
+    removed,
+  });
+}