kojee-mcp 0.2.2 → 0.5.0

package/dist/hook-server-QF5JVUHV.js

@@ -0,0 +1,99 @@
+// src/tandem/hook-server.ts
+import { createServer } from "http";
+async function startHookServer(opts) {
+  const server = createServer((req, res) => {
+    handleRequest(req, res, opts).catch((err) => {
+      console.error("[hook-server] error:", err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "internal_error" }));
+      }
+    });
+  });
+  await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+  const addr = server.address();
+  return {
+    port: addr.port,
+    stop: () => new Promise((resolve, reject) => {
+      server.close((err) => err ? reject(err) : resolve());
+    })
+  };
+}
+async function handleRequest(req, res, opts) {
+  const url = new URL(req.url ?? "/", "http://x");
+  if (req.method === "GET" && url.pathname === "/health") {
+    return json(res, 200, { ok: true });
+  }
+  if (req.method === "GET" && url.pathname === "/status") {
+    return respondWithStatus(res, opts);
+  }
+  if (req.method === "GET" && url.pathname === "/poll") {
+    const type = url.searchParams.get("type") ?? "";
+    const timeoutMs = Number.parseInt(url.searchParams.get("timeout_ms") ?? "0", 10);
+    if (type === "user-prompt-submit") {
+      return respondWithEvents(res, opts);
+    }
+    if (type === "stop") {
+      return longPollAndRespond(res, opts, Math.max(0, timeoutMs));
+    }
+    return json(res, 400, { error: "unknown type", detail: "type must be 'stop' or 'user-prompt-submit'" });
+  }
+  return json(res, 404, { error: "not_found", detail: `${req.method} ${url.pathname}` });
+}
+function respondWithEvents(res, opts) {
+  const entries = opts.queue.takeForHook();
+  const events = entries.map((entry) => opts.adapter.formatTandemEvent(entry.event));
+  json(res, 200, { events, count: events.length });
+}
+function respondWithStatus(res, opts) {
+  const now = Date.now();
+  if (!opts.getStreamState) {
+    return json(res, 200, { stream: "unknown", now });
+  }
+  const s = opts.getStreamState();
+  const lastEventAgeMs = s.lastEventAt === null ? null : now - s.lastEventAt;
+  const lastHeartbeatAgeMs = s.lastHeartbeatAt === null ? null : now - s.lastHeartbeatAt;
+  const stale = s.connected && s.staleAfterMs !== null && lastEventAgeMs !== null && lastEventAgeMs >= s.staleAfterMs;
+  json(res, 200, {
+    stream: s.connected ? "connected" : "disconnected",
+    connected: s.connected,
+    connectedSince: s.connectedSince,
+    lastEventAt: s.lastEventAt,
+    lastEventAgeMs,
+    lastHeartbeatAt: s.lastHeartbeatAt,
+    lastHeartbeatAgeMs,
+    reconnectCount: s.reconnectCount,
+    subscribedTandemCount: Object.keys(s.cursors).length,
+    cursors: s.cursors,
+    staleAfterMs: s.staleAfterMs,
+    stale,
+    now
+  });
+}
+async function longPollAndRespond(res, opts, timeoutMs) {
+  const immediate = opts.queue.takeForHook();
+  if (immediate.length > 0) {
+    const events = immediate.map((e) => opts.adapter.formatTandemEvent(e.event));
+    return json(res, 200, { events, count: events.length });
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await sleep(100);
+    const batch = opts.queue.takeForHook();
+    if (batch.length > 0) {
+      const events = batch.map((e) => opts.adapter.formatTandemEvent(e.event));
+      return json(res, 200, { events, count: events.length });
+    }
+  }
+  json(res, 200, { events: [], count: 0 });
+}
+function json(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export {
+  startHookServer
+};

package/dist/index.d.ts

@@ -4,19 +4,6 @@ interface ProxyConfig {
     keystorePath: string;
 }
 
-/**
- * Bootstrap and start the Kojee MCP proxy.
- *
- * Startup sequence:
- * 1. Enroll keypair (or load existing)
- * 2. Derive session ID
- * 3. Create gateway client
- * 4. Discover tools from gateway
- * 5. Start MCP stdio server
- *
- * If step 4 fails with an auth error that looks like a stale keystore,
- * we wipe the keystore and retry once with a fresh enrollment.
- */
 declare function startProxy(config: ProxyConfig): Promise<void>;
 
 export { type ProxyConfig, startProxy };

package/dist/index.js

@@ -1,6 +1,9 @@
 import {
   startProxy
-} from "./chunk-QKAUM3TR.js";
+} from "./chunk-LCFCCWMM.js";
+import "./chunk-QB22PD6T.js";
+import "./chunk-E26AHU6J.js";
+import "./chunk-BJMASMKX.js";
 export {
   startProxy
 };

