@takosjp/yurucommu-core 3.2.1 → 3.4.0

package/src/backend/runtime/call-hub-port.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared HubPort construction. Both the Cloudflare DO and the in-process Bun
+ * hub build their `HubPort` from these deps, so signer loading, media
+ * provisioning, and durable persistence are single-sourced.
+ */
+
+import { eq } from "drizzle-orm";
+import type { Database } from "../../db/index.ts";
+import { actors } from "../../db/index.ts";
+import type { EnvVars } from "../types.ts";
+import type { RtcSignalEnvelopeV1 } from "../../../packages/api/src/types/call.ts";
+import type { CallRecord, HubConnection, HubPort } from "./call-hub-core.ts";
+import {
+  type CallSigner,
+  sendCallSignal,
+} from "../lib/rtc/signal-transport.ts";
+import { createRtcProvider } from "../lib/rtc/provider.ts";
+import { upsertCallSession } from "../lib/rtc/call-store.ts";
+import { logger } from "../lib/logger.ts";
+
+const log = logger.child({ component: "call.hub" });
+
+export interface CallHubPortDeps {
+  localActorApId: string;
+  db: Database;
+  env: EnvVars;
+  broadcast(frame: Parameters<HubConnection["send"]>[0]): void;
+  hasClients(): boolean;
+  ring?(envelope: RtcSignalEnvelopeV1): Promise<void> | void;
+}
+
+export function createCallHubPort(deps: CallHubPortDeps): HubPort {
+  const provider = createRtcProvider(deps.env);
+  let signer: CallSigner | null = null;
+
+  const loadSigner = async (): Promise<CallSigner> => {
+    if (signer) return signer;
+    const row = await deps.db.query.actors.findFirst({
+      where: eq(actors.apId, deps.localActorApId),
+      columns: { apId: true, privateKeyPem: true },
+    });
+    if (!row?.privateKeyPem) {
+      throw new Error(`no signing key for local actor ${deps.localActorApId}`);
+    }
+    signer = { apId: row.apId, privateKeyPem: row.privateKeyPem };
+    return signer;
+  };
+
+  return {
+    localActorApId: deps.localActorApId,
+    broadcast: deps.broadcast,
+    hasClients: deps.hasClients,
+    ring: deps.ring,
+    now: () => Date.now(),
+    log: (event, data) => log.info(event, data),
+    async sendToPeer(envelope, peerSignalEndpoint) {
+      const s = await loadSigner();
+      await sendCallSignal(deps.db, s, envelope, peerSignalEndpoint);
+    },
+    async provisionMedia(media) {
+      const [iceServers, sfuFocus] = await Promise.all([
+        provider.getIceServers(),
+        provider.getSfuFocus(media),
+      ]);
+      return { iceServers, sfuFocus };
+    },
+    async persist(call: CallRecord) {
+      try {
+        await upsertCallSession(deps.db, deps.localActorApId, call);
+      } catch (err) {
+        log.warn("call session persist failed", {
+          callId: call.callId,
+          error: String(err),
+        });
+      }
+    },
+  };
+}

package/src/backend/runtime/call-signaling-do.ts

