@ziamana/bruine 0.1.0

package/dist/plugins/herdr.js

@@ -0,0 +1,470 @@
+// src/compat.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function appEnv(suffix, env = process.env) {
+  return env[`BRUINE_${suffix}`] ?? env[`KUMO_${suffix}`];
+}
+
+// src/plugins/herdr.ts
+import net from "net";
+var name = "bruine-herdr";
+var REQUEST_TIMEOUT_MS = 500;
+function readHerdrEnv(env = process.env) {
+  try {
+    if (env.HERDR_ENV !== "1") return void 0;
+    const socketPath = env.HERDR_SOCKET_PATH;
+    const paneId = env.HERDR_PANE_ID;
+    if (socketPath === void 0 || socketPath === "" || paneId === void 0 || paneId === "") {
+      return void 0;
+    }
+    return { socketPath, paneId };
+  } catch {
+    return void 0;
+  }
+}
+function endpointFor(socketPath, platform = process.platform) {
+  return platform === "win32" ? `\\\\.\\pipe\\${socketPath}` : socketPath;
+}
+function netConnect(endpoint, line, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let socket;
+    try {
+      socket = net.createConnection({ path: endpoint });
+    } catch (err) {
+      reject(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      reject(new Error("herdr: request timed out"));
+    }, timeoutMs);
+    if (typeof timer.unref === "function") timer.unref();
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    let buf = "";
+    socket.on("connect", () => {
+      try {
+        socket.write(`${line}
+`);
+      } catch (err) {
+        finish(() => reject(err instanceof Error ? err : new Error(String(err))));
+      }
+    });
+    socket.on("data", (chunk) => {
+      buf += chunk.toString("utf8");
+      const nl = buf.indexOf("\n");
+      if (nl >= 0) {
+        const reply = buf.slice(0, nl);
+        finish(() => {
+          try {
+            socket.destroy();
+          } catch {
+          }
+          resolve(reply);
+        });
+      }
+    });
+    socket.on("error", (err) => {
+      finish(() => {
+        try {
+          socket.destroy();
+        } catch {
+        }
+        reject(err);
+      });
+    });
+    socket.on("close", () => {
+      finish(() => reject(new Error("herdr: connection closed")));
+    });
+  });
+}
+function randomSuffix() {
+  try {
+    const s = Math.random().toString(36).slice(2, 10);
+    return s === "" ? "0" : s;
+  } catch {
+    return "0";
+  }
+}
+var HerdrReporter = class {
+  paneId;
+  endpoint;
+  #sessionId;
+  #connect;
+  #timeoutMs;
+  #seq;
+  #tail = Promise.resolve();
+  constructor(opts) {
+    this.paneId = opts.paneId;
+    this.endpoint = opts.endpoint;
+    this.#sessionId = opts.sessionId;
+    this.#timeoutMs = opts.timeoutMs ?? REQUEST_TIMEOUT_MS;
+    const timeoutMs = this.#timeoutMs;
+    this.#connect = opts.connect ?? ((endpoint, line) => netConnect(endpoint, line, timeoutMs));
+    this.#seq = Date.now() * 1e3;
+  }
+  currentSession() {
+    try {
+      return this.#sessionId();
+    } catch {
+      return void 0;
+    }
+  }
+  #enqueue(method, params) {
+    const seq = this.#seq;
+    this.#seq += 1;
+    let line;
+    try {
+      line = JSON.stringify({
+        id: `bruine:${String(Date.now())}:${randomSuffix()}`,
+        method,
+        params: { ...params, seq }
+      });
+    } catch {
+      return;
+    }
+    const endpoint = this.endpoint;
+    const connect = this.#connect;
+    const timeoutMs = this.#timeoutMs;
+    this.#tail = this.#tail.then(
+      () => Promise.race([
+        Promise.resolve().then(() => connect(endpoint, line)).then(() => void 0),
+        new Promise((_resolve, reject) => {
+          const t = setTimeout(() => reject(new Error("herdr: request timed out")), timeoutMs);
+          if (typeof t.unref === "function") t.unref();
+        })
+      ]).then(
+        () => void 0,
+        () => void 0
+      )
+    );
+  }
+  /** `pane.report_agent` with the current (or given) session id. */
+  reportState(state, sessionId) {
+    try {
+      const sid = sessionId ?? this.currentSession();
+      if (sid === void 0) return;
+      this.#enqueue("pane.report_agent", {
+        pane_id: this.paneId,
+        source: "bruine",
+        agent: "bruine",
+        state,
+        agent_session_id: sid
+      });
+    } catch {
+    }
+  }
+  /** `pane.report_agent_session` on /new (a new dsh session took over). */
+  reportSession(sessionId) {
+    try {
+      this.#enqueue("pane.report_agent_session", {
+        pane_id: this.paneId,
+        source: "bruine",
+        agent: "bruine",
+        agent_session_id: sessionId,
+        session_start_source: "new"
+      });
+    } catch {
+    }
+  }
+  /** `pane.release_agent` on exit. Fire and forget. */
+  release() {
+    try {
+      this.#enqueue("pane.release_agent", {
+        pane_id: this.paneId,
+        source: "bruine",
+        agent: "bruine"
+      });
+    } catch {
+    }
+  }
+  /**
+   * Enqueue a release after everything before it and wait for the queue,
+   * never longer than the request timeout. Never throws. The exit path.
+   */
+  async close() {
+    this.release();
+    try {
+      await Promise.race([
+        this.#tail,
+        new Promise((resolve) => {
+          const t = setTimeout(resolve, this.#timeoutMs);
+          if (typeof t.unref === "function") t.unref();
+        })
+      ]);
+    } catch {
+    }
+  }
+  /** Settle the queue (tests). Never throws. */
+  async settled(timeoutMs = 1e4) {
+    try {
+      await Promise.race([
+        this.#tail,
+        new Promise((resolve) => {
+          const t = setTimeout(resolve, timeoutMs);
+          if (typeof t.unref === "function") t.unref();
+        })
+      ]);
+    } catch {
+    }
+  }
+};
+function sessionIdOf(agent) {
+  try {
+    const id = agent?.session?.id;
+    return id === void 0 || id === null ? void 0 : String(id);
+  } catch {
+    return void 0;
+  }
+}
+function apply(ctx, opts) {
+  const noop = () => {
+  };
+  let env;
+  try {
+    env = readHerdrEnv();
+  } catch {
+    return noop;
+  }
+  if (env === void 0 || appEnv("HEADLESS") === "1") return noop;
+  const paneId = env.paneId;
+  const endpoint = endpointFor(env.socketPath);
+  let repl;
+  const reporter = new HerdrReporter({
+    paneId,
+    endpoint,
+    sessionId: () => repl === void 0 ? void 0 : sessionIdOf(repl.agent),
+    ...opts?.connect !== void 0 ? { connect: opts.connect } : {}
+  });
+  let lastSessionId;
+  let disposed = false;
+  const offs = [];
+  const liveAgent = () => {
+    try {
+      return repl?.agent;
+    } catch {
+      return void 0;
+    }
+  };
+  const isOurs = (agent) => {
+    try {
+      if (repl === void 0 || agent === void 0) return false;
+      if (agent === liveAgent()) return true;
+      const modes = ctx.get("bruineModes");
+      if (modes !== void 0 && typeof modes.governs === "function") {
+        try {
+          return modes.governs(agent) === true;
+        } catch {
+          return false;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  };
+  const liveAgentSession = () => {
+    try {
+      return liveAgent()?.session;
+    } catch {
+      return void 0;
+    }
+  };
+  try {
+    offs.push(
+      ctx.on("session/event", (session, event) => {
+        try {
+          if (disposed || repl === void 0) return;
+          if (session !== liveAgentSession()) return;
+          const type = event?.type;
+          if (type === "turn/start") {
+            const sid = sessionIdOf(liveAgent());
+            if (sid !== void 0) reporter.reportState("working", sid);
+          } else if (type === "turn/end") {
+            const sid = sessionIdOf(liveAgent());
+            if (sid === void 0) return;
+            reporter.reportState(event?.data?.reason?.kind === "error" ? "blocked" : "idle", sid);
+          }
+        } catch {
+        }
+      })
+    );
+  } catch {
+  }
+  const trackWait = (req, next) => {
+    let ours = false;
+    try {
+      ours = isOurs(req?.agent);
+    } catch {
+      ours = false;
+    }
+    if (!ours) return next();
+    const opened = sessionIdOf(liveAgent());
+    if (opened !== void 0) reporter.reportState("blocked", opened);
+    let result;
+    try {
+      result = next();
+    } catch (err) {
+      const sid2 = sessionIdOf(liveAgent());
+      if (sid2 !== void 0) reporter.reportState("working", sid2);
+      throw err;
+    }
+    if (result !== void 0 && result !== null && typeof result.then === "function") {
+      return result.then(
+        (value) => {
+          const sid2 = sessionIdOf(liveAgent());
+          if (sid2 !== void 0) reporter.reportState("working", sid2);
+          return value;
+        },
+        (err) => {
+          const sid2 = sessionIdOf(liveAgent());
+          if (sid2 !== void 0) reporter.reportState("working", sid2);
+          throw err;
+        }
+      );
+    }
+    const sid = sessionIdOf(liveAgent());
+    if (sid !== void 0) reporter.reportState("working", sid);
+    return result;
+  };
+  try {
+    offs.push(ctx.on("approval/request", trackWait));
+  } catch {
+  }
+  try {
+    offs.push(ctx.on("user-questions/request", trackWait));
+  } catch {
+  }
+  try {
+    ctx.inject(["bruineRepl"], (c) => {
+      try {
+        if (disposed) return;
+        const service = c?.bruineRepl;
+        if (service === void 0 || service === null || service.agent === void 0) return;
+        if (repl === service) return;
+        repl = service;
+        const sid = sessionIdOf(service.agent);
+        lastSessionId = sid;
+        if (sid !== void 0) reporter.reportState("idle", sid);
+        try {
+          let current = service.agent;
+          Object.defineProperty(service, "agent", {
+            configurable: true,
+            enumerable: true,
+            get: () => current,
+            set: (next) => {
+              current = next;
+              try {
+                if (disposed) return;
+                const nid = sessionIdOf(next);
+                if (nid === void 0 || nid === lastSessionId) return;
+                lastSessionId = nid;
+                reporter.reportSession(nid);
+                reporter.reportState("idle", nid);
+              } catch {
+              }
+            }
+          });
+        } catch {
+        }
+      } catch {
+      }
+    });
+  } catch {
+  }
+  let restoreExit;
+  if (opts?.installExitHooks !== false) {
+    try {
+      const origExit = process.exit;
+      let exiting = false;
+      const patched = ((code) => {
+        if (disposed || exiting) return origExit(code);
+        exiting = true;
+        void reporter.close().finally(() => origExit(code));
+      });
+      process.exit = patched;
+      const onBeforeExit = () => {
+        if (!disposed) void reporter.close();
+      };
+      const resignal = (sig) => {
+        void reporter.close().finally(() => {
+          try {
+            process.removeListener("SIGTERM", onSigTerm);
+            process.removeListener("SIGINT", onSigInt);
+          } catch {
+          }
+          try {
+            process.kill(process.pid, sig);
+          } catch {
+          }
+        });
+      };
+      const onSigTerm = () => {
+        if (!disposed) resignal("SIGTERM");
+      };
+      const onSigInt = () => {
+        if (!disposed) resignal("SIGINT");
+      };
+      process.once("beforeExit", onBeforeExit);
+      process.once("SIGTERM", onSigTerm);
+      process.once("SIGINT", onSigInt);
+      restoreExit = () => {
+        try {
+          if (process.exit === patched) process.exit = origExit;
+        } catch {
+        }
+        try {
+          process.removeListener("beforeExit", onBeforeExit);
+        } catch {
+        }
+        try {
+          process.removeListener("SIGTERM", onSigTerm);
+        } catch {
+        }
+        try {
+          process.removeListener("SIGINT", onSigInt);
+        } catch {
+        }
+      };
+    } catch {
+    }
+  }
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    for (const off of offs) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    try {
+      restoreExit?.();
+    } catch {
+    }
+    try {
+      reporter.release();
+    } catch {
+    }
+  };
+}
+export {
+  HerdrReporter,
+  REQUEST_TIMEOUT_MS,
+  apply,
+  endpointFor,
+  name,
+  netConnect,
+  readHerdrEnv
+};