@dollhousemcp/mcp-server 2.0.0-rc.6 → 2.0.0

package/dist/web/routes/metricsRoutes.js

@@ -0,0 +1,90 @@
+/**
+ * Metrics API routes for the unified dev console.
+ *
+ * Mounts on the existing Express app to provide:
+ * - GET /api/metrics        — JSON query (delegates to MemoryMetricsSink)
+ * - GET /api/metrics/stream — SSE endpoint, pushes each new snapshot
+ */
+import { Router } from 'express';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+function normalizedStringParam(query, key) {
+    const val = query[key];
+    if (typeof val === 'string' && val) {
+        return UnicodeValidator.normalize(val).normalizedContent;
+    }
+    return undefined;
+}
+function parseMetricsQueryOptions(query) {
+    const options = {};
+    const names = normalizedStringParam(query, 'names');
+    if (names)
+        options['names'] = names.split(',').map(s => s.trim());
+    const source = normalizedStringParam(query, 'source');
+    if (source)
+        options['source'] = source;
+    const type = normalizedStringParam(query, 'type');
+    if (type)
+        options['type'] = type;
+    for (const field of ['since', 'until']) {
+        if (typeof query[field] === 'string' && query[field])
+            options[field] = query[field];
+    }
+    if (typeof query['latest'] === 'string') {
+        options['latest'] = query['latest'] !== 'false';
+    }
+    for (const field of ['limit', 'offset']) {
+        if (typeof query[field] === 'string') {
+            const parsed = Number.parseInt(query[field], 10);
+            if (!Number.isNaN(parsed))
+                options[field] = parsed;
+        }
+    }
+    return options;
+}
+export function createMetricsRoutes(metricsSink) {
+    const router = Router();
+    const clients = new Set();
+    // GET /api/metrics — JSON query
+    router.get('/metrics', (req, res) => {
+        const result = metricsSink.query(parseMetricsQueryOptions(req.query));
+        res.json(result);
+    });
+    // GET /api/metrics/stream — SSE endpoint for real-time metric snapshots.
+    // Currently unused by the built-in web console (which polls /api/metrics).
+    // Retained for third-party consumers (Prometheus, Grafana agent, custom dashboards)
+    // that benefit from push-based metric delivery.
+    router.get('/metrics/stream', (req, res) => {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+        });
+        res.write(':connected\n\n');
+        const client = { res };
+        clients.add(client);
+        // Keep-alive heartbeat — prevents proxies from closing idle connections
+        const heartbeat = setInterval(() => {
+            res.write(': heartbeat\n\n');
+        }, 30_000);
+        req.on('close', () => {
+            clearInterval(heartbeat);
+            clients.delete(client);
+        });
+    });
+    function onSnapshot(snapshot) {
+        const data = JSON.stringify(snapshot);
+        for (const client of clients) {
+            if (client.res.destroyed) {
+                clients.delete(client);
+                continue;
+            }
+            client.res.write(`data: ${data}\n\n`);
+        }
+    }
+    return {
+        router,
+        onSnapshot,
+        clientCount: () => clients.size,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metricsRoutes.js","sourceRoot":"","sources":["../../../src/web/routes/metricsRoutes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Metrics API routes for the unified dev console.\n *\n * Mounts on the existing Express app to provide:\n * - GET /api/metrics        — JSON query (delegates to MemoryMetricsSink)\n * - GET /api/metrics/stream — SSE endpoint, pushes each new snapshot\n */\n\nimport { Router } from 'express';\nimport type { Request, Response } from 'express';\nimport type { MemoryMetricsSink } from '../../metrics/sinks/MemoryMetricsSink.js';\nimport type { MetricSnapshot, MetricType } from '../../metrics/types.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\n\ninterface SSEClient {\n  res: Response;\n}\n\nexport interface MetricsRoutesResult {\n  router: Router;\n  onSnapshot: (snapshot: MetricSnapshot) => void;\n  clientCount: () => number;\n}\n\nfunction normalizedStringParam(query: Request['query'], key: string): string | undefined {\n  const val = query[key];\n  if (typeof val === 'string' && val) {\n    return UnicodeValidator.normalize(val).normalizedContent;\n  }\n  return undefined;\n}\n\nfunction parseMetricsQueryOptions(query: Request['query']): Record<string, unknown> {\n  const options: Record<string, unknown> = {};\n\n  const names = normalizedStringParam(query, 'names');\n  if (names) options['names'] = names.split(',').map(s => s.trim());\n\n  const source = normalizedStringParam(query, 'source');\n  if (source) options['source'] = source;\n\n  const type = normalizedStringParam(query, 'type');\n  if (type) options['type'] = type as MetricType;\n\n  for (const field of ['since', 'until'] as const) {\n    if (typeof query[field] === 'string' && query[field]) options[field] = query[field];\n  }\n  if (typeof query['latest'] === 'string') {\n    options['latest'] = query['latest'] !== 'false';\n  }\n  for (const field of ['limit', 'offset'] as const) {\n    if (typeof query[field] === 'string') {\n      const parsed = Number.parseInt(query[field], 10);\n      if (!Number.isNaN(parsed)) options[field] = parsed;\n    }\n  }\n  return options;\n}\n\nexport function createMetricsRoutes(metricsSink: MemoryMetricsSink): MetricsRoutesResult {\n  const router = Router();\n  const clients = new Set<SSEClient>();\n\n  // GET /api/metrics — JSON query\n  router.get('/metrics', (req: Request, res: Response) => {\n    const result = metricsSink.query(parseMetricsQueryOptions(req.query));\n    res.json(result);\n  });\n\n  // GET /api/metrics/stream — SSE endpoint for real-time metric snapshots.\n  // Currently unused by the built-in web console (which polls /api/metrics).\n  // Retained for third-party consumers (Prometheus, Grafana agent, custom dashboards)\n  // that benefit from push-based metric delivery.\n  router.get('/metrics/stream', (req: Request, res: Response) => {\n    res.writeHead(200, {\n      'Content-Type': 'text/event-stream',\n      'Cache-Control': 'no-cache',\n      'Connection': 'keep-alive',\n    });\n    res.write(':connected\\n\\n');\n\n    const client: SSEClient = { res };\n    clients.add(client);\n\n    // Keep-alive heartbeat — prevents proxies from closing idle connections\n    const heartbeat = setInterval(() => {\n      res.write(': heartbeat\\n\\n');\n    }, 30_000);\n\n    req.on('close', () => {\n      clearInterval(heartbeat);\n      clients.delete(client);\n    });\n  });\n\n  function onSnapshot(snapshot: MetricSnapshot): void {\n    const data = JSON.stringify(snapshot);\n    for (const client of clients) {\n      if (client.res.destroyed) { clients.delete(client); continue; }\n      client.res.write(`data: ${data}\\n\\n`);\n    }\n  }\n\n  return {\n    router,\n    onSnapshot,\n    clientCount: () => clients.size,\n  };\n}\n"]}

package/dist/web/routes/permissionRoutes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Permission evaluation HTTP routes and decision tracking.
+ *
+ * Provides:
+ * - POST /evaluate_permission — evaluates tool permissions via MCP-AQL
+ * - GET /permissions/status — returns current policies and recent decisions
+ * - Decision tracking ring buffer for the live dashboard feed
+ */
+import { Router } from 'express';
+import type { MCPAQLHandler } from '../../handlers/mcp-aql/MCPAQLHandler.js';
+/**
+ * Register permission-related routes on a gateway router.
+ * Must be called with the MCP-AQL handler for policy evaluation.
+ */
+export declare function registerPermissionRoutes(router: Router, handler: MCPAQLHandler): void;
+//# sourceMappingURL=permissionRoutes.d.ts.map

package/dist/web/routes/permissionRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/permissionRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAkD7E;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAiGrF"}

package/dist/web/routes/permissionRoutes.js

@@ -0,0 +1,133 @@
+/**
+ * Permission evaluation HTTP routes and decision tracking.
+ *
+ * Provides:
+ * - POST /evaluate_permission — evaluates tool permissions via MCP-AQL
+ * - GET /permissions/status — returns current policies and recent decisions
+ * - Decision tracking ring buffer for the live dashboard feed
+ */
+import express from 'express';
+import { logger } from '../../utils/logger.js';
+import { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';
+const DECISION_BUFFER_SIZE = 200;
+const recentDecisions = [];
+let decisionCounter = 0;
+/** Extract a string field from a record, trying multiple keys in order */
+function extractString(obj, keys, fallback) {
+    for (const key of keys) {
+        const val = obj?.[key];
+        if (typeof val === 'string')
+            return val;
+    }
+    return fallback;
+}
+function trackDecision(toolName, input, result) {
+    const entry = {
+        id: `d-${++decisionCounter}`,
+        timestamp: new Date().toISOString(),
+        tool_name: toolName,
+        command: toolName === 'Bash' && typeof input?.command === 'string' ? input.command : undefined,
+        decision: extractString(result, ['decision', 'behavior'], 'unknown'),
+        reason: extractString(result, ['reason', 'message'], ''),
+    };
+    recentDecisions.unshift(entry);
+    if (recentDecisions.length > DECISION_BUFFER_SIZE) {
+        recentDecisions.length = DECISION_BUFFER_SIZE;
+    }
+}
+/** Helper to extract single result from MCP-AQL batch response */
+function asSingleResult(results) {
+    if (Array.isArray(results))
+        return results[0] || { success: false, error: 'Empty result' };
+    return results;
+}
+/**
+ * Register permission-related routes on a gateway router.
+ * Must be called with the MCP-AQL handler for policy evaluation.
+ */
+export function registerPermissionRoutes(router, handler) {
+    /**
+     * POST /api/evaluate_permission
+     * Permission evaluation endpoint for PreToolUse hooks.
+     * Routes through evaluate_permission MCP-AQL READ operation.
+     * Fail-open: returns allow on any error to avoid blocking the user.
+     */
+    const permissionLimiter = new SlidingWindowRateLimiter(120, 60_000);
+    router.post('/evaluate_permission', express.json(), async (req, res) => {
+        if (!permissionLimiter.tryAcquire()) {
+            res.json({ decision: 'allow' }); // fail open on rate limit
+            return;
+        }
+        const body = req.body;
+        // Unicode normalization (NFC) on string inputs to prevent homograph attacks
+        const tool_name = typeof body.tool_name === 'string' ? body.tool_name.normalize('NFC') : undefined;
+        const platform = typeof body.platform === 'string' ? body.platform.normalize('NFC') : undefined;
+        const input = body.input;
+        if (!tool_name) {
+            res.json({ decision: 'allow' }); // fail open on bad input
+            return;
+        }
+        try {
+            const opResult = asSingleResult(await handler.handleRead({
+                operation: 'evaluate_permission',
+                params: {
+                    tool_name,
+                    input: input || {},
+                    platform: platform || 'claude_code',
+                },
+            }));
+            if (!opResult.success) {
+                logger.warn(`[WebUI/Gateway] evaluate_permission failed: ${opResult.error}`);
+                res.json({ decision: 'allow' }); // fail open
+                return;
+            }
+            // Track decision for live dashboard feed
+            trackDecision(tool_name, input || {}, opResult.data);
+            res.json(opResult.data);
+        }
+        catch (err) {
+            logger.error('[WebUI/Gateway] evaluate_permission error:', err);
+            res.json({ decision: 'allow' }); // fail open
+        }
+    });
+    /**
+     * GET /api/permissions/status
+     * Returns current permission policies and recent decisions
+     * for the live permissions dashboard.
+     */
+    router.get('/permissions/status', async (_req, res) => {
+        try {
+            const opResult = asSingleResult(await handler.handleRead({
+                operation: 'get_effective_cli_policies',
+            }));
+            if (!opResult.success) {
+                res.status(500).json({ error: opResult.error || 'Failed to get policies' });
+                return;
+            }
+            const data = opResult.data;
+            // Extract confirm patterns from elements
+            const elements = (data.elements || []);
+            const confirmPatterns = [];
+            for (const el of elements) {
+                const confirm = el.confirmPatterns;
+                if (confirm?.length)
+                    confirmPatterns.push(...confirm);
+            }
+            res.json({
+                activeElementCount: data.activeElementCount,
+                hasAllowlist: data.hasAllowlist,
+                denyPatterns: data.combinedDenyPatterns,
+                allowPatterns: data.combinedAllowPatterns,
+                confirmPatterns,
+                elements,
+                permissionPromptActive: data.permissionPromptActive,
+                recentDecisions,
+            });
+        }
+        catch (err) {
+            logger.error('[WebUI/Gateway] permissions/status error:', err);
+            res.status(500).json({ error: 'Failed to get permission status' });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionRoutes.js","sourceRoot":"","sources":["../../../src/web/routes/permissionRoutes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Permission evaluation HTTP routes and decision tracking.\n *\n * Provides:\n * - POST /evaluate_permission — evaluates tool permissions via MCP-AQL\n * - GET /permissions/status — returns current policies and recent decisions\n * - Decision tracking ring buffer for the live dashboard feed\n */\n\nimport express, { Router } from 'express';\nimport { logger } from '../../utils/logger.js';\nimport type { MCPAQLHandler } from '../../handlers/mcp-aql/MCPAQLHandler.js';\n\nimport { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';\n\n// ── Permission Decision Tracking ─────────────────────────────────────────────\n// Ring buffer of recent permission decisions for the live dashboard feed.\n\ninterface PermissionDecision {\n  id: string;\n  timestamp: string;\n  tool_name: string;\n  command?: string;\n  decision: string;\n  reason?: string;\n}\n\nconst DECISION_BUFFER_SIZE = 200;\nconst recentDecisions: PermissionDecision[] = [];\nlet decisionCounter = 0;\n\n/** Extract a string field from a record, trying multiple keys in order */\nfunction extractString(obj: Record<string, unknown>, keys: string[], fallback: string): string {\n  for (const key of keys) {\n    const val = obj?.[key];\n    if (typeof val === 'string') return val;\n  }\n  return fallback;\n}\n\nfunction trackDecision(toolName: string, input: Record<string, unknown>, result: Record<string, unknown>): void {\n  const entry: PermissionDecision = {\n    id: `d-${++decisionCounter}`,\n    timestamp: new Date().toISOString(),\n    tool_name: toolName,\n    command: toolName === 'Bash' && typeof input?.command === 'string' ? input.command : undefined,\n    decision: extractString(result, ['decision', 'behavior'], 'unknown'),\n    reason: extractString(result, ['reason', 'message'], ''),\n  };\n  recentDecisions.unshift(entry);\n  if (recentDecisions.length > DECISION_BUFFER_SIZE) {\n    recentDecisions.length = DECISION_BUFFER_SIZE;\n  }\n}\n\n/** Helper to extract single result from MCP-AQL batch response */\nfunction asSingleResult(results: unknown): { success: boolean; data?: unknown; error?: string } {\n  if (Array.isArray(results)) return results[0] || { success: false, error: 'Empty result' };\n  return results as { success: boolean; data?: unknown; error?: string };\n}\n\n/**\n * Register permission-related routes on a gateway router.\n * Must be called with the MCP-AQL handler for policy evaluation.\n */\nexport function registerPermissionRoutes(router: Router, handler: MCPAQLHandler): void {\n  /**\n   * POST /api/evaluate_permission\n   * Permission evaluation endpoint for PreToolUse hooks.\n   * Routes through evaluate_permission MCP-AQL READ operation.\n   * Fail-open: returns allow on any error to avoid blocking the user.\n   */\n  const permissionLimiter = new SlidingWindowRateLimiter(120, 60_000);\n  router.post('/evaluate_permission', express.json(), async (req, res) => {\n    if (!permissionLimiter.tryAcquire()) {\n      res.json({ decision: 'allow' }); // fail open on rate limit\n      return;\n    }\n\n    const body = req.body as {\n      tool_name?: string;\n      input?: Record<string, unknown>;\n      platform?: string;\n    };\n\n    // Unicode normalization (NFC) on string inputs to prevent homograph attacks\n    const tool_name = typeof body.tool_name === 'string' ? body.tool_name.normalize('NFC') : undefined;\n    const platform = typeof body.platform === 'string' ? body.platform.normalize('NFC') : undefined;\n    const input = body.input;\n\n    if (!tool_name) {\n      res.json({ decision: 'allow' }); // fail open on bad input\n      return;\n    }\n\n    try {\n      const opResult = asSingleResult(await handler.handleRead({\n        operation: 'evaluate_permission',\n        params: {\n          tool_name,\n          input: input || {},\n          platform: platform || 'claude_code',\n        },\n      }));\n\n      if (!opResult.success) {\n        logger.warn(`[WebUI/Gateway] evaluate_permission failed: ${opResult.error}`);\n        res.json({ decision: 'allow' }); // fail open\n        return;\n      }\n\n      // Track decision for live dashboard feed\n      trackDecision(tool_name, input || {}, opResult.data as Record<string, unknown>);\n\n      res.json(opResult.data);\n    } catch (err) {\n      logger.error('[WebUI/Gateway] evaluate_permission error:', err);\n      res.json({ decision: 'allow' }); // fail open\n    }\n  });\n\n  /**\n   * GET /api/permissions/status\n   * Returns current permission policies and recent decisions\n   * for the live permissions dashboard.\n   */\n  router.get('/permissions/status', async (_req, res) => {\n    try {\n      const opResult = asSingleResult(await handler.handleRead({\n        operation: 'get_effective_cli_policies',\n      }));\n\n      if (!opResult.success) {\n        res.status(500).json({ error: opResult.error || 'Failed to get policies' });\n        return;\n      }\n\n      const data = opResult.data as Record<string, unknown>;\n\n      // Extract confirm patterns from elements\n      const elements = (data.elements || []) as Array<Record<string, unknown>>;\n      const confirmPatterns: string[] = [];\n      for (const el of elements) {\n        const confirm = el.confirmPatterns as string[] | undefined;\n        if (confirm?.length) confirmPatterns.push(...confirm);\n      }\n\n      res.json({\n        activeElementCount: data.activeElementCount,\n        hasAllowlist: data.hasAllowlist,\n        denyPatterns: data.combinedDenyPatterns,\n        allowPatterns: data.combinedAllowPatterns,\n        confirmPatterns,\n        elements,\n        permissionPromptActive: data.permissionPromptActive,\n        recentDecisions,\n      });\n    } catch (err) {\n      logger.error('[WebUI/Gateway] permissions/status error:', err);\n      res.status(500).json({ error: 'Failed to get permission status' });\n    }\n  });\n}\n"]}

package/dist/web/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/web/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAK1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AA6E1E,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAsa5D;AA0BD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CA2P3F"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/web/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAM1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAgd1E,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAiJ5D;AAqBD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CA0H3F"}