@everme/claude-code 0.1.0

package/hooks/scripts/lib/config.js

@@ -0,0 +1,129 @@
+/**
+ * Plugin config loader.
+ *
+ * Source precedence:
+ *
+ *   For EVERME_AGENT_TOKEN and EVERME_AGENT_ID — the per-machine
+ *   credentials evercli rotates — `~/.claude/everme.env` always wins.
+ *   evercli is the canonical owner of these values; if anything else
+ *   (a stale .claude.json mcp.env block, a leftover shell var) has a
+ *   different value, it's stale and the freshly-rotated evt must win.
+ *
+ *   For every other EVERME_* (EVERME_API_KEY for emk-mode debugging,
+ *   EVERME_API_BASE for self-hosted EverMe, …) process.env still wins:
+ *   users may legitimately want to override these from a shell or from
+ *   Claude Code's mcp .env block, and evercli does not own them.
+ *
+ *   Compiled defaults (everme.evermind.ai, no token) sit at the bottom.
+ *
+ * Auth modes (mutually exclusive, both wire-compatible):
+ *   evt — set EVERME_AGENT_TOKEN (per-machine token from evercli)
+ *   emk — set EVERME_API_KEY     (account-level, from EverMe Web UI)
+ *
+ * If neither is set the plugin runs in disabled-mode: hooks short-
+ * circuit silently so the host (Claude Code) is never blocked.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveConfig as sdkResolveConfig } from "@everme/agent-sdk";
+
+// Env-file location. EVERME_ENV_FILE_PATH overrides for tests so they
+// don't get polluted by a real file on the developer's box.
+function evermeEnvFilePath() {
+  return process.env.EVERME_ENV_FILE_PATH || join(homedir(), ".claude", "everme.env");
+}
+
+let cached = null;
+let envFileLoaded = false;
+
+// Keys that evercli rotates per machine. For these, the env file is
+// the canonical source — if process.env carries a different value
+// (stale .claude.json mcp.env block, leftover shell export from a
+// previous account), the env file's value MUST overwrite it. Without
+// this the freshly-rotated evt could be shadowed by a stale token,
+// leaving every memory call 401.
+const EVERME_ROTATED_KEYS = new Set([
+  "EVERME_AGENT_TOKEN",
+  "EVERME_AGENT_ID",
+]);
+
+/**
+ * Load ~/.claude/everme.env (KEY=value lines) into process.env.
+ * Idempotent — runs once per process.
+ *
+ * For EVERME_ROTATED_KEYS the env file always wins. For everything
+ * else (EVERME_API_KEY, EVERME_API_BASE, …) process.env wins so users
+ * can override via shell or mcp .env block.
+ *
+ * This is the path evercli uses to hand the freshly-minted evt to the
+ * plugin without editing the user's shell profile (which is brittle:
+ * profile name varies by shell, and a user might run `claude` from a
+ * non-interactive shell that doesn't load .zshrc).
+ */
+function loadEnvFile() {
+  if (envFileLoaded) return;
+  envFileLoaded = true;
+  const path = evermeEnvFilePath();
+  if (!existsSync(path)) return;
+  try {
+    const raw = readFileSync(path, "utf8");
+    for (const line of raw.split("\n")) {
+      const t = line.trim();
+      if (!t || t.startsWith("#")) continue;
+      const eq = t.indexOf("=");
+      if (eq < 1) continue;
+      const k = t.slice(0, eq).trim();
+      let v = t.slice(eq + 1).trim();
+      // Tolerate quoted values (single or double).
+      if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+        v = v.slice(1, -1);
+      }
+      if (EVERME_ROTATED_KEYS.has(k)) {
+        // evercli owns this key — env file always wins.
+        process.env[k] = v;
+      } else if (!process.env[k]) {
+        // user-overridable key — fill gap only.
+        process.env[k] = v;
+      }
+    }
+  } catch {
+    /* unreadable file is not fatal — plugin runs disabled */
+  }
+}
+
+export function getConfig() {
+  if (cached) return cached;
+  loadEnvFile();
+
+  const agentToken = process.env.EVERME_AGENT_TOKEN || process.env.EVERME_API_KEY || "";
+  const authMode = process.env.EVERME_AGENT_TOKEN
+    ? "evt"
+    : process.env.EVERME_API_KEY
+    ? "emk"
+    : "none";
+
+  const sdkCfg = sdkResolveConfig({
+    apiBase: process.env.EVERME_API_BASE,
+    agentId: process.env.EVERME_AGENT_ID,
+    agentToken,
+    topK: 5,
+  });
+
+  cached = {
+    ...sdkCfg,
+    authMode,
+    isConfigured: !!agentToken,
+  };
+  return cached;
+}
+
+export function isConfigured() {
+  return getConfig().isConfigured;
+}
+
+export function _resetCache() {
+  cached = null;
+  envFileLoaded = false;
+}

