@fudrouter/fsrouter 0.6.63 → 0.6.64

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

@@ -1,229 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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
-};