@4da/mcp-server 4.6.6 → 5.0.1

package/dist/index.js

@@ -8,12 +8,12 @@
  * Claude Desktop, and other MCP hosts. Runs locally; the only data leaving the
  * machine is public package names/versions sent to registries (OSV, npm, etc.).
  *
- * SECURITY: the server trusts its local environment and does NOT implement
- * authentication. The optional --http transport is intended for localhost use;
- * do NOT expose it over a network without putting your own auth in front.
- */
-/**
- * 4DA MCP Server v4.6.3 — Dependency Intelligence for AI Coding Agents
+ * SECURITY: stdio serving is unauthenticated by design — the MCP host launches
+ * this process and already holds local process rights. The optional --http
+ * transport defaults to 127.0.0.1 and applies a Host-header DNS rebinding
+ * guard to every request. Binding it anywhere else requires a shared auth
+ * secret (MCP_AUTH_SECRET) and then verifies an HMAC-SHA256-signed Bearer
+ * token on every request, enforcing the token's role at tool dispatch.
  *
  * 14 tools across 5 categories. Live vulnerability scanning (OSV.dev),
  * ecosystem news, persistent memory, and tech stack awareness for any MCP host.
@@ -25,10 +25,14 @@
  *   Decisions (2)     — decision memory, alignment checking
  *   Agent (1)         — cross-session persistent memory
  *   Identity (1)      — developer DNA profile
+ *
+ * Protocol: MCP TypeScript SDK v2. stdio serving goes through `serveStdio`,
+ * HTTP through `createMcpHandler` — both entries negotiate the era per
+ * connection/request, so 2025-era hosts (classic `initialize` handshake) and
+ * 2026-07-28 hosts (stateless `server/discover`) are both supported.
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { Server } from "@modelcontextprotocol/server";
 import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -73,15 +77,6 @@ function resolveProjectDir() {
         return dir;
     return process.cwd();
 }
-const server = new Server({
-    name: "4da-server",
-    version: SERVER_VERSION,
-}, {
-    capabilities: {
-        tools: { listChanged: true },
-        resources: {},
-    },
-});
 // Database instance (lazy initialized)
 let db = null;
 let liveIntel = null;
@@ -183,128 +178,136 @@ function getDatabase() {
     return db;
 }
 // =============================================================================
-// Tool Handlers
+// Server Factory
 // =============================================================================
 /**
- * List available tools (SLIM)
+ * Build a Server instance with every handler registered.
  *
- * Returns one-liner descriptions only (~500 tokens vs ~4500).
- * Full schemas available via MCP Resources: 4da://schema/{tool_name}
+ * The v2 serving entries take a factory: `serveStdio` pins one instance per
+ * connection; stateless HTTP (`createMcpHandler`) builds one per request.
+ * Handlers close over the module-level database singleton, so every instance
+ * shares the same lazily-initialized database and live-intelligence layer.
  */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const database = getDatabase();
