@takosjp/yurucommu-core 3.4.1 → 3.4.4

package/packages/api/src/lib/rtc-client.ts

@@ -19,6 +19,8 @@ import type {
   HubToClientFrame,
   IceServerConfig,
 } from "../types/call.ts";
+import { apiPost } from "./api/fetch.ts";
+import { getYurucommuApiTransport } from "./transport.ts";
 
 export type CallUiState =
   | "idle"
@@ -45,7 +47,7 @@ export interface CallClientEvents {
 }
 
 export interface CallClientOptions {
-  /** Origin the app is served from (defaults to the page origin). */
+  /** Explicit server-origin override; otherwise the configured API transport owns it. */
   origin?: string;
   /** WebSocket reconnect backoff ceiling (ms). */
   maxBackoffMs?: number;
@@ -67,12 +69,15 @@ interface ActiveCall {
 }
 
 const CANDIDATE_FLUSH_MS = 200;
+const MAX_PENDING_SOCKET_FRAMES = 64;
 
 export class CallClient {
   private ws: WebSocket | null = null;
   private wantConnected = false;
   private backoff = 500;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private openingSocket = false;
+  private readonly pendingFrames: ClientToHubFrame[] = [];
   private readonly listeners = new Map<keyof CallClientEvents, Set<Listener>>();
   private call: ActiveCall | null = null;
   private localStream: MediaStream | null = null;
@@ -114,16 +119,24 @@ export class CallClient {
   }
 
   // --- connection -----------------------------------------------------------
-  private origin(): string {
-    return (
-      this.options.origin ??
-      (typeof location !== "undefined" ? location.origin : "")
-    );
+  private apiUrl(path: string): string {
+    const origin = this.options.origin;
+    return origin ? new URL(path, `${origin}/`).toString() : path;
   }
 
-  private socketUrl(): string {
-    const o = this.origin();
-    return `${o.replace(/^http/, "ws")}/api/rtc/socket`;
+  private socketUrl(actorApId: string, ticket: string): string {
+    const transport = getYurucommuApiTransport();
+    const resolved = transport.resolveUrl(this.apiUrl("/api/rtc/socket"));
+    const base =
+      this.options.origin ??
+      (typeof location !== "undefined" ? location.origin : "http://localhost");
+    const url = new URL(resolved, base);
+    if (url.protocol === "http:") url.protocol = "ws:";
+    else if (url.protocol === "https:") url.protocol = "wss:";
+    else throw new Error("call socket URL must use HTTP(S)");
+    url.searchParams.set("actor", actorApId);
+    url.searchParams.set("ticket", ticket);
+    return url.toString();
   }
 
   connect(): void {
@@ -137,13 +150,46 @@ export class CallClient {
     this.reconnectTimer = null;
     this.ws?.close();
     this.ws = null;
+    this.pendingFrames.length = 0;
   }
 
   private openSocket(): void {
     if (this.ws && this.ws.readyState <= WebSocket.OPEN) return;
+    if (this.openingSocket) return;
+    this.openingSocket = true;
+    void this.openSocketWithTicket().finally(() => {
+      this.openingSocket = false;
+    });
+  }
+
+  private async openSocketWithTicket(): Promise<void> {
+    let actorApId: string;
+    let ticket: string;
+    try {
+      const response = await apiPost(this.apiUrl("/api/rtc/ticket"));
+      if (!response.ok) throw new Error(`ticket ${response.status}`);
+      const body = (await response.json()) as {
+        actor_ap_id?: unknown;
+        ticket?: unknown;
+      };
+      if (
+        typeof body.actor_ap_id !== "string" ||
+        typeof body.ticket !== "string"
+      ) {
+        throw new Error("bad ticket response");
+      }
+      actorApId = body.actor_ap_id;
+      ticket = body.ticket;
+    } catch (err) {
+      this.emit("error", "socket_ticket_failed", String(err));
+      this.scheduleReconnect();
+      return;
+    }
+    if (!this.wantConnected) return;
+
     let socket: WebSocket;
     try {
-      socket = new WebSocket(this.socketUrl());
+      socket = new WebSocket(this.socketUrl(actorApId, ticket));
     } catch (err) {
       this.emit("error", "socket_open_failed", String(err));
       this.scheduleReconnect();
@@ -152,8 +198,22 @@ export class CallClient {
     this.ws = socket;
     socket.onopen = () => {
       this.backoff = 500;
-      this.send({ t: "hello" });
-      if (this.call) this.send({ t: "resume", callId: this.call.callId });
+      socket.send(JSON.stringify({ t: "hello" } satisfies ClientToHubFrame));
+      const pending = this.pendingFrames.splice(0);
+      const hasInitialInvite =
+        this.call !== null &&
+        pending.some(
+          (frame) => frame.t === "invite" && frame.callId === this.call?.callId,
+        );
+      if (this.call && !hasInitialInvite) {
+        socket.send(
+          JSON.stringify({
+            t: "resume",
+            callId: this.call.callId,
+          } satisfies ClientToHubFrame),
+        );
+      }
+      for (const frame of pending) socket.send(JSON.stringify(frame));
     };
     socket.onmessage = (ev) => {
       void this.onFrame(ev.data);
@@ -181,7 +241,14 @@ export class CallClient {
   private send(frame: ClientToHubFrame): void {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(frame));
+      return;
     }
+    if (!this.wantConnected) return;
+    if (this.pendingFrames.length >= MAX_PENDING_SOCKET_FRAMES) {
+      this.emit("error", "socket_queue_full");
+      return;
+    }
+    this.pendingFrames.push(frame);
   }
 
   // --- public call control --------------------------------------------------
@@ -189,11 +256,9 @@ export class CallClient {
   /** Place an outgoing call. Fetches a callId + ICE, then rings the peer. */
   async startCall(peer: string, media: CallMediaKind): Promise<void> {
     if (this.call) throw new Error("already in a call");
-    const res = await fetch(`${this.origin()}/api/rtc/calls`, {
-      method: "POST",
-      credentials: "include",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ to: peer, media }),
+    const res = await apiPost(this.apiUrl("/api/rtc/calls"), {
+      to: peer,
+      media,
     });
     if (!res.ok) {
       const code = res.status === 403 ? "blocked" : "start_failed";
@@ -204,18 +269,19 @@ export class CallClient {
       callId: string;
       iceServers: IceServerConfig[];
     };
-    this.call = this.newCall(
+    const call = this.newCall(
       data.callId,
       peer,
       media,
       "caller",
       data.iceServers,
     );
+    this.call = call;
     this.setState("calling");
     this.connect();
     this.send({ t: "invite", callId: data.callId, to: peer, media });
-    await this.setupMedia(this.call);
-    await this.makeOffer(this.call);
+    if (!(await this.setupMedia(call))) return;
+    await this.makeOffer(call);
   }
 
   /** Accept the current incoming call. */
@@ -224,11 +290,14 @@ export class CallClient {
     if (!call || call.role !== "callee") return;
     this.setState("connecting");
     this.send({ t: "accept", callId: call.callId });
-    await this.setupMedia(call);
+    if (!(await this.setupMedia(call))) return;
     // The offer was already applied on arrival; create + send the answer.
-    if (call.pc && call.remoteDescriptionSet) {
-      const answer = await call.pc.createAnswer();
-      await call.pc.setLocalDescription(answer);
+    const pc = call.pc;
+    if (pc && call.remoteDescriptionSet && this.isActiveCall(call)) {
+      const answer = await pc.createAnswer();
+      if (!this.isActivePeer(call, pc)) return;
+      await pc.setLocalDescription(answer);
+      if (!this.isActivePeer(call, pc)) return;
       this.send({ t: "answer", callId: call.callId, sdp: answer.sdp ?? "" });
     }
   }
@@ -412,24 +481,45 @@ export class CallClient {
   }
 
   // --- media + peer connection ---------------------------------------------
-  private async setupMedia(call: ActiveCall): Promise<void> {
+  private isActiveCall(call: ActiveCall): boolean {
+    return this.call === call;
+  }
+
+  private isActivePeer(call: ActiveCall, pc: RTCPeerConnection): boolean {
+    return this.isActiveCall(call) && call.pc === pc;
+  }
+
+  private async setupMedia(call: ActiveCall): Promise<boolean> {
+    if (!this.isActiveCall(call)) return false;
     if (!this.localStream) {
+      let stream: MediaStream;
       try {
-        this.localStream = await navigator.mediaDevices.getUserMedia({
+        stream = await navigator.mediaDevices.getUserMedia({
           audio: call.media.audio,
           video: call.media.video,
         });
       } catch (err) {
+        if (!this.isActiveCall(call)) return false;
         this.emit("error", "media_denied", String(err));
         this.hangup("media_denied");
-        return;
+        return false;
+      }
+      if (!this.isActiveCall(call)) {
+        // Permission prompts resolve asynchronously. If the user cancelled or
+        // another call replaced this one while the prompt was open, the newly
+        // acquired tracks have no owner and must be stopped immediately.
+        stream.getTracks().forEach((track) => track.stop());
+        return false;
       }
+      this.localStream = stream;
       this.emit("localstream", this.localStream);
     }
+    if (!this.isActiveCall(call)) return false;
     if (!call.pc) this.buildPeerConnection(call);
     for (const track of this.localStream.getTracks()) {
       call.pc?.addTrack(track, this.localStream);
     }
+    return this.isActiveCall(call);
   }
 
   private buildPeerConnection(call: ActiveCall): void {
@@ -441,13 +531,16 @@ export class CallClient {
       })),
     });
     pc.onicecandidate = (ev) => {
+      if (!this.isActivePeer(call, pc)) return;
       if (ev.candidate) this.bufferCandidate(call, ev.candidate.toJSON());
       else this.flushCandidates(call);
     };
     pc.ontrack = (ev) => {
+      if (!this.isActivePeer(call, pc)) return;
       this.emit("remotestream", ev.streams[0] ?? null);
     };
     pc.onconnectionstatechange = () => {
+      if (!this.isActivePeer(call, pc)) return;
       if (pc.connectionState === "connected") this.setState("connected");
       else if (
         pc.connectionState === "failed" ||
@@ -460,9 +553,14 @@ export class CallClient {
   }
 
   private async makeOffer(call: ActiveCall): Promise<void> {
+    if (!this.isActiveCall(call)) return;
     if (!call.pc) this.buildPeerConnection(call);
-    const offer = await call.pc!.createOffer();
-    await call.pc!.setLocalDescription(offer);
+    const pc = call.pc;
+    if (!pc) return;
+    const offer = await pc.createOffer();
+    if (!this.isActivePeer(call, pc)) return;
+    await pc.setLocalDescription(offer);
+    if (!this.isActivePeer(call, pc)) return;
     this.send({ t: "offer", callId: call.callId, sdp: offer.sdp ?? "" });
   }
 

package/src/backend/federation-helpers.ts

@@ -11,6 +11,7 @@ export {
   activityApId,
   actorApId,
   communityApId,
+  formatPreferredUsername,
   formatUsername,
   generateId,
   getDomain,

package/src/backend/index.ts

@@ -47,7 +47,7 @@ import {
 import { logger } from "./lib/logger.ts";
 
 const log = logger.child({ component: "backend.index" });
-let lastNotificationPushRecoverySweep = 0;
+let lastOutboxRecoverySweep = 0;
 import type { IQueueBatch } from "./runtime/queue.ts";
 import type {
   D1Database,
@@ -56,16 +56,21 @@ import type {
   MessageBatch,
   Queue,
   R2Bucket,
+  ScheduledController,
 } from "@cloudflare/workers-types";
 import type {
   DeliveryDlqMessageV1,
   DeliveryQueueMessageV1,
 } from "./lib/delivery/types.ts";
 import {
+  enqueuePendingDeliveryEndpointJobs,
   handleDeliveryDlqBatch,
   handleDeliveryQueueBatch,
 } from "./lib/delivery/queue.ts";
+import { enqueuePendingDeliveryResolutionJobs } from "./lib/delivery/resolution-outbox.ts";
+import { enqueuePendingDeliveryFanoutJobs } from "./lib/delivery/fanout-outbox.ts";
 import { enqueuePendingNotificationPushJobs } from "./lib/notification-push.ts";
+import { runYurucommuRetention } from "./retention.ts";
 
 type YurucommuApp = Hono<{ Bindings: Env; Variables: Variables }>;
 
@@ -618,10 +623,20 @@ function applyGlobalMiddleware(
     const method = c.req.method.toUpperCase();
     const now = Date.now();
     const mutating = !["GET", "HEAD", "OPTIONS"].includes(method);
-    const recoveryDue = now - lastNotificationPushRecoverySweep >= 60_000;
+    const recoveryDue = now - lastOutboxRecoverySweep >= 60_000;
     if (mutating || recoveryDue) {
-      if (recoveryDue) lastNotificationPushRecoverySweep = now;
+      if (recoveryDue) lastOutboxRecoverySweep = now;
       const sweep = (async () => {
+        try {
+          await enqueuePendingDeliveryFanoutJobs(c.env);
+          await enqueuePendingDeliveryEndpointJobs(c.env);
+          await enqueuePendingDeliveryResolutionJobs(c.env);
+        } catch (error) {
+          log.error("Failed to enqueue durable federation outbox", {
+            event: "delivery.outbox.enqueue_failed",
+            error,
+          });
+        }
         try {
           await enqueuePendingNotificationPushJobs(c.env);
         } catch (error) {
@@ -994,6 +1009,12 @@ type WorkerBindings = EnvVars & {
   REALTIME_STREAM?: DurableObjectNamespace;
 };
 
+function isMaterializedRuntimeEnv(
+  bindings: WorkerBindings | Env,
+): bindings is Env {
+  return "DB_INSTANCE" in bindings && !!bindings.DB_INSTANCE;
+}
+
 export default {
   async fetch(
     request: Request,
@@ -1012,4 +1033,15 @@ export default {
       wrapCloudflareBindings(bindings),
     );
   },
+
+  async scheduled(
+    _controller: ScheduledController,
+    bindings: WorkerBindings | Env,
+    _ctx: ExecutionContext,
+  ): Promise<void> {
+    const env = isMaterializedRuntimeEnv(bindings)
+      ? bindings
+      : wrapCloudflareBindings(bindings);
+    await runYurucommuRetention(env);
+  },
 };