@alteran/astro 0.3.8 → 0.5.2

package/src/worker/sequencer/broadcast.ts

@@ -0,0 +1,91 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import {
+  encodeAccountFrame,
+  encodeCommitFrame,
+  encodeIdentityFrame,
+  encodeSyncFrame,
+} from '../../lib/firehose/frames';
+import type { Env } from '../../env';
+import { toWireStatus } from '../../lib/account-state';
+import type { AccountEvent, CommitEvent, IdentityEvent } from './types';
+import { createCommitPayload } from './payload';
+
+export async function broadcastCommit(
+  env: Env,
+  db: D1Database,
+  targets: WebSocket[],
+  event: CommitEvent,
+): Promise<void> {
+  const message = await createCommitPayload(env, db, event);
+  const bytes = encodeCommitFrame(message);
+
+  console.log(
+    JSON.stringify({
+      level: 'info',
+      type: 'firehose_broadcast_start',
+      seq: event.seq,
+      clients: targets.length,
+      ops: (event.ops || []).length,
+      ts: new Date().toISOString(),
+    }),
+  );
+
+  let dropped = 0;
+  for (const ws of targets) {
+    try {
+      ws.send(bytes);
+    } catch {
+      dropped++;
+    }
+  }
+
+  console.log(
+    JSON.stringify({
+      level: 'info',
+      type: 'firehose_broadcast_end',
+      seq: event.seq,
+      clients: targets.length,
+      dropped,
+      ts: new Date().toISOString(),
+    }),
+  );
+}
+
+export function broadcastIdentity(targets: WebSocket[], event: IdentityEvent): void {
+  const bytes = encodeIdentityFrame({
+    seq: event.seq,
+    did: event.did,
+    time: new Date(event.ts).toISOString(),
+    handle: event.handle,
+  });
+  for (const ws of targets) {
+    try {
+      ws.send(bytes);
+    } catch (sendError) {
+      console.warn('Sequencer: identity send failed:', sendError);
+    }
+  }
+}
+
+export function broadcastAccount(targets: WebSocket[], event: AccountEvent): void {
+  const time = new Date(event.ts).toISOString();
+  const wire = toWireStatus(event.state);
+  // dag-cbor refuses to encode `undefined`, so build the payload conditionally
+  // rather than passing { status: undefined } when the FSM is active.
+  const base = { seq: event.seq, did: event.did, time, active: wire.active };
+  const accountBytes = encodeAccountFrame(
+    wire.status ? { ...base, status: wire.status } : base,
+  );
+  // Compatibility #sync emission for clients on the legacy topic.
+  const syncBytes = encodeSyncFrame(
+    wire.status ? { ...base, status: wire.status } : base,
+  );
+  for (const ws of targets) {
+    try {
+      ws.send(accountBytes);
+      ws.send(syncBytes);
+    } catch (sendError) {
+      console.warn('Sequencer: account/sync send failed:', sendError);
+    }
+  }
+}

package/src/worker/sequencer/cid-helpers.ts

@@ -0,0 +1,39 @@
+import { CID } from 'multiformats/cid';
+import type { RepoOp } from '../../lib/firehose/frames';
+
+export function reviveCid(value: unknown): CID | null {
+  try {
+    if (value == null) return null;
+    const asCid = (CID as unknown as { asCID?: (v: unknown) => CID | null }).asCID?.(value);
+    if (asCid) return asCid;
+    if (typeof value === 'string') return CID.parse(value);
+    if (value && typeof value === 'object' && '/' in value) {
+      const link = (value as { '/'?: unknown })['/'];
+      if (typeof link === 'string') return CID.parse(link);
+    }
+  } catch {
+    // Fall through: caller treats null as unknown CID.
+  }
+  return null;
+}
+
+export function reviveOps(ops: unknown): RepoOp[] | undefined {
+  if (!Array.isArray(ops)) return undefined;
+  return ops.map((raw) => {
+    const op = raw as { action: RepoOp['action']; path: string; cid?: unknown; prev?: unknown };
+    const prev = op.prev != null ? reviveCid(op.prev) ?? undefined : undefined;
+    return {
+      action: op.action,
+      path: op.path,
+      cid: reviveCid(op.cid),
+      ...(prev ? { prev } : {}),
+    };
+  });
+}
+
+export function base64ToBytes(value: string): Uint8Array {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}

package/src/worker/sequencer/payload.ts

