@saadnvd1/agent-os 0.3.775 → 0.3.777

package/lib/live/service.ts

@@ -0,0 +1,318 @@
+/**
+ * Live shares from the host's side: mint, run, decide on guests, end.
+ * Nothing a guest sends reaches an agent except through sendSuggestion,
+ * which the host taps.
+ */
+
+import { loadConnect } from "../connect/config";
+import { addTap, getSession, registry } from "../chat/registry";
+import { sendChatConfirmed } from "../chat/runner";
+import { shareContext } from "../share/context";
+import { redactForShare } from "../share/redact";
+import { ShareError, createLiveRemote, revokeRemote } from "../share/connect";
+import type { LiveExpiry } from "../connect/control-api";
+import type { LiveView } from "./types";
+import { cleanBody } from "./clean";
+import { itemMapper } from "./frames";
+import { handleFrame } from "./inbox";
+import { onMessage, seed, flush } from "./publisher";
+import { Ring } from "./ring";
+import { LOBBY_MS, live, type Guest, type Runtime } from "./runtime";
+import { LiveSocket, type WsFactory } from "./socket";
+import {
+  activeLiveShareFor,
+  activeLiveShares,
+  admittedGuestIds,
+  insertLiveShare,
+  logLive,
+  markLiveEnded,
+  openSuggestions,
+  type LiveShareRow,
+} from "./store";
+
+const SWEEP_MS = 60_000;
+
+export function makeSocket(factory?: WsFactory): LiveSocket {
+  return new LiveSocket({
+    factory,
+    files: loadConnect,
+    onFrame: (shareId, frame) =>
+      handleFrame(shareId, frame, {
+        send: (id, action, data) => live.socket?.send(id, action, data),
+        ended: (id) => stop(id),
+      }),
+    onConfirmed: (shareId) => {
+      const rt = live.runtimes.get(shareId);
+      if (!rt) return;
+      live.socket?.send(shareId, "state", {
+        state: stateOfSession(rt.share.session_id),
+      });
+    },
+    onRejected: (shareId) => stop(shareId, true),
+  });
+}
+
+const socket = (): LiveSocket => (live.socket ??= makeSocket());
+
+function stateOfSession(sessionId: string) {
+  const l = registry.live.get(sessionId);
+  const s = l?.state;
+  return s === "running"
+    ? "working"
+    : s === "waiting"
+      ? "waiting_on_host"
+      : "idle";
+}
+
+function attach(row: LiveShareRow): Runtime {
+  const ctx = shareContext();
+  const rt: Runtime = {
+    share: row,
+    guests: new Map(),
+    ring: new Ring(),
+    ctx,
+    map: itemMapper(ctx),
+    streaming: new Map(),
+    dirty: new Map(),
+    flushTimer: null,
+    slowUntil: 0,
+    notice: null,
+    drops: 0,
+  };
+  live.runtimes.set(row.id, rt);
+  try {
+    seed(rt, row.session_id);
+  } catch {}
+  socket().subscribe(row.id);
+  return rt;
+}
+
+/** Stops publishing a share and drops its connection; the row stays as history. */
+function stop(shareId: string, markEnded = false): void {
+  const rt = live.runtimes.get(shareId);
+  if (markEnded) markLiveEnded(shareId);
+  if (rt?.flushTimer) clearTimeout(rt.flushTimer);
+  live.runtimes.delete(shareId);
+  live.socket?.unsubscribe(shareId);
+}
+
+/** Starts the tap and re-attaches the shares this machine still holds. */
+export function startLive(): void {
+  if (live.started) return;
+  live.started = true;
+  addTap(onMessage);
+  for (const row of activeLiveShares()) attach(row);
+  setInterval(sweep, SWEEP_MS).unref();
+}
+
+function sweep(now = Date.now()): void {
+  const active = new Set(activeLiveShares(now).map((s) => s.id));
+  for (const id of [...live.runtimes.keys()]) {
+    if (!active.has(id)) stop(id, true);
+    else {
+      const rt = live.runtimes.get(id)!;
+      for (const [gid, g] of rt.guests)
+        if (g.status === "pending" && now - g.at > LOBBY_MS)
+          rt.guests.delete(gid);
+    }
+  }
+}
+
+function runtimeFor(id: string): Runtime {
+  const rt = live.runtimes.get(id);
+  if (!rt || rt.share.ended_at) throw new ShareError("Not found.", 404);
+  return rt;
+}
+
+export async function createLive(
+  sessionId: string,
+  expiresIn: LiveExpiry
+): Promise<LiveView> {
+  startLive();
+  const session = getSession(sessionId);
+  if (activeLiveShareFor(sessionId))
+    throw new ShareError("This session already has a live link.", 409);
+  const ctx = shareContext();
+  const title =
+    redactForShare(session.name, ctx)
+      .text.replace(/\s+/g, " ")
+      .trim()
+      .slice(0, 120) || "Chat";
+  const made = await createLiveRemote({ title, expiresIn });
+  const row: LiveShareRow = {
+    id: made.id,
+    session_id: sessionId,
+    title,
+    url: made.url,
+    ends_with_session: made.ends_with_session ? 1 : 0,
+    max_guests: made.max_guests,
+    created_at: new Date().toISOString(),
+    expires_at: made.expires_at,
+    ended_at: null,
+  };
+  insertLiveShare(row);
+  attach(row);
+  return viewOf(row.id)!;
+}
+
+/** Ends access: Connect disconnects every guest, then this machine lets go. */
+export async function endLive(id: string): Promise<void> {
+  runtimeFor(id);
+  await revokeRemote(id);
+  markLiveEnded(id);
+  stop(id);
+}
+
+function guestOf(rt: Runtime, guestId: string): Guest {
+  const g = rt.guests.get(guestId);
+  if (!g) throw new ShareError("That guest isn't waiting any more.", 404);
+  return g;
+}
+
+function logGuest(rt: Runtime, kind: "admit" | "deny" | "kick", g: Guest) {
+  logLive({
+    share_id: rt.share.id,
+    kind,
+    guest_id: g.id,
+    guest_name: g.name,
+    ref: null,
+    text: null,
+    sent_text: null,
+  });
+}
+
+export function admit(id: string, guestId: string): void {
+  const rt = runtimeFor(id);
+  const g = guestOf(rt, guestId);
+  if (g.status !== "pending") throw new ShareError("Already let in.", 409);
+  logGuest(rt, "admit", g);
+  g.status = "admitted";
+  rt.notice = null;
+  live.socket?.send(id, "admit", { guest_id: g.id });
+}
+
+export function deny(id: string, guestId: string): void {
+  const rt = runtimeFor(id);
+  const g = guestOf(rt, guestId);
+  if (g.status !== "pending") throw new ShareError("Already let in.", 409);
+  logGuest(rt, "deny", g);
+  rt.guests.delete(g.id);
+  live.socket?.send(id, "deny", { guest_id: g.id });
+}
+
+export function kick(id: string, guestId: string): void {
+  const rt = runtimeFor(id);
+  const g = guestOf(rt, guestId);
+  logGuest(rt, "kick", g);
+  rt.guests.delete(g.id);
+  live.socket?.send(id, "kick", { guest_id: g.id });
+}
+
+const sending = new Set<string>();
+
+/**
+ * The only path from a guest's text to an agent: the host reviewed the card
+ * (and may have edited it). The text is cleaned again first.
+ */
+export async function sendSuggestion(
+  id: string,
+  suggestionId: string,
+  edited?: string
+): Promise<void> {
+  const rt = runtimeFor(id);
+  const card = openSuggestions(id).find((s) => s.id === suggestionId);
+  if (!card) throw new ShareError("That suggestion is gone.", 404);
+  const text = cleanBody(edited ?? card.text);
+  if (!text) throw new ShareError("The message is empty.", 400);
+  const key = `${id}:${suggestionId}`;
+  if (sending.has(key)) throw new ShareError("Already sending.", 409);
+  sending.add(key);
+  try {
+    await sendChatConfirmed(rt.share.session_id, {
+      text,
+      origin: { kind: "guest", label: card.guestName },
+    });
+    logLive({
+      share_id: id,
+      kind: "sent",
+      guest_id: card.guestId,
+      guest_name: card.guestName,
+      ref: card.id,
+      text: null,
+      sent_text: text,
+    });
+    live.socket?.send(id, "suggestion_status", {
+      guest_id: card.guestId,
+      id: card.id,
+      status: "sent",
+    });
+  } finally {
+    sending.delete(key);
+  }
+}
+
+export function dismissSuggestion(id: string, suggestionId: string): void {
+  runtimeFor(id);
+  const card = openSuggestions(id).find((s) => s.id === suggestionId);
+  if (!card) throw new ShareError("That suggestion is gone.", 404);
+  logLive({
+    share_id: id,
+    kind: "dismissed",
+    guest_id: card.guestId,
+    guest_name: card.guestName,
+    ref: card.id,
+    text: null,
+    sent_text: null,
+  });
+  live.socket?.send(id, "suggestion_status", {
+    guest_id: card.guestId,
+    id: card.id,
+    status: "dismissed",
+  });
+}
+
+export function viewOf(id: string, now = Date.now()): LiveView | null {
+  const rt = live.runtimes.get(id);
+  if (!rt || rt.share.ended_at) return null;
+  const names = new Map<string, number>();
+  const shown = [...rt.guests.values()].filter(
+    (g) => g.status === "admitted" || now - g.at <= LOBBY_MS
+  );
+  for (const g of shown) {
+    const k = g.name.normalize("NFKC").toLowerCase();
+    names.set(k, (names.get(k) ?? 0) + 1);
+  }
+  const admitted = admittedGuestIds(id);
+  return {
+    id,
+    sessionId: rt.share.session_id,
+    title: rt.share.title,
+    url: rt.share.url,
+    expiresAt: rt.share.expires_at,
+    endsWithSession: rt.share.ends_with_session === 1,
+    maxGuests: rt.share.max_guests,
+    connected: live.socket?.connected ?? false,
+    notice: rt.notice,
+    guests: shown
+      .filter((g) => g.status === "pending" || admitted.has(g.id))
+      .map((g) => ({
+        id: g.id,
+        name: g.name,
+        status: g.status,
+        online: g.online,
+        duplicateName:
+          (names.get(g.name.normalize("NFKC").toLowerCase()) ?? 0) > 1,
+      })),
+    suggestions: openSuggestions(id),
+  };
+}
+
+export function listLive(sessionId?: string): LiveView[] {
+  return [...live.runtimes.keys()]
+    .map((id) => viewOf(id))
+    .filter(
+      (v): v is LiveView => !!v && (!sessionId || v.sessionId === sessionId)
+    );
+}
+
+export { flush };

