kojee-mcp 0.4.0 → 0.5.2

package/dist/chunk-F7L25L2J.js

@@ -0,0 +1,60 @@
+// src/tandem/webhook-config.ts
+var WEBHOOK_DEFAULT_TIMEOUT_MS = 5e3;
+var WEBHOOK_DEFAULT_MAX_RETRIES = 4;
+function redactUrlUserinfo(rawUrl, parsed) {
+  if (!parsed.username && !parsed.password) return rawUrl;
+  parsed.username = "";
+  parsed.password = "";
+  return parsed.toString();
+}
+function parsePositiveInt(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) return fallback;
+  return n;
+}
+function resolveWebhookConfig(env = process.env) {
+  const url = (env["KOJEE_WEBHOOK_URL"] ?? "").trim();
+  if (!url) {
+    return { enabled: false, config: null };
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return {
+      enabled: false,
+      config: null,
+      error: `KOJEE_WEBHOOK_URL is not a valid URL \u2014 webhook sink DISABLED`
+    };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return {
+      enabled: false,
+      config: null,
+      error: `KOJEE_WEBHOOK_URL must be http(s) (got ${parsed.protocol}) \u2014 webhook sink DISABLED`
+    };
+  }
+  const secret = (env["KOJEE_WEBHOOK_SECRET"] ?? "").trim();
+  if (!secret) {
+    return {
+      enabled: false,
+      config: null,
+      error: "KOJEE_WEBHOOK_URL is set but KOJEE_WEBHOOK_SECRET is missing \u2014 webhook sink DISABLED (the proxy NEVER sends unsigned webhooks)"
+    };
+  }
+  const timeoutMs = parsePositiveInt(env["KOJEE_WEBHOOK_TIMEOUT_MS"], WEBHOOK_DEFAULT_TIMEOUT_MS);
+  const maxRetries = parsePositiveInt(env["KOJEE_WEBHOOK_MAX_RETRIES"], WEBHOOK_DEFAULT_MAX_RETRIES);
+  const safeUrl = redactUrlUserinfo(url, parsed);
+  const redactedSummary = `url=${safeUrl} secret=<redacted> timeoutMs=${timeoutMs} maxRetries=${maxRetries}`;
+  return {
+    enabled: true,
+    config: { url, secret, timeoutMs, maxRetries, redactedSummary }
+  };
+}
+
+export {
+  WEBHOOK_DEFAULT_TIMEOUT_MS,
+  WEBHOOK_DEFAULT_MAX_RETRIES,
+  resolveWebhookConfig
+};

package/dist/{chunk-WHTH6WBP.js → chunk-LSUB6QMP.js}

@@ -5,6 +5,7 @@ var NULL_RESULT = {
   sessionId: null,
   transcriptPath: null,
   hookEventName: null,
+  stopHookActive: false,
   raw: ""
 };
 async function readHookStdin() {
@@ -21,6 +22,7 @@ async function readHookStdin() {
       sessionId: stringOrNull(parsed["session_id"]),
       transcriptPath: stringOrNull(parsed["transcript_path"]),
       hookEventName: stringOrNull(parsed["hook_event_name"]),
+      stopHookActive: parsed["stop_hook_active"] === true,
       raw
     };
   } catch {
@@ -28,6 +30,7 @@ async function readHookStdin() {
       sessionId: null,
       transcriptPath: null,
       hookEventName: null,
+      stopHookActive: false,
       raw
     };
   }

package/dist/chunk-LVL25VLO.js

@@ -0,0 +1,22 @@
+// src/wizard/runtimes.ts
+var WIZARD_RUNTIMES = ["claude-code", "hermes", "openclaw", "codex"];
+var WEBHOOK_RUNTIMES = /* @__PURE__ */ new Set([
+  "hermes",
+  "openclaw"
+]);
+function isWizardRuntime(value) {
+  return WIZARD_RUNTIMES.includes(value);
+}
+var RUNTIME_MENU = [
+  { index: 1, runtime: "claude-code" },
+  { index: 2, runtime: "hermes" },
+  { index: 3, runtime: "openclaw" },
+  { index: 4, runtime: "codex" }
+];
+
+export {
+  WIZARD_RUNTIMES,
+  WEBHOOK_RUNTIMES,
+  isWizardRuntime,
+  RUNTIME_MENU
+};

package/dist/chunk-SQL56SEB.js

@@ -0,0 +1,14 @@
+// src/wizard/home.ts
+import os from "os";
+function kojeeHomeDir() {
+  const env = process.env;
+  const homeKey = "HOME";
+  const profileKey = "USERPROFILE";
+  const fromEnv = env[homeKey] ?? env[profileKey];
+  if (fromEnv && fromEnv.length > 0) return fromEnv;
+  return os.homedir();
+}
+
+export {
+  kojeeHomeDir
+};

package/dist/chunk-WBMX4CHB.js

@@ -0,0 +1,378 @@
+// 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);
+              }
+            }
+            if (opts.adapter.supportsChannels) {
+              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);
+              }
+            }
+            try {
+              opts.webhookSink?.enqueue(parsed);
+            } catch (err) {
+              console.error("[event-stream] webhook enqueue 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));
+}
+var MAX_DISPLAYNAME_CHARS = 64;
+function sanitizeDisplayname(name) {
+  return name.replace(/[\x00-\x1f\x7f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_DISPLAYNAME_CHARS);
+}
+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 rawSessionId = sender["session_id"];
+  const sessionId = typeof rawSessionId === "string" && rawSessionId.trim() ? rawSessionId : void 0;
+  const rawSeverity = obj["severity"];
+  const severity = typeof rawSeverity === "string" && rawSeverity.trim() ? rawSeverity : void 0;
+  const rawDisplay = sender["display"];
+  const trimmedDisplay = typeof rawDisplay === "string" ? rawDisplay.trim() : "";
+  const safeDisplay = trimmedDisplay ? sanitizeDisplayname(trimmedDisplay) : "";
+  const displayname = safeDisplay ? safeDisplay : 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 } : {},
+      ...sessionId ? { session_id: sessionId } : {},
+      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"] } : {},
+    ...severity ? { severity } : {}
+  };
+}
+
+export {
+  createDPoPProof,
+  MCP_SESSION_ID,
+  createAdaptiveWatchdog,
+  startEventStream
+};