@@ -0,0 +1,242 @@
+/**
+ * CallSignalingDurableObject — per-local-user signaling hub (call feature).
+ *
+ * One DO instance per local actor (`idFromName(actorApId)`). It is the standing
+ * presence socket the browser connects to (so an incoming ring can arrive before
+ * any call object exists), the fan-in point for cross-instance signals delivered
+ * to `/ap/rtc/signal`, and the owner of the per-call state machine (via the
+ * runtime-neutral `CallHub`).
+ *
+ * Uses Hibernatable WebSockets: idle presence sockets can be evicted and the DO
+ * reconstructs its `CallHub` from durable storage (`call:*` records) on wake.
+ * The CF/DO + Hibernatable-WebSocket surface is typed file-locally so this file
+ * does not depend on a specific `@cloudflare/workers-types` version.
+ */
+
+import { getDb } from "../../db/index.ts";
+import type { EnvVars } from "../types.ts";
+import { CallHub, type CallRecord } from "./call-hub-core.ts";
+import { createCallHubPort } from "./call-hub-port.ts";
+import type {
+  ClientToHubFrame,
+  HubToClientFrame,
+  RtcSignalEnvelopeV1,
+} from "../../../packages/api/src/types/call.ts";
+import {
+  isTerminalCallState,
+  parseRtcSignalEnvelope,
+} from "../../../packages/api/src/types/call.ts";
+
+// --- Minimal Cloudflare DO + Hibernatable WebSocket surface ----------------
+interface DoWebSocket {
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+}
+interface DoStorage {
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  put(key: string, value: unknown): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  list<T = unknown>(options?: { prefix?: string }): Promise<Map<string, T>>;
+  setAlarm(scheduledTime: number): Promise<void>;
+  getAlarm(): Promise<number | null>;
+}
+interface DoState {
+  acceptWebSocket(ws: DoWebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): DoWebSocket[];
+  readonly storage: DoStorage;
+}
+declare const WebSocketPair: {
+  new (): { 0: DoWebSocket; 1: DoWebSocket };
+};
+
+type CallDoEnv = EnvVars & {
+  DB: D1Database;
+  CALL_SIGNALING?: DurableObjectNamespace;
+};
+
+const ALARM_INTERVAL_MS = 15_000;
+const ACTOR_KEY = "actor";
+const CALL_PREFIX = "call:";
+
+export class CallSignalingDurableObject {
+  private hub: CallHub | null = null;
+  private actorApId: string | null = null;
+
+  constructor(
+    private readonly state: DoState,
+    private readonly env: CallDoEnv,
+  ) {}
+
+  // -------------------------------------------------------------------------
+  // HTTP entry (from the CloudflareSignalingHub adapter)
+  // -------------------------------------------------------------------------
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname === "/_ws") {
+      return this.handleUpgrade(request, url);
+    }
+    if (url.pathname === "/_ingest") {
+      return this.handleIngest(request);
+    }
+    return new Response("not found", { status: 404 });
+  }
+
+  private async handleUpgrade(request: Request, url: URL): Promise<Response> {
+    if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
+      return new Response("expected websocket", { status: 426 });
+    }
+    const actor =
+      request.headers.get("X-Call-Actor") ?? url.searchParams.get("actor");
+    if (!actor) return new Response("missing actor", { status: 400 });
+    await this.setActor(actor);
+
+    const pair = new WebSocketPair();
+    const client = pair[0];
+    const server = pair[1];
+    this.state.acceptWebSocket(server);
+    await this.scheduleAlarm();
+    return new Response(null, {
+      status: 101,
+      // `webSocket` is a Cloudflare-specific ResponseInit field.
+      webSocket: client,
+    } as unknown as ResponseInit);
+  }
+
+  private async handleIngest(request: Request): Promise<Response> {
+    let body: unknown;
+    try {
+      body = await request.json();
+    } catch {
+      return new Response("bad json", { status: 400 });
+    }
+    const envelope = parseRtcSignalEnvelope(body);
+    if (!envelope) return new Response("bad envelope", { status: 400 });
+    await this.setActor(envelope.to);
+    const hub = await this.ensureHub();
+    if (!hub) return new Response("no actor", { status: 409 });
+    await hub.handleInboundSignal(envelope);
+    await this.scheduleAlarm();
+    return new Response(null, { status: 204 });
+  }
+
+  // -------------------------------------------------------------------------
+  // Hibernatable WebSocket events
+  // -------------------------------------------------------------------------
+  async webSocketMessage(
+    ws: DoWebSocket,
+    message: string | ArrayBuffer,
+  ): Promise<void> {
+    if (typeof message !== "string") return;
+    let frame: ClientToHubFrame;
+    try {
+      const parsed = JSON.parse(message);
+      if (!parsed || typeof parsed.t !== "string") return;
+      frame = parsed as ClientToHubFrame;
+    } catch {
+      return;
+    }
+    const hub = await this.ensureHub();
+    if (!hub) {
+      this.send(ws, { t: "error", code: "no_session" });
+      return;
+    }
+    await hub.handleClientFrame(this.wrap(ws), frame);
+    await this.scheduleAlarm();
+  }
+
+  async webSocketClose(ws: DoWebSocket): Promise<void> {
+    try {
+      ws.close();
+    } catch {
+      // already closing
+    }
+  }
+
+  async webSocketError(): Promise<void> {
+    // getWebSockets() excludes the errored socket automatically.
+  }
+
+  async alarm(): Promise<void> {
+    const hub = await this.ensureHub();
+    hub?.tick();
+    const active = (hub?.activeCalls().length ?? 0) > 0;
+    const connected = this.state.getWebSockets().length > 0;
+    if (active || connected) await this.scheduleAlarm(true);
+  }
+
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  private async setActor(actor: string): Promise<void> {
+    if (this.actorApId === actor) return;
+    this.actorApId = actor;
+    await this.state.storage.put(ACTOR_KEY, actor);
+  }
+
+  private async ensureHub(): Promise<CallHub | null> {
+    if (this.hub) return this.hub;
+    const actor =
+      this.actorApId ?? (await this.state.storage.get<string>(ACTOR_KEY));
+    if (!actor) return null;
+    this.actorApId = actor;
+
+    const db = getDb(this.env.DB);
+    const storage = this.state.storage;
+    const base = createCallHubPort({
+      localActorApId: actor,
+      db,
+      env: this.env,
+      broadcast: (frame: HubToClientFrame) => {
+        for (const ws of this.state.getWebSockets()) this.send(ws, frame);
+      },
+      hasClients: () => this.state.getWebSockets().length > 0,
+    });
+    // Layer durable DO storage on top of the D1 persist so the in-memory call
+    // map survives hibernation.
+    const hub = new CallHub({
+      ...base,
+      persist: async (call: CallRecord) => {
+        if (isTerminalCallState(call.state)) {
+          await storage.delete(`${CALL_PREFIX}${call.callId}`);
+        } else {
+          await storage.put(`${CALL_PREFIX}${call.callId}`, call);
+        }
+        await base.persist?.(call);
+      },
+    });
+    const stored = await storage.list<CallRecord>({ prefix: CALL_PREFIX });
+    hub.hydrate([...stored.values()]);
+    this.hub = hub;
+    return hub;
+  }
+
+  private wrap(ws: DoWebSocket) {
+    return {
+      send: (frame: HubToClientFrame) => this.send(ws, frame),
+      close: (code?: number, reason?: string) => {
+        try {
+          ws.close(code, reason);
+        } catch {
+          // ignore
+        }
+      },
+    };
+  }
+
+  private send(ws: DoWebSocket, frame: HubToClientFrame): void {
+    try {
+      ws.send(JSON.stringify(frame));
+    } catch {
+      // socket gone; getWebSockets() will drop it
+    }
+  }
+
+  private async scheduleAlarm(force = false): Promise<void> {
+    const existing = await this.state.storage.getAlarm();
+    if (existing !== null && !force) return;
+    await this.state.storage.setAlarm(Date.now() + ALARM_INTERVAL_MS);
+  }
+}
+
+// Re-exported here so the type is available to callers that only import the DO.
+export type { RtcSignalEnvelopeV1 };

