@vgai/editor 0.2.0 → 0.4.0-canary.20260715.0

package/server/editor-sse.ts

@@ -8,22 +8,41 @@
 import type { ServerResponse } from 'node:http';
 
 const sseClients = new Set<ServerResponse>();
+const clientIds = new Map<ServerResponse, string>();
+const clientControlHealth = new Map<string, ClientControlHealth>();
+
+export interface ClientControlHealth {
+  /** `healthy` means the tab explicitly reported an empty pageErrors list. */
+  readonly errorState: 'healthy' | 'unknown' | 'errored';
+  readonly visible: boolean;
+  readonly focused: boolean;
+  readonly updatedAt: number;
+}
 
 const KEEPALIVE_MS = 15_000;
 let keepaliveTimer: ReturnType<typeof setInterval> | null = null;
 
+function dropClient(client: ServerResponse): void {
+  const clientId = clientIds.get(client);
+  sseClients.delete(client);
+  clientIds.delete(client);
+  if (clientId && ![...clientIds.values()].includes(clientId)) {
+    clientControlHealth.delete(clientId);
+  }
+}
+
 /** Write to a client, removing it from the pool if the socket is dead. */
 function writeOrDrop(client: ServerResponse, msg: string): void {
   try {
     // `writableEnded` guards against writing to a closed stream.
     if (client.writableEnded) {
-      sseClients.delete(client);
+      dropClient(client);
       return;
     }
     client.write(msg);
   } catch {
     // SC3: one dead client must not abort the broadcast loop.
-    sseClients.delete(client);
+    dropClient(client);
   }
 }
 
@@ -55,19 +74,111 @@ export function broadcast(event: string, data: unknown): void {
   for (const client of [...sseClients]) writeOrDrop(client, msg);
 }
 
+/**
+ * Send an SSE event to exactly one editor client.
+ *
+ * Commands are side effects, unlike asset/status notifications. Broadcasting
+ * them made every open tab execute Play/Stop and race to answer the same SDK
+ * request. The newest live connection is the controller: it is normally the
+ * tab the launcher most recently opened, and a reconnect naturally takes
+ * ownership after a reload. Returns null only when no writable client exists.
+ */
+export function sendToController(event: string, data: unknown): ServerResponse | null {
+  const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  while (true) {
+    const client = selectedController();
+    if (!client) return null;
+    if (client.writableEnded) {
+      dropClient(client);
+      continue;
+    }
+    try {
+      client.write(msg);
+      return client;
+    } catch {
+      dropClient(client);
+    }
+  }
+}
+
 /** Add an SSE client connection. Call from the /__editor/events handler. */
-export function addClient(res: ServerResponse): void {
+export function addClient(res: ServerResponse, clientId?: string): void {
   sseClients.add(res);
+  if (clientId) clientIds.set(res, clientId);
   ensureKeepalive();
 }
 
 /** Remove an SSE client connection. Call on request close. */
 export function removeClient(res: ServerResponse): void {
-  sseClients.delete(res);
+  dropClient(res);
   if (sseClients.size === 0) stopKeepalive();
 }
 
+/** Update the signals used to choose one command-owning browser tab. */
+export function updateClientControlHealth(clientId: string, health: ClientControlHealth): void {
+  clientControlHealth.set(clientId, health);
+}
+
 /** Number of currently-connected clients (exposed for tests). */
 export function clientCount(): number {
   return sseClients.size;
 }
+
+/** Identity of the same newest live tab that receives control commands. */
+export function controllerClientId(): string | null {
+  const controller = selectedController();
+  return controller ? (clientIds.get(controller) ?? null) : null;
+}
+
+function selectedController(): ServerResponse | null {
+  const clients = [...sseClients];
+  const candidates: Array<{
+    client: ServerResponse;
+    connectionOrder: number;
+    identified: boolean;
+    health: ClientControlHealth | undefined;
+  }> = [];
+  for (let i = 0; i < clients.length; i++) {
+    const client = clients[i]!;
+    if (client.writableEnded) {
+      dropClient(client);
+      continue;
+    }
+    const clientId = clientIds.get(client);
+    candidates.push({
+      client,
+      connectionOrder: i,
+      identified: clientId !== undefined,
+      health: clientId ? clientControlHealth.get(clientId) : undefined,
+    });
+  }
+  // A current editor tab always supplies a client id. Its SSE connection is
+  // established slightly before the app installs its command listener and
+  // posts the first state snapshot, so an identified client with no health
+  // report is connected but not command-ready yet. Sending into that window
+  // loses the command forever. Keep id-less legacy/test clients as a fallback,
+  // but never select a current identified tab until its first state report.
+  const ready = candidates.filter((candidate) => candidate.health !== undefined);
+  const legacy = candidates.filter((candidate) => !candidate.identified);
+  const selectable = ready.length > 0 ? ready : legacy;
+  selectable.sort((a, b) => compareControllerCandidates(a, b));
+  return selectable.at(-1)?.client ?? null;
+}
+
+function compareControllerCandidates(
+  a: { connectionOrder: number; health: ClientControlHealth | undefined },
+  b: { connectionOrder: number; health: ClientControlHealth | undefined },
+): number {
+  const errorRank = (health: ClientControlHealth | undefined) => {
+    if (health?.errorState === 'healthy') return 2;
+    if (!health || health.errorState === 'unknown') return 1;
+    return 0;
+  };
+  return (
+    errorRank(a.health) - errorRank(b.health) ||
+    Number(a.health?.visible ?? false) - Number(b.health?.visible ?? false) ||
+    Number(a.health?.focused ?? false) - Number(b.health?.focused ?? false) ||
+    (a.health?.updatedAt ?? 0) - (b.health?.updatedAt ?? 0) ||
+    a.connectionOrder - b.connectionOrder
+  );
+}