package/hooks/scripts/lib/profile.js

@@ -0,0 +1,75 @@
+/**
+ * Renderers for the gateway's /mem/context profile snapshot.
+ *
+ * Profile shape (from EverMe gateway):
+ *   { explicit_info: [{ category, description, evidence?, sources?[] }],
+ *     implicit_traits: [{ trait, description, basis?, evidence? }],
+ *     scenario, memcell_count, ... }
+ *
+ * `renderProfileBlock` is shared by:
+ *   - SessionStart hook (kicks off the conversation with a snapshot)
+ *   - UserPromptSubmit hook (fallback when search comes up empty)
+ *
+ * Centralising here so a tweak — wider truncation, extra fields, an
+ * empty-state message — lands once instead of drifting between two
+ * copies. The previous setup duplicated the whole function and we'd
+ * already accumulated minor divergences (truncation lengths matched
+ * but the function-name comments did not).
+ */
+
+/**
+ * Render `profile` into a markdown block wrapped in <everme_profile>.
+ * Returns "" when there's nothing to show — callers skip injection in
+ * that case.
+ */
+export function renderProfileBlock(profile) {
+  if (!profile) return "";
+  const explicit = Array.isArray(profile.explicit_info) ? profile.explicit_info : [];
+  const implicit = Array.isArray(profile.implicit_traits) ? profile.implicit_traits : [];
+  if (explicit.length === 0 && implicit.length === 0) return "";
+
+  const lines = ["<everme_profile>"];
+  if (explicit.length > 0) {
+    lines.push("Profile facts:");
+    for (const e of explicit.slice(0, 12)) {
+      const cat = e.category ? `[${e.category}] ` : "";
+      const desc = e.description || e.evidence || "";
+      if (!desc) continue;
+      lines.push(`- ${cat}${truncate(desc, 240)}`);
+    }
+  }
+  if (implicit.length > 0) {
+    lines.push("Implicit traits:");
+    for (const t of implicit.slice(0, 6)) {
+      const name = t.trait || t.name || "trait";
+      const desc = t.description || "";
+      lines.push(`- ${name}: ${truncate(desc, 200)}`);
+    }
+  }
+  lines.push("</everme_profile>");
+  return lines.join("\n");
+}
+
+/**
+ * Number of items the gateway included in this profile — used by the
+ * hook output's `systemMessage` ("loaded N items"). Counts both the
+ * explicit and implicit lists; matches what renderProfileBlock will
+ * surface (modulo per-list truncation, which is fine for a count).
+ */
+export function profileItemCount(profile) {
+  if (!profile) return 0;
+  return (
+    (Array.isArray(profile.explicit_info) ? profile.explicit_info.length : 0) +
+    (Array.isArray(profile.implicit_traits) ? profile.implicit_traits.length : 0)
+  );
+}
+
+/**
+ * One-line truncation: collapse whitespace, cap to `n` chars, append
+ * ellipsis. Both block renderers use the same shape so the output is
+ * visually consistent across SessionStart and UserPromptSubmit.
+ */
+export function truncate(s, n) {
+  s = String(s).replace(/\s+/g, " ").trim();
+  return s.length <= n ? s : s.slice(0, n - 1) + "…";
+}

package/hooks/scripts/lib/redact.js