-    return {
-        tools: getSlimToolList(database.isStandalone ? true : undefined),
-    };
-});
-/**
- * List schema resources
- *
- * Exposes full tool schemas as MCP Resources for lazy loading.
- * Also exposes skill manifest for agent dispatch.
- */
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    const resources = [
-        ...getSchemaResources(),
-        // Skill manifest for agent dispatch
-        {
-            uri: "4da://skills",
-            name: "Skill manifest",
-            description: "Registry of 4DA skills for Claude Code agent dispatch",
-            mimeType: "application/json",
-        },
-        // Category manifest for tool discovery
-        {
-            uri: "4da://categories",
-            name: "Tool categories",
-            description: "Tool groupings by category with tag metadata",
-            mimeType: "application/json",
+export function buildServer() {
+    const server = new Server({
+        name: "4da-server",
+        version: SERVER_VERSION,
+    }, {
+        capabilities: {
+            tools: { listChanged: true },
+            resources: {},
         },
-    ];
-    return { resources };
-});
-/**
- * Read a resource (schema or skill manifest)
- */
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    // Handle category manifest
-    if (uri === "4da://categories") {
+    });
+    // List available tools (SLIM): one-liner descriptions only (~500 tokens vs
+    // ~4500). Full schemas available via MCP Resources: 4da://schema/{tool_name}
+    server.setRequestHandler("tools/list", async () => {
+        const database = getDatabase();
         return {
-            contents: [
-                {
-                    uri,
-                    mimeType: "application/json",
-                    text: JSON.stringify(getCategoryManifest(), null, 2),
-                },
-            ],
+            tools: getSlimToolList(database.isStandalone ? true : undefined),
         };
-    }
-    // Handle skill manifest
-    if (uri === "4da://skills") {
-        const skillsPath = join(homedir(), ".local", "share", "4da", "skills", "registry.json");
-        if (!existsSync(skillsPath)) {
-            throw new Error("Skill manifest not found. Run 4DA setup to create it.");
+    });
+    // List schema resources: full tool schemas as MCP Resources for lazy
+    // loading, plus the skill and category manifests.
+    server.setRequestHandler("resources/list", async () => {
+        const resources = [
+            ...getSchemaResources(),
+            // Skill manifest for agent dispatch
+            {
+                uri: "4da://skills",
+                name: "Skill manifest",
+                description: "Registry of 4DA skills for Claude Code agent dispatch",
+                mimeType: "application/json",
+            },
+            // Category manifest for tool discovery
+            {
+                uri: "4da://categories",
+                name: "Tool categories",
+                description: "Tool groupings by category with tag metadata",
+                mimeType: "application/json",
+            },
+        ];
+        return { resources };
+    });
+    // Read a resource (schema or skill manifest)
+    server.setRequestHandler("resources/read", async (request) => {
+        const uri = request.params.uri;
+        // Handle category manifest
+        if (uri === "4da://categories") {
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(getCategoryManifest(), null, 2),
+                    },
+                ],
+            };
+        }
+        // Handle skill manifest
+        if (uri === "4da://skills") {
+            const skillsPath = join(homedir(), ".local", "share", "4da", "skills", "registry.json");
+            if (!existsSync(skillsPath)) {
+                throw new Error("Skill manifest not found. Run 4DA setup to create it.");
+            }
+            const skillsContent = readFileSync(skillsPath, "utf-8");
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: skillsContent,
+                    },
+                ],
+            };
+        }
+        // Parse tool name from URI: 4da://schema/{tool_name}
+        const match = uri.match(/^4da:\/\/schema\/(.+)$/);
+        if (!match) {
+            throw new Error(`Invalid resource URI: ${uri}`);
+        }
+        const toolName = match[1];
+        if (!hasToolSchema(toolName)) {
+            throw new Error(`Unknown tool: ${toolName}`);
         }
-        const skillsContent = readFileSync(skillsPath, "utf-8");
+        const schemaFile = getSchemaFilename(toolName);
+        if (!schemaFile) {
+            throw new Error(`No schema file for tool: ${toolName}`);
+        }
+        // Read schema from file
+        const schemaPath = join(__dirname, "schemas", schemaFile);
+        const schemaContent = readFileSync(schemaPath, "utf-8");
         return {
             contents: [
                 {
                     uri,
                     mimeType: "application/json",
-                    text: skillsContent,
+                    text: schemaContent,
                 },
             ],
         };
