kojee-mcp 0.5.11 → 0.5.12

package/dist/chunk-WLMPCX7T.js

@@ -0,0 +1,116 @@
+import {
+  buildCatchUpNote,
+  buildMonitorSpawn,
+  buildReplyRecipe
+} from "./chunk-X672ZN7V.js";
+import {
+  translateToolCallResult
+} from "./chunk-LDZXU3DW.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/version.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var FALLBACK_VERSION = "0.0.0-unknown";
+function resolveVersion() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const parsed = JSON.parse(
+      fs.readFileSync(path.join(here, "..", "package.json"), "utf8")
+    );
+    return typeof parsed?.version === "string" && parsed.version ? parsed.version : FALLBACK_VERSION;
+  } catch (err) {
+    process.stderr.write(
+      `kojee-mcp: could not resolve version from package.json, falling back to ${FALLBACK_VERSION}: ${String(err)}
+`
+    );
+    return FALLBACK_VERSION;
+  }
+}
+var VERSION = resolveVersion();
+
+// src/server.ts
+function buildChannelInstructions(_tandemMembershipCount, eventLogPath) {
+  const intro = `Tandem events are delivered to you in three ways depending on which is active in your Claude Code session:
+
+(1) If channel notifications are available, you'll see them as \`<channel source="kojee-mcp" ...>\` tags in your context. Each tag carries tandem_id, message_id, from_principal, kind, severity. To respond: ${buildReplyRecipe()}.
+
+`;
+  const monitorSection = `(2) For sustained wake-from-idle WITHOUT channel notifications, the proxy writes one event line per Tandem message to ${eventLogPath}. At the start of every session, spawn ONE Monitor task: ${buildMonitorSpawn(eventLogPath)}. Each appended line will arrive as a separate wake notification, and carries msg=<id> and cursor=<n>. To respond: ${buildReplyRecipe()}. ${buildCatchUpNote()} (\`kojee-mcp tail\` is a portable line-streamer shipped with this proxy \u2014 works on macOS, Linux, and Windows. It follows BOTH the messages log above and a status sibling; status/heartbeat telemetry never wakes you \u2014 only real messages do.)
+
+`;
+  const listenSection = "(3) If you want to BLOCK until any single reply lands (rather than receive a stream of events), call tandem_listen(tandem_id, since=cursor, timeout_ms=N) instead.";
+  const advice = "\n\nPrefer (2) at session start \u2014 it's the default no-allowlist wake mechanism. (1) supplements it when channels are enabled; (3) is for one-shot blocking waits.";
+  return intro + monitorSection + listenSection + advice;
+}
+function tandemIdArg(args) {
+  return typeof args["tandem_id"] === "string" ? args["tandem_id"] : null;
+}
+async function executeToolCall(registry, name, args, hooks) {
+  const rawResult = await registry.callTool(name, args);
+  const result = translateToolCallResult(rawResult);
+  if (!result.isError) {
+    if (name === "tandem_join") {
+      try {
+        hooks?.onTandemJoin?.(tandemIdArg(args));
+      } catch (err) {
+        console.error("[mcp] onTandemJoin hook failed:", err?.message ?? String(err));
+      }
+    } else if (name === "tandem_leave") {
+      try {
+        hooks?.onTandemLeave?.(tandemIdArg(args));
+      } catch (err) {
+        console.error("[mcp] onTandemLeave hook failed:", err?.message ?? String(err));
+      }
+    }
+  }
+  return result;
+}
+function createMcpServer(registry, adapter, tandemMembershipCount = -1, eventLogPath, hooks) {
+  const capabilities = { tools: {} };
+  if (adapter.supportsChannels) {
+    capabilities.experimental = { "claude/channel": {} };
+  }
+  const server = new Server(
+    { name: "kojee-mcp", version: VERSION },
+    {
+      capabilities,
+      ...adapter.supportsChannels ? { instructions: buildChannelInstructions(tandemMembershipCount, eventLogPath ?? "") } : {}
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = registry.getAllTools().map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema
+    }));
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const result = await executeToolCall(registry, name, args ?? {}, hooks);
+    return { content: result.content, isError: result.isError };
+  });
+  return server;
+}
+async function startMcpServer(server) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[mcp] Server started on stdio transport");
+}
+
+export {
+  VERSION,
+  buildChannelInstructions,
+  executeToolCall,
+  createMcpServer,
+  startMcpServer
+};

