kojee-mcp 0.4.0 → 0.5.2

package/dist/stop-hook-SEPWWETV.js

@@ -0,0 +1,119 @@
+import {
+  readHookStdin
+} from "./chunk-LSUB6QMP.js";
+import {
+  deriveDiscoveryKey,
+  findClaudeAncestorPid
+} from "./chunk-BJMASMKX.js";
+import {
+  buildMonitorNudge
+} from "./chunk-C6GZ2L2W.js";
+import {
+  monitorHeartbeatPath,
+  nudgeSentinelPath
+} from "./chunk-2TUAFAIW.js";
+import {
+  readSessionDiscoveryByKey
+} from "./chunk-DO42NPNR.js";
+import "./chunk-BLEGIR35.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-BYKO4DW6.js

@@ -0,0 +1,162 @@
+import {
+  createAdaptiveWatchdog
+} from "./chunk-WBMX4CHB.js";
+import {
+  STATUS_LINE_PREFIX,
+  monitorHeartbeatPath,
+  statusLogPath
+} from "./chunk-2TUAFAIW.js";
+import "./chunk-DO42NPNR.js";
+import "./chunk-BLEGIR35.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
+};

package/dist/{user-prompt-submit-hook-WSRIJVF4.js → user-prompt-submit-hook-ARPEO6FF.js}