package/lib/live/socket.ts

@@ -0,0 +1,293 @@
+/**
+ * The machine's one outbound connection to Connect's ActionCable, signed with
+ * the machine key like every other request. Open only while a live share is
+ * subscribed; nothing here accepts a connection from anywhere.
+ */
+
+import WebSocket from "ws";
+import type { ConnectFiles } from "@/lib/connect/config";
+import { signedHeaders } from "@/lib/connect/control-api";
+
+export const CABLE_PATH = "/cable";
+const PING_MS = 30_000;
+const STALE_MS = 30_000;
+const MAX_INCOMING = 256 * 1024;
+export const MAX_FRAME = 60 * 1024;
+const QUEUE_MAX = 500;
+// Under Connect's 40/s, 300/min and 2 MB/min.
+const PER_SECOND = 10;
+const PER_MINUTE = 250;
+const BYTES_PER_MINUTE = 1_500_000;
+
+export interface WsLike {
+  readyState: number;
+  send(data: string): void;
+  close(): void;
+  terminate(): void;
+  on(event: "open", fn: () => void): void;
+  on(event: "message", fn: (data: Buffer | string) => void): void;
+  on(event: "close" | "error" | "unexpected-response", fn: () => void): void;
+}
+
+export type WsFactory = (
+  url: string,
+  headers: Record<string, string>
+) => WsLike;
+
+const defaultFactory: WsFactory = (url, headers) =>
+  new WebSocket(url, ["actioncable-v1-json"], {
+    headers,
+    maxPayload: MAX_INCOMING,
+    followRedirects: false,
+    handshakeTimeout: 15_000,
+  }) as unknown as WsLike;
+
+export const cableUrl = (apiUrl: string) =>
+  `${apiUrl.replace(/^http/, "ws")}${CABLE_PATH}`;
+
+export interface SocketOptions {
+  files: () => ConnectFiles | null;
+  onFrame: (shareId: string, frame: Record<string, unknown>) => void;
+  /** A share's subscription was confirmed (again, after a reconnect). */
+  onConfirmed?: (shareId: string) => void;
+  /** Connect refused the subscription: the share is not ours or is gone. */
+  onRejected?: (shareId: string) => void;
+  factory?: WsFactory;
+  random?: () => number;
+}
+
+interface Queued {
+  shareId: string;
+  json: string;
+}
+
+const identifier = (shareId: string) =>
+  JSON.stringify({ channel: "LiveHostChannel", share_id: shareId });
+
+export class LiveSocket {
+  private ws: WsLike | null = null;
+  private welcomed = false;
+  private shares = new Set<string>();
+  private confirmed = new Set<string>();
+  private queue: Queued[] = [];
+  private attempts = 0;
+  private timers: ReturnType<typeof setTimeout>[] = [];
+  private pingTimer: ReturnType<typeof setInterval> | null = null;
+  private drainTimer: ReturnType<typeof setTimeout> | null = null;
+  private retryTimer: ReturnType<typeof setTimeout> | null = null;
+  private lastHeard = 0;
+  private sentAt: { at: number; bytes: number }[] = [];
+  dropped = 0;
+
+  constructor(private opts: SocketOptions) {}
+
+  get connected() {
+    return this.welcomed && this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  has(shareId: string) {
+    return this.shares.has(shareId);
+  }
+
+  subscribe(shareId: string): void {
+    this.shares.add(shareId);
+    if (this.connected) this.rawSubscribe(shareId);
+    else this.connect();
+  }
+
+  unsubscribe(shareId: string): void {
+    this.shares.delete(shareId);
+    this.confirmed.delete(shareId);
+    this.queue = this.queue.filter((q) => q.shareId !== shareId);
+    if (this.connected)
+      this.rawSend({ command: "unsubscribe", identifier: identifier(shareId) });
+    if (!this.shares.size) this.close();
+  }
+
+  /** An action on a share's channel, paced to Connect's limits. */
+  send(shareId: string, action: string, data: Record<string, unknown> = {}) {
+    if (!this.shares.has(shareId)) return;
+    const json = JSON.stringify({
+      command: "message",
+      identifier: identifier(shareId),
+      data: JSON.stringify({ action, ...data }),
+    });
+    if (Buffer.byteLength(json) > MAX_FRAME) {
+      this.dropped++;
+      return;
+    }
+    if (this.queue.length >= QUEUE_MAX) {
+      this.queue.shift();
+      this.dropped++;
+    }
+    this.queue.push({ shareId, json });
+    this.drain();
+  }
+
+  close(): void {
+    this.shares.clear();
+    this.confirmed.clear();
+    this.queue = [];
+    this.teardown();
+  }
+
+  private teardown() {
+    this.timers.forEach(clearTimeout);
+    this.timers = [];
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    if (this.drainTimer) clearTimeout(this.drainTimer);
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.pingTimer = this.drainTimer = this.retryTimer = null;
+    const ws = this.ws;
+    this.ws = null;
+    this.welcomed = false;
+    this.confirmed.clear();
+    try {
+      ws?.terminate();
+    } catch {}
+  }
+
+  private connect() {
+    if (this.ws || this.retryTimer || !this.shares.size) return;
+    const files = this.opts.files();
+    if (!files) return;
+    let ws: WsLike;
+    try {
+      ws = (this.opts.factory ?? defaultFactory)(
+        cableUrl(files.config.apiUrl),
+        signedHeaders({
+          machineId: files.config.machineId,
+          privateKey: files.machineKey,
+          method: "GET",
+          path: CABLE_PATH,
+          body: "",
+        })
+      );
+    } catch {
+      this.retry();
+      return;
+    }
+    this.ws = ws;
+    this.lastHeard = Date.now();
+    ws.on("message", (raw) => this.onMessage(ws, raw));
+    ws.on("close", () => this.lost(ws));
+    ws.on("error", () => this.lost(ws));
+    ws.on("unexpected-response", () => this.lost(ws));
+  }
+
+  private lost(ws: WsLike) {
+    if (this.ws !== ws) return;
+    this.teardown();
+    this.retry();
+  }
+
+  private retry() {
+    if (!this.shares.size || this.retryTimer) return;
+    const rand = this.opts.random ?? Math.random;
+    const base = Math.min(30_000, 1000 * 2 ** Math.min(this.attempts, 5));
+    this.attempts++;
+    this.retryTimer = setTimeout(
+      () => {
+        this.retryTimer = null;
+        this.connect();
+      },
+      base * (0.5 + rand() / 2)
+    );
+  }
+
+  private rawSend(msg: unknown) {
+    try {
+      this.ws?.send(JSON.stringify(msg));
+    } catch {}
+  }
+
+  private rawSubscribe(shareId: string) {
+    this.rawSend({ command: "subscribe", identifier: identifier(shareId) });
+  }
+
+  private onMessage(ws: WsLike, raw: Buffer | string) {
+    if (this.ws !== ws) return;
+    this.lastHeard = Date.now();
+    let m: Record<string, unknown>;
+    try {
+      m = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+    } catch {
+      return;
+    }
+    if (!m || typeof m !== "object") return;
+    switch (m.type) {
+      case "welcome":
+        this.welcomed = true;
+        this.attempts = 0;
+        for (const id of this.shares) this.rawSubscribe(id);
+        this.pingTimer = setInterval(() => {
+          if (Date.now() - this.lastHeard > STALE_MS) return this.lost(ws);
+          for (const id of this.confirmed) this.send(id, "ping");
+        }, PING_MS);
+        return;
+      case "ping":
+        return;
+      case "disconnect":
+        return this.lost(ws);
+      case "confirm_subscription":
+      case "reject_subscription": {
+        const id = shareOf(m.identifier);
+        if (!id || !this.shares.has(id)) return;
+        if (m.type === "confirm_subscription") {
+          this.confirmed.add(id);
+          this.opts.onConfirmed?.(id);
+          this.drain();
+        } else {
+          this.unsubscribe(id);
+          this.opts.onRejected?.(id);
+        }
+        return;
+      }
+    }
+    const id = shareOf(m.identifier);
+    const frame = m.message;
+    if (id && this.shares.has(id) && frame && typeof frame === "object")
+      this.opts.onFrame(id, frame as Record<string, unknown>);
+  }
+
+  private drain() {
+    if (this.drainTimer || !this.connected) return;
+    const now = Date.now();
+    this.sentAt = this.sentAt.filter((s) => now - s.at < 60_000);
+    while (this.queue.length) {
+      const next = this.queue.find((q) => this.confirmed.has(q.shareId));
+      if (!next) return;
+      const bytes = Buffer.byteLength(next.json);
+      const lastSecond = this.sentAt.filter((s) => now - s.at < 1000).length;
+      const minuteBytes = this.sentAt.reduce((a, s) => a + s.bytes, 0);
+      if (
+        lastSecond >= PER_SECOND ||
+        this.sentAt.length >= PER_MINUTE ||
+        minuteBytes + bytes > BYTES_PER_MINUTE
+      ) {
+        this.drainTimer = setTimeout(() => {
+          this.drainTimer = null;
+          this.drain();
+        }, 250);
+        return;
+      }
+      this.queue.splice(this.queue.indexOf(next), 1);
+      this.sentAt.push({ at: now, bytes });
+      try {
+        this.ws?.send(next.json);
+      } catch {}
+    }
+  }
+}
+
+function shareOf(identifier: unknown): string | null {
+  if (typeof identifier !== "string") return null;
+  try {
+    const i = JSON.parse(identifier) as Record<string, unknown>;
+    return i.channel === "LiveHostChannel" && typeof i.share_id === "string"
+      ? i.share_id
+      : null;
+  } catch {
+    return null;
+  }
+}