@@ -0,0 +1,84 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import { drizzle } from 'drizzle-orm/d1';
+import { commit_log } from '../../db/schema';
+import { eq, gt, desc } from 'drizzle-orm';
+import { CID } from 'multiformats/cid';
+import type { CommitMessage } from '../../lib/firehose/frames';
+import { encodeBlocksForCommit } from '../../services/car';
+import type { Env } from '../../env';
+import type { CommitEvent } from './types';
+
+export async function createCommitPayload(
+  env: Env,
+  db: D1Database,
+  event: CommitEvent,
+): Promise<CommitMessage> {
+  const commitData = JSON.parse(event.data) as { data?: string; prev?: string };
+
+  let blocks = event.blocks;
+  if (!blocks && event.ops && event.ops.length > 0) {
+    try {
+      const commitCid = CID.parse(event.commitCid);
+      const mstRoot = commitData.data ? CID.parse(commitData.data) : commitCid;
+      blocks = await encodeBlocksForCommit(env, commitCid, mstRoot, event.ops);
+    } catch (error) {
+      console.error('Failed to encode blocks for commit:', error);
+      blocks = new Uint8Array();
+    }
+  }
+
+  let prevCid: CID | null = null;
+  let prevDataCid: CID | null = null;
+  try {
+    if (commitData.prev) prevCid = CID.parse(String(commitData.prev));
+  } catch {
+    // Stays null; firehose consumers can tolerate a missing prev pointer.
+  }
+
+  let since: string | null = null;
+  try {
+    const drizzleDb = drizzle(db);
+    if (prevCid) {
+      const previous = await drizzleDb
+        .select()
+        .from(commit_log)
+        .where(eq(commit_log.cid, prevCid.toString()))
+        .get();
+      since = previous?.rev ?? null;
+      if (previous?.data) {
+        try {
+          prevDataCid = CID.parse(String(JSON.parse(previous.data).data));
+        } catch {
+          // Older rows may have a different shape; leave prevDataCid null.
+        }
+      }
+    } else {
+      const row = await drizzleDb
+        .select()
+        .from(commit_log)
+        .where(gt(commit_log.seq, 0))
+        .orderBy(desc(commit_log.seq))
+        .limit(1)
+        .get();
+      since = row?.rev ?? null;
+    }
+  } catch (error) {
+    console.warn('createCommitPayload: failed to resolve since/prev:', error);
+  }
+
+  return {
+    seq: event.seq,
+    rebase: false,
+    tooBig: false,
+    repo: event.did,
+    commit: CID.parse(event.commitCid),
+    prev: prevCid,
+    rev: event.rev,
+    since,
+    blocks: blocks || new Uint8Array(),
+    ops: event.ops || [],
+    blobs: [],
+    time: new Date(event.ts).toISOString(),
+    ...(prevDataCid ? { prevData: prevDataCid } : {}),
+  };
+}

package/src/worker/sequencer/types.ts

@@ -0,0 +1,36 @@
+import type { RepoOp } from '../../lib/firehose/frames';
+import type { AccountState } from '../../lib/account-state';
+
+export interface Client {
+  webSocket: WebSocket;
+  id: string;
+  cursor: number;
+}
+
+export interface CommitEvent {
+  seq: number;
+  did: string;
+  commitCid: string;
+  rev: string;
+  data: string;
+  sig: string;
+  ts: number;
+  ops?: RepoOp[];
+  blocks?: Uint8Array;
+}
+
+export interface IdentityEvent {
+  seq: number;
+  did: string;
+  handle?: string;
+  ts: number;
+}
+
+export interface AccountEvent {
+  seq: number;
+  did: string;
+  state: AccountState;
+  ts: number;
+}
+
+export type SequencerEvent = CommitEvent | IdentityEvent | AccountEvent;

package/src/worker/sequencer/upgrade.ts