package/dist/chunk-XXFVWP6H.js

@@ -0,0 +1,44 @@
+import {
+  buildReplyRecipe
+} from "./chunk-X672ZN7V.js";
+
+// src/adapters/claude-code.ts
+function computeSeverity(event) {
+  if (event.type === "state_change") return "high";
+  if (event.mentions && event.mentions.length > 0) {
+    return "high";
+  }
+  return "normal";
+}
+function formatBody(event) {
+  if (event.type === "state_change") {
+    return `[Tandem: ${event.tandem_id}] ${event.from.displayname}: ${event.content.body}`;
+  }
+  return [
+    `[Tandem: ${event.tandem_id}] ${event.from.displayname} (${event.from.principal}) \u2014 ${event.kind}:`,
+    event.content.body,
+    "",
+    `> ${buildReplyRecipe({ tandem_id: event.tandem_id, message_id: event.id })}`
+  ].join("\n");
+}
+var claudeCodeAdapter = {
+  runtime: "claude-code",
+  supportsChannels: true,
+  formatTandemEvent(event) {
+    const meta = {
+      tandem_id: event.tandem_id,
+      message_id: event.id,
+      cursor: String(event.cursor),
+      kind: event.kind,
+      from_principal: event.from.principal,
+      from_display: event.from.displayname,
+      severity: computeSeverity(event)
+    };
+    if (event.wake_reason) meta.wake_reason = event.wake_reason;
+    return { content: formatBody(event), meta };
+  }
+};
+
+export {
+  claudeCodeAdapter
+};

package/dist/cli.js

@@ -3,25 +3,27 @@ import {
   runPair
 } from "./chunk-OGHDTFAX.js";
 import {
-  VERSION,
   startProxy
-} from "./chunk-D42PZX2I.js";
-import "./chunk-X672ZN7V.js";
-import "./chunk-BJMASMKX.js";
+} from "./chunk-FQZCENSG.js";
+import "./chunk-XXFVWP6H.js";
 import {
   pairedConfigPath
 } from "./chunk-YH27B6SW.js";
-import "./chunk-JXMVZEQ7.js";
 import "./chunk-HSR3GXCL.js";
-import "./chunk-MKDMAAMN.js";
+import "./chunk-JXMVZEQ7.js";
 import "./chunk-2MIISF2W.js";
 import {
   defaultPairedKeystorePath,
   deriveKeystorePath
 } from "./chunk-CH32ELFX.js";
 import "./chunk-BLEGIR35.js";
-import "./chunk-YKW54DKF.js";
+import {
+  VERSION
+} from "./chunk-WLMPCX7T.js";
+import "./chunk-X672ZN7V.js";
 import "./chunk-LDZXU3DW.js";