package/dist/install-D2HIPOMT.js

@@ -0,0 +1,183 @@
+// src/hooks/install.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function discoverInstallTargets() {
+  const home = os.homedir();
+  const targets = [];
+  const cliPath = path.join(home, ".claude.json");
+  const cliHooksPath = path.join(home, ".claude", "settings.json");
+  targets.push({ kind: "cli", path: cliPath, exists: fs.existsSync(cliPath), hooksPath: cliHooksPath });
+  let desktopPath = null;
+  if (process.platform === "darwin") {
+    desktopPath = path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (process.platform === "win32") {
+    const appData = process.env["APPDATA"] ?? path.join(home, "AppData", "Roaming");
+    desktopPath = path.join(appData, "Claude", "claude_desktop_config.json");
+  } else if (process.platform === "linux") {
+    const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? path.join(home, ".config");
+    desktopPath = path.join(xdgConfig, "Claude", "claude_desktop_config.json");
+  }
+  if (desktopPath) {
+    targets.push({ kind: "desktop", path: desktopPath, exists: fs.existsSync(desktopPath) });
+  }
+  return targets;
+}
+var STOP_COMMAND = "npx -y kojee-mcp hook --type=stop";
+var UPS_COMMAND = "npx -y kojee-mcp hook --type=user-prompt-submit";
+var MCP_SERVER_CMD = "npx";
+var MCP_SERVER_ARGS = ["kojee-mcp"];
+var MCP_SERVER_ENV = { KOJEE_RUNTIME: "claude-code" };
+function defaultConfigPath() {
+  return path.join(os.homedir(), ".claude.json");
+}
+function defaultHooksPath() {
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+function deriveHooksPath(configPath) {
+  return path.join(path.dirname(configPath), ".claude", "settings.json");
+}
+function readConfig(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(p, cfg) {
+  const dir = path.dirname(p);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(cfg, null, 2), { mode: 384 });
+  try {
+    fs.chmodSync(p, 384);
+  } catch {
+  }
+}
+function hasKojeeEntry(arr, command) {
+  if (!arr) return false;
+  return arr.some((e) => e.hooks.some((h) => h.command === command));
+}
+function installHookEntry(cfg, event, command) {
+  cfg.hooks ??= {};
+  cfg.hooks[event] ??= [];
+  if (hasKojeeEntry(cfg.hooks[event], command)) return "already-installed";
+  cfg.hooks[event].push({ hooks: [{ type: "command", command }] });
+  return "added";
+}
+function uninstallHookEntries(cfg) {
+  let removed = false;
+  if (!cfg.hooks) return false;
+  for (const event of ["Stop", "UserPromptSubmit"]) {
+    const arr = cfg.hooks[event];
+    if (!arr) continue;
+    const before = arr.length;
+    cfg.hooks[event] = arr.filter(
+      (entry) => !entry.hooks.some((h) => h.command.startsWith("npx -y kojee-mcp hook"))
+    );
+    if (cfg.hooks[event].length !== before) removed = true;
+  }
+  return removed;
+}
+function installHooks(opts = {}) {
+  const p = opts.hooksPath ?? (opts.configPath ? deriveHooksPath(opts.configPath) : defaultHooksPath());
+  const cfg = readConfig(p);
+  const stop = installHookEntry(cfg, "Stop", STOP_COMMAND);
+  const ups = installHookEntry(cfg, "UserPromptSubmit", UPS_COMMAND);
+  writeConfig(p, cfg);
+  return { stop, ups };
+}
+function uninstallHooks(opts = {}) {
+  const p = opts.hooksPath ?? (opts.configPath ? deriveHooksPath(opts.configPath) : defaultHooksPath());
+  const cfg = readConfig(p);
+  const removed = uninstallHookEntries(cfg);
+  writeConfig(p, cfg);
+  return removed;
+}
+function installMcpServer(opts = {}) {
+  const p = opts.configPath ?? defaultConfigPath();
+  const cfg = readConfig(p);
+  cfg.mcpServers ??= {};
+  const existing = cfg.mcpServers["kojee"];
+  if (existing) {
+    const sameCommand = existing.command === MCP_SERVER_CMD;
+    const sameArgs = JSON.stringify(existing.args ?? []) === JSON.stringify(MCP_SERVER_ARGS);
+    const sameEnv = JSON.stringify(existing.env ?? {}) === JSON.stringify(MCP_SERVER_ENV);
+    if (sameCommand && sameArgs && sameEnv) return "already-installed";
+    return "preserved-different";
+  }
+  cfg.mcpServers["kojee"] = {
+    command: MCP_SERVER_CMD,
+    args: [...MCP_SERVER_ARGS],
+    env: { ...MCP_SERVER_ENV }
+  };
+  writeConfig(p, cfg);
+  return "added";
+}
+function uninstallMcpServer(opts = {}) {
+  const p = opts.configPath ?? defaultConfigPath();
+  const cfg = readConfig(p);
+  if (!cfg.mcpServers || !cfg.mcpServers["kojee"]) return false;
+  delete cfg.mcpServers["kojee"];
+  writeConfig(p, cfg);
+  return true;
+}
+function runInit(opts = {}) {
+  const targets = opts.configPath ? [{
+    kind: "cli",
+    path: opts.configPath,
+    exists: true,
+    hooksPath: opts.hooksPath ?? deriveHooksPath(opts.configPath)
+  }] : discoverInstallTargets();
+  const reports = [];
+  for (const t of targets) {
+    if (!t.exists) {
+      reports.push({ kind: t.kind, path: t.path, ...t.hooksPath ? { hooksPath: t.hooksPath } : {}, mcpServer: "not-found" });
+      continue;
+    }
+    const mcpServer = installMcpServer({ configPath: t.path });
+    let stopHook;
+    let upsHook;
+    if (t.kind === "cli") {
+      const hookReport = installHooks({ hooksPath: t.hooksPath ?? deriveHooksPath(t.path) });
+      stopHook = hookReport.stop;
+      upsHook = hookReport.ups;
+    }
+    reports.push({
+      kind: t.kind,
+      path: t.path,
+      ...t.hooksPath ? { hooksPath: t.hooksPath } : {},
+      mcpServer,
+      ...stopHook ? { stopHook } : {},
+      ...upsHook ? { userPromptSubmitHook: upsHook } : {}
+    });
+  }
+  return { targets: reports, configPath: targets[0]?.path };
+}
+function runUninstall(opts = {}) {
+  const targets = opts.configPath ? [{
+    kind: "cli",
+    path: opts.configPath,
+    exists: true,
+    hooksPath: opts.hooksPath ?? deriveHooksPath(opts.configPath)
+  }] : discoverInstallTargets();
+  const reports = [];
+  for (const t of targets) {
+    if (!t.exists) {
+      reports.push({ kind: t.kind, path: t.path, ...t.hooksPath ? { hooksPath: t.hooksPath } : {}, mcpServer: false, hooks: false });
+      continue;
+    }
+    const mcpServer = uninstallMcpServer({ configPath: t.path });
+    const hooks = t.kind === "cli" ? uninstallHooks({ hooksPath: t.hooksPath ?? deriveHooksPath(t.path) }) : false;
+    reports.push({ kind: t.kind, path: t.path, ...t.hooksPath ? { hooksPath: t.hooksPath } : {}, mcpServer, hooks });
+  }
+  return { targets: reports, configPath: targets[0]?.path };
+}
+export {
+  discoverInstallTargets,
+  installHooks,
+  installMcpServer,
+  runInit,
+  runUninstall,
+  uninstallHooks,
+  uninstallMcpServer
+};

package/dist/paired-config-RB4SABOS.js

@@ -0,0 +1,10 @@
+import {
+  loadPairedConfig,
+  pairedConfigPath,
+  savePairedConfig
+} from "./chunk-GBOTBYEP.js";
+export {
+  loadPairedConfig,
+  pairedConfigPath,
+  savePairedConfig
+};

package/dist/resubscribe-SLZNA76S.js

@@ -0,0 +1,59 @@
+// src/tandem/resubscribe.ts
+var DEFAULT_PER_CALL_TIMEOUT_MS = 1e4;
+var DEFAULT_CONCURRENCY = 4;
+var DEFAULT_DEBOUNCE_MS = 3e4;
+async function resubscribeMemberships(opts) {
+  const { gateway, eventLog } = opts;
+  const perCallTimeoutMs = opts.perCallTimeoutMs ?? DEFAULT_PER_CALL_TIMEOUT_MS;
+  const concurrency = Math.max(1, opts.concurrency ?? DEFAULT_CONCURRENCY);
+  const now = opts.now ?? Date.now;
+  const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  if (opts.debounceState && now() - opts.debounceState.lastRunAt < debounceMs) {
+    return 0;
+  }
+  let tandemIds;
+  try {
+    tandemIds = opts.listTandems ? await opts.listTandems() : opts.tandemIds ?? [];
+  } catch (err) {
+    console.error("[resubscribe] re-list failed:", err.message);
+    tandemIds = [];
+  }
+  let touched = 0;
+  async function touchOne(tandemId) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), perCallTimeoutMs);
+    try {
+      const result = await gateway.sendRpc(
+        "tools/call",
+        { name: "tandem_messages", arguments: { tandem_id: tandemId, limit: 1 } },
+        ac.signal
+      );
+      const maybeErr = result;
+      if (!maybeErr.isError) touched += 1;
+    } catch (err) {
+      console.error(
+        `[resubscribe] touch failed for ${tandemId}:`,
+        err.message
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  let next = 0;
+  async function worker() {
+    while (next < tandemIds.length) {
+      const i = next++;
+      await touchOne(tandemIds[i]);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, tandemIds.length) }, () => worker())
+  );
+  if (opts.debounceState) opts.debounceState.lastRunAt = now();
+  await eventLog?.appendStatus(`status=subscribed n=${tandemIds.length} touched=${touched}`).catch(() => {
+  });
+  return touched;
+}
+export {
+  resubscribeMemberships
+};

