kojee-mcp 0.4.0 → 0.5.0

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
+};

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

@@ -1,18 +1,18 @@
 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-W6YRLSD4.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/package.json

@@ -1,11 +1,12 @@
 {
   "name": "kojee-mcp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
     "kojee-mcp": "dist/cli.js"
   },
+  "_buildNote": "src/version.ts resolves package.json via '../package.json' from import.meta.url; this assumes dist output stays flat one level under the package root (tsup default outDir=dist, no nesting). If the build adds outDir nesting or a deeper entry, update version.ts's relative path.",
   "scripts": {
     "build": "tsup src/cli.ts src/index.ts --format esm --dts --clean",
     "dev": "tsup src/cli.ts --format esm --watch",
@@ -19,16 +20,17 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
-    "jose": "^5.0.0",
     "commander": "^12.0.0",
-    "zod": "^3.22.0",
-    "ulidx": "^2.3.0"
+    "jose": "^5.0.0",
+    "ps-list": "^8.1.1",
+    "ulidx": "^2.3.0",
+    "zod": "^3.22.0"
   },
   "devDependencies": {
-    "typescript": "^5.4.0",
     "@types/node": "^20.0.0",
     "tsup": "^8.0.0",
-    "vitest": "^1.0.0",
-    "tsx": "^4.7.0"
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.0.0"
   }
 }

package/dist/event-log-ETWR6PPY.js

@@ -1,112 +0,0 @@
-import {
-  sessionDiscoveryDir
-} from "./chunk-VZVGTHGF.js";
-
-// src/tandem/event-log.ts
-import fs from "fs";
-import path from "path";
-var DEFAULT_DIR = "/tmp";
-var MAX_BODY_CHARS = 200;
-var DEFAULT_MIN_AGE_MS = 6e4;
-function startEventLog(opts) {
-  const dir = opts.dir ?? DEFAULT_DIR;
-  const filePath = path.join(dir, `kojee-events-${opts.key}.log`);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(filePath, "", { mode: 384 });
-  try {
-    fs.chmodSync(filePath, 384);
-  } catch {
-  }
-  return {
-    path: filePath,
-    async append(event) {
-      const line = formatLine(event);
-      try {
-        await fs.promises.appendFile(filePath, line + "\n", { encoding: "utf8" });
-      } catch (err) {
-        console.error("[event-log] append failed:", err.message);
-      }
-    },
-    cleanup() {
-      try {
-        fs.unlinkSync(filePath);
-      } catch {
-      }
-    }
-  };
-}
-function formatLine(event) {
-  const body = (event.content?.body ?? "").replace(/[\r\n]+/g, " ").slice(0, MAX_BODY_CHARS + 1);
-  const truncated = body.length > MAX_BODY_CHARS;
-  const safeBody = truncated ? body.slice(0, MAX_BODY_CHARS) + "\u2026" : body;
-  return `[${event.time}] tandem=${event.tandem_id} from=${event.from.displayname} (${event.from.principal}) kind=${event.kind} cursor=${event.cursor}: ${safeBody}`;
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    if (err.code === "EPERM") return true;
-    return false;
-  }
-}
-function listActiveSessionIds() {
-  const dir = sessionDiscoveryDir();
-  const active = /* @__PURE__ */ new Set();
-  let entries;
-  try {
-    entries = fs.readdirSync(dir);
-  } catch {
-    return active;
-  }
-  for (const name of entries) {
-    if (!name.endsWith(".json")) continue;
-    const rawId = name.slice(0, -".json".length);
-    const sessionId = rawId.startsWith("cc-") ? rawId.slice("cc-".length) : rawId;
-    const filePath = path.join(dir, name);
-    try {
-      const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
-      if (typeof data.pid === "number" && isProcessAlive(data.pid)) {
-        active.add(sessionId);
-      } else {
-        try {
-          fs.unlinkSync(filePath);
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return active;
-}
-function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
-  try {
-    fs.unlinkSync(path.join(dir, "kojee-events-no-session.log"));
-  } catch {
-  }
-  const active = listActiveSessionIds();
-  let entries;
-  try {
-    entries = fs.readdirSync(dir);
-  } catch {
-    return;
-  }
-  const now = Date.now();
-  for (const name of entries) {
-    if (!name.startsWith("kojee-events-") || !name.endsWith(".log")) continue;
-    const sessionId = name.slice("kojee-events-".length, -".log".length);
-    if (active.has(sessionId)) continue;
-    const filePath = path.join(dir, name);
-    try {
-      const stat = fs.statSync(filePath);
-      const ageMs = Math.max(0, now - stat.mtimeMs);
-      if (ageMs < minAgeMs) continue;
-      fs.unlinkSync(filePath);
-    } catch {
-    }
-  }
-}
-export {
-  startEventLog,
-  sweepStaleEventLogs
-};

package/dist/stop-hook-5XU3EQAE.js

@@ -1,76 +0,0 @@
-import {
-  readHookStdin
-} from "./chunk-WHTH6WBP.js";
-import {
-  deriveDiscoveryKey,
-  findClaudeAncestorPid
-} from "./chunk-36DMIXH7.js";
-import {
-  readSessionDiscoveryByKey
-} from "./chunk-VZVGTHGF.js";
-
-// src/hooks/stop-hook.ts
-import { spawn } from "child_process";
-import fs from "fs";
-async function isMonitorRunning(logPath) {
-  return new Promise((resolve) => {
-    const child = spawn("pgrep", ["-f", `tail -n \\+1 -F ${logPath}`], { stdio: "ignore" });
-    child.on("exit", (code) => resolve(code === 0));
-    child.on("error", () => resolve(false));
-  });
-}
-var STOP_POLL_TIMEOUT_MS = Number.parseInt(
-  process.env["KOJEE_STOP_HOOK_TIMEOUT_MS"] ?? "30000",
-  10
-);
-async function runStopHook() {
-  await readHookStdin();
-  const ccPid = findClaudeAncestorPid();
-  const key = deriveDiscoveryKey(process.env["CLAUDE_PROJECT_DIR"], ccPid);
-  const discovery = readSessionDiscoveryByKey(key);
-  if (!discovery) {
-    process.stdout.write("{}");
-    return;
-  }
-  const logPath = `/tmp/kojee-events-${key}.log`;
-  const monitorAlive = await isMonitorRunning(logPath);
-  const pollTimeoutMs = monitorAlive ? 0 : STOP_POLL_TIMEOUT_MS;
-  let body = null;
-  try {
-    const res = await fetch(
-      `http://127.0.0.1:${discovery.port}/poll?type=stop&timeout_ms=${pollTimeoutMs}`
-    );
-    if (res.ok) {
-      body = await res.json();
-    }
-  } catch {
-  }
-  if (body && body.count > 0) {
-    const reason = formatEvents(body.events);
-    process.stdout.write(JSON.stringify({ decision: "block", reason }));
-    return;
-  }
-  if (!monitorAlive && fs.existsSync(logPath)) {
-    process.stdout.write(JSON.stringify({
-      decision: "block",
-      reason: `Before stopping, spawn the kojee Tandem event watcher: Monitor(command="tail -n +1 -F ${logPath}", persistent=true, description="kojee Tandem events"). This is needed so Tandem peer messages can wake you from idle. After spawning it once at the start of the session, you don't need to spawn it again.`
-    }));
-    return;
-  }
-  process.stdout.write("{}");
-}
-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 {
-  runStopHook
-};