@fdcn/sourcefed 0.3.6 → 0.3.7

package/README.md

@@ -33,7 +33,7 @@ OpenCode loads this package as both a server and a TUI plugin from one entry:
 
 ```json
 // ~/.config/opencode/opencode.jsonc
-{ "plugins": ["@fdcn/sourcefed@0.3.6"] }
+{ "plugins": ["@fdcn/sourcefed@0.3.7"] }
 ```
 
 The package exposes `./server`, `./tui`, `./opencode`, `./opencode/tui`, and `./pi` entrypoints for hosts that load them directly.

package/dist/{chunk-X3BZSHKZ.js → chunk-E6J3BAXP.js}

@@ -11387,29 +11387,6 @@ async function writeResponse(outgoing, response) {
     stream.pipe(outgoing);
   });
 }
-var RequestRouter = class {
-  pending = /* @__PURE__ */ new Map();
-  cursor = 1;
-  nextID() {
-    return this.cursor++;
-  }
-  register(id) {
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-    });
-  }
-  settle(id, frame) {
-    const pending = this.pending.get(id);
-    if (!pending) return;
-    this.pending.delete(id);
-    if (frame.error) pending.reject(new Error(frame.error));
-    else pending.resolve(frame.result);
-  }
-  rejectAll(error) {
-    for (const { reject } of this.pending.values()) reject(error);
-    this.pending.clear();
-  }
-};
 function defaultDaemonUrl() {
   const port = process.env.SOURCEFED_DAEMON_PORT ?? 18787;
   return `http://127.0.0.1:${port}`;
@@ -11802,164 +11779,225 @@ function parseDaemonFrame(line) {
     return void 0;
   }
 }