package/dist/session-discovery-QE5TTAPS.js

@@ -0,0 +1,26 @@
+import {
+  cleanupDiscoveryByKey,
+  cleanupSessionDiscovery,
+  discoveryFileName,
+  discoveryPathForKey,
+  readSessionDiscovery,
+  readSessionDiscoveryByKey,
+  sessionDiscoveryDir,
+  sessionDiscoveryPath,
+  sweepStaleDiscovery,
+  writeDiscoveryByKey,
+  writeSessionDiscovery
+} from "./chunk-W6YRLSD4.js";
+export {
+  cleanupDiscoveryByKey,
+  cleanupSessionDiscovery,
+  discoveryFileName,
+  discoveryPathForKey,
+  readSessionDiscovery,
+  readSessionDiscoveryByKey,
+  sessionDiscoveryDir,
+  sessionDiscoveryPath,
+  sweepStaleDiscovery,
+  writeDiscoveryByKey,
+  writeSessionDiscovery
+};

package/dist/stop-hook-VLQS6QPR.js

@@ -0,0 +1,118 @@
+import {
+  readHookStdin
+} from "./chunk-LSUB6QMP.js";
+import {
+  buildMonitorNudge
+} from "./chunk-E26AHU6J.js";
+import {
+  deriveDiscoveryKey,
+  findClaudeAncestorPid
+} from "./chunk-BJMASMKX.js";
+import {
+  monitorHeartbeatPath,
+  nudgeSentinelPath
+} from "./chunk-VLZADEFC.js";
+import {
+  readSessionDiscoveryByKey
+} from "./chunk-W6YRLSD4.js";
+
+// src/hooks/stop-hook.ts
+import fs from "fs";
+var STOP_POLL_TIMEOUT_MS = Number.parseInt(
+  process.env["KOJEE_STOP_HOOK_TIMEOUT_MS"] ?? "0",
+  10
+);
+var MONITOR_HEARTBEAT_STALE_MS = 5e3;
+var NUDGE_WINDOW_MS = Number.parseInt(
+  process.env["KOJEE_STOP_NUDGE_WINDOW_MS"] ?? "300000",
+  // 5 min
+  10
+);
+async function decideStopHook(deps) {
+  if (deps.stopHookActive) return "{}";
+  if (!deps.discovery) return "{}";
+  const body = await deps.pollEvents().catch(() => null);
+  if (body && body.count > 0) {
+    return JSON.stringify({ decision: "block", reason: formatEvents(body.events) });
+  }
+  const logPath = deps.discovery.eventLogPath;
+  if (logPath && deps.logHasContent(logPath) && !deps.monitorIsLive(logPath)) {
+    if (deps.nudgedRecently(logPath)) return "{}";
+    deps.recordNudge(logPath);
+    return JSON.stringify({ decision: "block", reason: buildMonitorNudge(logPath) });
+  }
+  return "{}";
+}
+function defaultNudgedRecently(logPath) {
+  try {
+    const { mtimeMs } = fs.statSync(nudgeSentinelPath(logPath));
+    return Date.now() - mtimeMs < NUDGE_WINDOW_MS;
+  } catch {
+    return false;
+  }
+}
+function defaultRecordNudge(logPath) {
+  const sentinel = nudgeSentinelPath(logPath);
+  const now = /* @__PURE__ */ new Date();
+  try {
+    fs.utimesSync(sentinel, now, now);
+  } catch {
+    try {
+      fs.writeFileSync(sentinel, "", { mode: 384 });
+    } catch {
+    }
+  }
+}
+async function runStopHook() {
+  const { stopHookActive } = await readHookStdin();
+  const ccPid = await findClaudeAncestorPid();
+  const key = deriveDiscoveryKey(process.env["CLAUDE_PROJECT_DIR"], ccPid);
+  const discovery = readSessionDiscoveryByKey(key);
+  const out = await decideStopHook({
+    stopHookActive,
+    discovery: discovery ? { port: discovery.port, eventLogPath: discovery.eventLogPath } : null,
+    pollEvents: async () => {
+      const res = await fetch(
+        `http://127.0.0.1:${discovery.port}/poll?type=stop&timeout_ms=${STOP_POLL_TIMEOUT_MS}`
+      );
+      if (!res.ok) return { events: [], count: 0 };
+      return await res.json();
+    },
+    logHasContent,
+    monitorIsLive,
+    nudgedRecently: defaultNudgedRecently,
+    recordNudge: defaultRecordNudge
+  });
+  process.stdout.write(out);
+}
+function logHasContent(logPath) {
+  try {
+    return fs.statSync(logPath).size > 0;
+  } catch {
+    return false;
+  }
+}
+function monitorIsLive(logPath) {
+  try {
+    const { mtimeMs } = fs.statSync(monitorHeartbeatPath(logPath));
+    return Date.now() - mtimeMs < MONITOR_HEARTBEAT_STALE_MS;
+  } catch {
+    return false;
+  }
+}
+function formatEvents(events) {
+  const header = `[${events.length} unread Tandem ${events.length === 1 ? "event" : "events"}]
+
+`;
+  const bodies = events.map((evt) => {
+    const attrs = Object.entries(evt.meta).map(([k, v]) => `${k}="${v}"`).join(" ");
+    return `<channel source="kojee-mcp" ${attrs}>
+${evt.content}
+</channel>`;
+  });
+  return header + bodies.join("\n\n");
+}
+export {
+  decideStopHook,
+  runStopHook
+};