package/src/backend/runtime/realtime-hub.ts

@@ -0,0 +1,257 @@
+/**
+ * IRealtimeHub — the seam that decouples the realtime event stream from the
+ * Durable Object runtime (mirrors `signaling-hub.ts` for calls).
+ *
+ * On Cloudflare it forwards to the per-user `RealtimeStreamDO`
+ * (`idFromName(actorApId)`); on a runtime without the DO binding the hub is a
+ * null object: `emit` is a no-op and upgrades answer 503, so clients detect
+ * the missing capability (`GET /api/realtime/config`) and fall back to their
+ * low-frequency polling loops. Emits are ALWAYS best-effort — a realtime
+ * delivery failure must never fail the REST write that produced it.
+ */
+
+import { gt } from "drizzle-orm";
+import type { Env } from "../types.ts";
+import { notificationPushJobs } from "../../db/index.ts";
+import { computeUnreadSnapshot } from "../lib/unread-counts.ts";
+import { logger } from "../lib/logger.ts";
+
+const log = logger.child({ component: "realtime.hub" });
+
+export interface IRealtimeHub {
+  /** Forward a browser WebSocket upgrade to `actorApId`'s stream (101). */
+  upgrade(
+    request: Request,
+    actorApId: string,
+    auth: "session" | "ticket",
+    ticket?: string,
+  ): Promise<Response>;
+  /** Mint a one-time short-lived WS ticket inside the user's stream DO. */
+  mintTicket(actorApId: string): Promise<string | null>;
+  /** Push one event to `actorApId`'s live sockets (best-effort). */
+  emit(
+    actorApId: string,
+    type: string,
+    data: Record<string, unknown>,
+  ): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Cloudflare: forward to the per-user Durable Object
+// ---------------------------------------------------------------------------
+class CloudflareRealtimeHub implements IRealtimeHub {
+  constructor(private readonly ns: DurableObjectNamespace) {}
+
+  private stub(actorApId: string): DurableObjectStub {
+    return this.ns.get(this.ns.idFromName(actorApId));
+  }
+
+  async upgrade(
+    request: Request,
+    actorApId: string,
+    auth: "session" | "ticket",
+    ticket?: string,
+  ): Promise<Response> {
+    const headers = new Headers(request.headers);
+    headers.set("X-Realtime-Auth", auth);
+    if (ticket) headers.set("X-Realtime-Ticket", ticket);
+    const forwarded = new Request("https://realtime-do/_ws", {
+      method: "GET",
+      headers,
+    });
+    return this.stub(actorApId).fetch(
+      forwarded as unknown as Parameters<DurableObjectStub["fetch"]>[0],
+    ) as unknown as Promise<Response>;
+  }
+
+  async mintTicket(actorApId: string): Promise<string | null> {
+    const response = await this.stub(actorApId).fetch(
+      "https://realtime-do/_ticket",
+      { method: "POST" },
+    );
+    if (!response.ok) return null;
+    const body = (await response.json()) as { ticket?: unknown };
+    return typeof body.ticket === "string" ? body.ticket : null;
+  }
+
+  async emit(
+    actorApId: string,
+    type: string,
+    data: Record<string, unknown>,
+  ): Promise<void> {
+    await this.stub(actorApId).fetch("https://realtime-do/_emit", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type, data }),
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Null hub (no DO binding): clients fall back to polling
+// ---------------------------------------------------------------------------
+class NullRealtimeHub implements IRealtimeHub {
+  async upgrade(): Promise<Response> {
+    return new Response(
+      JSON.stringify({
+        error: "realtime_unavailable",
+        message: "Realtime streaming requires the Durable Objects runtime.",
+      }),
+      { status: 503, headers: { "Content-Type": "application/json" } },
+    );
+  }
+
+  async mintTicket(): Promise<string | null> {
+    return null;
+  }
+
+  async emit(): Promise<void> {
+    // no-op: clients poll
+  }
+}
+
+const nullHub = new NullRealtimeHub();
+
+/** Resolve the realtime hub for this runtime. */
+export function getRealtimeHub(env: Env): IRealtimeHub {
+  if (env.REALTIME_STREAM) {
+    return new CloudflareRealtimeHub(env.REALTIME_STREAM);
+  }
+  return nullHub;
+}
+
+/** Whether realtime streaming can be served on this runtime. */
+export function isRealtimeAvailable(env: Env): boolean {
+  return Boolean(env.REALTIME_STREAM);
+}
+
+// ---------------------------------------------------------------------------
+// Best-effort emit helpers (producers call these; failures never propagate)
+// ---------------------------------------------------------------------------
+
+export interface RealtimeEmitInput {
+  actorApId: string;
+  type: string;
+  data: Record<string, unknown>;
+}
+
+/** Emit a batch of events, swallowing (but logging) any delivery failure. */
+export async function emitRealtimeBestEffort(
+  env: Env,
+  events: RealtimeEmitInput[],
+): Promise<void> {
+  if (!isRealtimeAvailable(env) || events.length === 0) return;
+  const hub = getRealtimeHub(env);
+  await Promise.all(
+    events.map(async ({ actorApId, type, data }) => {
+      try {
+        await hub.emit(actorApId, type, data);
+      } catch (error) {
+        log.warn("Realtime emit failed", {
+          event: "realtime.emit_failed",
+          type,
+          error,
+        });
+      }
+    }),
+  );
+}
+
+/**
+ * Compute and push the authoritative unread counters for one user. The
+ * counters are always server-derived (the same SQL as the badge endpoints) so
+ * a pushed badge can never drift from what the client would fetch.
+ */
+export async function emitUnreadSnapshot(
+  env: Env,
+  actorApId: string,
+): Promise<void> {
+  if (!isRealtimeAvailable(env)) return;
+  try {
+    const snapshot = await computeUnreadSnapshot(env.DB_INSTANCE, actorApId);
+    await getRealtimeHub(env).emit(actorApId, "unread", {
+      dm: snapshot.dm,
+      community: snapshot.community,
+      talk_total: snapshot.talkTotal,
+      notifications: snapshot.notifications,
+    });
+  } catch (error) {
+    log.warn("Realtime unread emit failed", {
+      event: "realtime.unread_emit_failed",
+      error,
+    });
+  }
+}
+
+/**
+ * Schedule best-effort realtime work after the response is sent. Mirrors the
+ * push-outbox sweep in index.ts: prefer `executionCtx.waitUntil`, fall back to
+ * awaiting inline where no runtime context exists (tests / plain fetch).
+ */
+export async function runRealtimeAfterResponse(
+  c: { executionCtx?: { waitUntil?: (p: Promise<unknown>) => void } },
+  task: () => Promise<void>,
+): Promise<void> {
+  const wrapped = task().catch((error) => {
+    log.warn("Realtime after-response task failed", {
+      event: "realtime.after_response_failed",
+      error,
+    });
+  });
+  try {
+    const ctx = c.executionCtx;
+    if (ctx && typeof ctx.waitUntil === "function") {
+      ctx.waitUntil(wrapped);
+      return;
+    }
+  } catch {
+    // No execution context; await inline below.
+  }
+  await wrapped;
+}
+
+// ---------------------------------------------------------------------------
+// Notification sweep (the same choke points that flush the push outbox)
+// ---------------------------------------------------------------------------
+
+// Every unread inbox insert is captured by the notification_push_jobs DB
+// trigger — the single choke point covering all nine scattered insert sites
+// (follow/like/reply/mention/DM/federation/community fanout). A DB trigger
+// cannot call a Durable Object, so this sweep reads the jobs the trigger
+// wrote and emits `notification.new` + `unread` to each affected user. It is
+// called from the SAME two flush points as `enqueuePendingNotificationPushJobs`
+// (the post-response middleware and the queue-consumer tail).
+//
+// The cursor is per-isolate in-memory, initialized to isolate start so a cold
+// isolate never replays history; a double-emit across isolates is harmless
+// (clients treat both event types idempotently: refetch + set-counter).
+let realtimeSweepCursor = new Date().toISOString();
+
+export async function sweepRealtimeNotifications(env: Env): Promise<void> {
+  if (!isRealtimeAvailable(env)) return;
+  const since = realtimeSweepCursor;
+  const nextCursor = new Date().toISOString();
+  try {
+    const rows = await env.DB_INSTANCE.selectDistinct({
+      actorApId: notificationPushJobs.actorApId,
+    })
+      .from(notificationPushJobs)
+      .where(gt(notificationPushJobs.createdAt, since))
+      .limit(50);
+    realtimeSweepCursor = nextCursor;
+    if (rows.length === 0) return;
+    await Promise.all(
+      rows.map(async ({ actorApId }) => {
+        await emitRealtimeBestEffort(env, [
+          { actorApId, type: "notification.new", data: {} },
+        ]);
+        await emitUnreadSnapshot(env, actorApId);
+      }),
+    );
+  } catch (error) {
+    log.warn("Realtime notification sweep failed", {
+      event: "realtime.sweep_failed",
+      error,
+    });
+  }
+}