+var DaemonEventStream = class {
+  constructor(url, headers, onEvents, acknowledge, onClose) {
+    this.url = url;
+    this.headers = headers;
+    this.onEvents = onEvents;
+    this.acknowledge = acknowledge;
+    this.onClose = onClose;
+  }
+  controller = new AbortController();
+  subscribed = Promise.withResolvers();
+  stream;
+  delivering = Promise.resolve();
+  closing;
+  ready = false;
+  failedDelivery = false;
+  async start(signal) {
+    const abort = () => {
+      void this.close();
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    const setup = withTimeout(this.subscribed.promise, 15e3, `sourcefed event stream did not subscribe at ${this.url}`);
+    if (signal?.aborted) abort();
+    const running = this.run();
+    void running.finally(() => signal?.removeEventListener("abort", abort));
+    try {
+      await setup;
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+  close() {
+    if (!this.closing) {
+      this.subscribed.reject(new Error("sourcefed event stream closed"));
+      if (!this.ready) this.controller.abort();
+      this.closing = this.drain();
+    }
+    return this.closing;
+  }
+  async drain() {
+    try {
+      await withTimeout(this.delivering, 15e3, "sourcefed event delivery did not drain");
+    } catch (error) {
+      console.error(`[sourcefed] closing event stream: ${String(error)}`);
+    } finally {
+      this.controller.abort();
+      this.stream?.abort();
+      this.onClose();
+    }
+  }
+  async run() {
+    let consecutiveFailures = 0;
+    while (!this.controller.signal.aborted) {
+      this.failedDelivery = false;
+      try {
+        await this.read();
+        consecutiveFailures = 0;
+      } catch (error) {
+        if (!this.controller.signal.aborted && !this.failedDelivery && ++consecutiveFailures === 1) {
+          console.error(`[sourcefed] event stream ended: ${String(error)}`);
+        }
+      }
+      await this.waitForDelivery();
+      if (!this.controller.signal.aborted) await pause(500, this.controller.signal);
+    }
+  }
+  async read() {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    this.stream = controller;
+    this.controller.signal.addEventListener("abort", abort, { once: true });
+    let reader;
+    try {
+      this.controller.signal.throwIfAborted();
+      const response = await fetch(this.url, { signal: controller.signal, headers: this.headers });
+      if (!response.ok || !response.body) {
+        await response.body?.cancel();
+        throw new Error(`event stream failed: ${response.status}`);
+      }
+      reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (!controller.signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) return;
+        buffer += decoder.decode(value, { stream: true });
+        const frames = buffer.split("\n\n");
+        buffer = frames.pop() ?? "";
+        for (const chunk of frames) await this.frame(chunk);
+      }
+    } finally {
+      await reader?.cancel().catch(() => void 0);
+      reader?.releaseLock();
+      this.controller.signal.removeEventListener("abort", abort);
+      if (this.stream === controller) this.stream = void 0;
+    }
+  }
+  async frame(chunk) {
+    if (this.closing || this.controller.signal.aborted) return;
+    for (const line of chunk.split("\n")) {
+      if (!line.startsWith("data: ")) continue;
+      const frame = parseDaemonFrame(line.slice(6));
+      if (!frame || !("type" in frame)) continue;
+      if (frame.type === "subscribed") {
+        this.ready = true;
+        this.subscribed.resolve();
+      }
+      if (frame.type === "event" && frame.events.length > 0) {
+        this.deliver(frame.events);
+        await this.waitForDelivery();
+      }
+    }
+  }
+  deliver(events) {
+    this.delivering = this.delivering.then(async () => {
+      if (this.failedDelivery || this.controller.signal.aborted) return;
+      try {
+        await this.onEvents(events);
+        await this.acknowledge(events, this.controller.signal);
+      } catch (error) {
+        if (!this.controller.signal.aborted) console.error(`[sourcefed] event delivery failed: ${String(error)}`);
+        this.failedDelivery = true;
+        this.stream?.abort();
+      }
+    });
+  }
+  async waitForDelivery() {
+    if (this.controller.signal.aborted) return;
+    const stopped = Promise.withResolvers();
+    const abort = () => stopped.resolve();
+    this.controller.signal.addEventListener("abort", abort, { once: true });
+    try {
+      await Promise.race([this.delivering, stopped.promise]);
+    } finally {
+      this.controller.signal.removeEventListener("abort", abort);
+    }
+  }
+};
+function pause(ms, signal) {
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", finish, { once: true });
+    if (signal.aborted) finish();
+  });
+}
 async function connectDaemonClient(options) {
   const url = options.url ?? process.env.SOURCEFED_DAEMON_URL ?? defaultDaemonUrl();
   return new HttpDaemonClient(url, options.token ?? process.env.SOURCEFED_DAEMON_TOKEN);
 }
 var HttpDaemonClient = class {
-  baseURL;
-  token;
-  router = new RequestRouter();
-  listeners = /* @__PURE__ */ new Map();
-  streams = /* @__PURE__ */ new Set();
   constructor(baseURL, token) {
-    this.baseURL = baseURL.replace(/\/+$/, "");
     this.token = token;
+    this.baseURL = baseURL.replace(/\/+$/, "");
   }
+  baseURL;
+  streams = /* @__PURE__ */ new Set();
+  lifetime = new AbortController();
+  cursor = 0;
+  closing;
   headers() {
     return this.token ? { authorization: `Bearer ${this.token}` } : {};
   }
-  async request(method, params) {
-    const id = this.router.nextID();
-    const promise = this.router.register(id);
+  async request(method, params, signal = this.lifetime.signal) {
+    if (this.closing && signal === this.lifetime.signal) throw new Error("daemon closed");
+    signal.throwIfAborted();
+    const response = await fetch(`${this.baseURL}/rpc`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...this.headers() },
+      body: JSON.stringify({ id: ++this.cursor, method, params }),
+      signal: AbortSignal.any([signal, this.lifetime.signal, AbortSignal.timeout(15e3)])
+    });
+    const frame = await response.json();
+    if (!response.ok || frame.error) throw new Error(frame.error ?? `daemon request failed: ${response.status}`);
+    return frame.result;
+  }
+  async subscribe(target, onEvents, options) {
+    if (this.closing) throw new Error("daemon closed");
+    this.lifetime.signal.throwIfAborted();
+    const stream = new DaemonEventStream(
+      `${this.baseURL}/events?target=${encodeTarget(target)}`,
+      this.headers(),
+      onEvents,
+      (events, signal) => this.acknowledge(target, events, signal),
+      () => this.streams.delete(stream)
+    );
+    this.streams.add(stream);
     try {
-      const response = await fetch(`${this.baseURL}/rpc`, {
-        method: "POST",
-        headers: { "content-type": "application/json", ...this.headers() },
-        body: JSON.stringify({ id, method, params })
-      });
-      const frame = await response.json();
-      if (!response.ok || frame.error) throw new Error(frame.error ?? `daemon request failed: ${response.status}`);
-      this.router.settle(id, { result: frame.result });
+      await stream.start(options?.signal);
+      return { close: () => stream.close() };
     } catch (error) {
-      this.router.settle(id, { error: error instanceof Error ? error.message : String(error) });
+      await stream.close();
+      throw error;
     }
-    return promise;
   }
