@projectsolo/solo-mission-mcp 0.23.2 → 0.23.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectsolo/solo-mission-mcp",
-  "version": "0.23.2",
+  "version": "0.23.3",
   "description": "MCP server for SoloMission Platform — lets AI agents create missions, browse humans, and chat.",
   "type": "module",
   "main": "dist/index.js",
@@ -30,6 +30,6 @@
     "vitest": "^4.1.11"
   },
   "engines": {
-    "node": ">=20"
+    "node": "^22.23.4 || ^24.22.1 || >=26.12.1"
   }
 }

package/src/index.ts

@@ -1,92 +1,20 @@
 #!/usr/bin/env node
 /**
- * Solo Mission MCP Server
- * Exposes MCP tools for AI agents to interact with the Solo Mission Platform.
+ * Entry point. Refuses to run on a Node.js that still trusts the eMudhra CAs compromised in
+ * October 2026 (see nodeVersion.ts), and only then loads the server. There is deliberately no
+ * override.
+ *
+ * The server is imported dynamically so that nothing else is evaluated before the check. A static
+ * import would be hoisted above it, and the bundler moves shared modules such as config.ts (which
+ * reads SOLO_AGENT_KEY as it loads) into chunks that run before this file's own code. Keep
+ * nodeVersion.js the only static import here.
  */
+import { isPatchedNode, unpatchedNodeMessage } from './nodeVersion.js';
 
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-
-// Tool definitions
-import { missionTools, handleMissionTool } from './tools/missions.js';
-import { humanTools, handleHumanTool } from './tools/humans.js';
-import { conversationTools, handleConversationTool } from './tools/conversations.js';
-import { realtimeTools, handleRealtimeTool } from './tools/realtime.js';
-import { agentTools, handleAgentTool } from './tools/agent.js';
-import { trackTools, handleTrackTool } from './tools/tracks.js';
-import { solanaTools, SOLANA_TOOL_NAMES, handleSolanaTool } from './tools/solana.js';
-
-const ALL_TOOLS = [...agentTools, ...missionTools, ...humanTools, ...conversationTools, ...realtimeTools, ...trackTools, ...solanaTools];
-
-const AGENT_TOOL_NAMES = new Set(agentTools.map((t) => t.name));
-const MISSION_TOOL_NAMES = new Set(missionTools.map((t) => t.name));
-const HUMAN_TOOL_NAMES = new Set(humanTools.map((t) => t.name));
-const CONVERSATION_TOOL_NAMES = new Set(conversationTools.map((t) => t.name));
-const REALTIME_TOOL_NAMES = new Set(realtimeTools.map((t) => t.name));
-const TRACK_TOOL_NAMES = new Set(trackTools.map((t) => t.name));
-
-const server = new Server(
-  { name: 'solo-mission-mcp', version: '0.23.1' },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: ALL_TOOLS,
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args = {} } = request.params;
-
-  try {
-    let result: unknown;
-
-    if (AGENT_TOOL_NAMES.has(name)) {
-      result = await handleAgentTool(name, args as Record<string, any>);
-    } else if (MISSION_TOOL_NAMES.has(name)) {
-      result = await handleMissionTool(name, args as Record<string, any>);
-    } else if (HUMAN_TOOL_NAMES.has(name)) {
-      result = await handleHumanTool(name, args as Record<string, any>);
-    } else if (CONVERSATION_TOOL_NAMES.has(name)) {
-      result = await handleConversationTool(name, args as Record<string, any>);
-    } else if (REALTIME_TOOL_NAMES.has(name)) {
-      result = await handleRealtimeTool(name, args as Record<string, any>);
-    } else if (TRACK_TOOL_NAMES.has(name)) {
-      result = await handleTrackTool(name, args as Record<string, any>);
-    } else if (SOLANA_TOOL_NAMES.has(name)) {
-      result = await handleSolanaTool(name, args as Record<string, any>);
-    } else {
-      return {
-        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-        isError: true,
-      };
-    }
-
-    return {
-      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-    };
-  } catch (error: any) {
-    const message = error?.response?.data
-      ? JSON.stringify(error.response.data)
-      : (error?.message ?? String(error));
-
-    return {
-      content: [{ type: 'text', text: `Error: ${message}` }],
-      isError: true,
-    };
-  }
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  // Server runs until process exits
+if (!isPatchedNode(process.versions.node)) {
+  // stderr only: stdout is the MCP protocol channel.
+  process.stderr.write(`${unpatchedNodeMessage(process.versions.node)}\n`);
+  process.exit(1);
 }
 
