kojee-mcp 0.5.0 → 0.5.2

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

package/dist/wizard-7KHD5JT4.js

@@ -0,0 +1,265 @@
+import {
+  buildCodexMcpServerTable,
+  buildCodexStopHookBlock,
+  removeCodexConfig,
+  writeCodexConfig
+} from "./chunk-ZW4SW7LJ.js";
+import {
+  WIZARD_RUNTIMES,
+  isWizardRuntime
+} from "./chunk-LVL25VLO.js";
+import {
+  clearRuntimeRecord,
+  readRecordedRuntime,
+  recordRuntime
+} from "./chunk-EW72ZNQL.js";
+import {
+  kojeeHomeDir
+} from "./chunk-SQL56SEB.js";
+import {
+  CODEX_LISTEN_CAP_MS,
+  buildWebhookReceiverNote
+} from "./chunk-C6GZ2L2W.js";
+import {
+  secureFile
+} from "./chunk-BLEGIR35.js";
+import {
+  resolveWebhookConfig
+} from "./chunk-F7L25L2J.js";
+
+// src/wizard/wizard.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+function generateWebhookSecret() {
+  return crypto.randomBytes(32).toString("hex");
+}
+async function resolveRuntime(opts) {
+  if (opts.runtime !== void 0) {
+    if (!isWizardRuntime(opts.runtime)) {
+      return {
+        error: `Unknown --runtime "${opts.runtime}". Expected one of: ${WIZARD_RUNTIMES.join(", ")}.`
+      };
+    }
+    return { runtime: opts.runtime };
+  }
+  if (opts.interactive && opts.promptRuntime) {
+    const picked = await opts.promptRuntime();
+    if (!isWizardRuntime(picked)) {
+      return { error: `Unknown runtime "${picked}". Expected one of: ${WIZARD_RUNTIMES.join(", ")}.` };
+    }
+    return { runtime: picked };
+  }
+  return { runtime: "claude-code" };
+}
+function resolveWizardWebhook(opts) {
+  const env = opts.env ?? process.env;
+  const url = (opts.webhookUrl ?? env["KOJEE_WEBHOOK_URL"] ?? "").trim();
+  let secret = (opts.webhookSecret ?? env["KOJEE_WEBHOOK_SECRET"] ?? "").trim();
+  if (url && !secret) secret = generateWebhookSecret();
+  const resolution = resolveWebhookConfig({
+    KOJEE_WEBHOOK_URL: url,
+    KOJEE_WEBHOOK_SECRET: secret,
+    ...env["KOJEE_WEBHOOK_TIMEOUT_MS"] !== void 0 ? { KOJEE_WEBHOOK_TIMEOUT_MS: env["KOJEE_WEBHOOK_TIMEOUT_MS"] } : {},
+    ...env["KOJEE_WEBHOOK_MAX_RETRIES"] !== void 0 ? { KOJEE_WEBHOOK_MAX_RETRIES: env["KOJEE_WEBHOOK_MAX_RETRIES"] } : {}
+  });
+  if (resolution.error) {
+    return { url, secret, redactedSummary: "", error: resolution.error };
+  }
+  return {
+    url,
+    secret,
+    redactedSummary: resolution.config?.redactedSummary ?? `url=${url} secret=<redacted>`
+  };
+}
+function writeRuntimeEnvFile(runtime, url, secret) {
+  const envPath = path.join(kojeeHomeDir(), ".kojee", `${runtime}.env`);
+  const body = [
+    `# kojee daemon env for runtime=${runtime} (source this before starting the daemon)`,
+    `export KOJEE_RUNTIME="${runtime}"`,
+    `export KOJEE_WEBHOOK_URL="${url}"`,
+    `export KOJEE_WEBHOOK_SECRET="${secret}"`,
+    ""
+  ].join("\n");
+  fs.mkdirSync(path.dirname(envPath), { recursive: true, mode: 448 });
+  fs.writeFileSync(envPath, body, { mode: 384 });
+  secureFile(envPath);
+  return envPath;
+}
+var CODEX_UNVERIFIED_NOTE = "NOTE: live Codex verification (hook fires, MCP server connects, bounded listen works) has not been run on this build \u2014 confirm in a real Codex session. This is the owner morning step.";
+async function runWizard(opts) {
+  const resolved = await resolveRuntime(opts);
+  if ("error" in resolved) {
+    return { runtime: "claude-code", output: resolved.error, exitCode: 2 };
+  }
+  const runtime = resolved.runtime;
+  if (opts.uninstall) {
+    return runWizardUninstall(runtime, opts);
+  }
+  if (runtime === "claude-code") return configureClaudeCode(opts);
+  if (runtime === "codex") return configureCodex(opts);
+  return configureWebhookDaemon(runtime, opts);
+}
+async function configureClaudeCode(opts) {
+  const { runInit } = await import("./install-WBIUVBZW.js");
+  const report = runInit({
+    ...opts.configPath ? { configPath: opts.configPath } : {},
+    ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {}
+  });
+  recordRuntime("claude-code");
+  return { runtime: "claude-code", output: formatClaudeInit(report), exitCode: 0 };
+}
+function formatClaudeInit(report) {
+  const tick = (s) => {
+    if (s === "added") return "\u2713 added";
+    if (s === "already-installed") return "\u21BB already installed";
+    if (s === "preserved-different") return "\u26A0 preserved (existing entry differs \u2014 left untouched)";
+    if (s === "not-found") return "\u2014 not found";
+    return s ?? "\u2014";
+  };
+  const lines = ["Configured runtime: claude-code", "", "Installing kojee for Claude:"];
+  for (const t of report.targets) {
+    const label = t.kind === "cli" ? "CLI" : "Claude.app";
+    lines.push("");
+    lines.push(`  ${t.path} (${label})`);
+    lines.push(`    mcpServers.kojee           ${tick(t.mcpServer)}`);
+    if (t.kind === "cli") {
+      if (t.hooksPath) lines.push(`  ${t.hooksPath} (hooks)`);
+      lines.push(`    hooks.Stop                 ${tick(t.stopHook)}`);
+      lines.push(`    hooks.UserPromptSubmit     ${tick(t.userPromptSubmitHook)}`);
+    } else {
+      lines.push(`    (hooks not applicable for Claude.app agent mode)`);
+    }
+  }
+  lines.push("");
+  if (report.targets.some((t) => t.kind === "desktop" && t.mcpServer === "added")) {
+    lines.push(
+      "Existing Claude.app agent-mode sessions snapshotted the previous config",
+      "and won't pick up this change automatically. Start a NEW agent-mode",
+      "session (not a resumed one) to use the updated kojee config.",
+      ""
+    );
+  }
+  lines.push("To verify: in any new CC session, run /mcp and confirm `kojee` is listed.");
+  lines.push("                          run /hooks and confirm both Stop and UserPromptSubmit show the kojee entries.");
+  lines.push("To remove: `kojee-mcp init --uninstall`");
+  return lines.join("\n");
+}
+function configureCodex(opts) {
+  const wh = resolveWizardWebhook(opts);
+  if (wh.error) {
+    return { runtime: "codex", output: `webhook env ERROR: ${wh.error}`, exitCode: 2 };
+  }
+  const url = wh.url || "https://YOUR-CODEX-WEBHOOK-RECEIVER.local/kojee";
+  const secret = wh.secret || generateWebhookSecret();
+  writeCodexConfig({
+    ...opts.configPath ? { configPath: opts.configPath } : {},
+    ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {},
+    webhookUrl: url,
+    webhookSecret: secret
+  });
+  recordRuntime("codex");
+  const lines = [];
+  lines.push("Configured runtime: codex");
+  lines.push("Wake mode: webhook-sink + stop-hook peek (Codex has no channel injection).");
+  lines.push("");
+  lines.push("Wrote [mcp_servers.kojee] to ~/.codex/config.toml:");
+  lines.push(indent(buildCodexMcpServerTable({ webhookUrl: url, webhookSecret: "<redacted>" })));
+  lines.push("");
+  lines.push("Wrote the Codex Stop hook (~/.codex/hooks.json; inline TOML form):");
+  lines.push(indent(buildCodexStopHookBlock()));
+  lines.push("");
+  lines.push(`webhook: ${wh.url ? wh.redactedSummary : "(receiver URL not set \u2014 fill KOJEE_WEBHOOK_URL above)"}`);
+  lines.push(`bounded-listen cap: ${CODEX_LISTEN_CAP_MS}ms (the model picks listen vs drain vs ignore).`);
+  lines.push("");
+  lines.push("Next steps (codex):");
+  lines.push("  Restart Codex (or start a new `codex` / `codex exec` session) to load the MCP server and hook.");
+  lines.push("  Stand up your webhook receiver at KOJEE_WEBHOOK_URL \u2014 contract:");
+  lines.push(indent(buildWebhookReceiverNote()));
+  lines.push("  Verify: kojee-mcp doctor");
+  lines.push("");
+  lines.push(CODEX_UNVERIFIED_NOTE);
+  return { runtime: "codex", output: lines.join("\n"), exitCode: 0 };
+}
+function configureWebhookDaemon(runtime, opts) {
+  const wh = resolveWizardWebhook(opts);
+  if (wh.error) {
+    return { runtime, output: `webhook env ERROR: ${wh.error}`, exitCode: 2 };
+  }
+  recordRuntime(runtime);
+  const lines = [];
+  lines.push(`Configured runtime: ${runtime}`);
+  lines.push("Wake mode: webhook sink (daemon-consumed). NO MCP-config file, NO hooks written.");
+  lines.push("");
+  if (wh.url) {
+    const envFile = writeRuntimeEnvFile(runtime, wh.url, wh.secret);
+    lines.push("Export these before starting the daemon (also written to a source-able file):");
+    lines.push(`  export KOJEE_RUNTIME="${runtime}"`);
+    lines.push(`  export KOJEE_WEBHOOK_URL="${wh.url}"`);
+    lines.push(`  export KOJEE_WEBHOOK_SECRET=<generated; in ${envFile}>`);
+    lines.push(`  (validated: ${wh.redactedSummary})`);
+    lines.push(`  source ${envFile}`);
+  } else {
+    lines.push("Set the daemon env (no receiver URL supplied yet):");
+    lines.push(`  export KOJEE_RUNTIME="${runtime}"`);
+    lines.push(`  export KOJEE_WEBHOOK_URL="https://YOUR-RECEIVER.local/kojee"`);
+    lines.push(`  export KOJEE_WEBHOOK_SECRET=<generate a hex secret>`);
+  }
+  lines.push("");
+  lines.push("Receiver contract:");
+  lines.push(indent(buildWebhookReceiverNote()));
+  lines.push("");
+  lines.push(`Next steps (${runtime}):`);
+  lines.push("  Start the daemon with the env above. Verify: kojee-mcp doctor (after the daemon is up).");
+  return { runtime, output: lines.join("\n"), exitCode: 0 };
+}
+async function runWizardUninstall(runtime, opts) {
+  const effective = opts.runtime !== void 0 ? runtime : readRecordedRuntime() ?? runtime;
+  const lines = [`Uninstalling runtime: ${effective}`];
+  if (effective === "claude-code") {
+    const { runUninstall } = await import("./install-WBIUVBZW.js");
+    const report = runUninstall({
+      ...opts.configPath ? { configPath: opts.configPath } : {},
+      ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {}
+    });
+    lines.push("Removing kojee from Claude:");
+    for (const t of report.targets) {
+      const label = t.kind === "cli" ? "CLI" : "Claude.app";
+      lines.push("");
+      lines.push(`  ${t.path} (${label})`);
+      lines.push(`    mcpServers.kojee   ${t.mcpServer ? "\u2713 removed" : "\u2014 not found"}`);
+      if (t.kind === "cli") {
+        if (t.hooksPath) lines.push(`  ${t.hooksPath} (hooks)`);
+        lines.push(`    hook entries       ${t.hooks ? "\u2713 removed" : "\u2014 not found"}`);
+      }
+    }
+  } else if (effective === "codex") {
+    const removed = removeCodexConfig({
+      ...opts.configPath ? { configPath: opts.configPath } : {},
+      ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {}
+    });
+    lines.push(`  config.toml [mcp_servers.kojee]: ${removed.mcpServer ? "removed" : "not found"}`);
+    lines.push(`  hooks.json Stop: ${removed.stopHook ? "removed" : "not found"}`);
+  } else {
+    lines.push("  (hermes/openclaw write no MCP-config or hooks \u2014 nothing to tear down.");
+    lines.push("   Stop the daemon and unset KOJEE_WEBHOOK_URL/SECRET to disable the sink.)");
+    const envPath = path.join(kojeeHomeDir(), ".kojee", `${effective}.env`);
+    try {
+      fs.unlinkSync(envPath);
+      lines.push(`  removed ${envPath}`);
+    } catch {
+    }
+  }
+  clearRuntimeRecord();
+  return { runtime: effective, output: lines.join("\n"), exitCode: 0 };
+}
+function indent(s) {
+  return s.split("\n").map((l) => "    " + l).join("\n");
+}
+export {
+  CODEX_UNVERIFIED_NOTE,
+  generateWebhookSecret,
+  resolveRuntime,
+  resolveWizardWebhook,
+  runWizard
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kojee-mcp",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/dist/chunk-E26AHU6J.js

@@ -1,27 +0,0 @@
-// src/tandem/recipe.ts
-var SEND_BODY_PARAM = "body";
-function buildMonitorCommand(logPath) {
-  return `npx kojee-mcp tail "${logPath}"`;
-}
-function buildMonitorSpawn(logPath) {
-  return `Monitor(command=\`${buildMonitorCommand(logPath)}\`, persistent=true, description="kojee Tandem events")`;
-}
-function buildReplyRecipe(event) {
-  if (event) {
-    return `reply directly with tandem_send(tandem_id="${event.tandem_id}", ${SEND_BODY_PARAM}="...", reply_to="${event.message_id}"); fetch context only if needed via tandem_messages(tandem_id, since=cursor-1)`;
-  }
-  return `reply directly with tandem_send(tandem_id, ${SEND_BODY_PARAM}, reply_to=<msg>); fetch context only if needed via tandem_messages(tandem_id, since=cursor-1)`;
-}
-function buildCatchUpNote() {
-  return "If the event line `cursor=<n>` ever jumps (a gap) or the log resets (the proxy caps and truncates the messages log in place on overflow \u2014 a `status=rotated` line is recorded in the status sibling), you may have missed messages: catch up with tandem_messages(tandem_id, since=<last cursor you saw>).";
-}
-function buildMonitorNudge(logPath) {
-  return `[kojee] Tandem events are being logged but no Monitor is reading them \u2014 you may be missing wake notifications. Spawn the watcher once: ${buildMonitorSpawn(logPath)}. Then ${buildReplyRecipe()}.`;
-}
-
-export {
-  buildMonitorSpawn,
-  buildReplyRecipe,
-  buildCatchUpNote,
-  buildMonitorNudge
-};