@fdcn/sourcefed 0.3.6 → 0.3.7

package/dist/opencode.js

@@ -7,7 +7,7 @@ import {
   daemonCommand,
   daemonEnvironment,
   spawnLocalDaemon
-} from "./chunk-X3BZSHKZ.js";
+} from "./chunk-E6J3BAXP.js";
 import "./chunk-MLKGABMK.js";
 
 // packages/sourcefed/src/server.ts
@@ -22,9 +22,193 @@ import { Plugin } from "@opencode/plugin";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Rpc } from "@opencode/plugin";
+
+// adapters/opencode/subscriptions.ts
+var REFRESH_MS = 15e3;
+var OpenCodeSubscriptions = class {
+  constructor(connect) {
+    this.connect = connect;
+  }
+  owners = /* @__PURE__ */ new Set();
+  subscriptions = /* @__PURE__ */ new Map();
+  lifetime = new AbortController();
+  daemon;
+  connecting;
+  refreshing;
+  dirty = false;
+  lastAttemptAt = -Infinity;
+  timer;
+  get closed() {
+    return this.lifetime.signal.aborted;
+  }
+  async add(owner) {
+    if (this.closed) throw new Error("sourcefed subscription hub is closed");
+    this.owners.add(owner);
+    if (!this.timer) {
+      this.timer = setInterval(() => void this.refresh(), REFRESH_MS);
+      this.timer.unref?.();
+    }
+    await this.refresh();
+  }
+  async remove(owner) {
+    this.owners.delete(owner);
+    const closing = [];
+    for (const [id, subscription] of this.subscriptions) {
+      if (this.ownerFor(subscription.info)) continue;
+      this.subscriptions.delete(id);
+      closing.push(this.closeSubscription(subscription));
+    }
+    if (this.owners.size > 0) {
+      await Promise.all(closing);
+      await this.refresh();
+      return;
+    }
+    this.lifetime.abort();
+    clearInterval(this.timer);
+    this.timer = void 0;
+    await Promise.all(closing);
+    await this.daemon?.close();
+    this.daemon = void 0;
+    await this.connecting;
+    await this.refreshing;
+  }
+  async request(method, params) {
+    const daemon = await this.ensureDaemon();
+    if (!daemon || this.closed) throw new Error("sourcefed daemon unavailable or bridge closed");
+    return daemon.request(method, params);
+  }
+  refresh() {
+    if (this.closed) return Promise.resolve();
+    this.dirty = true;
+    if (!this.refreshing) {
+      this.refreshing = this.refreshLoop();
+    }
+    return this.refreshing;
+  }
+  async refreshLoop() {
+    try {
+      do {
+        this.dirty = false;
+        try {
+          const daemon = await this.ensureDaemon();
+          if (daemon && !this.closed) await this.reconcile(daemon);
+        } catch (error) {
+          if (!this.closed) console.error(`[sourcefed] refresh failed: ${String(error)}`);
+        }
+      } while (this.dirty && !this.closed);
+    } finally {
+      this.refreshing = void 0;
+    }
+  }
+  async ensureDaemon() {
+    if (this.closed) return void 0;
+    if (this.daemon) return this.daemon;
+    if (this.connecting) return this.connecting;
+    if (Date.now() - this.lastAttemptAt < REFRESH_MS) return void 0;
+    this.lastAttemptAt = Date.now();
+    this.connecting = this.connect().then(async (daemon) => {
+      if (this.closed) {
+        await daemon.close();
+        return void 0;
+      }
+      this.daemon = daemon;
+      return daemon;
+    }).catch((error) => {
+      console.error(`[sourcefed] daemon unavailable: ${String(error)}`);
+      return void 0;
+    }).finally(() => {
+      this.connecting = void 0;
+    });
+    return this.connecting;
+  }
+  async reconcile(daemon) {
+    const result = await daemon.request("monitor.targets", { kind: "opencode-session" });
+    const targets = enabledSessions(result);
+    for (const [id, subscription] of this.subscriptions) {
+      if (targets.has(id)) continue;
+      this.subscriptions.delete(id);
+      await this.closeSubscription(subscription);
+    }
+    for (const id of targets) {
+      if (this.closed) return;
+      const reader = this.owners.values().next().value;
+      if (!reader) return;
+      let info;
+      try {
+        info = await reader.getSession(id, this.lifetime.signal);
+      } catch (error) {
+        if (!error || typeof error !== "object" || !("_tag" in error) || error._tag !== "SessionNotFoundError") {
+          if (!this.closed) console.error(`[sourcefed] session ${id} lookup failed: ${String(error)}`);
+          continue;
+        }
+      }
+      if (this.closed) return;
+      const owner = info && this.ownerFor(info);
+      const existing = this.subscriptions.get(id);
+      if (!owner || !info) {
+        if (existing) {
+          this.subscriptions.delete(id);
+          await this.closeSubscription(existing);
+        }
+      } else if (existing) {
+        existing.info = info;
+      } else {
+        await this.subscribe(daemon, id, info);
+      }
+    }
+  }
+  ownerFor(info) {
+    const candidates = [...this.owners].filter((owner) => owner.location.project.id === info.projectID);
+    return candidates.find((owner) => owner.location.directory === info.location.directory) ?? candidates[0];
+  }
+  async subscribe(daemon, id, info) {
+    const controller = new AbortController();
+    const subscription = {
+      info,
+      controller,
+      listener: daemon.subscribe({ kind: "opencode-session", id }, async (events) => {
+        await this.route(id, subscription, events);
+      }, { signal: controller.signal })
+    };
+    this.subscriptions.set(id, subscription);
+    try {
+      await subscription.listener;
+    } catch (error) {
+      if (this.subscriptions.get(id) === subscription) this.subscriptions.delete(id);
+      if (!controller.signal.aborted) console.error(`[sourcefed] subscribe ${id} failed: ${String(error)}`);
+    }
+  }
+  async route(id, subscription, events) {
+    const reader = this.owners.values().next().value;
+    if (!reader) throw new Error("sourcefed session owner unloaded");
+    const info = await reader.getSession(id, this.lifetime.signal);
+    const owner = this.ownerFor(info);
+    if (!owner) throw new Error("sourcefed session has no loaded project owner");
+    subscription.info = info;
+    await owner.routeEvents(events);
+  }
+  async closeSubscription(subscription) {
+    subscription.controller.abort();
+    await subscription.listener.then((listener) => listener.close(), () => void 0);
+  }
+};
+function enabledSessions(result) {
+  if (!result || typeof result !== "object" || !("targets" in result) || !Array.isArray(result.targets)) {
+    throw new Error("invalid monitor.targets response");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const target of result.targets) {
+    if (!target || target.kind !== "opencode-session" || typeof target.id !== "string") {
+      throw new Error("invalid opencode-session target");
+    }
+    ids.add(target.id);
+  }
+  return ids;
+}
+
+// adapters/opencode/bridge.ts
 var TARGET_KIND = "opencode-session";
 var GATE_TIMEOUT_MS = 3e3;
