@fdcn/sourcefed 0.3.5 → 0.3.7

package/dist/cli.js

@@ -11363,36 +11363,10 @@ 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(error2) {
-    for (const { reject } of this.pending.values()) reject(error2);
-    this.pending.clear();
-  }
-};
 function defaultDaemonUrl() {
   const port = process.env.SOURCEFED_DAEMON_PORT ?? 18787;
   return `http://127.0.0.1:${port}`;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 async function withTimeout(promise, ms, message) {
   let timer;
   try {
@@ -11725,164 +11699,225 @@ function parseDaemonFrame(line) {
     return void 0;
   }
 }
+var DaemonEventStream = class {
+  constructor(url2, headers, onEvents, acknowledge, onClose) {
+    this.url = url2;
+    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 (error2) {
+      await this.close();
+      throw error2;
+    }
+  }
+  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 (error2) {
+      console.error(`[sourcefed] closing event stream: ${String(error2)}`);
+    } 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 (error2) {
+        if (!this.controller.signal.aborted && !this.failedDelivery && ++consecutiveFailures === 1) {
+          console.error(`[sourcefed] event stream ended: ${String(error2)}`);
+        }
+      }
+      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(events2) {
+    this.delivering = this.delivering.then(async () => {
+      if (this.failedDelivery || this.controller.signal.aborted) return;
+      try {
+        await this.onEvents(events2);
+        await this.acknowledge(events2, this.controller.signal);
+      } catch (error2) {
+        if (!this.controller.signal.aborted) console.error(`[sourcefed] event delivery failed: ${String(error2)}`);
+        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 url2 = options.url ?? process.env.SOURCEFED_DAEMON_URL ?? defaultDaemonUrl();
   return new HttpDaemonClient(url2, 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,
+      (events2, signal) => this.acknowledge(target, events2, 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 (error2) {
-      this.router.settle(id, { error: error2 instanceof Error ? error2.message : String(error2) });
+      await stream.close();
+      throw error2;
     }
-    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 url2 = `${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 = (events2) => {
-      if (!callbacks?.has(onEvents) || events2.length === 0) return Promise.resolve();
-      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 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;
-        } 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)}`);
-          }
-          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, events2, signal) {
+    let attempt = 0;
+    while (!signal.aborted) {
       try {
-        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();
-        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: events2.map((event) => event.id) }, signal);
+        return;
       } catch (error2) {
-        if (!controller.signal.aborted && !retryStream) {
-          consecutiveFailures += 1;
-          if (consecutiveFailures === 1) {
-            console.error(`[sourcefed] event stream ended: ${error2 instanceof Error ? error2.message : String(error2)}`);
-          }
+        if (++attempt === 3) {
+          console.error(`[sourcefed] event acknowledgement still failing; retrying without repeating delivery: ${String(error2)}`);
         }
-      } 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 ${url2}`);
-    } catch (error2) {
-      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 error2;
     }
-    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) {
@@ -22324,7 +22359,7 @@ var REQUEST_STATE_ONLY_LEG_PACING_MS = 250;
 function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
-function sleep2(ms, signal) {
+function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal.reason)));
@@ -31059,7 +31094,7 @@ var LegacyInputRequiredShim = class {
         } finally {
           roundAbort.dispose();
         }
-      } else await sleep2(REQUEST_STATE_ONLY_LEG_PACING_MS, outerSignal);
+      } else await sleep(REQUEST_STATE_ONLY_LEG_PACING_MS, outerSignal);
       let ctxNext = {
         ...ctx,
         mcpReq: {
@@ -44192,9 +44227,7 @@ async function runMonitor(argv) {
 
 // packages/cli/src/utils/setup.ts
 import { execFile } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import os8 from "node:os";
-import path8 from "node:path";
+import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 function setupSpec() {
   const manifest = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
@@ -44211,59 +44244,19 @@ async function setupHost(name, args, spec) {
     const code = error2 && typeof error2 === "object" && "code" in error2 ? String(error2.code) : "";
     if (code === "ENOENT") {
       console.error(`[sourcefed] ${name} is not on PATH \u2014 install it manually:`);
-      console.error(name === "opencode" ? `  add "${spec}" to the plugins array in ~/.config/opencode/opencode.jsonc and cli.json` : `  run: pi install ${spec}`);
+      console.error(name === "opencode" ? `  add "${spec}" to the plugins array in ~/.config/opencode/opencode.jsonc` : `  run: pi install ${spec}`);
       return false;
     }
     throw error2;
   }
 }
-function configureOpenCodeCliPlugin(spec) {
-  const file = openCodeCliConfigPath();
-  const config2 = readOpenCodeCliConfig(file);
-  const plugins = config2.plugins;
-  if (plugins === void 0) {
-    config2.plugins = [spec];
-  } else if (!Array.isArray(plugins)) {
-    throw new Error(`OpenCode CLI config has a non-array plugins setting: ${file}`);
-  } else if (!plugins.some((plugin) => isPluginEntry(plugin, spec))) {
-    config2.plugins = [...plugins, spec];
-  } else {
-    return;
-  }
-  mkdirSync(path8.dirname(file), { recursive: true });
-  writeFileSync(file, `${JSON.stringify(config2, null, 2)}
-`);
-}
-function openCodeCliConfigPath() {
-  const configHome = process.env.XDG_CONFIG_HOME ?? path8.join(os8.homedir(), ".config");
-  return path8.join(configHome, "opencode", "cli.json");
-}
-function readOpenCodeCliConfig(file) {
-  try {
-    const value = JSON.parse(readFileSync(file, "utf8"));
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`OpenCode CLI config must contain a JSON object: ${file}`);
-    }
-    return value;
-  } catch (error2) {
-    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") return {};
-    if (error2 instanceof SyntaxError) throw new Error(`OpenCode CLI config is not valid JSON: ${file}`);
-    throw error2;
-  }
-}
-function isPluginEntry(value, spec) {
-  if (value === spec) return true;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  return "package" in value && value.package === spec;
-}
 
 // packages/cli/src/commands/setup.ts
 async function runSetup(args) {
   const spec = setupSpec();
   const requested = args[0] ?? "all";
   if (requested === "opencode" || requested === "all") {
-    const installed = await setupHost("opencode", ["plugin", "add", spec], spec);
-    if (installed) configureOpenCodeCliPlugin(spec);
+    await setupHost("opencode", ["plugin", "add", spec], spec);
   }
   if (requested === "pi" || requested === "all") {
     await setupHost("pi", ["install", `npm:${spec}`], `npm:${spec}`);
@@ -44272,12 +44265,12 @@ async function runSetup(args) {
 
 // packages/cli/src/skills/command.ts
 import { readFile as readFile7, readdir as readdir2, stat as stat2 } from "node:fs/promises";
-import path10 from "node:path";
+import path9 from "node:path";
 
 // packages/cli/src/skills/discovery.ts
 import { statSync } from "node:fs";
 import { readdir, readFile as readFile6, stat } from "node:fs/promises";
-import path9 from "node:path";
+import path8 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/cli/src/skills/frontmatter.ts
@@ -44325,7 +44318,7 @@ async function skillsDirs() {
   }
   const directories = [];
   for (const name of SKILL_DIRS) {
-    const candidate = path9.join(skillRoot(), name);
+    const candidate = path8.join(skillRoot(), name);
     try {
       if ((await stat(candidate)).isDirectory()) directories.push(candidate);
     } catch {
@@ -44337,7 +44330,7 @@ async function discoverSkills() {
   const skills = [];
   for (const dir of await skillsDirs()) {
     for (const entry of await readdir(dir)) {
-      const skillDir = path9.join(dir, entry);
+      const skillDir = path8.join(dir, entry);
       let entryStat;
       try {
         entryStat = await stat(skillDir);
@@ -44345,7 +44338,7 @@ async function discoverSkills() {
         continue;
       }
       if (!entryStat.isDirectory()) continue;
-      const skillFile = path9.join(skillDir, "SKILL.md");
+      const skillFile = path8.join(skillDir, "SKILL.md");
       try {
         const content = await readFile6(skillFile, "utf8");
         const parsed = parseFrontmatter(content);
@@ -44358,15 +44351,15 @@ async function discoverSkills() {
   return skills;
 }
 function skillRoot() {
-  let dir = path9.dirname(fileURLToPath2(import.meta.url));
+  let dir = path8.dirname(fileURLToPath2(import.meta.url));
   for (let depth = 0; depth < 6; depth++) {
-    const marker = path9.join(dir, "data");
+    const marker = path8.join(dir, "data");
     if (statSync(marker, { throwIfNoEntry: false })?.isDirectory()) return dir;
-    const parent = path9.dirname(dir);
+    const parent = path8.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path9.dirname(fileURLToPath2(import.meta.url));
+  return path8.dirname(fileURLToPath2(import.meta.url));
 }
 
 // packages/cli/src/skills/command.ts
@@ -44413,7 +44406,7 @@ async function runGet(args) {
     output += `# ${skill.name}
 
 `;
-    output += await readFile7(path10.join(skill.dir, "SKILL.md"), "utf8");
+    output += await readFile7(path9.join(skill.dir, "SKILL.md"), "utf8");
     output += "\n";
     if (full) output += await supplementaryFiles(skill.dir);
   }
@@ -44436,7 +44429,7 @@ async function runPath(name) {
 async function supplementaryFiles(skillDir) {
   let output = "";
   for (const subdirName of ["references", "templates"]) {
-    const subdir = path10.join(skillDir, subdirName);
+    const subdir = path9.join(skillDir, subdirName);
     try {
       if (!(await stat2(subdir)).isDirectory()) continue;
     } catch {
@@ -44444,7 +44437,7 @@ async function supplementaryFiles(skillDir) {
     }
     const entries = (await readdir2(subdir)).sort();
     for (const entry of entries) {
-      const filePath = path10.join(subdir, entry);
+      const filePath = path9.join(subdir, entry);
       try {
         if (!(await stat2(filePath)).isFile()) continue;
       } catch {