-    }
-    // Parse tool name from URI: 4da://schema/{tool_name}
-    const match = uri.match(/^4da:\/\/schema\/(.+)$/);
-    if (!match) {
-        throw new Error(`Invalid resource URI: ${uri}`);
-    }
-    const toolName = match[1];
-    if (!hasToolSchema(toolName)) {
-        throw new Error(`Unknown tool: ${toolName}`);
-    }
-    const schemaFile = getSchemaFilename(toolName);
-    if (!schemaFile) {
-        throw new Error(`No schema file for tool: ${toolName}`);
-    }
-    // Read schema from file
-    const schemaPath = join(__dirname, "schemas", schemaFile);
-    const schemaContent = readFileSync(schemaPath, "utf-8");
-    return {
-        contents: [
-            {
-                uri,
-                mimeType: "application/json",
-                text: schemaContent,
-            },
-        ],
-    };
-});
-/**
- * Execute a tool
- */
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        const database = getDatabase();
-        return await dispatchTool(name, database, args);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ error: errorMessage }, null, 2),
-                },
-            ],
-            isError: true,
-        };
-    }
-});
+    });
+    // Execute a tool
+    server.setRequestHandler("tools/call", async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const database = getDatabase();
+            return await dispatchTool(name, database, args);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: errorMessage }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
 // =============================================================================
 // Server Lifecycle
 // =============================================================================
@@ -312,8 +315,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
  * Start the MCP server
  *
  * Supports three modes:
- *   (default)  stdio transport — classic MCP, works with all hosts
- *   --http     Streamable HTTP transport (spec 2025-03-26)
+ *   (default)  stdio transport — serves 2025-era and 2026-07-28 hosts
+ *   --http     Streamable HTTP transport — stateless, both eras
  *   --setup    Configure editors for 4DA MCP
  */
 async function main() {
@@ -338,13 +341,23 @@ async function main() {
   Options:
     --http              Use Streamable HTTP instead of stdio
     --port <number>     HTTP port (default: 4840)
-    --host <address>    HTTP bind address (default: 127.0.0.1)
+    --host <address>    HTTP bind address (default: 127.0.0.1). A non-loopback
+                        address exposes every tool to the network and is
+                        refused unless MCP_AUTH_SECRET is set; authentication
+                        is then mandatory for every request.
     --setup             Detect editors and write MCP config
     --doctor            Validate database, bindings, and LLM providers
 
   Environment:
     FOURDA_DB_PATH      Path to 4DA's SQLite database (auto-detected if omitted)
     FOURDA_OFFLINE      Set to "true" to disable all network calls (OSV.dev, HN)
+    MCP_AUTH_SECRET     Shared secret for verifying relay-issued Bearer tokens
+                        (HMAC-SHA256). Falls back to JWT_SECRET. Without it, no
+                        token is accepted.
+    MCP_AUTH_REQUIRED   Set to "true" to require auth on a loopback --http bind
+                        (always required on a non-loopback bind)
+    MCP_ALLOWED_HOSTS   Extra comma-separated hostnames accepted in the Host /
+                        Origin headers (needed when binding to 0.0.0.0)
 
   Works standalone (scans your project on startup) or with the full
   4DA desktop app for content scoring, source monitoring, and more.
@@ -365,10 +378,35 @@ async function main() {
     }
     // HTTP transport mode
     if (args.includes("--http")) {
-        const portIndex = args.indexOf("--port");
-        const port = portIndex !== -1 ? parseInt(args[portIndex + 1], 10) : 4840;
-        const host = args.includes("--host") ? args[args.indexOf("--host") + 1] : "127.0.0.1";
-        await startHttpServer(server, { port, host });
+        const flagValue = (flag) => {
+            const i = args.indexOf(flag);
+            if (i === -1)
+                return undefined;
+            const value = args[i + 1];
+            // A flag with no value (or followed by another flag) is a typo, not a
+            // request to bind everywhere — refuse rather than guess.
+            if (value === undefined || value.startsWith("-")) {
+                console.error(`[4DA] ${flag} requires a value`);
+                process.exit(1);
+            }
+            return value;
+        };
+        const rawPort = flagValue("--port");
+        const port = rawPort === undefined ? 4840 : Number.parseInt(rawPort, 10);
+        if (!Number.isInteger(port) || port < 0 || port > 65535) {
+            console.error(`[4DA] Invalid --port value: ${rawPort}`);
+            process.exit(1);
+        }
+        const host = flagValue("--host") ?? "127.0.0.1";
+        try {
+            await startHttpServer(buildServer, { port, host });
+        }
+        catch (error) {
+            // Bind-policy refusals carry an actionable message; print it plainly
+            // rather than as an unhandled stack trace.
+            console.error(`[4DA] ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
         return;
     }
     // -------------------------------------------------------------------------
@@ -392,9 +430,14 @@ async function main() {
         console.error(`  Or run: npx @4da/mcp-server --doctor  for diagnostics`);
         console.error(``);
     }
-    // Default: stdio transport (existing behavior)
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+    // Default: stdio serving. `serveStdio` owns the era decision per connection —
+    // a 2025-era `initialize` opening is served exactly as before; a 2026-07-28
+    // `server/discover` opening gets the stateless modern protocol.
+    serveStdio(buildServer, {
+        onerror: (error) => {
+            console.error(`[4DA] stdio serving error: ${error.message}`);
+        },
+    });
     // Handle graceful shutdown
     process.on("SIGINT", () => {
         console.error("[4DA] Received SIGINT — shutting down gracefully");
@@ -409,7 +452,7 @@ async function main() {
         process.exit(0);
     });
     const toolCount = getSlimToolList().length;
-    console.error(`4DA MCP Server v4.6.3 started — ${toolCount} tools, stdio transport`);
+    console.error(`4DA MCP Server v${SERVER_VERSION} started — ${toolCount} tools, stdio transport`);
     console.error("  Use --http for Streamable HTTP, --setup to configure editors, --doctor to check health");
 }
 main().catch((error) => {

package/dist/tool-dispatch.d.ts

@@ -4,6 +4,7 @@
  * Map-based dispatch for the 14 active tools.
  * Adding a new tool = add to this map + schema-registry + barrel export.
  */
+import type { CallToolResult } from "@modelcontextprotocol/server";
 import type { FourDADatabase } from "./db.js";
 /**
  * Executor signature — all tool execute functions follow this shape.
@@ -13,13 +14,12 @@ export type ToolExecutor = (db: FourDADatabase, params: any) => unknown | Promis
 /**
  * Dispatch a tool call by name. Awaits uniformly (no-op for sync executors).
  * Returns MCP-formatted response with JSON-serialized result.
+ *
+ * Authenticated HTTP callers are role-checked here — the single choke point
+ * every tool call passes through. Stdio callers are unaffected (no auth
+ * context; the host already owns the process).
  */
-export declare function dispatchTool(name: string, db: FourDADatabase, args: Record<string, unknown> | undefined): Promise<{
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}>;
+export declare function dispatchTool(name: string, db: FourDADatabase, args: Record<string, unknown> | undefined): Promise<CallToolResult>;
 /** Check if a tool exists in the dispatch map */
 export declare function hasDispatchTool(name: string): boolean;
 /** Get count of registered tool executors */

package/dist/tool-dispatch.js

@@ -5,6 +5,7 @@
  * Map-based dispatch for the 14 active tools.
  * Adding a new tool = add to this map + schema-registry + barrel export.
  */
+import { assertToolPermission } from "./auth-context.js";
 import { executeGetRelevantContent, executeGetContext, executeRecordFeedback, executeGetActionableSignals, executeKnowledgeGaps, executeDecisionMemory, executeCheckDecisionAlignment, executeAgentMemory, executeDeveloperDna, executeWhatShouldIKnow, executeVulnerabilityScan, executeEcosystemPulse, executeDependencyHealth, executeUpgradePlanner, } from "./tools/index.js";
 import { getLiveIntelligence } from "./live-singleton.js";
 /**
@@ -46,12 +47,17 @@ const FRESHNESS_TOOLS = new Set([
 /**
  * Dispatch a tool call by name. Awaits uniformly (no-op for sync executors).
  * Returns MCP-formatted response with JSON-serialized result.
+ *
+ * Authenticated HTTP callers are role-checked here — the single choke point
+ * every tool call passes through. Stdio callers are unaffected (no auth
+ * context; the host already owns the process).
  */
 export async function dispatchTool(name, db, args) {
     const executor = DISPATCH_MAP[name];
     if (!executor) {
         throw new Error(`Unknown tool: ${name}`);
     }
+    assertToolPermission(name);
     const result = await executor(db, (args || {}));
     const payload = FRESHNESS_TOOLS.has(name) ? attachFreshness(db, result) : result;
     return {

package/dist/tools/get-actionable-signals.js

@@ -250,7 +250,11 @@ export function executeGetActionableSignals(db, params) {
         items = db.getRelevantContent(0.1, undefined, 200, 168); // Try 7 days
     }
     if (items.length === 0) {
-        items = db.getRelevantContent(0.0, undefined, 200, 720); // Try 30 days, any score
+        // Deep 30-day/any-score fallback reaches the stale-epoch tail after a
+        // pipeline-version bump. This path trusts stored signal_type/signal_priority
+        // verbatim (confidence 0.90 below), so it MUST only see current-version
+        // rows — stale persisted signals are claims the live brain no longer makes.
+        items = db.getRelevantContent(0.0, undefined, 200, 720, true);
     }
     // Get user's detected tech for cross-referencing
     const context = db.getUserContext(true, false);

package/dist/tools/get-relevant-content.js

@@ -60,7 +60,10 @@ export function executeGetRelevantContent(db, params) {
         items = db.getRelevantContent(minScore, params.source_type, limit, 168);
     }
     if (items.length === 0) {
-        items = db.getRelevantContent(0.0, params.source_type, limit, 720);
+        // Deep 30-day fallback at zero floor reaches the stale-epoch tail after a
+        // pipeline-version bump — require current-version scores so we never rank
+        // numbers the live scoring brain doesn't stand behind.
+        items = db.getRelevantContent(0.0, params.source_type, limit, 720, true);
     }
     return items;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4da/mcp-server",
-  "version": "4.6.6",
+  "version": "5.0.1",
   "mcpName": "io.github.4DA-Systems/4da-mcp-server",
   "description": "Dependency intelligence for AI coding agents. Live CVE scanning, dependency health, upgrade planning, ecosystem news, decision memory — zero config, privacy-first. 9 tools standalone, 14 total with desktop app.",
   "type": "module",
@@ -18,6 +18,17 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc && pnpm run copy-schemas",
+    "copy-schemas": "node -e \"const fs=require('fs');const path=require('path');const src='src/schemas';const dst='dist/schemas';if(!fs.existsSync(dst))fs.mkdirSync(dst,{recursive:true});fs.readdirSync(src).filter(f=>f.endsWith('.json')).forEach(f=>fs.copyFileSync(path.join(src,f),path.join(dst,f)))\"",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "setup": "node dist/setup.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm run build"
+  },
   "keywords": [
     "mcp",
     "mcp-server",
@@ -69,8 +80,10 @@
     "url": "https://github.com/4DA-Systems/4DA/issues"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "better-sqlite3": "^12.9.0"
+    "better-sqlite3": "^12.9.0",
+    "@modelcontextprotocol/node": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
+    "hono": "^4.12.34"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.11",
@@ -80,16 +93,20 @@
     "vitest": "^4.1.5"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
-  "scripts": {
-    "build": "tsc && pnpm run copy-schemas",
-    "copy-schemas": "node -e \"const fs=require('fs');const path=require('path');const src='src/schemas';const dst='dist/schemas';if(!fs.existsSync(dst))fs.mkdirSync(dst,{recursive:true});fs.readdirSync(src).filter(f=>f.endsWith('.json')).forEach(f=>fs.copyFileSync(path.join(src,f),path.join(dst,f)))\"",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js",
-    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
-    "setup": "node dist/setup.js",
-    "test": "vitest run",
-    "test:watch": "vitest"
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "esbuild"
+    ],
+    "overrides": {
+      "fast-uri": ">=3.1.2",
+      "ip-address": "^10.1.1",
+      "vite": ">=7.3.5 <8",
+      "esbuild": ">=0.28.1",
+      "hono": ">=4.12.34 <5",
+      "@hono/node-server": ">=2.0.5 <3"
+    }
   }
-}
+}