@elisym/mcp 0.15.1 → 0.15.2

package/dist/index.js

@@ -5,8 +5,8 @@ import { createIrohTransport, loadGlobalConfig, writeGlobalConfig } from '@elisy
 import { getBase58Encoder, getBase58Decoder, generateKeyPairSigner, createSolanaRpc, address, createSolanaRpcSubscriptions, sendAndConfirmTransactionFactory, getSignatureFromTransaction, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, createKeyPairSignerFromBytes, isAddress } from '@solana/kit';
 import { Command } from 'commander';
 import { generateSecretKey, nip19, getPublicKey } from 'nostr-tools';
-import { realpath, readFile, stat, rm, writeFile, rename, unlink } from 'node:fs/promises';
-import { tmpdir, homedir, platform } from 'node:os';
+import { realpath, readFile, stat, mkdir, rm, writeFile, rename, unlink } from 'node:fs/promises';
+import { tmpdir, platform, homedir } from 'node:os';
 import { dirname, join, resolve, isAbsolute, basename, relative } from 'node:path';
 import { readFileSync, mkdtempSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
@@ -370,6 +370,9 @@ function decodeNpub(npub) {
 function elisymPackageArgs() {
   return ["-y", `@elisym/mcp@~${PACKAGE_VERSION}`];
 }
+function userHome() {
+  return process.env.HOME ?? homedir();
+}
 function validateClientName(name) {
   if (name === void 0) {
     return;
@@ -399,8 +402,9 @@ async function safeRewriteJson(path, expectedRaw, newConfig) {
 var CLIENTS = [
   {
     name: "claude-desktop",
+    format: "json",
     configPath() {
-      const home = homedir();
+      const home = userHome();
       switch (platform()) {
         case "darwin":
           return join(home, "Library/Application Support/Claude/claude_desktop_config.json");
@@ -413,21 +417,29 @@ var CLIENTS = [
   },
   {
     name: "claude-code",
+    format: "json",
     // Claude Code CLI keeps user-scope MCP servers under `mcpServers` at the top
     // level of `~/.claude.json`. Project-scope (`.mcp.json` in cwd) and local-scope
     // (`projects.<path>.mcpServers` inside the same file) are deliberately not
     // touched here - this installer only writes user scope so the server is
     // available across all projects.
-    configPath: () => join(homedir(), ".claude.json")
+    configPath: () => join(userHome(), ".claude.json")
   },
   {
     name: "cursor",
-    configPath: () => join(homedir(), ".cursor/mcp.json")
+    format: "json",
+    configPath: () => join(userHome(), ".cursor/mcp.json")
+  },
+  {
+    name: "codex",
+    format: "codex-toml",
+    configPath: () => join(userHome(), ".codex/config.toml")
   },
   {
     name: "windsurf",
+    format: "json",
     configPath() {
-      const home = homedir();
+      const home = userHome();
       if (platform() === "darwin") {
         return join(home, "Library/Application Support/Windsurf/mcp.json");
       }
@@ -480,7 +492,7 @@ async function runInstall(options) {
       continue;
     }
     try {
-      const result = await installToConfig(path, entry, effectiveAgent);
+      const result = client.format === "codex-toml" ? await installToCodexConfig(path, entry, options.agent) : await installToConfig(path, entry, options.agent);
       if (result === "installed") {
         console.log(`Installed to ${client.name}: ${path}`);
         installed++;
@@ -499,7 +511,7 @@ async function runInstall(options) {
   }
 }
 async function resolveDefaultAgent() {
-  const agents = await listAgents(process.cwd());
+  const agents = await listAgents(userHome());
   const [first, second] = agents;
   if (!first) {
     return { kind: "none" };
@@ -523,6 +535,20 @@ async function runUpdate(options) {
     if (!path) {
       continue;
     }
+    if (client.format === "codex-toml") {
+      try {
+        const result = await updateCodexConfig(path, options.agent);
+        if (result === "updated") {
+          console.log(`Updated ${client.name}: ${path} -> @elisym/mcp@~${PACKAGE_VERSION}`);
+          updated++;
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          console.log(`Skipped ${client.name}: ${err.message}`);
+        }
+      }
+      continue;
+    }
     let raw;
     try {
       raw = await readFile(path, "utf-8");
@@ -561,12 +587,16 @@ async function runUpdate(options) {
     }
     const entry = existing;
     const newArgs = elisymPackageArgs();
+    const packageArg = newArgs[1];
+    if (packageArg === void 0) {
+      throw new Error("Internal error: missing package argument for elisym MCP install.");
+    }
     if (Array.isArray(entry.args)) {
       const idx = entry.args.findIndex(
         (a) => typeof a === "string" && a.startsWith("@elisym/mcp@")
       );
       if (idx >= 0) {
-        entry.args[idx] = newArgs[1];
+        entry.args[idx] = packageArg;
       } else {
         entry.args = newArgs;
       }
@@ -601,6 +631,16 @@ async function runUninstall(options) {
     if (!path) {
       continue;
     }
+    if (client.format === "codex-toml") {
+      try {
+        const result = await uninstallFromCodexConfig(path);
+        if (result === "removed") {
+          console.log(`Removed from ${client.name}: ${path}`);
+        }
+      } catch {
+      }
+      continue;
+    }
     let raw;
     try {
       raw = await readFile(path, "utf-8");
@@ -634,8 +674,7 @@ async function runList() {
     }
     try {
       const raw = await readFile(path, "utf-8");
-      const config = JSON.parse(raw);
-      const installed = !!config.mcpServers?.elisym;
+      const installed = client.format === "codex-toml" ? findCodexElisymBlock(raw) !== null : !!JSON.parse(raw).mcpServers?.elisym;
       console.log(`${client.name}: ${installed ? "installed" : "available"} (${path})`);
     } catch {
       console.log(`${client.name}: not found`);
@@ -687,6 +726,457 @@ async function installToConfig(path, entry, agentRebind) {
   await safeRewriteJson(path, raw, config);
   return "installed";
 }
+function findCodexElisymBlock(raw) {
+  const table = findTomlTableRange(raw, "mcp_servers.elisym");
+  if (!table) {
+    return null;
+  }
+  return { start: table.start, end: table.end, body: raw.slice(table.start, table.end) };
+}
+function findTomlTableRange(raw, path) {
+  return findTomlTableRanges(raw).find((table) => table.path === path) ?? null;
+}
+function findTomlTableRanges(raw) {
+  const lines = raw.match(/^.*(?:\n|$)/gm) ?? [];
+  const offsets = [];
+  let offset = 0;
+  for (const line of lines) {
+    offsets.push(offset);
+    offset += line.length;
+  }
+  const ranges = [];
+  for (const [lineIndex, line] of lines.entries()) {
+    const path = parseTomlTableHeader(line);
+    if (!path) {
+      continue;
+    }
+    let end = raw.length;
+    for (let nextLineIndex = lineIndex + 1; nextLineIndex < lines.length; nextLineIndex++) {
+      if (parseTomlTableHeader(lines[nextLineIndex] ?? "")) {
+        end = offsets[nextLineIndex] ?? raw.length;
+        break;
+      }
+    }
+    ranges.push({ start: offsets[lineIndex] ?? 0, end, path });
+  }
+  return ranges;
+}
+function parseTomlTableHeader(line) {
+  const match = /^\s*\[([^\]]+)\]\s*(?:#.*)?$/.exec(line.trimEnd());
+  return match ? match[1] : null;
+}
+function parseCodexEnv(block) {
+  const env = {};
+  let section = "other";
+  for (const line of block.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[")) {
+      if (/^\[mcp_servers\.elisym\]\s*(?:#.*)?$/.test(trimmed)) {
+        section = "elisym";
+      } else if (/^\[mcp_servers\.elisym\.env\]\s*(?:#.*)?$/.test(trimmed)) {
+        section = "env";
+      } else {
+        section = "other";
+      }
+      continue;
+    }
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      continue;
+    }
+    if (section === "elisym") {
+      Object.assign(env, parseCodexInlineEnv(trimmed));
+    } else if (section === "env") {
+      const match = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+?)\s*(?:#.*)?$/.exec(trimmed);
+      if (!match) {
+        continue;
+      }
+      const [, key, rawValue] = match;
+      const value = parseTomlString(rawValue);
+      if (value !== void 0) {
+        env[key] = value;
+      }
+    }
+  }
+  return env;
+}
+function parseCodexInlineEnv(line) {
+  const env = {};
+  const match = /^env\s*=\s*\{(.*)\}\s*(?:#.*)?$/.exec(line);
+  if (!match) {
+    return env;
+  }
+  const [, body] = match;
+  for (const entry of splitInlineTableEntries(body)) {
+    const entryMatch = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+?)\s*$/.exec(entry);
+    if (!entryMatch) {
+      continue;
+    }
+    const [, key, rawValue] = entryMatch;
+    const value = parseTomlString(rawValue);
+    if (value !== void 0) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function splitInlineTableEntries(body) {
+  const entries = [];
+  let current = "";
+  let inString = false;
+  let escaped = false;
+  for (const char of body) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && inString) {
+      current += char;
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      current += char;
+      inString = !inString;
+      continue;
+    }
+    if (char === "," && !inString) {
+      entries.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim() !== "") {
+    entries.push(current);
+  }
+  return entries;
+}
+function parseTomlString(rawValue) {
+  if (rawValue.startsWith("'") && rawValue.endsWith("'")) {
+    return rawValue.slice(1, -1);
+  }
+  try {
+    return JSON.parse(rawValue);
+  } catch {
+    return void 0;
+  }
+}
+function quoteTomlString(value) {
+  return JSON.stringify(value);
+}
+function renderTomlStringArray(values) {
+  return `[${values.map((value) => quoteTomlString(value)).join(", ")}]`;
+}
+function renderCodexTomlBlock(entry) {
+  const lines = [
+    "[mcp_servers.elisym]",
+    `command = ${quoteTomlString(String(entry.command ?? "npx"))}`,
+    `args = ${renderTomlStringArray(Array.isArray(entry.args) ? entry.args.map(String) : [])}`
+  ];
+  const env = entry.env && typeof entry.env === "object" && !Array.isArray(entry.env) ? entry.env : {};
+  const envEntries = Object.entries(env);
+  if (envEntries.length > 0) {
+    lines.push("", "[mcp_servers.elisym.env]");
+    for (const [key, value] of envEntries) {
+      lines.push(`${key} = ${quoteTomlString(String(value))}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function updateCodexTomlBlock(body, env, rewriteEnv) {
+  const withFreshPackagePin = updateCodexPackagePin(body);
+  if (!rewriteEnv) {
+    return withFreshPackagePin;
+  }
+  const agent = env.ELISYM_AGENT;
+  if (agent === void 0) {
+    return withFreshPackagePin;
+  }
+  return replaceCodexAgentEnv(withFreshPackagePin, agent);
+}
+function updateCodexPackagePin(body) {
+  const lines = body.match(/^.*(?:\n|$)/gm) ?? [];
+  let section = "other";
+  for (const [lineIndex, line] of lines.entries()) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[")) {
+      if (/^\[mcp_servers\.elisym\]\s*(?:#.*)?$/.test(trimmed)) {
+        section = "elisym";
+      } else if (/^\[mcp_servers\.elisym\.env\]\s*(?:#.*)?$/.test(trimmed)) {
+        section = "env";
+      } else {
+        section = "other";
+      }
+      continue;
+    }
+    if (section !== "elisym" || !/^\s*args\s*=/.test(line)) {
+      continue;
+    }
+    const packageSpec = `@elisym/mcp@~${PACKAGE_VERSION}`;
+    const assignmentEndIndex = findTomlAssignmentEnd(lines, lineIndex);
+    const assignmentLines = lines.slice(lineIndex, assignmentEndIndex + 1);
+    const packageLineOffset = assignmentLines.findIndex(
+      (assignmentLine) => assignmentLine.includes("@elisym/mcp@")
+    );
+    if (packageLineOffset >= 0) {
+      const packageLineIndex = lineIndex + packageLineOffset;
+      const packageLine = lines[packageLineIndex] ?? "";
+      lines[packageLineIndex] = packageLine.replace(/@elisym\/mcp@[^"\],\s]+/, packageSpec);
+    } else {
+      lines.splice(
+        lineIndex,
+        assignmentEndIndex - lineIndex + 1,
+        replaceTomlAssignmentValue(line, renderTomlStringArray(elisymPackageArgs()))
+      );
+    }
+    break;
+  }
+  return lines.join("");
+}
+function findTomlAssignmentEnd(lines, startIndex) {
+  const firstLine = lines[startIndex] ?? "";
+  const assignmentStart = firstLine.indexOf("=");
+  if (assignmentStart < 0) {
+    return startIndex;
+  }
+  let depth = 0;
+  let sawArray = false;
+  for (let lineIndex = startIndex; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex] ?? "";
+    if (lineIndex > startIndex && /^\s*\[/.test(line) && depth > 0) {
+      return lineIndex - 1;
+    }
+    const scanFrom = lineIndex === startIndex ? assignmentStart + 1 : 0;
+    const scan = scanTomlArrayLine(line, scanFrom, depth);
+    depth = scan.depth;
+    sawArray = sawArray || scan.sawArray;
+    if (!sawArray) {
+      return startIndex;
+    }
+    if (depth <= 0) {
+      return lineIndex;
+    }
+  }
+  return lines.length - 1;
+}
+function scanTomlArrayLine(line, startIndex, initialDepth) {
+  let depth = initialDepth;
+  let sawArray = false;
+  let inString = false;
+  let escaped = false;
+  for (let charIndex = startIndex; charIndex < line.length; charIndex++) {
+    const char = line[charIndex];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (char === "#" && !inString) {
+      break;
+    }
+    if (char === "[" && !inString) {
+      depth++;
+      sawArray = true;
+    } else if (char === "]" && !inString) {
+      depth--;
+    }
+  }
+  return { depth, sawArray };
+}
+function replaceTomlAssignmentValue(line, value) {
+  const match = /^(\s*[A-Za-z_][A-Za-z0-9_]*\s*=\s*).*(\r?\n)?$/.exec(line);
+  if (!match) {
+    return line;
+  }
+  const [, prefix, newline = ""] = match;
+  return `${prefix}${value}${newline}`;
+}
+function replaceCodexAgentEnv(body, agent) {
+  const lines = body.match(/^.*(?:\n|$)/gm) ?? [];
+  let section = "other";
+  let envInsertionIndex = -1;
+  let elisymInsertionIndex = -1;
+  for (const [lineIndex, line] of lines.entries()) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[")) {
+      if (section === "env" && envInsertionIndex < 0) {
+        envInsertionIndex = lineIndex;
+      }
+      if (section === "elisym") {
+        elisymInsertionIndex = lineIndex;
+      }
+      const header = parseTomlTableHeader(trimmed);
+      if (header === "mcp_servers.elisym") {
+        section = "elisym";
+      } else if (header === "mcp_servers.elisym.env") {
+        section = "env";
+        continue;
+      } else {
+        section = "other";
+      }
+    }
+    if (section === "env") {
+      if (/^\s*ELISYM_AGENT\s*=/.test(line)) {
+        lines[lineIndex] = replaceTomlAssignmentValue(line, quoteTomlString(agent));
+        return lines.join("");
+      }
+      continue;
+    }
+    if (section === "elisym") {
+      elisymInsertionIndex = lineIndex + 1;
+      if (/^\s*env\s*=/.test(line)) {
+        const nextLine = replaceCodexInlineEnvAgent(line, agent);
+        if (nextLine !== null) {
+          lines[lineIndex] = nextLine;
+          return lines.join("");
+        }
+      }
+    }
+  }
+  if (section === "env") {
+    envInsertionIndex = lines.length;
+  } else if (section === "elisym") {
+    elisymInsertionIndex = lines.length;
+  }
+  const agentLine = `ELISYM_AGENT = ${quoteTomlString(agent)}
+`;
+  if (envInsertionIndex >= 0) {
+    lines.splice(envInsertionIndex, 0, agentLine);
+    return lines.join("");
+  }
+  const insertionIndex = elisymInsertionIndex >= 0 ? elisymInsertionIndex : lines.length;
+  lines.splice(insertionIndex, 0, "\n", "[mcp_servers.elisym.env]\n", agentLine);
+  return lines.join("");
+}
+function replaceCodexInlineEnvAgent(line, agent) {
+  const match = /^(\s*env\s*=\s*\{)(.*)(\}\s*(?:#.*)?(?:\r?\n)?)$/.exec(line);
+  if (!match) {
+    return null;
+  }
+  const [, prefix, body, suffix] = match;
+  const entries = splitInlineTableEntries(body);
+  const nextEntries = [];
+  let replaced = false;
+  for (const entry of entries) {
+    if (/^\s*ELISYM_AGENT\s*=/.test(entry)) {
+      const entryMatch = /^(\s*ELISYM_AGENT\s*=\s*).*$/.exec(entry);
+      if (!entryMatch) {
+        return null;
+      }
+      nextEntries.push(`${entryMatch[1]}${quoteTomlString(agent)}`);
+      replaced = true;
+    } else {
+      nextEntries.push(entry);
+    }
+  }
+  if (!replaced) {
+    nextEntries.push(` ELISYM_AGENT = ${quoteTomlString(agent)} `);
+  }
+  return `${prefix}${nextEntries.join(",")}${suffix}`;
+}
+function removeCodexElisymTables(raw) {
+  const ranges = findTomlTableRanges(raw).filter((table) => isCodexElisymPath(table.path)).sort((left, right) => right.start - left.start);
+  let nextRaw = raw;
+  for (const range of ranges) {
+    nextRaw = `${nextRaw.slice(0, range.start)}${nextRaw.slice(range.end)}`;
+  }
+  return nextRaw;
+}
+function isCodexElisymPath(path) {
+  return path === "mcp_servers.elisym" || path.startsWith("mcp_servers.elisym.");
+}
+function replaceCodexBlock(raw, block, replacement) {
+  {
+    let separator = "\n\n";
+    if (raw.length === 0 || raw.endsWith("\n\n")) {
+      separator = "";
+    } else if (raw.endsWith("\n")) {
+      separator = "\n";
+    }
+    return `${raw}${separator}${replacement}`;
+  }
+}
+async function installToCodexConfig(path, entry, agentRebind) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFileAtomic(path, renderCodexTomlBlock(entry), 384);
+    return "installed";
+  }
+  const block = findCodexElisymBlock(raw);
+  if (block) {
+    if (agentRebind === void 0) {
+      return "unchanged";
+    }
+    const env = parseCodexEnv(raw);
+    if (env.ELISYM_AGENT === agentRebind) {
+      return "unchanged";
+    }
+    env.ELISYM_AGENT = agentRebind;
+    const replacement = updateCodexTomlBlock(raw, env, true);
+    await safeRewriteRaw(path, raw, replacement);
+    return "rebound";
+  }
+  await safeRewriteRaw(path, raw, replaceCodexBlock(raw, null, renderCodexTomlBlock(entry)));
+  return "installed";
+}
+async function updateCodexConfig(path, agentOverride) {
+  const raw = await readFile(path, "utf-8");
+  const block = findCodexElisymBlock(raw);
+  if (!block) {
+    return "unchanged";
+  }
+  const env = parseCodexEnv(raw);
+  const existingAgentRaw = typeof env.ELISYM_AGENT === "string" ? env.ELISYM_AGENT : void 0;
+  if (existingAgentRaw !== void 0 && agentOverride === void 0) {
+    validateAgentName(existingAgentRaw);
+  }
+  if (agentOverride !== void 0) {
+    env.ELISYM_AGENT = agentOverride;
+  }
+  const replacement = updateCodexTomlBlock(raw, env, agentOverride !== void 0);
+  await safeRewriteRaw(path, raw, replacement);
+  return "updated";
+}
+async function uninstallFromCodexConfig(path) {
+  const raw = await readFile(path, "utf-8");
+  const replacement = removeCodexElisymTables(raw);
+  if (replacement === raw) {
+    return "unchanged";
+  }
+  await safeRewriteRaw(path, raw, replacement);
+  return "removed";
+}
+async function safeRewriteRaw(path, expectedRaw, nextRaw) {
+  let recheck;
+  try {
+    recheck = await readFile(path, "utf-8");
+  } catch (err) {
+    throw new Error(
+      `${path} disappeared between read and write: ${err.message}. Re-run after the file is restored.`
+    );
+  }
+  if (recheck !== expectedRaw) {
+    throw new Error(
+      `${path} was modified by another process during update. Close the MCP client and re-run.`
+    );
+  }
+  await writeFileAtomic(path, nextRaw, 384);
+}
 function ensureIrohTransport(agent) {
   if (agent.irohTransport) {
     return agent.irohTransport;
@@ -4446,7 +4936,10 @@ program.command("init [name]").description("Create a new agent identity").option
     }
   })
 );
-program.command("install").description("Install elisym MCP server into client configs").option("--client <name>", "Specific client (claude-desktop, claude-code, cursor, windsurf)").option("--agent <name>", "Bind to specific agent").option("--list", "List detected clients").action(
+program.command("install").description("Install elisym MCP server into client configs").option(
+  "--client <name>",
+  "Specific client (claude-desktop, claude-code, cursor, codex, windsurf)"
+).option("--agent <name>", "Bind to specific agent").option("--list", "List detected clients").action(
   safe(async (options) => {
     if (options.list) {
       await runList();
@@ -4455,7 +4948,10 @@ program.command("install").description("Install elisym MCP server into client co
     }
   })
 );
-program.command("update").description("Refresh the elisym MCP entry in installed client configs").option("--client <name>", "Specific client (claude-desktop, claude-code, cursor, windsurf)").option("--agent <name>", "Override the agent binding").action(
+program.command("update").description("Refresh the elisym MCP entry in installed client configs").option(
+  "--client <name>",
+  "Specific client (claude-desktop, claude-code, cursor, codex, windsurf)"
+).option("--agent <name>", "Override the agent binding").action(
   safe(async (options) => {
     await runUpdate({ client: options.client, agent: options.agent });
   })