@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/http-channel-manager.ts

@@ -0,0 +1,468 @@
+import crypto from "node:crypto";
+import { db } from "./db.ts";
+import { HttpError, sessions } from "./sessions.ts";
+import type { LiveTextPart } from "./live-session.ts";
+import { activeRows, bindingRow, effectiveBrain, listBindings, listSources, saveBindingOverrides, setBindingActive, sourceRow, type BindingRow, type SourceRow } from "./http-channel-store.ts";
+import { HTTP_CHANNEL_LIMIT, HTTP_INBOX_LIMIT, type HttpBindingOverrides, type HttpChannelsInfo, type HttpChannelStats, type HttpPollResponse, type HttpTextMessage, type HttpPushMessage, type HttpExtraBody, type HttpJsonValue } from "../shared/http-channels.ts";
+
+const NEXT_POLL_MS = 20;
+const PUSH_QUEUE_LIMIT = 1024;
+const PUSH_BYTES_LIMIT = 16 * 1024 * 1024;
+const RESPONSE_BYTES_LIMIT = 256 * 1024;
+const TEXT_BYTES_LIMIT = 64 * 1024;
+
+class RecentIds {
+  private ids = new Set<string>();
+  has(id: string) { return this.ids.has(id); }
+  add(id: string) {
+    this.ids.add(id);
+    if (this.ids.size > HTTP_INBOX_LIMIT) this.ids.delete(this.ids.values().next().value!);
+  }
+}
+
+type Runtime = {
+  binding: BindingRow;
+  source: SourceRow;
+  headers: Headers;
+  extraBody: HttpExtraBody;
+  abort: AbortController;
+  pollAbort?: AbortController;
+  seen: RecentIds;
+  pushSeen: RecentIds;
+  pendingIds: Set<string>;
+  pushPendingIds: Set<string>;
+  stats: HttpChannelStats;
+  pushing: boolean;
+};
+type InboxEntry = { runtime: Runtime; id: string; uuid: string; text: string; retryAt: number };
+type PushEntry = { runtime: Runtime; message: HttpPushMessage; body: string; bytes: number; url: string; headers: Headers; timeoutMs: number };
+
+function sleep(ms: number, signal: AbortSignal) {
+  return new Promise<void>((resolve) => {
+    if (signal.aborted) return resolve();
+    const done = () => { clearTimeout(timer); signal.removeEventListener("abort", done); resolve(); };
+    const timer = setTimeout(done, ms);
+    timer.unref();
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+
+function jsonHeaders(source: SourceRow) {
+  const headers = new Headers(JSON.parse(source.headers_json));
+  // Also override legacy persisted Content-Type entries, regardless of capitalization.
+  headers.set("content-type", "application/json");
+  return headers;
+}
+
+function brainEndpoint(source: SourceRow, endpoint: "brain-to-agent" | "agent-to-brain") {
+  const url = new URL(source.url);
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}/${endpoint}`;
+  return url.href;
+}
+
+function setChannelError(runtime: Runtime, direction: "pull" | "push", message?: string) {
+  if (direction === "pull") runtime.stats.lastPullError = message;
+  else runtime.stats.lastPushError = message;
+  runtime.stats.lastError = runtime.stats.lastPullError ?? runtime.stats.lastPushError;
+}
+
+/** Substitute string values before serialization so quotes/newlines cannot break JSON. */
+function renderExtraBody(value: HttpJsonValue, message: HttpPushMessage, budget = { bytes: 0 }): HttpJsonValue {
+  if (typeof value === "string") {
+    budget.bytes += Buffer.byteLength(value);
+    if (budget.bytes > RESPONSE_BYTES_LIMIT) throw new Error("Extra body 展开后超过 256KB");
+    return value.replace(/\{\{(text|id|sessionId)\}\}/g, (token, key: "text" | "id" | "sessionId") => {
+      budget.bytes += Buffer.byteLength(message[key]) - Buffer.byteLength(token);
+      if (budget.bytes > RESPONSE_BYTES_LIMIT) throw new Error("Extra body 展开后超过 256KB");
+      return message[key];
+    });
+  }
+  if (Array.isArray(value)) return value.map((item) => renderExtraBody(item, message, budget));
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, renderExtraBody(item, message, budget)]));
+  return value;
+}
+
+async function readPollResponse(response: Response): Promise<{ kind: "empty" } | HttpTextMessage> {
+  if (!response.body) throw new Error("订阅响应没有 JSON 内容");
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > RESPONSE_BYTES_LIMIT) throw new Error("订阅响应超过 256KB");
+      chunks.push(value);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {});
+    throw error;
+  } finally { reader.releaseLock(); }
+  let data: unknown;
+  try { data = JSON.parse(Buffer.concat(chunks).toString("utf8")); } catch { throw new Error("订阅响应不是有效 JSON"); }
+  if (!data || typeof data !== "object") throw new Error("订阅响应应为 empty 或 text");
+  const message = data as Partial<HttpPollResponse>;
+  if (message.kind === "empty") return { kind: "empty" };
+  if (message.kind !== "text" || (message.id !== undefined && (typeof message.id !== "string" || !message.id.trim() || message.id.length > 1024)) || typeof message.text !== "string" || !message.text.trim() || Buffer.byteLength(message.text) > TEXT_BYTES_LIMIT) {
+    throw new Error("text 响应需要非空 text（最大 64KB）；id 可省略，填写时须为非空字符串");
+  }
+  return { kind: "text", id: message.id ?? crypto.randomUUID(), text: message.text };
+}
+
+/** Only active bindings live here. Config and inactive registrations stay in SQLite. */
+export class HttpChannelManager {
+  constructor(private readonly pause: typeof sleep = sleep) {}
+  private active = new Map<string, Runtime>();
+  private pushBySession = new Map<string, Set<Runtime>>();
+  private inbox: InboxEntry[] = [];
+  private pollingReservations = 0;
+  private deliveries = 0;
+  private deliveringSessions = new Set<string>();
+  private inboxTimer?: NodeJS.Timeout;
+  private pushQueue: PushEntry[] = [];
+  private pushBytes = 0;
+  private pushRequests = 0;
+  private running = false;
+  private unlisten?: () => void;
+  private undrop?: () => void;
+
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.unlisten = sessions.onTextPart((part) => this.enqueuePush(part));
+    this.undrop = sessions.onSessionDropped((sessionId) => this.removeSession(sessionId));
+    const rows = activeRows().reverse();
+    const keep = new Set(rows.map((row) => row.id));
+    // Repair an over-limit persisted state, without loading inactive configurations.
+    for (const row of db.prepare("SELECT id FROM session_http_bindings WHERE active=1").all() as { id: string }[]) {
+      if (!keep.has(row.id)) setBindingActive(row.id, false, "超过激活上限");
+    }
+    for (const row of rows) this.load(row);
+  }
+
+  stop() {
+    this.running = false;
+    this.unlisten?.();
+    this.undrop?.();
+    for (const runtime of [...this.active.values()]) this.unload(runtime);
+    clearTimeout(this.inboxTimer);
+    this.inboxTimer = undefined;
+  }
+
+  info(sessionId?: string): HttpChannelsInfo {
+    return {
+      sources: listSources(),
+      bindings: listBindings(sessionId).map((binding) => {
+        const runtime = this.active.get(binding.id);
+        return { ...binding, stats: runtime ? { ...runtime.stats, pending: runtime.pendingIds.size + runtime.pushPendingIds.size } : null };
+      }),
+      activeCount: this.active.size, activeLimit: HTTP_CHANNEL_LIMIT,
+      inboxSize: this.inbox.length + this.deliveries, inboxLimit: HTTP_INBOX_LIMIT,
+    };
+  }
+
+  activate(id: string): string | null {
+    const row = bindingRow(id);
+    if (!row) throw new HttpError(404, "注册不存在");
+    const source = sourceRow(row.source_id);
+    if (!source) throw new HttpError(404, "HTTP 源不存在");
+    if (source.kind === "brain-api" && !effectiveBrain(source, row).brainId) throw new HttpError(400, "激活 brain-api 前，请在源或会话注册中填写 brain_id");
+    if (!db.prepare("SELECT 1 FROM session_view WHERE session_id=?").get(row.session_id)) throw new HttpError(404, "会话不存在");
+    if (this.active.has(id)) return null;
+    const oldest = this.active.size >= HTTP_CHANNEL_LIMIT
+      ? [...this.active.values()].sort((a, b) => (a.binding.activated_at ?? 0) - (b.binding.activated_at ?? 0))[0]
+      : undefined;
+    db.exec("BEGIN");
+    try {
+      if (oldest) setBindingActive(oldest.binding.id, false, "激活名额被新注册替换");
+      setBindingActive(id, true);
+      db.exec("COMMIT");
+    } catch (error) { db.exec("ROLLBACK"); throw error; }
+    if (oldest) this.unload(oldest);
+    this.load(bindingRow(id)!);
+    return oldest?.binding.id ?? null;
+  }
+
+  deactivate(id: string) {
+    if (!bindingRow(id)) throw new HttpError(404, "注册不存在");
+    setBindingActive(id, false, "主动反激活");
+    const runtime = this.active.get(id);
+    if (runtime) this.unload(runtime);
+  }
+
+  removeBinding(id: string) {
+    this.deactivate(id);
+    db.prepare("DELETE FROM session_http_bindings WHERE id=?").run(id);
+  }
+
+  sourceChanged(id: string) {
+    const source = sourceRow(id);
+    if (!source) return;
+    for (const runtime of [...this.active.values()]) {
+      if (runtime.source.id !== id) continue;
+      this.refresh(runtime, source, runtime.binding);
+    }
+  }
+
+  updateBinding(id: string, input: HttpBindingOverrides) {
+    const binding = saveBindingOverrides(id, input);
+    const runtime = this.active.get(id);
+    if (runtime) this.refresh(runtime, sourceRow(binding.source_id)!, binding);
+  }
+
+  private refresh(runtime: Runtime, source: SourceRow, binding: BindingRow) {
+    const brain = effectiveBrain(source, binding);
+    if (source.kind === "brain-api" && !brain.brainId) {
+      setBindingActive(binding.id, false, "请在源或会话注册中填写 brain_id");
+      this.unload(runtime);
+      return;
+    }
+    const headers = jsonHeaders(source);
+    const requestChanged = runtime.source.url !== source.url || runtime.source.timeout_ms !== source.timeout_ms
+      || effectiveBrain(runtime.source, runtime.binding).brainId !== brain.brainId
+      || runtime.source.subscribe_method !== source.subscribe_method
+      || (source.subscribe_method === "POST" && runtime.source.extra_body_json !== source.extra_body_json)
+      || JSON.stringify([...runtime.headers]) !== JSON.stringify([...headers]);
+    runtime.source = source;
+    runtime.binding = binding;
+    runtime.headers = headers;
+    runtime.extraBody = JSON.parse(source.extra_body_json);
+    // Keep the same runtime, queues, dedup cache and FIFO activation age.
+    // Restart a changed subscription; an already submitted push finishes without being resent.
+    if (requestChanged) runtime.pollAbort?.abort();
+  }
+
+  removeSource(id: string) {
+    if (!sourceRow(id)) throw new HttpError(404, "HTTP 源不存在");
+    for (const runtime of [...this.active.values()]) if (runtime.source.id === id) this.unload(runtime);
+    db.exec("BEGIN");
+    try {
+      db.prepare("DELETE FROM session_http_bindings WHERE source_id=?").run(id);
+      db.prepare("DELETE FROM http_sources WHERE id=?").run(id);
+      db.exec("COMMIT");
+    } catch (error) { db.exec("ROLLBACK"); throw error; }
+  }
+
+  private removeSession(id: string) {
+    for (const runtime of [...this.active.values()]) if (runtime.binding.session_id === id) this.unload(runtime);
+    db.prepare("DELETE FROM session_http_bindings WHERE session_id=?").run(id);
+  }
+
+  private isActive(runtime: Runtime) {
+    return this.running && !runtime.abort.signal.aborted && this.active.get(runtime.binding.id) === runtime;
+  }
+
+  private load(binding: BindingRow) {
+    const source = sourceRow(binding.source_id);
+    if (!source || !db.prepare("SELECT 1 FROM session_view WHERE session_id=?").get(binding.session_id)) {
+      setBindingActive(binding.id, false, "源或会话不存在");
+      return;
+    }
+    if (source.kind === "brain-api" && !effectiveBrain(source, binding).brainId) {
+      setBindingActive(binding.id, false, "请在源或会话注册中填写 brain_id");
+      return;
+    }
+    const runtime: Runtime = {
+      binding, source, headers: jsonHeaders(source), extraBody: JSON.parse(source.extra_body_json), abort: new AbortController(), seen: new RecentIds(), pushSeen: new RecentIds(), pendingIds: new Set(), pushPendingIds: new Set(), pushing: false,
+      stats: { requests: 0, delivered: 0, received: 0, pushed: 0, duplicates: 0, dropped: 0, pending: 0 },
+    };
+    this.active.set(binding.id, runtime);
+    if (binding.direction === "subscribe") void this.poll(runtime);
+    if (binding.direction === "push" || source.kind === "brain-api") {
+      const set = this.pushBySession.get(binding.session_id) ?? new Set<Runtime>();
+      set.add(runtime);
+      this.pushBySession.set(binding.session_id, set);
+    }
+  }
+
+  private unload(runtime: Runtime) {
+    this.active.delete(runtime.binding.id);
+    runtime.abort.abort();
+    const pushes = this.pushBySession.get(runtime.binding.session_id);
+    pushes?.delete(runtime);
+    if (pushes?.size === 0) this.pushBySession.delete(runtime.binding.session_id);
+    this.inbox = this.inbox.filter((entry) => entry.runtime !== runtime);
+    this.pushQueue = this.pushQueue.filter((entry) => {
+      if (entry.runtime !== runtime) return true;
+      this.pushBytes -= entry.bytes;
+      return false;
+    });
+    runtime.pendingIds.clear();
+    runtime.pushPendingIds.clear();
+    this.drainPush();
+  }
+
+  private async poll(runtime: Runtime) {
+    let missingDelay = 0;
+    while (this.isActive(runtime)) {
+      let delay = NEXT_POLL_MS;
+      if (this.inbox.length + this.deliveries + this.pollingReservations >= HTTP_INBOX_LIMIT) {
+        await this.pause(delay, runtime.abort.signal);
+        continue;
+      }
+      // Reserve capacity before the HTTP source can consume a message.
+      this.pollingReservations++;
+      const requestAbort = new AbortController();
+      runtime.pollAbort = requestAbort;
+      try {
+        runtime.stats.requests++;
+        const brain = runtime.source.kind === "brain-api";
+        const response = await fetch(brain ? brainEndpoint(runtime.source, "brain-to-agent") : runtime.source.url, {
+          method: runtime.source.subscribe_method, headers: runtime.headers, redirect: "error", cache: "no-store",
+          body: brain ? JSON.stringify({ brain_id: effectiveBrain(runtime.source, runtime.binding).brainId }) : runtime.source.subscribe_method === "POST" ? runtime.source.extra_body_json : undefined,
+          signal: AbortSignal.any([runtime.abort.signal, requestAbort.signal, AbortSignal.timeout(runtime.source.timeout_ms)]),
+        });
+        if (!response.ok) {
+          await response.body?.cancel();
+          if (response.status === 404) delay = missingDelay = Math.min(missingDelay ? missingDelay * 2 : 100, 2000);
+          else missingDelay = 0;
+          throw new Error(`HTTP ${response.status}`);
+        }
+        missingDelay = 0;
+        const message = await readPollResponse(response);
+        if (!this.isActive(runtime)) return;
+        if (requestAbort.signal.aborted) continue;
+        runtime.stats.lastSuccessAt = Date.now();
+        setChannelError(runtime, "pull");
+        if (message.kind === "text") {
+          if (runtime.seen.has(message.id) || runtime.pendingIds.has(message.id)) runtime.stats.duplicates++;
+          else {
+            runtime.seen.add(message.id);
+            runtime.pendingIds.add(message.id);
+            this.inbox.push({ runtime, id: message.id, uuid: crypto.randomUUID(), text: message.text, retryAt: 0 });
+            this.kickInbox();
+          }
+        }
+      } catch (error) {
+        if (this.isActive(runtime) && !requestAbort.signal.aborted) setChannelError(runtime, "pull", error instanceof Error ? error.message : String(error));
+      } finally {
+        this.pollingReservations--;
+        if (runtime.pollAbort === requestAbort) runtime.pollAbort = undefined;
+      }
+      await this.pause(delay, runtime.abort.signal);
+    }
+  }
+
+  private kickInbox() {
+    if (!this.running || !this.inbox.length || this.inboxTimer) return;
+    this.inboxTimer = setTimeout(() => { this.inboxTimer = undefined; this.drainInbox(); }, NEXT_POLL_MS);
+    this.inboxTimer.unref();
+  }
+
+  private drainInbox() {
+    while (this.running && this.deliveries < 4) {
+      const firstForSession = new Set(this.deliveringSessions);
+      const index = this.inbox.findIndex((entry) => {
+        const sessionId = entry.runtime.binding.session_id;
+        if (firstForSession.has(sessionId)) return false;
+        firstForSession.add(sessionId);
+        return this.isActive(entry.runtime) && entry.retryAt <= Date.now() && (sessions.get(sessionId)?.queuedMessageCount ?? 0) < 32;
+      });
+      if (index < 0) break;
+      const entry = this.inbox.splice(index, 1)[0]!;
+      this.deliveries++;
+      this.deliveringSessions.add(entry.runtime.binding.session_id);
+      void this.deliver(entry).finally(() => {
+        this.deliveries--;
+        this.deliveringSessions.delete(entry.runtime.binding.session_id);
+        this.kickInbox();
+      });
+    }
+    this.kickInbox();
+  }
+
+  private async deliver(entry: InboxEntry) {
+    const runtime = entry.runtime;
+    try {
+      if (!this.isActive(runtime)) return;
+      const view = db.prepare("SELECT project_path FROM session_view WHERE session_id=?").get(runtime.binding.session_id) as { project_path: string } | undefined;
+      if (!view) { this.deactivate(runtime.binding.id); return; }
+      const accepted = await (await sessions.getOrCreate(runtime.binding.session_id, view.project_path))
+        .sendExternalText(entry.uuid, entry.text, () => this.isActive(runtime));
+      if (accepted && this.isActive(runtime)) { runtime.stats.delivered++; runtime.stats.received++; runtime.pendingIds.delete(entry.id); }
+    } catch (error) {
+      if (this.isActive(runtime)) {
+        setChannelError(runtime, "pull", error instanceof Error ? error.message : String(error));
+        entry.retryAt = Date.now() + 1000;
+        // Retry at the head: a later message for this session must not overtake it.
+        // Other sessions are still eligible while this entry waits for its retry time.
+        this.inbox.unshift(entry);
+      }
+    }
+  }
+
+  private enqueuePush(part: LiveTextPart) {
+    const recipients = this.pushBySession.get(part.sessionId);
+    if (!recipients?.size) return;
+    const message: HttpPushMessage = { kind: "text", ...part };
+    for (const runtime of recipients) {
+      if (!this.isActive(runtime)) continue;
+      if (runtime.pushSeen.has(part.id)) { runtime.stats.duplicates++; continue; }
+      let body: string;
+      const brain = effectiveBrain(runtime.source, runtime.binding);
+      try { body = JSON.stringify(runtime.source.kind === "brain-api" ? { brain_id: brain.brainId, text: part.text } : { ...renderExtraBody(runtime.extraBody, message) as HttpExtraBody, ...message }); }
+      catch (error) {
+        runtime.stats.dropped++;
+        setChannelError(runtime, "push", error instanceof Error ? error.message : String(error));
+        continue;
+      }
+      const bytes = Buffer.byteLength(body);
+      if (this.pushQueue.length + this.pushRequests >= PUSH_QUEUE_LIMIT || this.pushBytes + bytes > PUSH_BYTES_LIMIT) {
+        runtime.stats.dropped++;
+        setChannelError(runtime, "push", "推送队列已满，本条未发送");
+        continue;
+      }
+      runtime.pushSeen.add(part.id);
+      runtime.pushPendingIds.add(part.id);
+      const headers = new Headers(runtime.headers);
+      if (runtime.source.kind === "brain-api") {
+        if (brain.brainVoice) headers.set("x-brain-voice", brain.brainVoice);
+        else if (runtime.binding.brain_voice === "") headers.delete("x-brain-voice");
+      }
+      // Queue a complete request snapshot: later edits must not mix old bodies with new destinations or credentials.
+      this.pushQueue.push({ runtime, message, body, bytes,
+        url: runtime.source.kind === "brain-api" ? brainEndpoint(runtime.source, "agent-to-brain") : runtime.source.url,
+        headers, timeoutMs: runtime.source.timeout_ms,
+      });
+      this.pushBytes += bytes;
+    }
+    this.drainPush();
+  }
+
+  private drainPush() {
+    while (this.running && this.pushRequests < 8) {
+      const index = this.pushQueue.findIndex((entry) => this.isActive(entry.runtime) && !entry.runtime.pushing);
+      if (index < 0) break;
+      const entry = this.pushQueue.splice(index, 1)[0]!;
+      entry.runtime.pushing = true;
+      this.pushRequests++;
+      void this.push(entry).finally(() => {
+        this.pushBytes -= entry.bytes;
+        entry.runtime.pushing = false;
+        entry.runtime.pushPendingIds.delete(entry.message.id);
+        this.pushRequests--;
+        this.drainPush();
+      });
+    }
+  }
+
+  private async push(entry: PushEntry) {
+    const runtime = entry.runtime;
+    if (!this.isActive(runtime)) return;
+    try {
+      runtime.stats.requests++;
+      const response = await fetch(entry.url, {
+        method: "POST", headers: entry.headers, body: entry.body, redirect: "error",
+        signal: AbortSignal.any([runtime.abort.signal, AbortSignal.timeout(entry.timeoutMs)]),
+      });
+      await response.body?.cancel();
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      if (this.isActive(runtime)) { runtime.stats.delivered++; runtime.stats.pushed++; runtime.stats.lastSuccessAt = Date.now(); setChannelError(runtime, "push"); }
+    } catch (error) {
+      if (this.isActive(runtime)) { runtime.stats.dropped++; setChannelError(runtime, "push", error instanceof Error ? error.message : String(error)); }
+    }
+  }
+}
+
+export const httpChannels = new HttpChannelManager();