@@ -0,0 +1,43 @@
+/**
+ * Re-exports the SDK's redactError so hook scripts have a single
+ * import target. `debug` is plugin-local because it formats output
+ * with the [everme:<prefix>] tag specific to Claude Code stderr.
+ */
+
+import { redactError } from "@everme/agent-sdk";
+
+export { redactError };
+
+const DEBUG = process.env.EVERME_DEBUG === "1";
+
+/**
+ * Synchronous stderr trace, gated on EVERME_DEBUG=1. Earlier revisions
+ * dynamic-imported `redactError` here to "guard against tests mocking
+ * the SDK at module-load time" — but the static export above already
+ * load-fails in that scenario, AND the dynamic import is async, so
+ * any line written after `process.exit(0)` was silently dropped. Using
+ * the static `redactError` makes debug logging actually appear.
+ */
+export function debug(prefix, ...args) {
+  if (!DEBUG) return;
+  try {
+    process.stderr.write(
+      `[everme:${prefix}] ` +
+        args
+          .map((a) => (typeof a === "string" ? a : safeStringify(a)))
+          .map(redactError)
+          .join(" ") +
+        "\n",
+    );
+  } catch {
+    /* never throw from debug */
+  }
+}
+
+function safeStringify(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}

package/hooks/scripts/lib/source-key.js

@@ -0,0 +1,54 @@
+/**
+ * Stable per-machine source key for documentKey derivation.
+ *
+ * The hooks pass this into `buildDocumentKey(sourceKey, logicalPath)`
+ * to anchor a version chain. In evt mode the agentId (`agt_…`) is
+ * unique per machine + user + platform, so it works as the source key
+ * unmodified. In emk mode the user has no agentId, so the previous
+ * code fell back to the literal `"agt_claude_code"` — which means
+ * every user on every machine sharing the same EverMe account would
+ * write into the SAME version chain, overwriting each other's runtime
+ * docs.
+ *
+ * This module computes a stable replacement: `claude-code:<host>:<user>`,
+ * SHA256-truncated to a 24-hex prefix. Same machine + user → same
+ * key across processes and reboots; two machines under one account →
+ * two distinct chains.
+ */
+
+import { createHash } from "node:crypto";
+import { hostname, userInfo } from "node:os";
+
+let cached = null;
+
+/**
+ * Returns the source key the runtime hooks should pass into
+ * buildDocumentKey. Honours `cfg.agentId` (evt mode) when present —
+ * agentId is already the canonical per-machine fingerprint that
+ * evercli writes — and falls back to a hashed host+user string when
+ * the user is on emk auth.
+ */
+export function getSourceKey(cfg) {
+  if (cfg?.agentId) return cfg.agentId;
+  if (cached) return cached;
+  let host = "unknown-host";
+  let user = "unknown-user";
+  try {
+    host = hostname() || host;
+  } catch {
+    /* fall through */
+  }
+  try {
+    user = userInfo().username || user;
+  } catch {
+    /* fall through */
+  }
+  const sum = createHash("sha256").update(`claude-code:${host}:${user}`).digest("hex");
+  cached = "agt_emk_" + sum.slice(0, 24);
+  return cached;
+}
+
+/** Test seam — wipes the per-process cache. */
+export function _reset() {
+  cached = null;
+}

package/hooks/scripts/lib/transcript.js