-  async subscribe(target, onEvents) {
-    const key = targetKey(target);
-    let callbacks = this.listeners.get(key);
-    if (!callbacks) {
-      callbacks = /* @__PURE__ */ new Set();
-      this.listeners.set(key, callbacks);
-    }
-    callbacks.add(onEvents);
-    const controller = new AbortController();
-    this.streams.add(controller);
-    const url = `${this.baseURL}/events?target=${encodeTarget(target)}`;
-    let markSubscribed;
-    const subscribed = new Promise((resolve) => {
-      markSubscribed = () => resolve();
-    });
-    let delivering = Promise.resolve();
-    let activeStream;
-    let retryStream = false;
-    const deliver = (events) => {
-      if (!callbacks?.has(onEvents) || events.length === 0) return Promise.resolve();
-      delivering = delivering.then(async () => {
-        try {
-          await onEvents(events);
-        } catch (error) {
-          console.error(`[sourcefed] event delivery failed: ${error instanceof Error ? error.message : String(error)}`);
-          retryStream = true;
-          activeStream?.abort();
-          return;
-        }
-        await acknowledge(events);
-      }).catch((error) => {
-        console.error(`[sourcefed] event delivery failed: ${error instanceof Error ? error.message : String(error)}`);
-      });
-      return delivering;
-    };
-    const acknowledge = async (events) => {
-      let attempt = 0;
-      while (!controller.signal.aborted && callbacks?.has(onEvents)) {
-        try {
-          await this.request("monitor.ack", { target, eventIDs: events.map((event) => event.id) });
-          return;
-        } catch (error) {
-          attempt += 1;
-          if (attempt === 3) {
-            console.error(`[sourcefed] event acknowledgement still failing; retrying without repeating delivery: ${error instanceof Error ? error.message : String(error)}`);
-          }
-          await sleep(Math.min(250 * 2 ** (attempt - 1), 4e3));
-        }
-      }
-    };
-    const runStream = async () => {
-      const streamController = new AbortController();
-      const closeStream = () => streamController.abort();
-      activeStream = streamController;
-      controller.signal.addEventListener("abort", closeStream, { once: true });
+  async acknowledge(target, events, signal) {
+    let attempt = 0;
+    while (!signal.aborted) {
       try {
-        const response = await fetch(url, { signal: streamController.signal, headers: this.headers() });
-        if (!response.ok || !response.body) throw new Error(`event stream failed: ${response.status}`);
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const frames = buffer.split("\n\n");
-          buffer = frames.pop() ?? "";
-          for (const chunk of frames) {
-            for (const line of chunk.split("\n")) {
-              if (!line.startsWith("data: ")) continue;
-              const frame = parseDaemonFrame(line.slice(6));
-              if (!frame || !("type" in frame)) continue;
-              if (frame.type === "subscribed") markSubscribed();
-              if (frame.type === "event") void deliver(frame.events);
-            }
-          }
-        }
-        consecutiveFailures = 0;
+        await this.request("monitor.ack", { target, eventIDs: events.map((event) => event.id) }, signal);
+        return;
       } catch (error) {
-        if (!controller.signal.aborted && !retryStream) {
-          consecutiveFailures += 1;
-          if (consecutiveFailures === 1) {
-            console.error(`[sourcefed] event stream ended: ${error instanceof Error ? error.message : String(error)}`);
-          }
+        if (++attempt === 3) {
+          console.error(`[sourcefed] event acknowledgement still failing; retrying without repeating delivery: ${String(error)}`);
         }
-      } finally {
-        controller.signal.removeEventListener("abort", closeStream);
-        if (activeStream === streamController) activeStream = void 0;
-        retryStream = false;
+        await pause(Math.min(250 * 2 ** Math.min(attempt - 1, 4), 4e3), signal);
       }
-    };
-    let consecutiveFailures = 0;
-    void (async () => {
-      while (!controller.signal.aborted && callbacks?.has(onEvents)) {
-        await runStream();
-        if (controller.signal.aborted) break;
-        await sleep(500);
-      }
-    })();
-    try {
-      await withTimeout(subscribed, 15e3, `sourcefed event stream did not subscribe at ${url}`);
-    } catch (error) {
-      const callbacks2 = this.listeners.get(key);
-      callbacks2?.delete(onEvents);
-      if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);
-      controller.abort();
-      this.streams.delete(controller);
-      throw error;
     }
-    return {
-      close: async () => {
-        const callbacks2 = this.listeners.get(key);
-        callbacks2?.delete(onEvents);
-        if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);
-        controller.abort();
-        this.streams.delete(controller);
-      }
-    };
   }
-  async close() {
-    for (const controller of this.streams) controller.abort();
-    this.streams.clear();
-    this.router.rejectAll(new Error("daemon closed"));
-    this.listeners.clear();
+  close() {
+    this.closing ??= Promise.all([...this.streams].map((stream) => stream.close())).then(() => {
+      this.lifetime.abort();
+      this.streams.clear();
+    });
+    return this.closing;
   }
 };
 async function dispatchDaemonRequest(daemon, method, params) {