+import "./chunk-VHKPWUX7.js";
+import "./chunk-YKW54DKF.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -43,15 +45,15 @@ program.command("pair <code>").description("Pair this machine against Kojee usin
 });
 program.command("hook").description("Run a kojee MCP hook script (called by Claude Code via ~/.claude/settings.json)").requiredOption("--type <type>", "Hook type: stop, user-prompt-submit, or codex-stop").action(async (opts) => {
   if (opts.type === "stop") {
-    const { runStopHook } = await import("./stop-hook-GEJF47SN.js");
+    const { runStopHook } = await import("./stop-hook-CUVDKXP7.js");
     await runStopHook();
     process.exit(0);
   } else if (opts.type === "user-prompt-submit") {
-    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-DGRRFHOB.js");
+    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-PMBUPKUV.js");
     await runUserPromptSubmitHook();
     process.exit(0);
   } else if (opts.type === "codex-stop") {
-    const { runCodexStopHook } = await import("./codex-stop-hook-SWA53ECG.js");
+    const { runCodexStopHook } = await import("./codex-stop-hook-VY7DOMAG.js");
     await runCodexStopHook();
     process.exit(0);
   } else {
@@ -77,7 +79,7 @@ Restart Claude Code for hooks to take effect.`
 program.command("send <tandem_id>").description(
   "Send a Tandem message using this machine's paired credentials (~/.kojee). Prints one JSON envelope to stdout: {ok, message_id, cursor, text} on success, {ok:false, error:<typed code>, message} on failure (exit 1)."
 ).requiredOption("--body <text>", "Message body (required)").option("--reply-to <message_id>", "Message id this send replies to").option("--kind <kind>", "Message kind: message | status (default: backend default)").action(async (tandemId, opts) => {
-  const { runSendCli } = await import("./send-cli-CN5EX7PO.js");
+  const { runSendCli } = await import("./send-cli-NZP5XE7T.js");
   const { exitCode, envelope } = await runSendCli({
     tandemId,
     body: opts.body,
@@ -88,7 +90,7 @@ program.command("send <tandem_id>").description(
   process.exit(exitCode);
 });
 program.command("tail <path>").description("Stream a file's contents and follow appends (portable replacement for `tail -F`)").action(async (filePath) => {
-  const { runTail } = await import("./tail-stream-JNR4WFW3.js");
+  const { runTail } = await import("./tail-stream-VZ462ZON.js");
   try {
     await runTail(filePath);
   } catch (err) {
@@ -97,7 +99,7 @@ program.command("tail <path>").description("Stream a file's contents and follow
   }
 });
 program.command("doctor").description("Diagnose the kojee wake path (proxy, hook-server, SSE stream, event log, Monitor) and print the exact wake recipe").action(async () => {
-  const { runDoctor } = await import("./doctor-XK335W7B.js");
+  const { runDoctor } = await import("./doctor-FVTALRQD.js");
   const code = await runDoctor();
   process.exit(code);
 });
@@ -138,7 +140,7 @@ program.command("init").description(
     console.error("Not paired. Run `kojee-mcp pair <code> --url <broker>` first, then re-run `init` \u2014 or pass --token/--pair-code, or run `init` in a terminal for the guided wizard.");
     process.exit(1);
   }
-  const { runWizard } = await import("./wizard-PLGHYCT3.js");
+  const { runWizard } = await import("./wizard-L4MYRLJI.js");
   const result = await runWizard({
     ...opts.runtime !== void 0 ? { runtime: opts.runtime } : {},
     ...opts.uninstall ? { uninstall: true } : {},

package/dist/codex-stop-hook-VY7DOMAG.js

@@ -0,0 +1,16 @@
+import {
+  CODEX_PEEK_BUDGET_MS,
+  codexPendingMarkerPath,
+  decideCodexStopHook,
+  defaultPeekPending,
+  runCodexStopHook
+} from "./chunk-35XBRG3V.js";
+import "./chunk-LSUB6QMP.js";
+import "./chunk-X672ZN7V.js";
+export {
+  CODEX_PEEK_BUDGET_MS,
+  codexPendingMarkerPath,
+  decideCodexStopHook,
+  defaultPeekPending,
+  runCodexStopHook
+};

package/dist/{doctor-XK335W7B.js → doctor-FVTALRQD.js}

@@ -1,14 +1,20 @@
+import "./chunk-XLKGPGZT.js";
+import {
+  loadControlToken
+} from "./chunk-GI2CKKBL.js";
 import {
   monitorHeartbeatPath,
   statusLogPath
-} from "./chunk-DS26OORG.js";
+} from "./chunk-CO73VGWM.js";
 import {
   discoveryPathForKey,
-  readSessionDiscoveryByKey
+  readSessionDiscoveryByKey,
+  sessionDiscoveryDir
 } from "./chunk-DO42NPNR.js";
 import {
-  loadControlToken
-} from "./chunk-GI2CKKBL.js";
+  loadPairedConfig
+} from "./chunk-YH27B6SW.js";
+import "./chunk-BLEGIR35.js";
 import {
   buildMonitorSpawn,
   buildReplyRecipe
@@ -16,14 +22,74 @@ import {
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid
-} from "./chunk-BJMASMKX.js";
-import {
-  loadPairedConfig
-} from "./chunk-YH27B6SW.js";
-import "./chunk-BLEGIR35.js";
+} from "./chunk-VHKPWUX7.js";
 
 // src/doctor.ts
 import fs from "fs";
+import os from "os";
+import path from "path";
+var SENTINEL_FRESH_MS = 5e3;
+function eventLogKey(logPath) {
+  const m = logPath.replace(/^.*[/\\]/, "").match(/^kojee-events-(.+)\.log$/);
+  return m ? m[1] : null;
+}
+function defaultListSiblingProxies(selfKey) {
+  const dir = sessionDiscoveryDir();
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.startsWith("cc-") || !name.endsWith(".json")) continue;
+    const key = name.slice("cc-".length, -".json".length);
+    if (key === selfKey) continue;
+    try {
+      const entry = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+      const proxyPid = entry.proxyPid ?? entry.pid;
+      const proxyPidAlive = typeof proxyPid === "number" && defaultIsPidAlive(proxyPid);
+      let webhookStatusLine = null;
+      if (entry.eventLogPath) {
+        const last = defaultReadLastStatusLine(statusLogPath(entry.eventLogPath));
+        if (last && last.includes("status=webhook enabled")) webhookStatusLine = last;
+      }
+      out.push({ key, proxyPidAlive, webhookStatusLine });
+    } catch {
+    }
+  }
+  return out;
+}
+async function resolveThisWebhookEnabled() {
+  try {
+    const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
+    return resolveWebhookConfig().enabled === true;
+  } catch {
+    return false;
+  }
+}
+function defaultListMonitorSentinels() {
+  const dir = os.tmpdir();
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const m = name.match(/^kojee-monitor-(.+)\.alive$/);
+    if (!m) continue;
+    const p = path.join(dir, name);
+    try {
+      const s = fs.statSync(p);
+      out.push({ path: p, key: m[1], mtimeMs: s.mtimeMs });
+    } catch {
+    }
+  }
+  return out;
+}
 function defaultIsPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -33,23 +99,23 @@ function defaultIsPidAlive(pid) {
     return false;
   }
 }
-function defaultStat(path) {
+function defaultStat(path2) {
   try {
-    const s = fs.statSync(path);
+    const s = fs.statSync(path2);
     return { mtimeMs: s.mtimeMs, size: s.size };
   } catch {
     return null;
   }
 }
 var STATUS_TAIL_BYTES = 64 * 1024;
-function defaultReadLastStatusLine(path) {
+function defaultReadLastStatusLine(path2) {
   let fd = null;
   try {
-    const { size } = fs.statSync(path);
+    const { size } = fs.statSync(path2);
     const start = Math.max(0, size - STATUS_TAIL_BYTES);
     const len = size - start;
     if (len === 0) return null;
-    fd = fs.openSync(path, "r");
+    fd = fs.openSync(path2, "r");
     const buf = Buffer.alloc(len);
     fs.readSync(fd, buf, 0, len, start);
     const text = buf.toString("utf8");
@@ -181,6 +247,35 @@ async function collectDoctorReport(deps = {}) {
       detail: sentinelFresh ? "live (a Monitor is reading the log)" : "no fresh sentinel \u2014 spawn the Monitor (recipe below)"
     });
   }
+  const webhookSinkEnabled = deps.webhookSinkEnabled !== void 0 ? deps.webhookSinkEnabled : await resolveThisWebhookEnabled();
+  if (!webhookSinkEnabled) {
+    const listSiblings = deps.listSiblingProxies ?? defaultListSiblingProxies;
+    const siblingsWithWebhook = listSiblings(discoveryKey).filter(
+      (s) => s.proxyPidAlive && s.webhookStatusLine
+    );
+    if (siblingsWithWebhook.length > 0) {
+      checks.push({
+        name: "sibling webhook sink",
+        ok: "warn",
+        detail: `another live proxy has a webhook sink enabled while this session's is OFF \u2014 Tandem events may be delivered via that sibling's webhook, not your Monitor. Sibling key(s): ${siblingsWithWebhook.map((s) => s.key).join(", ")}.`
+      });
+    }
+  }
+  if (logPath) {
+    const currentKey = eventLogKey(logPath);
+    const listSentinels = deps.listMonitorSentinels ?? defaultListMonitorSentinels;
+    const now = Date.now();
+    const staleLiveMonitors = listSentinels().filter(
+      (s) => now - s.mtimeMs < SENTINEL_FRESH_MS && s.key !== currentKey
+    );
+    if (staleLiveMonitors.length > 0) {
+      checks.push({
+        name: "stale Monitor",
+        ok: "warn",
+        detail: `a live Monitor is tailing ${staleLiveMonitors.map((s) => s.path).join(", ")}, but current events go to ${logPath} \u2014 re-spawn the Monitor with the recipe below.`
+      });
+    }
+  }
   checks.push({
     name: "wire contract",
     ok: "unknown",
@@ -233,7 +328,7 @@ function formatDoctorReport(report) {
 async function runDoctor() {
   const { readRecordedRuntime } = await import("./runtime-record-WO4IECM6.js");
   if (readRecordedRuntime() === "codex") {
-    const { collectCodexDoctorReport, formatCodexDoctorReport } = await import("./doctor-codex-SMROUYGV.js");
+    const { collectCodexDoctorReport, formatCodexDoctorReport } = await import("./doctor-codex-PA3WO6LR.js");
     const report2 = collectCodexDoctorReport();
     console.error(formatCodexDoctorReport(report2));
     return report2.verdict === "broken" ? 1 : 0;

package/dist/{event-log-B27VVEMK.js → event-log-VZD7NKYX.js}

@@ -5,7 +5,7 @@ import {
   startEventLog,
   statusLogPath,
   sweepStaleEventLogs
-} from "./chunk-DS26OORG.js";
+} from "./chunk-CO73VGWM.js";
 import "./chunk-DO42NPNR.js";
 import "./chunk-BLEGIR35.js";
 export {

package/dist/event-stream-FOT7MJZH.js

@@ -0,0 +1,19 @@
+import {
+  UNDICI_DEFAULT_BODY_TIMEOUT_MS,
+  createAdaptiveWatchdog,
+  createBackoffController,
+  normalizeBackendEvent,
+  sanitizeDisplayname,
+  serializeCursorMap,
+  startEventStream
+} from "./chunk-5XP2UOFK.js";
+import "./chunk-2MIISF2W.js";
+export {
+  UNDICI_DEFAULT_BODY_TIMEOUT_MS,
+  createAdaptiveWatchdog,
+  createBackoffController,
+  normalizeBackendEvent,
+  sanitizeDisplayname,
+  serializeCursorMap,
+  startEventStream
+};

package/dist/{gateway-client-93P1E0CZ.d.ts → gateway-client-C6yx1mfM.d.ts}

@@ -26,6 +26,11 @@ interface LoadedKeyPair {
     publicJwk: JWK;
     kid: string;
 }
+interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
 interface GovernanceMeta {
     decision: "require_approval" | "deny" | "allow";
     approval_id?: string;
@@ -89,4 +94,4 @@ declare class GatewayClient {
     private tryParseErrorBody;
 }
 
-export { GatewayClient as G, type KeystoreData as K, type LoadedKeyPair as L, type ProxyConfig as P, type ToolCallResult as T };
+export { GatewayClient as G, type KeystoreData as K, type LoadedKeyPair as L, type McpToolDefinition as M, type ProxyConfig as P, type ToolCallResult as T };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { G as GatewayClient, P as ProxyConfig } from './gateway-client-93P1E0CZ.js';
+import { G as GatewayClient, P as ProxyConfig } from './gateway-client-C6yx1mfM.js';
 import 'jose';
 
 /**

package/dist/index.js

@@ -1,17 +1,18 @@
 import {
   listTandemIds,
   startProxy
-} from "./chunk-D42PZX2I.js";
-import "./chunk-X672ZN7V.js";
-import "./chunk-BJMASMKX.js";
-import "./chunk-JXMVZEQ7.js";
+} from "./chunk-FQZCENSG.js";
+import "./chunk-XXFVWP6H.js";
 import "./chunk-HSR3GXCL.js";
-import "./chunk-MKDMAAMN.js";
+import "./chunk-JXMVZEQ7.js";
 import "./chunk-2MIISF2W.js";
 import "./chunk-CH32ELFX.js";
 import "./chunk-BLEGIR35.js";
-import "./chunk-YKW54DKF.js";
+import "./chunk-WLMPCX7T.js";
+import "./chunk-X672ZN7V.js";
 import "./chunk-LDZXU3DW.js";
+import "./chunk-VHKPWUX7.js";
+import "./chunk-YKW54DKF.js";
 export {
   listTandemIds,
   startProxy