@fdcn/sourcefed 0.2.4 → 0.2.5

package/README.md

@@ -33,12 +33,12 @@ OpenCode loads this package as both a server and a TUI plugin:
 
 ```json
 // opencode.json
-{ "plugin": ["@fdcn/sourcefed@0.2.4"] }
+{ "plugin": ["@fdcn/sourcefed@0.2.5"] }
 ```
 
 ```json
 // tui.json
-{ "plugin": ["@fdcn/sourcefed@0.2.4"] }
+{ "plugin": ["@fdcn/sourcefed@0.2.5"] }
 ```
 
 The package exposes `./server`, `./tui`, `./opencode`, `./opencode/tui`, and `./pi` entrypoints for hosts that load them directly.

package/dist/{chunk-SKEBKW2L.js → chunk-5NFCKXDQ.js}

@@ -11638,11 +11638,16 @@ var SourcefedDaemon = class {
       this.listeners.set(key, listeners);
     }
     listeners.add(onEvents);
+    this.emit(target);
     return () => {
       listeners.delete(onEvents);
+      const receivedByListener = this.received.get(key);
+      const released = receivedByListener?.delete(onEvents) ?? false;
       if (listeners.size === 0) {
         this.listeners.delete(key);
         this.received.delete(key);
+      } else if (released) {
+        this.emit(target);
       }
     };
   }
@@ -11678,23 +11683,28 @@ var SourcefedDaemon = class {
       receivedByListener = /* @__PURE__ */ new Map();
       this.received.set(key, receivedByListener);
     }
-    const listenerResults = [...listeners].map(async (listener) => {
+    const claimed = /* @__PURE__ */ new Set();
+    for (const received of receivedByListener.values()) {
+      for (const id of received) claimed.add(id);
+    }
+    const fresh = queued.filter((event) => !claimed.has(event.id));
+    if (fresh.length === 0) return;
+    for (const listener of [...listeners]) {
       let received = receivedByListener.get(listener);
       if (!received) {
         received = /* @__PURE__ */ new Set();
         receivedByListener.set(listener, received);
       }
-      const fresh = queued.filter((event) => !received.has(event.id));
-      if (fresh.length === 0) return;
       for (const event of fresh) received.add(event.id);
       try {
         await listener(fresh);
+        return;
       } catch (error) {
         console.error(`[sourcefed] event delivery failed: ${error instanceof Error ? error.message : String(error)}`);
         for (const event of fresh) received.delete(event.id);
+        if (received.size === 0) receivedByListener.delete(listener);
       }
-    });
-    await Promise.all(listenerResults);
+    }
   }
 };
 function monitorView(monitor) {
@@ -11803,72 +11813,48 @@ var HttpDaemonClient = class {
     const subscribed = new Promise((resolve) => {
       markSubscribed = () => resolve();
     });
-    let drainComplete = false;
-    let draining = false;
-    let redrainRequested = false;
-    let retryTimer;
-    let markDrained;
-    const drained = new Promise((resolve) => {
-      markDrained = resolve;
-    });
-    let buffered = [];
     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(() => deliverWithRetry(events, 0)).catch((error) => {
+      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 deliverWithRetry = async (events, attempt) => {
-      try {
-        await onEvents(events);
-      } catch (error) {
-        if (attempt >= 2) {
-          console.error(`[sourcefed] event delivery failed after retries; re-draining queue: ${error instanceof Error ? error.message : String(error)}`);
-          redrainRequested = true;
-          void performDrain();
+    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));
         }
-        await sleep(250 * (attempt + 1));
-        await deliverWithRetry(events, attempt + 1);
-      }
-    };
-    const performDrain = async () => {
-      if (draining) {
-        redrainRequested = true;
-        return;
-      }
-      draining = true;
-      try {
-        let passes = 0;
-        do {
-          redrainRequested = false;
-          passes += 1;
-          try {
-            const drainResult = await this.request("monitor.events", { target });
-            drainComplete = true;
-            const drainedIds = new Set((drainResult.events ?? []).map((event) => event.id));
-            if (drainResult.events && drainResult.events.length > 0) await deliver(drainResult.events);
-            for (const batch of buffered) {
-              const fresh = batch.filter((event) => !drainedIds.has(event.id));
-              if (fresh.length > 0) await deliver(fresh);
-            }
-            buffered = [];
-            markDrained();
-          } catch (error) {
-            console.error(`[sourcefed] event drain failed: ${error instanceof Error ? error.message : String(error)}`);
-            redrainRequested = true;
-          }
-        } while (redrainRequested && passes < 3);
-        if (redrainRequested) markDrained();
-      } finally {
-        draining = false;
       }
     };
     const runStream = async () => {
+      const streamController = new AbortController();
+      const closeStream = () => streamController.abort();
+      activeStream = streamController;
+      controller.signal.addEventListener("abort", closeStream, { once: true });
       try {
-        const response = await fetch(url, { signal: controller.signal, headers: this.headers() });
+        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();
@@ -11884,26 +11870,23 @@ var HttpDaemonClient = class {
               if (!line.startsWith("data: ")) continue;
               const frame = parseDaemonFrame(line.slice(6));
               if (!frame || !("type" in frame)) continue;
-              if (frame.type === "subscribed") {
-                markSubscribed();
-                drainComplete = false;
-                void performDrain();
-              }
-              if (frame.type === "event") {
-                if (drainComplete) void deliver(frame.events);
-                else buffered.push(frame.events);
-              }
+              if (frame.type === "subscribed") markSubscribed();
+              if (frame.type === "event") void deliver(frame.events);
             }
           }
         }
         consecutiveFailures = 0;
       } catch (error) {
-        if (!controller.signal.aborted) {
+        if (!controller.signal.aborted && !retryStream) {
           consecutiveFailures += 1;
           if (consecutiveFailures === 1) {
             console.error(`[sourcefed] event stream ended: ${error instanceof Error ? error.message : String(error)}`);
           }
         }
+      } finally {
+        controller.signal.removeEventListener("abort", closeStream);
+        if (activeStream === streamController) activeStream = void 0;
+        retryStream = false;
       }
     };
     let consecutiveFailures = 0;
@@ -11916,9 +11899,7 @@ var HttpDaemonClient = class {
     })();
     try {
       await withTimeout(subscribed, 15e3, `sourcefed event stream did not subscribe at ${url}`);
-      await withTimeout(drained, 15e3, "sourcefed initial event drain timed out");
     } catch (error) {
-      if (retryTimer) clearTimeout(retryTimer);
       const callbacks2 = this.listeners.get(key);
       callbacks2?.delete(onEvents);
       if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);
