kojee-mcp 0.4.0 → 0.5.0

package/dist/chunk-QB22PD6T.js

@@ -0,0 +1,358 @@
+// src/auth/dpop.ts
+import { SignJWT, base64url } from "jose";
+import crypto from "crypto";
+async function createDPoPProof(privateKey, kid, method, url, nonce, accessToken) {
+  const payload = {
+    htm: method,
+    htu: url,
+    jti: crypto.randomUUID()
+  };
+  if (nonce) {
+    payload.nonce = nonce;
+  }
+  if (accessToken) {
+    payload.ath = computeAth(accessToken);
+  }
+  const header = {
+    typ: "dpop+jwt",
+    alg: "ES256",
+    jwk: { kid }
+  };
+  return new SignJWT(payload).setProtectedHeader(header).setIssuedAt().sign(privateKey);
+}
+function computeAth(accessToken) {
+  const hash = crypto.createHash("sha256").update(accessToken).digest();
+  return base64url.encode(hash);
+}
+
+// src/tandem/session-id.ts
+import { ulid } from "ulidx";
+var MCP_SESSION_ID = ulid();
+
+// src/tandem/event-stream.ts
+var STALE_FLOOR_MS = 9e4;
+var STALE_INTERVAL_MULTIPLIER = 3;
+var STALE_CHECK_INTERVAL_MS = 5e3;
+var UNARMED_FALLBACK_MS = 12 * 6e4;
+function createAdaptiveWatchdog(options = {}) {
+  const floorMs = options.floorMs ?? STALE_FLOOR_MS;
+  const multiplier = options.multiplier ?? STALE_INTERVAL_MULTIPLIER;
+  const unarmedFallbackMs = options.unarmedFallbackMs ?? UNARMED_FALLBACK_MS;
+  let prevHeartbeatAt = null;
+  let lastIntervalMs = null;
+  function thresholdMs() {
+    if (lastIntervalMs === null) return null;
+    return Math.max(lastIntervalMs * multiplier, floorMs);
+  }
+  return {
+    onHeartbeat(now) {
+      if (prevHeartbeatAt !== null) {
+        const interval = now - prevHeartbeatAt;
+        if (interval > 0) lastIntervalMs = interval;
+      }
+      prevHeartbeatAt = now;
+    },
+    onByte(_now) {
+    },
+    shouldAbort(lastByteAt, now) {
+      const t = thresholdMs();
+      if (t === null) {
+        return now - lastByteAt >= unarmedFallbackMs;
+      }
+      return now - lastByteAt >= t;
+    },
+    armedThresholdMs() {
+      return thresholdMs();
+    }
+  };
+}
+var BACKOFF_BASE_MS = 1e3;
+var BACKOFF_CEILING_MS = 3e4;
+var STABLE_CONNECTION_MS = 1e4;
+function createBackoffController(options = {}) {
+  const baseMs = options.baseMs ?? BACKOFF_BASE_MS;
+  const ceilingMs = options.ceilingMs ?? BACKOFF_CEILING_MS;
+  const stableMs = options.stableMs ?? STABLE_CONNECTION_MS;
+  let backoffMs = baseMs;
+  let connectedAt = null;
+  return {
+    currentBackoffMs() {
+      return backoffMs;
+    },
+    markConnected(now) {
+      connectedAt = now;
+    },
+    markDisconnected(now) {
+      const lasted = connectedAt !== null ? now - connectedAt : 0;
+      connectedAt = null;
+      if (lasted >= stableMs) {
+        backoffMs = baseMs;
+      } else {
+        backoffMs = Math.min(backoffMs * 2, ceilingMs);
+      }
+    }
+  };
+}
+var LOG_HEARTBEAT_INTERVAL_MS = 6e4;
+async function startEventStream(opts) {
+  let stopped = false;
+  const cursors = /* @__PURE__ */ new Map();
+  let currentController = new AbortController();
+  let connectGeneration = 0;
+  const state = {
+    connected: false,
+    connectedSince: null,
+    lastEventAt: null,
+    lastHeartbeatAt: null,
+    reconnectCount: 0,
+    // null until the adaptive watchdog learns a cadence (≥2 heartbeats).
+    staleAfterMs: null
+  };
+  void (async function loop() {
+    const backoff = createBackoffController();
+    while (!stopped) {
+      currentController = new AbortController();
+      const isReconnect = connectGeneration > 0;
+      try {
+        const opened = await connectAndConsume(
+          opts,
+          cursors,
+          currentController,
+          isReconnect,
+          state,
+          (tandemId, cursor) => {
+            const prev = cursors.get(tandemId);
+            if (prev === void 0 || cursor > prev) cursors.set(tandemId, cursor);
+          },
+          () => {
+            backoff.markConnected(Date.now());
+            connectGeneration += 1;
+            state.connected = true;
+            state.connectedSince = Date.now();
+            state.reconnectCount = connectGeneration - 1;
+          }
+        );
+        if (!opened && stopped) return;
+      } catch (err) {
+        if (stopped) return;
+        console.error("[event-stream] disconnect:", err.message);
+        state.connected = false;
+        await emitStatus(opts, `status=disconnected reason=${statusReason(err)}`);
+      }
+      if (stopped) return;
+      state.connected = false;
+      backoff.markDisconnected(Date.now());
+      const jitter = Math.random() * backoff.currentBackoffMs();
+      await sleep(jitter);
+    }
+  })();
+  const handle = (() => {
+    stopped = true;
+    state.connected = false;
+    currentController.abort();
+  });
+  handle.getState = () => ({
+    connected: state.connected,
+    connectedSince: state.connectedSince,
+    lastEventAt: state.lastEventAt,
+    lastHeartbeatAt: state.lastHeartbeatAt,
+    cursors: Object.fromEntries(cursors),
+    reconnectCount: state.reconnectCount,
+    staleAfterMs: state.staleAfterMs
+  });
+  return handle;
+}
+async function connectAndConsume(opts, cursors, controller, isReconnect, state, onCursor, onOpen) {
+  const mapSince = cursors.size > 0 ? serializeCursorMap(cursors) : null;
+  let res = await openStream(opts, controller, mapSince);
+  if (res.status === 400 && mapSince !== null) {
+    console.error("[event-stream] per-room ?since rejected (400) \u2014 falling back to bare cursor");
+    res = await openStream(opts, controller, String(Math.min(...cursors.values())));
+  }
+  if (!res.ok) throw new Error(`SSE connect failed: ${res.status}`);
+  if (!res.body) throw new Error("SSE response has no body");
+  onOpen();
+  await emitStatus(opts, isReconnect ? "status=reconnected" : "status=connected");
+  if (opts.onConnected) {
+    void Promise.resolve().then(() => opts.onConnected()).catch((err) => {
+      console.error("[event-stream] onConnected (resubscribe) failed:", err.message);
+    });
+  }
+  await consumeSse(res.body, opts, controller, state, onCursor);
+  return true;
+}
+async function openStream(opts, controller, sinceValue) {
+  const params = new URLSearchParams();
+  if (sinceValue !== null) params.set("since", sinceValue);
+  const url = `${opts.brokerUrl}/api/v2/tandems/stream${params.toString() ? "?" + params.toString() : ""}`;
+  const proof = await createDPoPProof(
+    opts.gateway.getPrivateKey(),
+    opts.gateway.getKid(),
+    "GET",
+    url,
+    void 0,
+    opts.token
+  );
+  return fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `DPoP ${opts.token}`,
+      DPoP: proof,
+      "Mcp-Session-Id": MCP_SESSION_ID,
+      Accept: "text/event-stream"
+    },
+    signal: controller.signal
+  });
+}
+async function consumeSse(body, opts, controller, state, onCursor) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let lastByteAt = Date.now();
+  const watchdog = createAdaptiveWatchdog();
+  let lastLogHeartbeatAt = 0;
+  const watchdogTimer = setInterval(() => {
+    if (watchdog.shouldAbort(lastByteAt, Date.now())) {
+      const armed = watchdog.armedThresholdMs();
+      const reason = armed !== null ? `no bytes for \u2265${armed}ms, cadence learned` : `no bytes for \u2265${UNARMED_FALLBACK_MS}ms, UNARMED fallback (no cadence learned \u2014 presumed wedged)`;
+      console.error(`[event-stream] stale connection (${reason}) \u2014 aborting to reconnect`);
+      controller.abort();
+    }
+  }, STALE_CHECK_INTERVAL_MS);
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) return;
+      lastByteAt = Date.now();
+      watchdog.onByte(lastByteAt);
+      state.lastEventAt = lastByteAt;
+      buffer += decoder.decode(value, { stream: true });
+      const events = drainSseEvents(buffer);
+      buffer = events.remaining;
+      for (const evt of events.events) {
+        if (evt.event === "stream_revoked") {
+          throw new Error("stream_revoked \u2014 reconnect needed");
+        }
+        if (evt.event === "heartbeat") {
+          const now = Date.now();
+          state.lastHeartbeatAt = now;
+          watchdog.onHeartbeat(now);
+          state.staleAfterMs = watchdog.armedThresholdMs();
+          if (now - lastLogHeartbeatAt >= LOG_HEARTBEAT_INTERVAL_MS) {
+            lastLogHeartbeatAt = now;
+            void opts.eventLog?.appendStatus("status=heartbeat").catch(() => {
+            });
+          }
+          continue;
+        }
+        if (evt.event === "message" || evt.event === "state_change") {
+          try {
+            const raw = JSON.parse(evt.data);
+            const parsed = normalizeBackendEvent(raw, evt.event);
+            onCursor(parsed.tandem_id, parsed.cursor);
+            opts.queue?.push(parsed);
+            if (opts.eventLog) {
+              try {
+                await opts.eventLog.append(parsed);
+                opts.queue?.markMonitorDelivered(parsed.id);
+              } catch (err) {
+                console.error("[event-stream] event-log append failed:", err);
+              }
+            }
+            try {
+              const channel = opts.adapter.formatTandemEvent(parsed);
+              await opts.server.notification({
+                method: "notifications/claude/channel",
+                params: channel
+              });
+              opts.queue?.markChannelDelivered(parsed.id);
+            } catch (err) {
+              console.error("[event-stream] channel notification failed:", err);
+            }
+          } catch (err) {
+            console.error("[event-stream] failed to handle event:", err);
+          }
+        }
+      }
+    }
+  } finally {
+    clearInterval(watchdogTimer);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+async function emitStatus(opts, fields) {
+  try {
+    await opts.eventLog?.appendStatus(fields);
+  } catch {
+  }
+}
+function statusReason(err) {
+  const msg = err?.message ?? String(err);
+  return msg.replace(/\s+/g, "_").slice(0, 60);
+}
+function serializeCursorMap(cursors) {
+  return [...cursors.entries()].map(([tandemId, cursor]) => `${tandemId}:${cursor}`).join(",");
+}
+function drainSseEvents(input) {
+  const events = [];
+  const parts = input.split("\n\n");
+  const remaining = parts.pop() ?? "";
+  for (const block of parts) {
+    let id;
+    let event = "message";
+    const dataLines = [];
+    for (const line of block.split("\n")) {
+      if (line.startsWith("id: ")) id = line.slice(4);
+      else if (line.startsWith("event: ")) event = line.slice(7);
+      else if (line.startsWith("data: ")) dataLines.push(line.slice(6));
+    }
+    if (dataLines.length > 0) events.push({ id, event, data: dataLines.join("\n") });
+  }
+  return { events, remaining };
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function normalizeBackendEvent(raw, sseEventType) {
+  const obj = raw ?? {};
+  const maybeFrom = obj["from"];
+  if (maybeFrom && typeof maybeFrom["principal"] === "string") {
+    return raw;
+  }
+  const sender = obj["sender"] ?? {};
+  const principal = sender["principal_id"] ?? "";
+  const agentId = sender["agent_id"];
+  const displayname = principal ? `principal:${principal.slice(0, 8)}` : "unknown";
+  const type = sseEventType === "state_change" ? "state_change" : "message";
+  const kind = obj["kind"] ?? "message";
+  return {
+    type,
+    id: obj["message_id"] ?? obj["id"] ?? "",
+    tandem_id: obj["tandem_id"] ?? "",
+    cursor: obj["cursor"] ?? 0,
+    time: obj["time"] ?? (/* @__PURE__ */ new Date()).toISOString(),
+    from: {
+      member_id: "",
+      principal,
+      ...agentId ? { agent_id: agentId } : {},
+      displayname
+    },
+    kind,
+    content: {
+      body: obj["body"] ?? "",
+      ...typeof obj["format"] === "string" ? { format: obj["format"] } : {}
+    },
+    ...Array.isArray(obj["mentions"]) ? { mentions: obj["mentions"] } : {},
+    ...obj["reply_to"] !== void 0 ? { reply_to: obj["reply_to"] } : {}
+  };
+}
+
+export {
+  createDPoPProof,
+  MCP_SESSION_ID,
+  createAdaptiveWatchdog,
+  startEventStream
+};

package/dist/chunk-VLZADEFC.js

@@ -0,0 +1,247 @@
+import {
+  sessionDiscoveryDir
+} from "./chunk-W6YRLSD4.js";
+
+// src/tandem/event-log.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_DIR = os.tmpdir();
+var MAX_BODY_CHARS = 200;
+var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_STATUS_MAX_BYTES = 1 * 1024 * 1024;
+var DEFAULT_MIN_AGE_MS = 6e4;
+var STATUS_LINE_PREFIX = "kojee-status";
+function statusLogPath(eventLogPath) {
+  const dir = path.dirname(eventLogPath);
+  const base = path.basename(eventLogPath);
+  const m = base.match(/^kojee-events-(.+)\.log$/);
+  return path.join(dir, m ? `kojee-status-${m[1]}.log` : `${base}.status`);
+}
+function startEventLog(opts) {
+  const dir = opts.dir ?? DEFAULT_DIR;
+  const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+  const statusMaxBytes = opts.statusMaxBytes ?? DEFAULT_STATUS_MAX_BYTES;
+  const filePath = path.join(dir, `kojee-events-${opts.key}.log`);
+  const statusPath = statusLogPath(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, "", { mode: 384 });
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+  fs.writeFileSync(statusPath, "", { mode: 384 });
+  try {
+    fs.chmodSync(statusPath, 384);
+  } catch {
+  }
+  let writtenIds = /* @__PURE__ */ new Set();
+  let bytesWritten = 0;
+  let linesWritten = 0;
+  let statusBytesWritten = 0;
+  let writingMsg = Promise.resolve();
+  function enqueueMsg(fn) {
+    writingMsg = writingMsg.then(fn, fn);
+    return writingMsg;
+  }
+  let writingStatus = Promise.resolve();
+  function enqueueStatus(fn) {
+    writingStatus = writingStatus.then(fn, fn);
+    return writingStatus;
+  }
+  async function writeStatusRaw(fields) {
+    const note = formatStatusLine(fields);
+    if (statusBytesWritten >= statusMaxBytes) {
+      try {
+        await fs.promises.truncate(statusPath, 0);
+        statusBytesWritten = 0;
+      } catch (err) {
+        console.error("[event-log] status rotate-truncate failed:", err.message);
+      }
+    }
+    await fs.promises.appendFile(statusPath, note + "\n", { encoding: "utf8" });
+    statusBytesWritten += Buffer.byteLength(note + "\n");
+  }
+  async function writeMsgRaw(line) {
+    if (bytesWritten >= maxBytes) {
+      const dropped = linesWritten;
+      try {
+        await fs.promises.truncate(filePath, 0);
+        bytesWritten = 0;
+        linesWritten = 0;
+        writtenIds = /* @__PURE__ */ new Set();
+        void enqueueStatus(() => writeStatusRaw(`status=rotated dropped=${dropped}`)).catch(() => {
+        });
+      } catch (err) {
+        console.error("[event-log] rotate-truncate failed:", err.message);
+      }
+    }
+    await fs.promises.appendFile(filePath, line + "\n", { encoding: "utf8" });
+    bytesWritten += Buffer.byteLength(line + "\n");
+    linesWritten += 1;
+  }
+  return {
+    path: filePath,
+    statusPath,
+    async append(event) {
+      if (event.id && writtenIds.has(event.id)) return;
+      if (event.id) writtenIds.add(event.id);
+      const line = formatLine(event);
+      await enqueueMsg(async () => {
+        try {
+          await writeMsgRaw(line);
+        } catch (err) {
+          console.error("[event-log] append failed:", err.message);
+          if (event.id) writtenIds.delete(event.id);
+        }
+      });
+    },
+    async appendStatus(fields) {
+      await enqueueStatus(async () => {
+        try {
+          await writeStatusRaw(fields);
+        } catch (err) {
+          console.error("[event-log] appendStatus failed:", err.message);
+        }
+      });
+    },
+    cleanup() {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+      }
+      try {
+        fs.unlinkSync(statusPath);
+      } catch {
+      }
+    }
+  };
+}
+function formatStatusLine(fields) {
+  return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${STATUS_LINE_PREFIX} ${fields}`;
+}
+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} msg=${event.id}: ${safeBody}`;
+}
+function monitorHeartbeatPath(eventLogPath) {
+  const dir = path.dirname(eventLogPath);
+  const base = path.basename(eventLogPath);
+  const m = base.match(/^kojee-events-(.+)\.log$/);
+  return path.join(dir, m ? `kojee-monitor-${m[1]}.alive` : `${base}.alive`);
+}
+function nudgeSentinelPath(eventLogPath) {
+  const dir = path.dirname(eventLogPath);
+  const base = path.basename(eventLogPath);
+  const m = base.match(/^kojee-events-(.+)\.log$/);
+  return path.join(dir, m ? `kojee-nudge-${m[1]}.touch` : `${base}.nudge`);
+}
+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();
+  const livePaths = /* @__PURE__ */ new Set();
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return { active, livePaths };
+  }
+  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);
+        if (data.eventLogPath) livePaths.add(path.resolve(data.eventLogPath));
+      } else {
+        try {
+          fs.unlinkSync(filePath);
+        } catch {
+        }
+        if (data.eventLogPath) {
+          try {
+            fs.unlinkSync(data.eventLogPath);
+          } catch {
+          }
+          try {
+            fs.unlinkSync(statusLogPath(data.eventLogPath));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return { active, livePaths };
+}
+function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
+  try {
+    fs.unlinkSync(path.join(dir, "kojee-events-no-session.log"));
+  } catch {
+  }
+  const { active, livePaths } = 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);
+    if (livePaths.has(path.resolve(filePath))) continue;
+    try {
+      const stat = fs.statSync(filePath);
+      const ageMs = Math.max(0, now - stat.mtimeMs);
+      if (ageMs < minAgeMs) continue;
+      fs.unlinkSync(filePath);
+      try {
+        fs.unlinkSync(statusLogPath(filePath));
+      } catch {
+      }
+    } catch {
+    }
+  }
+  for (const name of entries) {
+    if (!name.startsWith("kojee-status-") || !name.endsWith(".log")) continue;
+    const statusFile = path.join(dir, name);
+    const key = name.slice("kojee-status-".length, -".log".length);
+    const messagesFile = path.join(dir, `kojee-events-${key}.log`);
+    if (active.has(key)) continue;
+    if (livePaths.has(path.resolve(messagesFile))) continue;
+    if (fs.existsSync(messagesFile)) continue;
+    try {
+      const stat = fs.statSync(statusFile);
+      const ageMs = Math.max(0, now - stat.mtimeMs);
+      if (ageMs < minAgeMs) continue;
+      fs.unlinkSync(statusFile);
+    } catch {
+    }
+  }
+}
+
+export {
+  STATUS_LINE_PREFIX,
+  statusLogPath,
+  startEventLog,
+  monitorHeartbeatPath,
+  nudgeSentinelPath,
+  sweepStaleEventLogs
+};

package/dist/{chunk-VZVGTHGF.js → chunk-W6YRLSD4.js}

@@ -1,8 +1,9 @@
 // src/tandem/session-discovery.ts
 import fs from "fs";
+import os from "os";
 import path from "path";
 function sessionDiscoveryDir() {
-  return path.join(process.env["HOME"] ?? "~", ".kojee", "sessions");
+  return path.join(os.homedir(), ".kojee", "sessions");
 }
 function sessionDiscoveryPath(sessionId) {
   return path.join(sessionDiscoveryDir(), `${sessionId}.json`);