-var RESUBSCRIBE_MS = 15e3;
 var ChauffeurGate = Rpc.define({
   id: "chauffeur",
   methods: {
@@ -52,97 +236,53 @@ var ChauffeurGate = Rpc.define({
   },
   events: {}
 });
-var activeBridge;
+var HUB = Symbol.for("sourcefed.opencode.subscriptions.v1");
+var shared = globalThis;
+function subscriptions() {
+  if (!shared[HUB] || shared[HUB].closed) shared[HUB] = new OpenCodeSubscriptions(connectDaemon);
+  return shared[HUB];
+}
 var OpenCodeBridge = class {
-  constructor(session, rpc) {
+  constructor(session, rpc, location, hub = subscriptions()) {
     this.session = session;
     this.rpc = rpc;
+    this.location = location;
+    this.hub = hub;
   }
-  daemon;
-  listeners = /* @__PURE__ */ new Map();
-  lastAttemptAt = 0;
-  lastError;
-  timer;
+  started;
+  closed = false;
+  closing;
   /**
    * Chauffeur or the CLI can create a monitor for a session here at any time,
    * without this bridge's tools, so check for new targets periodically too.
    */
   async start() {
-    await this.ensureDaemon();
-    this.timer = setInterval(() => void this.refresh(), RESUBSCRIBE_MS);
-    this.timer.unref?.();
+    if (this.closed) throw new Error("sourcefed bridge is closed");
+    this.started ??= this.hub.add(this);
+    await this.started;
   }
-  async ensureTarget(sessionID) {
-    await this.ensureDaemon();
-    const existing = this.listeners.get(sessionID);
-    if (existing) {
-      await existing;
-      return;
-    }
-    const pending = this.daemon.subscribe(this.target(sessionID), async (events) => {
-      await this.routeEvents(events);
-    });
-    this.listeners.set(sessionID, pending);
+  async callTool(name, arguments_, sessionID) {
     try {
-      await pending;
+      await this.start();
+      const method = name.replace(/_/g, ".");
+      const result = await this.hub.request(method, { ...arguments_, target: this.target(sessionID) });
+      if (["monitor.create", "monitor.start", "monitor.stop", "monitor.remove"].includes(method)) await this.hub.refresh();
+      return result;
     } catch (error) {
-      this.listeners.delete(sessionID);
-      throw error;
-    }
-  }
-  async callTool(name, arguments_, sessionID) {
-    await this.ensureDaemon();
-    if (!this.daemon) {
-      return { ok: false, error: `sourcefed daemon unavailable: ${this.lastError ?? "not started"}` };
+      return { ok: false, error: String(error) };
     }
-    await this.ensureTarget(sessionID);
-    return this.daemon.request(name.replace(/_/g, "."), { ...arguments_, target: this.target(sessionID) });
   }
-  async close() {
-    clearInterval(this.timer);
-    this.timer = void 0;
-    for (const pending of this.listeners.values()) await pending.then((listener) => listener.close(), () => void 0);
-    this.listeners.clear();
-    await this.daemon?.close();
-    this.daemon = void 0;
+  close() {
+    if (this.closing) return this.closing;
+    this.closed = true;
+    this.closing = this.started ? this.hub.remove(this) : Promise.resolve();
+    return this.closing;
   }
   async refresh() {
-    if (!this.daemon) return this.ensureDaemon();
-    await this.resubscribe();
+    if (!this.closed) await this.hub.refresh();
   }
-  async ensureDaemon() {
-    if (this.daemon) return;
-    if (Date.now() - this.lastAttemptAt < 15e3) return;
-    this.lastAttemptAt = Date.now();
-    try {
-      this.daemon = await connectDaemon();
-      void this.resubscribe();
-    } catch (error) {
-      this.lastError = error instanceof Error ? error.message : String(error);
-      console.error(`[sourcefed] daemon unavailable: ${this.lastError}`);
-    }
-  }
-  /**
-   * Monitors outlive this process, so after a restart nothing listens for their
-   * sessions until something subscribes. Subscribe every session that has an
-   * enabled monitor and still exists here; a deleted session is skipped, since
-   * delivering to it would fail and retry forever.
-   */
-  async resubscribe() {
-    try {
-      const { targets } = await this.daemon.request("monitor.targets", { kind: TARGET_KIND });
-      await Promise.all(targets.map((target) => this.resubscribeTarget(target.id)));
-    } catch (error) {
-      console.error(`[sourcefed] resubscribe failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async resubscribeTarget(sessionID) {
-    if (this.listeners.has(sessionID)) return;
-    const exists = await this.session.get({ sessionID }).then(() => true, () => false);
-    if (!exists) return;
-    await this.ensureTarget(sessionID).catch((error) => {
-      console.error(`[sourcefed] subscribe ${sessionID} failed: ${error instanceof Error ? error.message : String(error)}`);
-    });
+  getSession(sessionID, signal) {
+    return this.session.get({ sessionID }, { signal: AbortSignal.any([signal, AbortSignal.timeout(3e3)]) });
   }
   // Every event arrives as a synthetic message, never as a user prompt, so it is
   // not mistaken for the user's own words. Actionable events resume an idle
@@ -182,7 +322,7 @@ var OpenCodeBridge = class {
         },
         { signal: AbortSignal.timeout(GATE_TIMEOUT_MS) }
       );
-      return reply.deliver !== false;
+      return !(reply && typeof reply === "object" && "deliver" in reply && reply.deliver === false);
     } catch {
       return true;
     }
@@ -207,22 +347,15 @@ function cliEntry() {
   if (existsSync(bundled)) return bundled;
   return fileURLToPath(import.meta.resolve("@sourcefed/cli"));
 }
-function setOpenCodeBridge(bridge) {
-  activeBridge = bridge;
-}
-function getOpenCodeBridge() {
-  if (!activeBridge) throw new Error("Sourcefed OpenCode bridge is not initialized");
-  return activeBridge;
-}
 
 // adapters/opencode/tool-result.ts
-async function callMonitorTool(name, arguments_, sessionID) {
-  const result = await getOpenCodeBridge().callTool(name, arguments_, sessionID);
+async function callMonitorTool(bridge, name, arguments_, sessionID) {
+  const result = await bridge.callTool(name, arguments_, sessionID);
   return JSON.stringify(result);
 }
 
 // adapters/opencode/tools/monitor_create.ts
-var definition = {
+var monitor_create_default = (bridge) => ({
   name: "monitor_create",
   description: "Create a detect-only monitor that watches a Jira issue, GitHub PR, Slack thread, or Slack DM and routes NEW events into the current session. Slack monitors only read and notify; they never reply. GitHub and Slack use webhooks when configured and polling otherwise; Jira uses polling.",
   input: {
@@ -242,13 +375,12 @@ var definition = {
     additionalProperties: false
   },
   async execute(input, context) {
-    return { content: await callMonitorTool("monitor_create", input ?? {}, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_create", input ?? {}, context.sessionID) };
   }
-};
-var monitor_create_default = definition;
+});
 
 // adapters/opencode/tools/monitor_list.ts
-var definition2 = {
+var monitor_list_default = (bridge) => ({
   name: "monitor_list",
   description: "List monitors created by the current session (id, name, source, delivery, enabled).",
   input: {
@@ -257,13 +389,12 @@ var definition2 = {
     additionalProperties: false
   },
   async execute(_input, context) {
-    return { content: await callMonitorTool("monitor_list", {}, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_list", {}, context.sessionID) };
   }
-};
-var monitor_list_default = definition2;
+});
 
 // adapters/opencode/tools/monitor_status.ts
-var definition3 = {
+var monitor_status_default = (bridge) => ({
   name: "monitor_status",
   description: "Get the status of a monitor created by the current session.",
   input: {
@@ -276,13 +407,12 @@ var definition3 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_status", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_status", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_status_default = definition3;
+});
 
 // adapters/opencode/tools/monitor_start.ts
-var definition4 = {
+var monitor_start_default = (bridge) => ({
   name: "monitor_start",
   description: "Start (re-enable) a stopped monitor created by the current session.",
   input: {
@@ -295,13 +425,12 @@ var definition4 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_start", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_start", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_start_default = definition4;
+});
 
 // adapters/opencode/tools/monitor_stop.ts
-var definition5 = {
+var monitor_stop_default = (bridge) => ({
   name: "monitor_stop",
   description: "Stop a monitor created by the current session.",
   input: {
@@ -314,23 +443,26 @@ var definition5 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_stop", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_stop", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_stop_default = definition5;
+});
 
 // adapters/opencode/index.ts
 async function setupSourcefed(ctx) {
-  const bridge = new OpenCodeBridge(ctx.session, ctx.rpc);
-  setOpenCodeBridge(bridge);
-  await bridge.start();
-  await ctx.tool.transform((editor) => {
-    editor.add(monitor_create_default);
-    editor.add(monitor_list_default);
-    editor.add(monitor_status_default);
-    editor.add(monitor_start_default);
-    editor.add(monitor_stop_default);
-  });
+  const bridge = new OpenCodeBridge(ctx.session, ctx.rpc, ctx.location);
+  try {
+    await bridge.start();
+    await ctx.tool.transform((editor) => {
+      editor.add(monitor_create_default(bridge));
+      editor.add(monitor_list_default(bridge));
+      editor.add(monitor_status_default(bridge));
+      editor.add(monitor_start_default(bridge));
+      editor.add(monitor_stop_default(bridge));
+    });
+  } catch (error) {
+    await bridge.close();
+    throw error;
+  }
   return () => bridge.close();
 }
 var opencode_default = Plugin.define({
@@ -345,11 +477,16 @@ var server_default = Plugin2.define({
   id: "sourcefed",
   async setup(ctx) {
     const cleanup = await setupSourcefed(ctx);
-    await ctx.session.hook("context", (event) => {
-      if (!event.system.some((part) => part.type === "text" && part.text.includes(heading))) {
-        event.system.push({ type: "text", text: guidance });
-      }
-    });
+    try {
+      await ctx.session.hook("context", (event) => {
+        if (!event.system.some((part) => part.type === "text" && part.text.includes(heading))) {
+          event.system.push({ type: "text", text: guidance });
+        }
+      });
+    } catch (error) {
+      await cleanup?.();
+      throw error;
+    }
     return cleanup;
   }
 });

package/dist/pi.js

@@ -6,7 +6,7 @@ import {
   daemonCommand,
   daemonEnvironment,
   spawnLocalDaemon
-} from "./chunk-X3BZSHKZ.js";
+} from "./chunk-E6J3BAXP.js";
 import "./chunk-MLKGABMK.js";
 
 // adapters/pi/src/index.ts

package/dist.dts/adapters/opencode/bridge.d.ts

@@ -1,34 +1,80 @@
+import { type QueuedMonitorEvent } from "@fdcn/sourcefed/core";
 import { type Plugin } from "@opencode/plugin";
+import { OpenCodeSubscriptions, type SessionLocation } from "./subscriptions.js";
 type SessionDomain = Plugin.Context["session"];
-type RpcDomain = Plugin.Context["rpc"];
+type RpcDomain = (definition: typeof ChauffeurGate) => {
+    gate(input: unknown, options: {
+        signal: AbortSignal;
+    }): Promise<unknown>;
+};
+/**
+ * Chauffeur's gate, declared here so sourcefed does not depend on Chauffeur.
+ * When the Chauffeur plugin runs in this OpenCode process, it decides which
+ * events reach the session; otherwise every event is delivered.
+ */
+declare const ChauffeurGate: {
+    readonly id: "chauffeur";
+    readonly methods: {
+        readonly gate: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly sessionID: {
+                        readonly type: "string";
+                    };
+                    readonly monitorID: {
+                        readonly type: "string";
+                    };
+                    readonly source: {
+                        readonly type: "string";
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                    };
+                    readonly summary: {
+                        readonly type: "string";
+                    };
+                    readonly body: {
+                        readonly type: "string";
+                    };
+                    readonly actionable: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["sessionID", "source", "kind", "summary", "actionable"];
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly deliver: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["deliver"];
+            };
+        };
+    };
+    readonly events: {};
+};
 export declare class OpenCodeBridge {
     private readonly session;
-    private readonly rpc?;
-    private daemon?;
-    private readonly listeners;
-    private lastAttemptAt;
-    private lastError;
-    private timer;
-    constructor(session: SessionDomain, rpc?: RpcDomain | undefined);
+    private readonly rpc;
+    readonly location: SessionLocation;
+    private readonly hub;
+    private started;
+    private closed;
+    private closing;
+    constructor(session: Pick<SessionDomain, "get" | "synthetic">, rpc: RpcDomain | undefined, location: SessionLocation, hub?: OpenCodeSubscriptions);
     /**
      * Chauffeur or the CLI can create a monitor for a session here at any time,
      * without this bridge's tools, so check for new targets periodically too.
      */
     start(): Promise<void>;
-    ensureTarget(sessionID: string): Promise<void>;
     callTool(name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<unknown>;
     close(): Promise<void>;
-    private refresh;
-    private ensureDaemon;
-    /**
-     * Monitors outlive this process, so after a restart nothing listens for their
-     * sessions until something subscribes. Subscribe every session that has an
-     * enabled monitor and still exists here; a deleted session is skipped, since
-     * delivering to it would fail and retry forever.
-     */
-    private resubscribe;
-    private resubscribeTarget;
-    private routeEvents;
+    refresh(): Promise<void>;
+    getSession(sessionID: string, signal: AbortSignal): Promise<import("@opencode/client").SessionInfo>;
+    routeEvents(events: QueuedMonitorEvent[]): Promise<void>;
     /**
      * Ask Chauffeur's gate, when it runs in this process. Only an explicit
      * `deliver: false` withholds the event; no gate, an error, or a slow answer
@@ -37,6 +83,4 @@ export declare class OpenCodeBridge {
     private admitted;
     private target;
 }
-export declare function setOpenCodeBridge(bridge: OpenCodeBridge): void;
-export declare function getOpenCodeBridge(): OpenCodeBridge;
 export {};

package/dist.dts/adapters/opencode/subscriptions.d.ts

@@ -0,0 +1,46 @@
+import type { QueuedMonitorEvent } from "@fdcn/sourcefed/core";
+import type { DaemonClient } from "@fdcn/sourcefed/daemon";
+export type SessionLocation = {
+    directory: string;
+    project: {
+        id: string;
+    };
+};
+type SessionInfo = {
+    projectID: string;
+    location: {
+        directory: string;
+    };
+};
+export interface SubscriptionOwner {
+    readonly location: SessionLocation;
+    getSession(sessionID: string, signal: AbortSignal): Promise<SessionInfo>;
+    routeEvents(events: QueuedMonitorEvent[]): Promise<void>;
+}
+/** One client, timer and stream per enabled session, shared by all plugin locations. */
+export declare class OpenCodeSubscriptions {
+    private readonly connect;
+    private readonly owners;
+    private readonly subscriptions;
+    private readonly lifetime;
+    private daemon;
+    private connecting;
+    private refreshing;
+    private dirty;
+    private lastAttemptAt;
+    private timer;
+    constructor(connect: () => Promise<DaemonClient>);
+    get closed(): boolean;
+    add(owner: SubscriptionOwner): Promise<void>;
+    remove(owner: SubscriptionOwner): Promise<void>;
+    request(method: string, params: Record<string, unknown>): Promise<unknown>;
+    refresh(): Promise<void>;
+    private refreshLoop;
+    private ensureDaemon;
+    private reconcile;
+    private ownerFor;
+    private subscribe;
+    private route;
+    private closeSubscription;
+}
+export {};

package/dist.dts/adapters/opencode/tool-result.d.ts

@@ -1 +1,2 @@
-export declare function callMonitorTool(name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<string>;
+import type { OpenCodeBridge } from "./bridge.js";
+export declare function callMonitorTool(bridge: OpenCodeBridge, name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<string>;

package/dist.dts/adapters/opencode/tools/monitor_create.d.ts

@@ -1,5 +1,6 @@
 import type { ToolContext } from "@opencode/plugin/promise/tool";
-declare const definition: {
+import type { OpenCodeBridge } from "../bridge.js";
+declare const _default: (bridge: OpenCodeBridge) => {
     name: string;
     description: string;
     input: {
@@ -50,4 +51,4 @@ declare const definition: {
         content: string;
     }>;
 };
-export default definition;
+export default _default;