@@ -11928,7 +11909,6 @@ var HttpDaemonClient = class {
     }
     return {
       close: async () => {
-        if (retryTimer) clearTimeout(retryTimer);
         const callbacks2 = this.listeners.get(key);
         callbacks2?.delete(onEvents);
         if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);

package/dist/cli.js

@@ -11561,11 +11561,16 @@ var SourcefedDaemon = class {
       this.listeners.set(key, listeners);
     }
     listeners.add(onEvents);
+    this.emit(target);
     return () => {
       listeners.delete(onEvents);
+      const receivedByListener = this.received.get(key);
+      const released = receivedByListener?.delete(onEvents) ?? false;
       if (listeners.size === 0) {
         this.listeners.delete(key);
         this.received.delete(key);
+      } else if (released) {
+        this.emit(target);
       }
     };
   }
@@ -11601,23 +11606,28 @@ var SourcefedDaemon = class {
       receivedByListener = /* @__PURE__ */ new Map();
       this.received.set(key, receivedByListener);
     }
-    const listenerResults = [...listeners].map(async (listener) => {
+    const claimed = /* @__PURE__ */ new Set();
+    for (const received of receivedByListener.values()) {
+      for (const id of received) claimed.add(id);
+    }
+    const fresh = queued.filter((event) => !claimed.has(event.id));
+    if (fresh.length === 0) return;
+    for (const listener of [...listeners]) {
       let received = receivedByListener.get(listener);
       if (!received) {
         received = /* @__PURE__ */ new Set();
         receivedByListener.set(listener, received);
       }
-      const fresh = queued.filter((event) => !received.has(event.id));
-      if (fresh.length === 0) return;
       for (const event of fresh) received.add(event.id);
       try {
         await listener(fresh);
+        return;
       } catch (error2) {
         console.error(`[sourcefed] event delivery failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
         for (const event of fresh) received.delete(event.id);
+        if (received.size === 0) receivedByListener.delete(listener);
       }
-    });
-    await Promise.all(listenerResults);
+    }
   }
 };
 function monitorView(monitor) {
@@ -11726,72 +11736,48 @@ var HttpDaemonClient = class {
     const subscribed = new Promise((resolve) => {
       markSubscribed = () => resolve();
     });
-    let drainComplete = false;
-    let draining = false;
-    let redrainRequested = false;
-    let retryTimer;
-    let markDrained;
-    const drained = new Promise((resolve) => {
-      markDrained = resolve;
-    });
-    let buffered = [];
     let delivering = Promise.resolve();
+    let activeStream;
+    let retryStream = false;
     const deliver = (events2) => {
       if (!callbacks?.has(onEvents) || events2.length === 0) return Promise.resolve();
-      delivering = delivering.then(() => deliverWithRetry(events2, 0)).catch((error2) => {
+      delivering = delivering.then(async () => {
+        try {
+          await onEvents(events2);
+        } catch (error2) {
+          console.error(`[sourcefed] event delivery failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+          retryStream = true;
+          activeStream?.abort();
+          return;
+        }
+        await acknowledge(events2);
+      }).catch((error2) => {
         console.error(`[sourcefed] event delivery failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
       });
       return delivering;
     };
-    const deliverWithRetry = async (events2, attempt) => {
-      try {
-        await onEvents(events2);
-      } catch (error2) {
-        if (attempt >= 2) {
-          console.error(`[sourcefed] event delivery failed after retries; re-draining queue: ${error2 instanceof Error ? error2.message : String(error2)}`);
-          redrainRequested = true;
-          void performDrain();
+    const acknowledge = async (events2) => {
+      let attempt = 0;
+      while (!controller.signal.aborted && callbacks?.has(onEvents)) {
+        try {
+          await this.request("monitor.ack", { target, eventIDs: events2.map((event) => event.id) });
           return;
-        }
-        await sleep(250 * (attempt + 1));
-        await deliverWithRetry(events2, attempt + 1);
-      }
-    };
-    const performDrain = async () => {
-      if (draining) {
-        redrainRequested = true;
-        return;
-      }
-      draining = true;
-      try {
-        let passes = 0;
-        do {
-          redrainRequested = false;
-          passes += 1;
-          try {
-            const drainResult = await this.request("monitor.events", { target });
-            drainComplete = true;
-            const drainedIds = new Set((drainResult.events ?? []).map((event) => event.id));
-            if (drainResult.events && drainResult.events.length > 0) await deliver(drainResult.events);
-            for (const batch of buffered) {
-              const fresh = batch.filter((event) => !drainedIds.has(event.id));
-              if (fresh.length > 0) await deliver(fresh);
-            }
-            buffered = [];
-            markDrained();
-          } catch (error2) {
-            console.error(`[sourcefed] event drain failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
-            redrainRequested = true;
+        } catch (error2) {
+          attempt += 1;
+          if (attempt === 3) {
+            console.error(`[sourcefed] event acknowledgement still failing; retrying without repeating delivery: ${error2 instanceof Error ? error2.message : String(error2)}`);
           }
-        } while (redrainRequested && passes < 3);
-        if (redrainRequested) markDrained();
-      } finally {
-        draining = false;
+          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 });
       try {
-        const response = await fetch(url2, { signal: controller.signal, headers: this.headers() });
+        const response = await fetch(url2, { 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();
@@ -11807,26 +11793,23 @@ var HttpDaemonClient = class {
               if (!line.startsWith("data: ")) continue;
               const frame = parseDaemonFrame(line.slice(6));
               if (!frame || !("type" in frame)) continue;
-              if (frame.type === "subscribed") {
-                markSubscribed();
-                drainComplete = false;
-                void performDrain();
-              }
-              if (frame.type === "event") {
-                if (drainComplete) void deliver(frame.events);
-                else buffered.push(frame.events);
-              }
+              if (frame.type === "subscribed") markSubscribed();
+              if (frame.type === "event") void deliver(frame.events);
             }
           }
         }
         consecutiveFailures = 0;
       } catch (error2) {
-        if (!controller.signal.aborted) {
+        if (!controller.signal.aborted && !retryStream) {
           consecutiveFailures += 1;
           if (consecutiveFailures === 1) {
             console.error(`[sourcefed] event stream ended: ${error2 instanceof Error ? error2.message : String(error2)}`);
           }
         }
+      } finally {
+        controller.signal.removeEventListener("abort", closeStream);
+        if (activeStream === streamController) activeStream = void 0;
+        retryStream = false;
       }
     };
     let consecutiveFailures = 0;
@@ -11839,9 +11822,7 @@ var HttpDaemonClient = class {
     })();
     try {
       await withTimeout(subscribed, 15e3, `sourcefed event stream did not subscribe at ${url2}`);
-      await withTimeout(drained, 15e3, "sourcefed initial event drain timed out");
     } catch (error2) {
-      if (retryTimer) clearTimeout(retryTimer);
       const callbacks2 = this.listeners.get(key);
       callbacks2?.delete(onEvents);
       if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);
@@ -11851,7 +11832,6 @@ var HttpDaemonClient = class {
     }
     return {
       close: async () => {
-        if (retryTimer) clearTimeout(retryTimer);
         const callbacks2 = this.listeners.get(key);
         callbacks2?.delete(onEvents);
         if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);

package/dist/daemon.js

@@ -11663,11 +11663,16 @@ var SourcefedDaemon = class {
       this.listeners.set(key, listeners);
     }
     listeners.add(onEvents);
+    this.emit(target);
     return () => {
       listeners.delete(onEvents);
+      const receivedByListener = this.received.get(key);
+      const released = receivedByListener?.delete(onEvents) ?? false;
       if (listeners.size === 0) {
         this.listeners.delete(key);
         this.received.delete(key);
+      } else if (released) {
+        this.emit(target);
       }
     };
   }
@@ -11703,23 +11708,28 @@ var SourcefedDaemon = class {
       receivedByListener = /* @__PURE__ */ new Map();
       this.received.set(key, receivedByListener);
     }
-    const listenerResults = [...listeners].map(async (listener) => {
+    const claimed = /* @__PURE__ */ new Set();
+    for (const received of receivedByListener.values()) {
+      for (const id of received) claimed.add(id);
+    }
+    const fresh = queued.filter((event) => !claimed.has(event.id));
+    if (fresh.length === 0) return;
+    for (const listener of [...listeners]) {
       let received = receivedByListener.get(listener);
       if (!received) {
         received = /* @__PURE__ */ new Set();
         receivedByListener.set(listener, received);
       }
-      const fresh = queued.filter((event) => !received.has(event.id));
-      if (fresh.length === 0) return;
       for (const event of fresh) received.add(event.id);
       try {
         await listener(fresh);
+        return;
       } catch (error) {
         console.error(`[sourcefed] event delivery failed: ${error instanceof Error ? error.message : String(error)}`);
         for (const event of fresh) received.delete(event.id);
+        if (received.size === 0) receivedByListener.delete(listener);
       }
-    });
-    await Promise.all(listenerResults);
+    }
   }
 };
 function monitorView(monitor) {
@@ -11832,72 +11842,48 @@ var HttpDaemonClient = class {
     const subscribed = new Promise((resolve) => {
       markSubscribed = () => resolve();
     });
-    let drainComplete = false;
-    let draining = false;
-    let redrainRequested = false;
-    let retryTimer;
-    let markDrained;
-    const drained = new Promise((resolve) => {
-      markDrained = resolve;
-    });
-    let buffered = [];
     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(() => deliverWithRetry(events, 0)).catch((error) => {
+      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 deliverWithRetry = async (events, attempt) => {
-      try {
-        await onEvents(events);
-      } catch (error) {
-        if (attempt >= 2) {
-          console.error(`[sourcefed] event delivery failed after retries; re-draining queue: ${error instanceof Error ? error.message : String(error)}`);
-          redrainRequested = true;
-          void performDrain();
+    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));
         }
-        await sleep(250 * (attempt + 1));
-        await deliverWithRetry(events, attempt + 1);
-      }
-    };
-    const performDrain = async () => {
-      if (draining) {
-        redrainRequested = true;
-        return;
-      }
-      draining = true;
-      try {
-        let passes = 0;
-        do {
-          redrainRequested = false;
-          passes += 1;
-          try {
-            const drainResult = await this.request("monitor.events", { target });
-            drainComplete = true;
-            const drainedIds = new Set((drainResult.events ?? []).map((event) => event.id));
-            if (drainResult.events && drainResult.events.length > 0) await deliver(drainResult.events);
-            for (const batch of buffered) {
-              const fresh = batch.filter((event) => !drainedIds.has(event.id));
-              if (fresh.length > 0) await deliver(fresh);
-            }
-            buffered = [];
-            markDrained();
-          } catch (error) {
-            console.error(`[sourcefed] event drain failed: ${error instanceof Error ? error.message : String(error)}`);
-            redrainRequested = true;
-          }
-        } while (redrainRequested && passes < 3);
-        if (redrainRequested) markDrained();
-      } finally {
-        draining = false;
       }
     };
     const runStream = async () => {
+      const streamController = new AbortController();
+      const closeStream = () => streamController.abort();
+      activeStream = streamController;
+      controller.signal.addEventListener("abort", closeStream, { once: true });
       try {
-        const response = await fetch(url, { signal: controller.signal, headers: this.headers() });
+        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();
@@ -11913,26 +11899,23 @@ var HttpDaemonClient = class {
               if (!line.startsWith("data: ")) continue;
               const frame = parseDaemonFrame(line.slice(6));
               if (!frame || !("type" in frame)) continue;
-              if (frame.type === "subscribed") {
-                markSubscribed();
-                drainComplete = false;
-                void performDrain();
-              }
-              if (frame.type === "event") {
-                if (drainComplete) void deliver(frame.events);
-                else buffered.push(frame.events);
-              }
+              if (frame.type === "subscribed") markSubscribed();
+              if (frame.type === "event") void deliver(frame.events);
             }
           }
         }
         consecutiveFailures = 0;
       } catch (error) {
-        if (!controller.signal.aborted) {
+        if (!controller.signal.aborted && !retryStream) {
           consecutiveFailures += 1;
           if (consecutiveFailures === 1) {
             console.error(`[sourcefed] event stream ended: ${error instanceof Error ? error.message : String(error)}`);
           }
         }
+      } finally {
+        controller.signal.removeEventListener("abort", closeStream);
+        if (activeStream === streamController) activeStream = void 0;
+        retryStream = false;
       }
     };
     let consecutiveFailures = 0;
@@ -11945,9 +11928,7 @@ var HttpDaemonClient = class {
     })();
     try {
       await withTimeout(subscribed, 15e3, `sourcefed event stream did not subscribe at ${url}`);
-      await withTimeout(drained, 15e3, "sourcefed initial event drain timed out");
     } catch (error) {
-      if (retryTimer) clearTimeout(retryTimer);
       const callbacks2 = this.listeners.get(key);
       callbacks2?.delete(onEvents);
       if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);