@@ -0,0 +1,263 @@
+/**
+ * Claude Code transcript reader.
+ *
+ * Stop / SessionEnd hooks receive `transcript_path` on stdin — a JSONL
+ * file Claude Code writes per session. Each line is one event; we
+ * parse selectively into the message shape EverMe wants:
+ *
+ *   { role, text, ts, hasToolCall }
+ *   { role, timestamp, content, toolCalls?, toolCallId? } for realtime writes
+ *
+ * `hasToolCall` is retained for legacy markdown rendering tests. Runtime
+ * persistence uses extractAgentMessages so tool calls/results can go directly
+ * to /mem/agent-memory.
+ */
+
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { AGENT_MEMORY_ROLES, AGENT_MEMORY_TOOL_CALL_TYPES } from "@everme/agent-sdk";
+
+const READ_RETRIES = 5;
+const RETRY_DELAY_MS = 100;
+
+/**
+ * Read the transcript with a small retry budget. Stop hook can fire
+ * before Claude Code has flushed the final line; we wait for the
+ * `turn_duration` marker which Claude Code writes when the turn is
+ * complete.
+ *
+ * Async IO: hooks run in their own short-lived Node process, but
+ * transcripts can grow to several MB and the previous synchronous
+ * `readFileSync` blocked the event loop for the entire read on each
+ * of the 5 retries. Using fs.promises.readFile lets the loop service
+ * other tasks (timer for sleep, GC) between retries. The retry budget
+ * itself is unchanged.
+ */
+export async function readTranscript(path) {
+  if (!path || !existsSync(path)) return [];
+  for (let i = 0; i < READ_RETRIES; i++) {
+    const raw = await readFile(path, "utf8");
+    const lines = raw.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      await sleep(RETRY_DELAY_MS);
+      continue;
+    }
+    let complete = false;
+    try {
+      const last = JSON.parse(lines[lines.length - 1]);
+      if (last?.type === "turn_duration" || last?.event === "turn_duration") {
+        complete = true;
+      }
+    } catch {
+      /* incomplete line — retry */
+    }
+    if (complete || i === READ_RETRIES - 1) return lines;
+    await sleep(RETRY_DELAY_MS);
+  }
+  return [];
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Walk the JSONL events and produce the {role, text, hasToolCall, ts}
+ * sequence the hooks need. Robust to Claude Code's evolving transcript
+ * shape — we only consume the fields we recognise and silently skip
+ * unknown event kinds.
+ */
+export function extractTurns(lines) {
+  const turns = [];
+  for (const line of lines) {
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    // User-side prompt
+    if (ev.role === AGENT_MEMORY_ROLES.USER && typeof ev.content === "string") {
+      turns.push({
+        role: AGENT_MEMORY_ROLES.USER,
+        text: ev.content,
+        ts: ev.timestamp || Date.now(),
+        hasToolCall: false,
+      });
+      continue;
+    }
+    // Assistant message — content can be a string or an array of
+    // content blocks (text / tool_use / tool_result).
+    if (ev.role === AGENT_MEMORY_ROLES.ASSISTANT) {
+      const { text, hasToolCall } = flattenAssistant(ev.content);
+      if (text) {
+        turns.push({
+          role: AGENT_MEMORY_ROLES.ASSISTANT,
+          text,
+          ts: ev.timestamp || Date.now(),
+          hasToolCall,
+        });
+      }
+      continue;
+    }
+    // Tool result event — Claude Code emits these as a separate role.
+    if (ev.role === AGENT_MEMORY_ROLES.TOOL || ev.type === "tool_result") {
+      const tr =
+        typeof ev.content === "string"
+          ? ev.content
+          : safeJsonStringify(ev.content);
+      turns.push({
+        role: AGENT_MEMORY_ROLES.TOOL,
+        text: tr,
+        ts: ev.timestamp || Date.now(),
+        hasToolCall: true,
+      });
+    }
+  }
+  return turns;
+}
+
+export function extractAgentMessages(lines) {
+  const messages = [];
+  for (const line of lines) {
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const timestamp = normalizeTimestamp(ev.timestamp);
+    if (ev.role === AGENT_MEMORY_ROLES.USER) {
+      const content = textFromContent(ev.content);
+      if (content) messages.push({ role: AGENT_MEMORY_ROLES.USER, timestamp, content });
+      continue;
+    }
+    if (ev.role === AGENT_MEMORY_ROLES.ASSISTANT) {
+      const msg = agentAssistantMessage(ev.content, timestamp);
+      if (msg) messages.push(msg);
+      continue;
+    }
+    if (ev.role === AGENT_MEMORY_ROLES.TOOL || ev.type === "tool_result") {
+      const toolCallId = ev.toolCallId || ev.tool_call_id || ev.tool_use_id;
+      if (!toolCallId) continue;
+      const content =
+        typeof ev.content === "string" ? ev.content : safeJsonStringify(ev.content);
+      messages.push({ role: AGENT_MEMORY_ROLES.TOOL, timestamp, toolCallId, content });
+    }
+  }
+  return messages;
+}
+
+function agentAssistantMessage(content, timestamp) {
+  if (typeof content === "string") {
+    return content ? { role: AGENT_MEMORY_ROLES.ASSISTANT, timestamp, content } : null;
+  }
+  if (!Array.isArray(content)) return null;
+  const textParts = [];
+  const toolCalls = [];
+  for (const [i, b] of content.entries()) {
+    if (!b || typeof b !== "object") continue;
+    if (b.type === "text" && typeof b.text === "string") {
+      textParts.push(b.text);
+    } else if (b.type === "tool_use" || b.type === "toolCall") {
+      const args = b.input ?? b.arguments ?? {};
+      toolCalls.push({
+        id: b.id || b.tool_use_id || `claude_tool_${timestamp}_${i}`,
+        type: AGENT_MEMORY_TOOL_CALL_TYPES.FUNCTION,
+        name: b.name || "unknown",
+        arguments: typeof args === "string" ? args : safeJsonStringify(args),
+      });
+    }
+  }
+  const out = { role: AGENT_MEMORY_ROLES.ASSISTANT, timestamp };
+  const text = textParts.join("\n\n");
+  if (text) out.content = text;
+  if (toolCalls.length) out.toolCalls = toolCalls;
+  return out.content || out.toolCalls ? out : null;
+}
+
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((b) => {
+      if (typeof b === "string") return b;
+      if (b?.type === "text" && typeof b.text === "string") return b.text;
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function normalizeTimestamp(ts) {
+  if (typeof ts === "number" && Number.isFinite(ts)) {
+    return ts > 10_000_000_000 ? Math.trunc(ts) : Math.trunc(ts * 1000);
+  }
+  const parsed = Date.parse(ts);
+  if (Number.isFinite(parsed)) return parsed;
+  return Date.now();
+}
+
+function flattenAssistant(content) {
+  if (typeof content === "string") {
+    return { text: content, hasToolCall: false };
+  }
+  if (!Array.isArray(content)) return { text: "", hasToolCall: false };
+  const parts = [];
+  let hasToolCall = false;
+  for (const b of content) {
+    if (!b || typeof b !== "object") continue;
+    if (b.type === "text" && typeof b.text === "string") {
+      parts.push(b.text);
+    } else if (b.type === "tool_use") {
+      hasToolCall = true;
+      parts.push(
+        `[tool_use ${b.name || "unknown"}] ${safeJsonStringify(b.input)}`,
+      );
+    } else if (b.type === "tool_result") {
+      hasToolCall = true;
+      const tr =
+        typeof b.content === "string" ? b.content : safeJsonStringify(b.content);
+      parts.push(`[tool_result ${b.tool_use_id || ""}] ${tr}`);
+    }
+  }
+  return { text: parts.join("\n\n"), hasToolCall };
+}
+
+function safeJsonStringify(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+/**
+ * Build a single markdown document from a turn sequence — same shape
+ * the @everme/memory-mcp runtime buffer writes, so backend chunkers /
+ * classifiers behave identically.
+ */
+export function buildTranscriptMarkdown(turns, { sessionId, agentId }) {
+  const now = new Date().toISOString();
+  const lines = [
+    "---",
+    `everme_runtime_version: 1`,
+    `agent_id: ${agentId || "agt_claude_code"}`,
+    `session_key: ${sessionId || "claude-code-session"}`,
+    `last_flushed_at: ${now}`,
+    `turn_count: ${turns.length}`,
+    "---",
+    "",
+    `# Claude Code session ${sessionId || ""}`,
+    "",
+  ];
+  for (const t of turns) {
+    lines.push(`## ${t.role} · ${new Date(t.ts).toISOString()}`);
+    lines.push("");
+    lines.push(t.text);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}

package/hooks/scripts/mcp-server.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * MCP server bundled with the Claude Code plugin. Exposes the
+ * EverMe gateway's search + context endpoints as MCP tools so users
+ * can ALSO recall memory manually via natural language ("search my
+ * memory for the Postgres index thing"), even when the
+ * UserPromptSubmit hook has already done implicit recall.
+ *
+ * Wire format: MCP stdio transport (JSON-RPC 2.0 framed by line).
+ * We hand-roll the tiny subset Claude Code uses rather than pulling
+ * in @modelcontextprotocol/sdk — keeps the install fast (no npm
+ * install required) and the dependency surface minimal.
+ *
+ * Tools:
+ *   everme_search   — POST /api/v1/mem/search
+ *   everme_context  — POST /api/v1/mem/context (server-rendered prompt block)
+ */
+
+import { createInterface } from "readline";
+import { searchMemories, getContext, EvermeError } from "./lib/api.js";
+import { isConfigured } from "./lib/config.js";
+import { redactError, debug } from "./lib/redact.js";
+
+const TOOLS = [
+  {
+    name: "everme_search",
+    description:
+      "Search EverMe memories from past sessions. Returns ranked memory items with subject, summary, and relevance score. Use when the user asks about previous work, decisions, or context. Params: query (required), topK (default 10, max 25).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query — keywords or a question" },
+        topK: { type: "number", description: "Max results (default 10, max 25)" },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "everme_context",
+    description:
+      "Fetch the server-rendered context block (profile + recent episodes) the gateway uses for prompt injection. Useful when you want a single ready-to-paste summary. Params: query (optional), topK (default 5).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Optional query for relevance-biased context" },
+        topK: { type: "number", description: "Max items to include (default 5)" },
+      },
+    },
+  },
+];
+
+const handlers = {
+  initialize: () => ({
+    protocolVersion: "2024-11-05",
+    capabilities: { tools: { listChanged: false } },
+    serverInfo: { name: "everme", version: "0.1.0" },
+  }),
+  "tools/list": () => ({ tools: TOOLS }),
+  "tools/call": async (params) => {
+    const name = params?.name;
+    const args = params?.arguments || {};
+    if (!isConfigured()) {
+      return errResp("EverMe not configured: set EVERME_API_KEY (emk) or EVERME_AGENT_TOKEN");
+    }
+    try {
+      switch (name) {
+        case "everme_search": {
+          const topK = Math.min(Number(args.topK) || 10, 25);
+          const res = await searchMemories(String(args.query || ""), { topK });
+          return ok(JSON.stringify(res, null, 2));
+        }
+        case "everme_context": {
+          const topK = Number(args.topK) || 5;
+          const res = await getContext(String(args.query || ""), { topK });
+          return ok(JSON.stringify(res, null, 2));
+        }
+        default:
+          return errResp(`unknown tool: ${name}`);
+      }
+    } catch (err) {
+      const safe = redactError(err instanceof EvermeError ? err.message : err?.message || String(err));
+      debug("mcp", `tool ${name} failed:`, safe);
+      return errResp(safe);
+    }
+  },
+};
+
+function ok(text) {
+  return { content: [{ type: "text", text: String(text ?? "") }] };
+}
+function errResp(msg) {
+  return { isError: true, content: [{ type: "text", text: `error: ${msg}` }] };
+}
+
+const rl = createInterface({ input: process.stdin, terminal: false });
+rl.on("line", async (line) => {
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch {
+    return; // ignore malformed lines
+  }
+  const handler = handlers[req?.method];
+  if (!handler) {
+    if (req?.id != null) {
+      respond(req.id, undefined, { code: -32601, message: `method not found: ${req?.method}` });
+    }
+    return;
+  }
+  try {
+    const result = await handler(req?.params);
+    if (req?.id != null) respond(req.id, result);
+  } catch (err) {
+    if (req?.id != null) {
+      respond(req.id, undefined, {
+        code: -32000,
+        message: redactError(err?.message || String(err)),
+      });
+    }
+  }
+});
+
+function respond(id, result, error) {
+  const env = error
+    ? { jsonrpc: "2.0", id, error }
+    : { jsonrpc: "2.0", id, result };
+  process.stdout.write(JSON.stringify(env) + "\n");
+}
+
+debug("mcp", "everme MCP server ready");