@@ -1,18 +1,19 @@
 import {
   readHookStdin
-} from "./chunk-WHTH6WBP.js";
+} from "./chunk-LSUB6QMP.js";
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
-} from "./chunk-36DMIXH7.js";
+} from "./chunk-BJMASMKX.js";
 import {
   readSessionDiscoveryByKey
-} from "./chunk-VZVGTHGF.js";
+} from "./chunk-DO42NPNR.js";
+import "./chunk-BLEGIR35.js";
 
 // src/hooks/user-prompt-submit-hook.ts
 async function runUserPromptSubmitHook() {
   await readHookStdin();
-  const ccPid = findClaudeAncestorPid();
+  const ccPid = await findClaudeAncestorPid();
   const key = deriveDiscoveryKey(process.env["CLAUDE_PROJECT_DIR"], ccPid);
   const discovery = readSessionDiscoveryByKey(key);
   if (!discovery) {

package/dist/webhook-config-5TLLX7RA.js

@@ -0,0 +1,10 @@
+import {
+  WEBHOOK_DEFAULT_MAX_RETRIES,
+  WEBHOOK_DEFAULT_TIMEOUT_MS,
+  resolveWebhookConfig
+} from "./chunk-F7L25L2J.js";
+export {
+  WEBHOOK_DEFAULT_MAX_RETRIES,
+  WEBHOOK_DEFAULT_TIMEOUT_MS,
+  resolveWebhookConfig
+};

package/dist/webhook-sink-7OYZBWXA.js

@@ -0,0 +1,163 @@
+// src/tandem/webhook-sink.ts
+import crypto from "crypto";
+import { ulid } from "ulidx";
+var DEFAULT_MAX_QUEUE = 1e3;
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_CEILING_MS = 3e4;
+function computeWebhookSignature(secret, rawBody) {
+  return crypto.createHmac("sha256", secret).update(Buffer.from(rawBody, "utf8")).digest("hex");
+}
+function defaultBackoffMs(attempt) {
+  const exp = Math.min(BACKOFF_BASE_MS * 2 ** attempt, BACKOFF_CEILING_MS);
+  return Math.random() * exp;
+}
+function classifyStatus(status) {
+  if (status >= 200 && status < 300) return "success";
+  if (status === 408 || status === 429) return "retry";
+  if (status >= 500) return "retry";
+  return "permanent";
+}
+function sleep(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((r) => setTimeout(r, ms));
+}
+function createWebhookSink(config, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const maxQueue = options.maxQueue ?? DEFAULT_MAX_QUEUE;
+  const backoffMs = options.backoffMs ?? defaultBackoffMs;
+  const log = options.log ?? ((line) => console.error(`[webhook] ${line}`));
+  const queue = [];
+  let inFlight = false;
+  let stopped = false;
+  let draining = false;
+  const stats = {
+    delivered: 0,
+    dropped: 0,
+    overflowDropped: 0,
+    queueDepth: 0,
+    lastOutcome: "none",
+    lastAttemptAt: null
+  };
+  let idleResolvers = [];
+  function maybeResolveIdle() {
+    if (queue.length === 0 && !inFlight) {
+      const r = idleResolvers;
+      idleResolvers = [];
+      for (const fn of r) fn();
+    }
+  }
+  function currentDepth() {
+    return queue.length + (inFlight ? 1 : 0);
+  }
+  function prepare(event) {
+    const body = JSON.stringify(event);
+    const signature = computeWebhookSignature(config.secret, body);
+    const deliveryId = event.id || ulid();
+    return { event, body, signature, deliveryId };
+  }
+  async function attempt(item) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), config.timeoutMs);
+    try {
+      const res = await fetchImpl(config.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          // hex SHA-256 HMAC of the RAW body bytes — the receiver re-verifies.
+          "X-Kojee-Signature": item.signature,
+          "X-Kojee-Delivery": item.deliveryId
+        },
+        body: item.body,
+        signal: controller.signal
+      });
+      return classifyStatus(res.status);
+    } catch {
+      return "retry";
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async function deliver(item) {
+    for (let n = 0; n <= config.maxRetries; n++) {
+      if (stopped) return;
+      const outcome = await attempt(item);
+      if (outcome === "success") {
+        stats.delivered += 1;
+        stats.lastOutcome = "delivered";
+        stats.lastAttemptAt = Date.now();
+        return;
+      }
+      if (outcome === "permanent") {
+        stats.dropped += 1;
+        stats.lastOutcome = "dropped";
+        stats.lastAttemptAt = Date.now();
+        log(`delivery=${item.deliveryId} dropped: permanent failure (4xx rejection), no retry`);
+        return;
+      }
+      if (n < config.maxRetries) {
+        await sleep(backoffMs(n));
+      }
+    }
+    stats.dropped += 1;
+    stats.lastOutcome = "dropped";
+    stats.lastAttemptAt = Date.now();
+    log(`delivery=${item.deliveryId} dropped: retries exhausted (${config.maxRetries})`);
+  }
+  async function drain() {
+    if (draining) return;
+    draining = true;
+    try {
+      while (queue.length > 0 && !stopped) {
+        const item = queue.shift();
+        inFlight = true;
+        stats.queueDepth = currentDepth();
+        try {
+          await deliver(item);
+        } catch {
+          stats.dropped += 1;
+        } finally {
+          inFlight = false;
+          stats.queueDepth = currentDepth();
+        }
+      }
+    } finally {
+      draining = false;
+      maybeResolveIdle();
+    }
+  }
+  return {
+    enqueue(event) {
+      try {
+        if (stopped) return;
+        if (queue.length >= maxQueue) {
+          stats.overflowDropped += 1;
+          log(`queue overflow (cap=${maxQueue}) \u2014 dropping newest event; receiver will redeliver on replay`);
+          return;
+        }
+        queue.push(prepare(event));
+        stats.queueDepth = currentDepth();
+        void drain();
+      } catch {
+      }
+    },
+    stats() {
+      return { ...stats, queueDepth: currentDepth() };
+    },
+    configSummary() {
+      return config.redactedSummary;
+    },
+    idle() {
+      if (queue.length === 0 && !inFlight) return Promise.resolve();
+      return new Promise((resolve) => idleResolvers.push(resolve));
+    },
+    async stop() {
+      stopped = true;
+      queue.length = 0;
+      maybeResolveIdle();
+    }
+  };
+}
+export {
+  computeWebhookSignature,
+  createWebhookSink
+};