@@ -11957,7 +11938,6 @@ var HttpDaemonClient = class {
     }
     return {
       close: async () => {
-        if (retryTimer) clearTimeout(retryTimer);
         const callbacks2 = this.listeners.get(key);
         callbacks2?.delete(onEvents);
         if (callbacks2 && callbacks2.size === 0) this.listeners.delete(key);

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   decodeTarget,
   encodeTarget
-} from "./chunk-SKEBKW2L.js";
+} from "./chunk-5NFCKXDQ.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";

package/dist/opencode.js

@@ -4,7 +4,7 @@ import {
   daemonCommand,
   daemonEnvironment,
   spawnLocalDaemon
-} from "./chunk-SKEBKW2L.js";
+} from "./chunk-5NFCKXDQ.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -74,20 +74,12 @@ var OpenCodeBridge = class {
     }
   }
   async routeEvents(events) {
-    const delivered = [];
     for (const queued of events) {
       const body = {
         ...queued.event.actionable ? {} : { noReply: true },
         parts: [{ type: "text", text: eventText(queued.event) }]
       };
       await this.opencode.session.prompt({ path: { id: queued.target.id }, body });
-      delivered.push(queued);
-    }
-    if (delivered.length > 0 && this.daemon) {
-      await this.daemon.request("monitor.ack", {
-        target: { kind: "opencode-session", id: delivered[0].target.id },
-        eventIDs: delivered.map((queued) => queued.id)
-      });
     }
   }
   target(sessionID) {