@@ -0,0 +1,141 @@
+import type { DurableObjectState } from '@cloudflare/workers-types';
+import { encodeInfoFrame } from '../../lib/firehose/frames';
+import { InvalidRequest } from '../../lib/errors';
+
+export type WebSocketAttachment = {
+  id: string;
+  cursor: number;
+};
+
+export type HibernatableSocket = WebSocket & {
+  serializeAttachment?: (value: WebSocketAttachment) => void;
+  deserializeAttachment?: () => WebSocketAttachment | undefined;
+  accept?: () => void;
+  addEventListener?: (
+    type: 'message' | 'close',
+    handler: (event: MessageEvent | { code: number; reason: string }) => void,
+  ) => void;
+  send?: (data: string | ArrayBuffer | Uint8Array) => void;
+};
+
+export type HibernatableState = DurableObjectState & {
+  acceptWebSocket?: (ws: WebSocket) => void;
+  getWebSockets?: () => WebSocket[];
+};
+
+export type UpgradeContext = {
+  readonly state: HibernatableState;
+  readonly nextSeq: number;
+  readonly hibernate: boolean;
+  readonly onClient: (id: string, cursor: number, server: HibernatableSocket) => void;
+};
+
+// Reject NaN / negative / non-integer cursors at the boundary. parseInt('abc')
+// yields NaN, which would silently bypass `cursor > nextSeq - 1` (all NaN
+// comparisons are false) and get persisted into the attachment.
+export function parseCursorParam(raw: string | null): number {
+  if (raw === null || raw === '') return 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new InvalidRequest('cursor must be a non-negative integer');
+  }
+  return parsed;
+}
+
+export function handleUpgrade(
+  request: Request,
+  url: URL,
+  context: UpgradeContext,
+): Response {
+  let cursor: number;
+  try {
+    cursor = parseCursorParam(url.searchParams.get('cursor'));
+  } catch (error) {
+    if (error instanceof InvalidRequest) {
+      return new Response(
+        JSON.stringify({ error: 'InvalidRequest', message: error.message }),
+        { status: 400, headers: { 'Content-Type': 'application/json' } },
+      );
+    }
+    throw error;
+  }
+
+  const pair = new WebSocketPair();
+  const [client, server] = Object.values(pair) as [WebSocket, HibernatableSocket];
+  const id = crypto.randomUUID();
+
+  const requestedProtoHeader =
+    request.headers.get('Sec-WebSocket-Protocol') ||
+    request.headers.get('sec-websocket-protocol');
+  const requestedProtocol = requestedProtoHeader
+    ? requestedProtoHeader.split(',').map((s) => s.trim()).filter(Boolean)[0] || undefined
+    : undefined;
+
+  if (cursor > context.nextSeq - 1) {
+    // Future cursor: send an info frame then 1008-close. Use the standard
+    // WebSocket accept path rather than hibernation for this short-lived case.
+    try {
+      server.accept?.();
+    } catch (acceptError) {
+      console.warn('Sequencer: server.accept failed for OutdatedCursor:', acceptError);
+    }
+    try {
+      server.send?.(encodeInfoFrame('OutdatedCursor', 'Cursor is ahead of current sequence'));
+    } catch (sendError) {
+      console.warn('Sequencer: send(info) failed for OutdatedCursor:', sendError);
+    }
+    try {
+      server.close(1008, 'OutdatedCursor');
+    } catch (closeError) {
+      console.warn('Sequencer: close failed for OutdatedCursor:', closeError);
+    }
+    return buildUpgradeResponse(client, requestedProtocol);
+  }
+
+  if (context.hibernate) {
+    context.state.acceptWebSocket?.(server);
+    try {
+      server.serializeAttachment?.({ id, cursor });
+    } catch (attachError) {
+      console.warn('Sequencer: serializeAttachment failed:', attachError);
+    }
+  } else {
+    server.accept?.();
+    server.addEventListener?.('message', (event) => {
+      const evt = event as MessageEvent;
+      try {
+        const data =
+          typeof evt.data === 'string' ? evt.data : new TextDecoder().decode(evt.data);
+        if (data === 'ping') server.send?.('pong');
+      } catch (messageError) {
+        console.warn('Sequencer: ping handler failed:', messageError);
+      }
+    });
+    server.addEventListener?.('close', (event) => {
+      const cls = event as { code: number; reason: string };
+      console.log(`Client ${id} disconnected (std): code=${cls.code} reason=${cls.reason}`);
+    });
+  }
+
+  console.log(
+    JSON.stringify({
+      level: 'info',
+      type: 'ws_upgrade',
+      id,
+      path: url.pathname,
+      cursor,
+      protocol: requestedProtocol || null,
+      timestamp: new Date().toISOString(),
+    }),
+  );
+
+  context.onClient(id, cursor, server);
+
+  return buildUpgradeResponse(client, requestedProtocol);
+}
+
+function buildUpgradeResponse(client: WebSocket, requestedProtocol: string | undefined): Response {
+  const headers = new Headers();
+  if (requestedProtocol) headers.set('Sec-WebSocket-Protocol', requestedProtocol);
+  return new Response(null, { status: 101, webSocket: client, headers });
+}