-main().catch((err) => {
-  console.error('Failed to start solo-mission-mcp:', err);
-  process.exit(1);
-});
+await import('./server.js');

package/src/nodeVersion.test.ts

@@ -0,0 +1,67 @@
+/**
+ * The server must refuse every Node.js that still trusts the eMudhra CAs compromised in October 2026.
+ */
+import { readFileSync } from 'node:fs'
+import { describe, it, expect } from 'vitest'
+import { isPatchedNode, unpatchedNodeMessage } from './nodeVersion'
+
+describe('isPatchedNode', () => {
+  it.each([
+    ['20.19.0', false],
+    ['22.23.3', false],
+    ['22.23.4', true],
+    ['23.11.1', false],
+    ['24.22.0', false],
+    ['24.22.1', true],
+    ['25.9.0', false],
+    ['26.12.0', false],
+    ['26.12.1', true],
+    ['26.13.0', true],
+    ['27.0.0', true],
+  ])('%s -> %s', (version, patched) => {
+    expect(isPatchedNode(version)).toBe(patched)
+  })
+
+  it('compares the minor before the patch', () => {
+    expect(isPatchedNode('22.22.9')).toBe(false)
+    expect(isPatchedNode('22.24.0')).toBe(true)
+    expect(isPatchedNode('24.21.9')).toBe(false)
+    expect(isPatchedNode('24.23.0')).toBe(true)
+    expect(isPatchedNode('26.11.9')).toBe(false)
+  })
+
+  it('refuses old and end-of-life majors at any version', () => {
+    for (const v of ['18.20.8', '21.7.3', '23.99.99', '25.99.99']) expect(isPatchedNode(v)).toBe(false)
+  })
+
+  it('treats a prerelease of a fixed version as unpatched', () => {
+    expect(isPatchedNode('22.23.4-pre')).toBe(false)
+    expect(isPatchedNode('22.23.5-pre')).toBe(true)
+    expect(isPatchedNode('27.0.0-alpha.0.0.0')).toBe(true)
+  })
+
+  it('fails closed on anything it cannot parse', () => {
+    for (const v of ['', '22', '22.23', '22.23.4.1', 'abc', ' 22.23.4']) expect(isPatchedNode(v)).toBe(false)
+  })
+})
+
+describe('unpatchedNodeMessage', () => {
+  it('names the running version and the fixed releases', () => {
+    expect(unpatchedNodeMessage('20.19.0')).toBe(
+      'solo-mission-mcp: Node.js v20.19.0 trusts certificate authorities compromised in October 2026 (eMudhra), ' +
+        'so a network attacker could read or change your SOLO traffic, including your agent key. ' +
+        'Upgrade to Node.js 22.23.4+, 24.22.1+ or 26.12.1+ and restart.',
+    )
+  })
+})
+
+describe('index.ts', () => {
+  // A static import is evaluated before the check runs, so the entry may statically import only
+  // the side-effect-free check and must load the server after it.
+  it('statically imports nothing but the version check', () => {
+    const src = readFileSync(new URL('./index.ts', import.meta.url), 'utf8')
+    const staticImports = [...src.matchAll(/^import\s[^'"]*['"]([^'"]+)['"]/gm)].map((m) => m[1])
+    expect(staticImports).toEqual(['./nodeVersion.js'])
+    expect(src.indexOf("await import('./server.js')")).toBeGreaterThan(src.indexOf('process.exit(1)'))
+  })
+})

package/src/nodeVersion.ts

@@ -0,0 +1,49 @@
+/**
+ * Which Node.js releases this server will run on.
+ *
+ * In October 2026 the private keys of eight eMudhra intermediate CAs turned out to be recoverable
+ * from their public certificates, so anyone can forge a certificate for any domain, the mission
+ * API's included. Node.js checks TLS against its own bundled root list and does no revocation
+ * checking, so a Node that still bundles those roots accepts the forgeries. The security releases
+ * of 2026-10-20/21 removed them: 22.23.4, 24.22.1 and 26.12.1. Node 20, 21, 23 and 25 are
+ * end-of-life and will never get the fix.
+ *
+ * `index.ts` applies this at startup. This module has no side effects so it can be tested.
+ */
+
+/** The first fixed [minor, patch] for each supported major. */
+const FIXED_IN: Readonly<Record<number, readonly [number, number]>> = {
+  22: [23, 4],
+  24: [22, 1],
+  26: [12, 1],
+};
+
+/** Every major from this one on was cut after the fix. */
+const FIRST_FIXED_MAJOR = 27;
+
+/**
+ * Whether `version` (in `process.versions.node` form, e.g. "22.23.4") is a patched release.
+ * Anything it can't parse counts as unpatched, and so does a prerelease of a fixed version
+ * ("22.23.4-pre" predates 22.23.4).
+ */
+export function isPatchedNode(version: string): boolean {
+  const m = /^(\d+)\.(\d+)\.(\d+)(-.+)?$/.exec(version);
+  if (!m) return false;
+  const major = Number(m[1]);
+  const minor = Number(m[2]);
+  const patch = Number(m[3]);
+  if (major >= FIRST_FIXED_MAJOR) return true;
+  const fixed = FIXED_IN[major];
+  if (!fixed) return false;
+  if (minor !== fixed[0]) return minor > fixed[0];
+  if (patch !== fixed[1]) return patch > fixed[1];
+  return m[4] === undefined;
+}
+
+export function unpatchedNodeMessage(version: string): string {
+  return (
+    `solo-mission-mcp: Node.js v${version} trusts certificate authorities compromised in October 2026 (eMudhra), ` +
+    'so a network attacker could read or change your SOLO traffic, including your agent key. ' +
+    'Upgrade to Node.js 22.23.4+, 24.22.1+ or 26.12.1+ and restart.'
+  );
+}

package/src/server.ts

@@ -0,0 +1,92 @@
+/**
+ * Solo Mission MCP Server
+ * Exposes MCP tools for AI agents to interact with the Solo Mission Platform.
+ * Loaded by index.ts only after the Node.js version check passes.
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+// Tool definitions
+import { missionTools, handleMissionTool } from './tools/missions.js';
+import { humanTools, handleHumanTool } from './tools/humans.js';
+import { conversationTools, handleConversationTool } from './tools/conversations.js';
+import { realtimeTools, handleRealtimeTool } from './tools/realtime.js';
+import { agentTools, handleAgentTool } from './tools/agent.js';
+import { trackTools, handleTrackTool } from './tools/tracks.js';
+import { solanaTools, SOLANA_TOOL_NAMES, handleSolanaTool } from './tools/solana.js';
+
+const ALL_TOOLS = [...agentTools, ...missionTools, ...humanTools, ...conversationTools, ...realtimeTools, ...trackTools, ...solanaTools];
+
+const AGENT_TOOL_NAMES = new Set(agentTools.map((t) => t.name));
+const MISSION_TOOL_NAMES = new Set(missionTools.map((t) => t.name));
+const HUMAN_TOOL_NAMES = new Set(humanTools.map((t) => t.name));
+const CONVERSATION_TOOL_NAMES = new Set(conversationTools.map((t) => t.name));
+const REALTIME_TOOL_NAMES = new Set(realtimeTools.map((t) => t.name));
+const TRACK_TOOL_NAMES = new Set(trackTools.map((t) => t.name));
+
+const server = new Server(
+  { name: 'solo-mission-mcp', version: '0.23.3' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: ALL_TOOLS,
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  try {
+    let result: unknown;
+
+    if (AGENT_TOOL_NAMES.has(name)) {
+      result = await handleAgentTool(name, args as Record<string, any>);
+    } else if (MISSION_TOOL_NAMES.has(name)) {
+      result = await handleMissionTool(name, args as Record<string, any>);
+    } else if (HUMAN_TOOL_NAMES.has(name)) {
+      result = await handleHumanTool(name, args as Record<string, any>);
+    } else if (CONVERSATION_TOOL_NAMES.has(name)) {
+      result = await handleConversationTool(name, args as Record<string, any>);
+    } else if (REALTIME_TOOL_NAMES.has(name)) {
+      result = await handleRealtimeTool(name, args as Record<string, any>);
+    } else if (TRACK_TOOL_NAMES.has(name)) {
+      result = await handleTrackTool(name, args as Record<string, any>);
+    } else if (SOLANA_TOOL_NAMES.has(name)) {
+      result = await handleSolanaTool(name, args as Record<string, any>);
+    } else {
+      return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true,
+      };
+    }
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  } catch (error: any) {
+    const message = error?.response?.data
+      ? JSON.stringify(error.response.data)
+      : (error?.message ?? String(error));
+
+    return {
+      content: [{ type: 'text', text: `Error: ${message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  // Server runs until process exits
+}
+
+main().catch((err) => {
+  console.error('Failed to start solo-mission-mcp:', err);
+  process.exit(1);
+});