package/dist/tail-stream-UZ42UIWO.js

@@ -0,0 +1,161 @@
+import {
+  createAdaptiveWatchdog
+} from "./chunk-QB22PD6T.js";
+import {
+  STATUS_LINE_PREFIX,
+  monitorHeartbeatPath,
+  statusLogPath
+} from "./chunk-VLZADEFC.js";
+import "./chunk-W6YRLSD4.js";
+
+// src/tail-stream.ts
+import fs from "fs";
+var STATUS_LINE_RE = new RegExp(`^\\[[^\\]]*\\] ${STATUS_LINE_PREFIX} (.*)$`);
+var HEARTBEAT_FIELDS_RE = /(^|\s)status=heartbeat(\s|$)/;
+var HEARTBEAT_STALE_FLOOR_MS = envInt("KOJEE_TAIL_STALE_MS", 12e4);
+var STALE_CHECK_INTERVAL_MS = envInt("KOJEE_TAIL_CHECK_MS", 5e3);
+function envInt(name, fallback) {
+  const v = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+async function runTail(messagesPath) {
+  const statusPath = statusLogPath(messagesPath);
+  let lastLifeAt = Date.now();
+  const watchdog = createAdaptiveWatchdog({ floorMs: HEARTBEAT_STALE_FLOOR_MS });
+  let staleAnnounced = false;
+  const heartbeatPath = monitorHeartbeatPath(messagesPath);
+  const touchHeartbeat = () => {
+    const now = /* @__PURE__ */ new Date();
+    try {
+      fs.utimesSync(heartbeatPath, now, now);
+    } catch {
+      try {
+        fs.writeFileSync(heartbeatPath, "", { mode: 384 });
+      } catch {
+      }
+    }
+  };
+  function onMessageLine(line) {
+    lastLifeAt = Date.now();
+    if (staleAnnounced) {
+      staleAnnounced = false;
+      process.stdout.write("[kojee] stream recovered \u2014 events flowing again.\n");
+    }
+    process.stdout.write(line + "\n");
+  }
+  function onStatusLine(line) {
+    const now = Date.now();
+    const m = STATUS_LINE_RE.exec(line);
+    const fields = m ? m[1] ?? "" : "";
+    if (HEARTBEAT_FIELDS_RE.test(fields)) {
+      watchdog.onHeartbeat(now);
+    }
+    lastLifeAt = now;
+    if (staleAnnounced) {
+      staleAnnounced = false;
+      process.stdout.write("[kojee] stream recovered \u2014 heartbeats resumed.\n");
+    }
+  }
+  const followers = [
+    makeFollower(messagesPath, onMessageLine, touchHeartbeat),
+    makeFollower(statusPath, onStatusLine, touchHeartbeat)
+  ];
+  void Promise.all(followers.map((f) => f.start()));
+  const staleTimer = setInterval(() => {
+    if (staleAnnounced) return;
+    const now = Date.now();
+    if (!watchdog.shouldAbort(lastLifeAt, now)) return;
+    staleAnnounced = true;
+    const silentMs = now - lastLifeAt;
+    process.stdout.write(
+      `[kojee] WARNING: no events or heartbeat for ${Math.round(silentMs / 1e3)}s (learned cadence) \u2014 stream may be dead; run \`npx kojee-mcp doctor\`.
+`
+    );
+  }, STALE_CHECK_INTERVAL_MS);
+  await new Promise((resolve) => {
+    const cleanup = () => {
+      clearInterval(staleTimer);
+      for (const f of followers) f.stop();
+      try {
+        fs.unlinkSync(heartbeatPath);
+      } catch {
+      }
+      resolve();
+    };
+    process.on("SIGTERM", cleanup);
+    process.on("SIGINT", cleanup);
+  });
+}
+function makeFollower(filePath, onLine, onActivity) {
+  let buffer = "";
+  let offset = 0;
+  let watcher = null;
+  let pollTimer = null;
+  let stopped = false;
+  async function _drain() {
+    let stat;
+    try {
+      stat = await fs.promises.stat(filePath);
+    } catch {
+      return;
+    }
+    if (stat.size < offset) {
+      buffer = "";
+      offset = 0;
+    }
+    if (stat.size === offset) return;
+    const fh = await fs.promises.open(filePath, "r");
+    try {
+      const len = stat.size - offset;
+      const buf = Buffer.alloc(len);
+      await fh.read(buf, 0, len, offset);
+      buffer += buf.toString("utf8");
+      offset = stat.size;
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        onLine(line);
+      }
+    } finally {
+      await fh.close();
+    }
+  }
+  let draining = Promise.resolve();
+  const scheduleDrain = () => {
+    draining = draining.then(_drain, _drain);
+    return draining;
+  };
+  return {
+    async start() {
+      while (!stopped && !fs.existsSync(filePath)) {
+        await sleep(250);
+      }
+      if (stopped) return;
+      onActivity();
+      await scheduleDrain();
+      watcher = fs.watch(filePath, { persistent: true });
+      watcher.on("change", () => {
+        onActivity();
+        void scheduleDrain();
+      });
+      watcher.on("error", () => {
+      });
+      pollTimer = setInterval(() => {
+        onActivity();
+        void scheduleDrain();
+      }, 1e3);
+    },
+    stop() {
+      stopped = true;
+      if (pollTimer) clearInterval(pollTimer);
+      if (watcher) watcher.close();
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export {
+  runTail
+};