@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/mcp-server/httpTransport.js

@@ -0,0 +1,229 @@
+import { randomUUID } from "node:crypto";
+import { createMcpServer } from "./server.ts";
+import { withMcpHttpAuthContext } from "./httpAuthContext.ts";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+let _sseServer = null;
+let _sseTransport = null;
+let _sseStartedAt = null;
+const _streamableSessions = /* @__PURE__ */ new Map();
+const MCP_SESSION_IDLE_MS = 5 * 60 * 1e3;
+const _mcpSessionSweep = setInterval(() => {
+  const now = Date.now();
+  for (const [sessionId, session] of _streamableSessions) {
+    if (now - session.lastActivityAt > MCP_SESSION_IDLE_MS) {
+      try {
+        closeStreamableSession(sessionId);
+      } catch {
+      }
+    }
+  }
+}, 6e4);
+if (typeof _mcpSessionSweep === "object" && "unref" in _mcpSessionSweep) {
+  _mcpSessionSweep.unref?.();
+}
+function closeSseTransport() {
+  if (_sseTransport) {
+    try {
+      _sseTransport.close();
+    } catch {
+    }
+  }
+  _sseServer = null;
+  _sseTransport = null;
+  _sseStartedAt = null;
+}
+function closeStreamableSession(sessionId) {
+  const session = _streamableSessions.get(sessionId);
+  if (!session) {
+    return;
+  }
+  try {
+    session.transport.close();
+  } catch {
+  }
+  _streamableSessions.delete(sessionId);
+}
+function closeAllStreamableSessions() {
+  for (const sessionId of _streamableSessions.keys()) {
+    closeStreamableSession(sessionId);
+  }
+}
+function ensureSseServer() {
+  if (_sseServer && _sseTransport) {
+    return { server: _sseServer, transport: _sseTransport };
+  }
+  closeAllStreamableSessions();
+  _sseServer = createMcpServer();
+  _sseTransport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID()
+  });
+  _sseStartedAt = Date.now();
+  void _sseServer.connect(_sseTransport);
+  console.log("[MCP] HTTP transport started (sse)");
+  return { server: _sseServer, transport: _sseTransport };
+}
+function createStreamableSession() {
+  closeSseTransport();
+  const sessionId = randomUUID();
+  const server = createMcpServer();
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: () => sessionId
+  });
+  const session = {
+    sessionId,
+    server,
+    transport,
+    startedAt: Date.now(),
+    lastActivityAt: Date.now()
+  };
+  void server.connect(transport);
+  _streamableSessions.set(sessionId, session);
+  console.log(`[MCP] HTTP transport started (streamable-http:${sessionId})`);
+  return session;
+}
+async function isInitializeRequest(request) {
+  if (request.method !== "POST") {
+    return false;
+  }
+  try {
+    const body = await request.clone().json();
+    return body?.method === "initialize";
+  } catch {
+    return false;
+  }
+}
+function errorResponse(message, code, status = 400) {
+  return new Response(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      error: { code, message },
+      id: null
+    }),
+    {
+      status,
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+function withSessionHeader(response, sessionId) {
+  if (response.headers.get("mcp-session-id")) {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  headers.set("mcp-session-id", sessionId);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+async function handleStreamableRequest(request) {
+  const sessionId = request.headers.get("mcp-session-id");
+  if (sessionId) {
+    const session2 = _streamableSessions.get(sessionId);
+    if (!session2) {
+      if (await isInitializeRequest(request)) {
+        const newSession = createStreamableSession();
+        try {
+          const response = await withMcpHttpAuthContext(
+            request,
+            () => newSession.transport.handleRequest(request)
+          );
+          return withSessionHeader(response, newSession.sessionId);
+        } catch (err) {
+          closeStreamableSession(newSession.sessionId);
+          console.error("[MCP] Streamable HTTP error during stale-session recovery:", err);
+          return new Response(JSON.stringify({ error: "MCP transport error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }
+      return errorResponse("Not Found: Unknown Mcp-Session-Id header", -32e3, 404);
+    }
+    try {
+      session2.lastActivityAt = Date.now();
+      const response = await withMcpHttpAuthContext(
+        request,
+        () => session2.transport.handleRequest(request)
+      );
+      if (request.method === "DELETE") {
+        closeStreamableSession(sessionId);
+      }
+      return withSessionHeader(response, sessionId);
+    } catch (err) {
+      console.error("[MCP] Streamable HTTP error:", err);
+      if (request.method === "DELETE") {
+        closeStreamableSession(sessionId);
+      }
+      return new Response(JSON.stringify({ error: "MCP transport error" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+  if (!await isInitializeRequest(request)) {
+    return errorResponse("Bad Request: Mcp-Session-Id header is required", -32e3);
+  }
+  const session = createStreamableSession();
+  try {
+    const response = await withMcpHttpAuthContext(
+      request,
+      () => session.transport.handleRequest(request)
+    );
+    return withSessionHeader(response, session.sessionId);
+  } catch (err) {
+    closeStreamableSession(session.sessionId);
+    console.error("[MCP] Streamable HTTP error:", err);
+    return new Response(JSON.stringify({ error: "MCP transport error" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+async function handleMcpStreamableHTTP(request) {
+  return handleStreamableRequest(request);
+}
+async function handleMcpSSE(request) {
+  const { transport } = ensureSseServer();
+  try {
+    return await withMcpHttpAuthContext(request, () => transport.handleRequest(request));
+  } catch (err) {
+    console.error("[MCP] SSE error:", err);
+    return new Response(JSON.stringify({ error: "MCP SSE transport error" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+function getMcpHttpStatus() {
+  const streamableStartedAt = _streamableSessions.size > 0 ? Math.min(...Array.from(_streamableSessions.values(), (session) => session.startedAt)) : null;
+  const startedAt = streamableStartedAt ?? _sseStartedAt;
+  const transport = _streamableSessions.size > 0 ? "streamable-http" : _sseTransport ? "sse" : null;
+  const online = transport !== null;
+  return {
+    online,
+    transport,
+    startedAt,
+    uptime: startedAt ? `${Math.floor((Date.now() - startedAt) / 1e3)}s` : null
+  };
+}
+function isMcpHttpTransportReady(enabled, transport) {
+  return enabled && (transport === "sse" || transport === "streamable-http");
+}
+function shutdownMcpHttp() {
+  closeSseTransport();
+  closeAllStreamableSessions();
+  console.log("[MCP] HTTP transport shutdown");
+}
+function isMcpHttpActive() {
+  return _sseTransport !== null || _streamableSessions.size > 0;
+}
+export {
+  getMcpHttpStatus,
+  handleMcpSSE,
+  handleMcpStreamableHTTP,
+  isMcpHttpActive,
+  isMcpHttpTransportReady,
+  shutdownMcpHttp
+};

package/open-sse/mcp-server/index.js

@@ -0,0 +1,33 @@
+import { createMcpServer, startMcpStdio } from "./server.ts";
+import { logToolCall, getRecentAuditEntries, getAuditStats, queryAuditEntries } from "./audit.ts";
+import {
+  resolveMcpHeartbeatPath,
+  readMcpHeartbeat,
+  isMcpHeartbeatOnline,
+  isProcessAlive
+} from "./runtimeHeartbeat.ts";
+import {
+  handleMcpSSE,
+  handleMcpStreamableHTTP,
+  getMcpHttpStatus,
+  shutdownMcpHttp,
+  isMcpHttpActive
+} from "./httpTransport.ts";
+export * from "./schemas/index.ts";
+export {
+  createMcpServer,
+  getAuditStats,
+  getMcpHttpStatus,
+  getRecentAuditEntries,
+  handleMcpSSE,
+  handleMcpStreamableHTTP,
+  isMcpHeartbeatOnline,
+  isMcpHttpActive,
+  isProcessAlive,
+  logToolCall,
+  queryAuditEntries,
+  readMcpHeartbeat,
+  resolveMcpHeartbeatPath,
+  shutdownMcpHttp,
+  startMcpStdio
+};

package/open-sse/mcp-server/mcpCallerIdentity.js

@@ -0,0 +1,21 @@
+import { getMcpHttpAuthHeadersForInternalFetch } from "./httpAuthContext.ts";
+import { extractApiKey } from "../../sse/services/auth.ts";
+import { getApiKeyMetadata } from "../../lib/db/apiKeys.ts";
+async function resolvePrincipalFromHeaders(headers, lookup = getApiKeyMetadata) {
+  if (!headers.Authorization && !headers["x-api-key"]) return void 0;
+  const rawKey = extractApiKey({ headers: new Headers(headers) }, { allowUrl: false });
+  if (!rawKey) return void 0;
+  try {
+    const meta = await lookup(rawKey);
+    return meta?.id != null && meta.id !== "" ? String(meta.id) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveMcpCallerApiKeyId() {
+  return resolvePrincipalFromHeaders(getMcpHttpAuthHeadersForInternalFetch());
+}
+export {
+  resolveMcpCallerApiKeyId,
+  resolvePrincipalFromHeaders
+};

package/open-sse/mcp-server/runtimeHeartbeat.js

@@ -0,0 +1,110 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const HEARTBEAT_FILE = "mcp-heartbeat.json";
+const RUNTIME_DIR = "runtime";
+const DEFAULT_INTERVAL_MS = 5e3;
+function resolveDataDir() {
+  const configured = process.env.DATA_DIR;
+  if (typeof configured === "string" && configured.trim().length > 0) {
+    return configured.trim();
+  }
+  return join(homedir(), ".omniroute");
+}
+function resolveMcpHeartbeatPath() {
+  return join(resolveDataDir(), RUNTIME_DIR, HEARTBEAT_FILE);
+}
+async function writeHeartbeat(snapshot) {
+  const heartbeatPath = resolveMcpHeartbeatPath();
+  const runtimeDir = join(resolveDataDir(), RUNTIME_DIR);
+  await fs.mkdir(runtimeDir, { recursive: true });
+  await fs.writeFile(heartbeatPath, JSON.stringify(snapshot, null, 2), "utf-8");
+}
+function startMcpHeartbeat(config) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let timer = null;
+  let stopped = false;
+  const intervalMs = typeof config.intervalMs === "number" && config.intervalMs > 0 ? config.intervalMs : DEFAULT_INTERVAL_MS;
+  const tick = async () => {
+    if (stopped) return;
+    const snapshot = {
+      pid: process.pid,
+      startedAt,
+      lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: config.version,
+      transport: "stdio",
+      scopesEnforced: config.scopesEnforced,
+      allowedScopes: [...config.allowedScopes],
+      toolCount: config.toolCount
+    };
+    try {
+      await writeHeartbeat(snapshot);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("[MCP Heartbeat] Failed to write heartbeat:", message);
+    }
+  };
+  void tick();
+  timer = setInterval(() => {
+    void tick();
+  }, intervalMs);
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    void tick();
+  };
+}
+async function readMcpHeartbeat() {
+  const heartbeatPath = resolveMcpHeartbeatPath();
+  try {
+    const raw = await fs.readFile(heartbeatPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "string" || typeof parsed.lastHeartbeatAt !== "string" || typeof parsed.version !== "string" || parsed.transport !== "stdio" || typeof parsed.scopesEnforced !== "boolean" || !Array.isArray(parsed.allowedScopes) || typeof parsed.toolCount !== "number") {
+      return null;
+    }
+    const allowedScopes = parsed.allowedScopes.filter((scope) => {
+      return typeof scope === "string";
+    });
+    return {
+      pid: parsed.pid,
+      startedAt: parsed.startedAt,
+      lastHeartbeatAt: parsed.lastHeartbeatAt,
+      version: parsed.version,
+      transport: "stdio",
+      scopesEnforced: parsed.scopesEnforced,
+      allowedScopes,
+      toolCount: parsed.toolCount
+    };
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMcpHeartbeatOnline(snapshot, options) {
+  if (!snapshot) return false;
+  const staleAfterMs = typeof options?.staleAfterMs === "number" && options.staleAfterMs > 0 ? options.staleAfterMs : DEFAULT_INTERVAL_MS * 3;
+  const elapsed = Date.now() - new Date(snapshot.lastHeartbeatAt).getTime();
+  if (!Number.isFinite(elapsed) || elapsed > staleAfterMs) return false;
+  if (options?.requireLivePid === false) return true;
+  return isProcessAlive(snapshot.pid);
+}
+export {
+  isMcpHeartbeatOnline,
+  isProcessAlive,
+  readMcpHeartbeat,
+  resolveMcpHeartbeatPath,
+  startMcpHeartbeat
+};

package/open-sse/mcp-server/schemas/a2a.js

@@ -0,0 +1,153 @@
+import { z } from "zod";
+const AgentSkillSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  tags: z.array(z.string()),
+  examples: z.array(z.string()).optional()
+});
+const AgentCardSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  url: z.string().url(),
+  version: z.string(),
+  capabilities: z.object({
+    streaming: z.boolean(),
+    pushNotifications: z.boolean()
+  }),
+  skills: z.array(AgentSkillSchema),
+  authentication: z.object({
+    schemes: z.array(z.string()),
+    apiKeyHeader: z.string().optional()
+  })
+});
+const TaskStateEnum = z.enum(["submitted", "working", "completed", "failed", "cancelled"]);
+const TaskInputSchema = z.object({
+  messages: z.array(
+    z.object({
+      role: z.string(),
+      content: z.string()
+    })
+  ).optional(),
+  model: z.string().optional(),
+  combo: z.string().optional(),
+  budget: z.number().optional(),
+  role: z.enum(["coding", "review", "planning", "analysis", "debugging", "documentation"]).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+const CostEnvelopeSchema = z.object({
+  estimated: z.number(),
+  actual: z.number(),
+  currency: z.string().default("USD")
+});
+const ResilienceTraceEventSchema = z.object({
+  event: z.string(),
+  provider: z.string().optional(),
+  reason: z.string().optional(),
+  timestamp: z.string()
+});
+const PolicyVerdictSchema = z.object({
+  allowed: z.boolean(),
+  reason: z.string(),
+  restrictions: z.array(z.string()).optional()
+});
+const TaskOutputSchema = z.object({
+  response: z.object({
+    content: z.string(),
+    model: z.string(),
+    tokens: z.object({
+      prompt: z.number(),
+      completion: z.number()
+    })
+  }).optional(),
+  routingExplanation: z.string().optional(),
+  costEnvelope: CostEnvelopeSchema.optional(),
+  resilienceTrace: z.array(ResilienceTraceEventSchema).optional(),
+  policyVerdict: PolicyVerdictSchema.optional()
+});
+const TaskSchema = z.object({
+  id: z.string().uuid(),
+  state: TaskStateEnum,
+  skillId: z.string(),
+  input: TaskInputSchema.optional(),
+  output: TaskOutputSchema.optional(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  completedAt: z.string().datetime().nullable().optional(),
+  expiresAt: z.string().datetime().nullable().optional()
+});
+const JsonRpcRequestSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  method: z.enum(["message/send", "message/stream", "tasks/get", "tasks/cancel"]),
+  params: z.record(z.string(), z.unknown()),
+  id: z.union([z.string(), z.number()])
+});
+const JsonRpcResponseSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  result: z.unknown().optional(),
+  error: z.object({
+    code: z.number(),
+    message: z.string(),
+    data: z.unknown().optional()
+  }).optional(),
+  id: z.union([z.string(), z.number()]).nullable()
+});
+const MessageSendParamsSchema = z.object({
+  task: z.object({
+    skillId: z.string()
+  }).optional(),
+  message: z.object({
+    role: z.string().default("user"),
+    content: z.string(),
+    metadata: z.record(z.string(), z.unknown()).optional()
+  }),
+  config: z.object({
+    model: z.string().optional(),
+    combo: z.string().optional(),
+    budget: z.number().optional(),
+    taskRole: z.enum(["coding", "review", "planning", "analysis", "debugging", "documentation"]).optional()
+  }).optional()
+});
+const TasksGetParamsSchema = z.object({
+  taskId: z.string().uuid()
+});
+const TasksCancelParamsSchema = z.object({
+  taskId: z.string().uuid()
+});
+const A2A_SSE_EVENTS = {
+  TASK_STATUS: "task.status",
+  TASK_ARTIFACT: "task.artifact",
+  TASK_CHUNK: "task.chunk",
+  TASK_COMPLETE: "task.complete",
+  TASK_ERROR: "task.error",
+  HEARTBEAT: "heartbeat"
+};
+const A2A_ERROR_CODES = {
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  TASK_NOT_FOUND: -32001,
+  TASK_ALREADY_COMPLETED: -32002,
+  UNAUTHORIZED: -32003,
+  BUDGET_EXCEEDED: -32004,
+  PROVIDER_UNAVAILABLE: -32005
+};
+export {
+  A2A_ERROR_CODES,
+  A2A_SSE_EVENTS,
+  AgentCardSchema,
+  AgentSkillSchema,
+  CostEnvelopeSchema,
+  JsonRpcRequestSchema,
+  JsonRpcResponseSchema,
+  MessageSendParamsSchema,
+  PolicyVerdictSchema,
+  ResilienceTraceEventSchema,
+  TaskInputSchema,
+  TaskOutputSchema,
+  TaskSchema,
+  TaskStateEnum,
+  TasksCancelParamsSchema,
+  TasksGetParamsSchema
+};

package/open-sse/mcp-server/schemas/audit.js

@@ -0,0 +1,17 @@
+async function hashInput(input) {
+  const data = JSON.stringify(input);
+  const encoder = new TextEncoder();
+  const hashBuffer = await crypto.subtle.digest("SHA-256", encoder.encode(data));
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function summarizeOutput(output, maxLength = 200) {
+  if (output === null || output === void 0) return "(null)";
+  const str = typeof output === "string" ? output : JSON.stringify(output);
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength) + "\u2026";
+}
+export {
+  hashInput,
+  summarizeOutput
+};