mergen-server 1.4.0

package/dist/intelligence/tools-sessions.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { listSessionMetas, loadSessionsByTimeRange } from "../sensor/session-history.js";
+import { getAuditLog } from "../sensor/audit-log.js";
+import { trackCall, withTierGate } from "./tools-state.js";
+import { getTierForTool } from "./tool-manifest.js";
+function registerSessionTools(server) {
+  server.registerTool(
+    "get_session_replay",
+    {
+      description: 'Retrieves events from past debugging sessions archived to disk. Use when you need historical context: "what errors happened yesterday at 3pm?", "show me the session from this morning", "compare error counts across sessions". Sessions are auto-saved when the buffer is cleared or the server restarts. Tip: call with list_only:true first to see what sessions are available.',
+      inputSchema: {
+        since: z.number().int().optional().describe("Start of time window as Unix ms timestamp (default: 24 h ago)"),
+        until: z.number().int().optional().describe("End of time window as Unix ms timestamp (default: now)"),
+        limit: z.number().int().min(1).max(500).optional().describe("Max events to return (default 200)"),
+        list_only: z.boolean().optional().describe("Return only session metadata without loading events (fast)")
+      }
+    },
+    async ({ since, until, limit = 200, list_only = false }) => {
+      trackCall("get_session_replay");
+      const metas = listSessionMetas();
+      if (metas.length === 0) {
+        return { content: [{ type: "text", text: "No past sessions found. Sessions are auto-saved on buffer clear and server restart. Capture some events first." }] };
+      }
+      if (list_only) {
+        const lines2 = [
+          `## Past Sessions (${metas.length} total)`,
+          "",
+          ...metas.slice(0, 20).map(
+            (m) => `- **${new Date(m.savedAt).toISOString()}** \u2014 ${m.eventCount} events \xB7 _${m.label}_`
+          )
+        ];
+        if (metas.length > 20) lines2.push(`_\u2026and ${metas.length - 20} more_`);
+        return { content: [{ type: "text", text: lines2.join("\n") }] };
+      }
+      const now = Date.now();
+      const sinceMs = since ?? now - 24 * 60 * 60 * 1e3;
+      const untilMs = until ?? now;
+      const events = loadSessionsByTimeRange(sinceMs, untilMs).slice(0, limit);
+      if (events.length === 0) {
+        const rangeStr = `${new Date(sinceMs).toISOString()} \u2192 ${new Date(untilMs).toISOString()}`;
+        const available = metas.slice(0, 5).map((m) => `  ${new Date(m.savedAt).toISOString()} (${m.eventCount} events)`).join("\n");
+        return { content: [{ type: "text", text: `No events found in range ${rangeStr}.
+
+Most recent sessions:
+${available}` }] };
+      }
+      const errors = events.filter((e) => e.type === "console" && e.level === "error");
+      const netFails = events.filter((e) => e.type === "network" && (e.status ?? 0) >= 400);
+      const lines = [
+        `## Session Replay`,
+        "",
+        `**Range:** ${new Date(sinceMs).toISOString()} \u2192 ${new Date(untilMs).toISOString()}`,
+        `**Events:** ${events.length} returned \xB7 ${errors.length} errors \xB7 ${netFails.length} network failures`,
+        "",
+        "### Console Errors"
+      ];
+      if (errors.length === 0) {
+        lines.push("No errors in this window.");
+      } else {
+        for (const e of errors.slice(0, 20)) {
+          const args = e.args ?? [];
+          const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 200);
+          lines.push(`- ${new Date(e.timestamp).toISOString()} \u2014 ${msg}`);
+        }
+        if (errors.length > 20) lines.push(`_\u2026${errors.length - 20} more errors_`);
+      }
+      lines.push("", "### Network Failures");
+      if (netFails.length === 0) {
+        lines.push("No network failures in this window.");
+      } else {
+        for (const e of netFails.slice(0, 20)) {
+          const n = e;
+          lines.push(`- ${new Date(e.timestamp).toISOString()} \u2014 ${n.method ?? "GET"} ${n.url} \u2192 ${n.status} (${n.duration}ms)`);
+        }
+        if (netFails.length > 20) lines.push(`_\u2026${netFails.length - 20} more failures_`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "get_audit_log",
+    {
+      description: "Returns the enterprise audit log \u2014 a record of all API calls made to this Mergen instance. Each entry shows: timestamp, actor identity, HTTP method + path, response status, and duration. Use for security reviews, compliance audits, or investigating unexpected access patterns.",
+      inputSchema: {
+        limit: z.number().int().min(1).max(500).optional().describe("Max entries to return, newest first (default 100)")
+      }
+    },
+    withTierGate(getTierForTool("get_audit_log"), async ({ limit = 100 }) => {
+      trackCall("get_audit_log");
+      const entries = getAuditLog(limit);
+      if (entries.length === 0) {
+        return { content: [{ type: "text", text: "Audit log is empty. Entries are written for all non-trivial API requests." }] };
+      }
+      const lines = [
+        `## Audit Log (last ${entries.length} entries)`,
+        "",
+        ...entries.map(
+          (e) => `${e.ts}  ${e.actor.padEnd(20)}  ${e.method.padEnd(6)}  ${e.path.padEnd(35)}  ${e.status}  ${e.durationMs}ms`
+        )
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    })
+  );
+}
+export {
+  registerSessionTools
+};

package/dist/intelligence/tools-state.js

@@ -0,0 +1,232 @@
+import { planAllowsGate, minPlanForGate, getPlan, describeEntitlement, estimateToolCallOverageCents, estimateSeatOverageCents } from "./plans.js";
+import { getActivePlanId } from "./license.js";
+import { getToolCallCounts as getGateMediatedToolCallCounts } from "./gate-analytics.js";
+import { listMembers } from "../sensor/rbac.js";
+function entitlementLines() {
+  const { unlocked, upgradeLines } = describeEntitlement(getActivePlanId());
+  const out = [];
+  if (unlocked.length > 0) {
+    out.push("", "**Governance unlocked:**");
+    for (const cap of unlocked) out.push(`  \u2022 ${cap}`);
+  }
+  if (upgradeLines.length > 0) out.push("", ...upgradeLines);
+  return out;
+}
+function executionUsageLines() {
+  const planId = getActivePlanId();
+  const plan = getPlan(planId);
+  let toolCallsThisMonth = 0;
+  for (const count of getGateMediatedToolCallCounts().values()) toolCallsThisMonth += count;
+  const activeSeats = listMembers().length;
+  const includedCalls = plan.includedToolCallsPerMonth;
+  const seatCap = plan.seatCap;
+  const toolCallOverageCents = estimateToolCallOverageCents(planId, toolCallsThisMonth);
+  const seatOverageCents = estimateSeatOverageCents(planId, activeSeats);
+  const out = ["", "**Execution volume (mediated tool-calls):**"];
+  out.push(includedCalls === 0 ? `  \u2022 ${toolCallsThisMonth} tool-call(s) this month (unlimited plan)` : `  \u2022 ${toolCallsThisMonth} / ${includedCalls} tool-call(s) this month`);
+  if (toolCallOverageCents > 0) {
+    out.push(`  \u2022 Estimated overage: $${(toolCallOverageCents / 100).toFixed(2)}`);
+  }
+  if (isFinite(seatCap)) {
+    out.push(`  \u2022 Seats: ${activeSeats} / ${seatCap} included`);
+    if (seatOverageCents > 0) {
+      out.push(`  \u2022 Seat overage: $${(seatOverageCents / 100).toFixed(2)}`);
+    }
+  }
+  return out;
+}
+const KNOWN_TOOLS = /* @__PURE__ */ new Set([
+  // Analysis
+  "quick_check",
+  "explain_warning",
+  "session_summary",
+  "analyze_runtime",
+  "reconstruct_context",
+  "explain_why",
+  "get_change_timeline",
+  "get_error_frequency",
+  "get_anomaly_baseline",
+  "get_regression_start",
+  "get_repro_steps",
+  "get_causal_graph",
+  // Buffer reads
+  "get_recent_logs",
+  "get_network_activity",
+  "get_dom_context",
+  "get_component_tree",
+  "get_diagnostics",
+  "get_test_results",
+  "get_snapshots",
+  "get_websocket_activity",
+  "get_sse_activity",
+  "get_service_topology",
+  // Backend / infra
+  "get_process_logs",
+  "get_backend_logs",
+  "get_backend_spans",
+  "get_correlated_trace",
+  "get_ci_results",
+  "get_deployments",
+  "get_unified_timeline",
+  "get_service_graph",
+  // Blast radius
+  "get_blast_radius",
+  "get_code_owners",
+  "get_attribution_accuracy",
+  // Incidents
+  "triage_incident",
+  "execute_fix",
+  "validate_fix",
+  "get_incident_history",
+  "list_open_incidents",
+  // Datadog
+  "get_incident_context",
+  "get_datadog_trace",
+  "get_datadog_logs",
+  // Debug sessions
+  "inject_logpoint",
+  "remove_logpoint",
+  "start_debug_session",
+  "checkpoint_debug_session",
+  "end_debug_session",
+  // Runbook / postmortem
+  "create_postmortem",
+  "list_postmortems",
+  "check_fix_history",
+  "explain_service",
+  "generate_runbook",
+  "search_postmortems",
+  "draft_postmortem",
+  "start_runbook",
+  "suggest_followups",
+  "find_similar_incidents",
+  // Sessions / audit
+  "get_session_replay",
+  "get_audit_log",
+  // Memory
+  "store_agent_memory",
+  "recall_agent_memory",
+  "get_override_patterns",
+  "get_detector_calibration",
+  "check_staged_changes",
+  // Intent
+  "create_ticket",
+  // Cloud credential broker
+  "request_credential",
+  // Utility
+  "clear_buffer",
+  "get_status",
+  "mark_capture_start",
+  "export_session",
+  "suggest_logging_locations",
+  "watch_for_fix",
+  "stop_file_watch",
+  // ADR / discovery / agent workflow
+  "search_adrs",
+  "discover_repo_context",
+  "report_confidence",
+  "plan_rollback",
+  "get_buffer_schema",
+  "get_behavior_map",
+  // Architectural governance
+  "check_arch_violations",
+  "score_change_risk",
+  "query_arch_graph",
+  "critique_implementation",
+  // Discovery and environment
+  "get_system_status",
+  "get_env_snapshot",
+  "get_diff_from_baseline"
+]);
+const toolCallCounts = {};
+let lastMcpCallAt = null;
+let firstAnalyzeAt = null;
+let lastTimeToFirstAnalysisMs = null;
+let _lastClearAt = Date.now();
+let humanCallCount = 0;
+let agentCallCount = 0;
+const AGENT_BURST_WINDOW_MS = 1e4;
+const AGENT_BURST_THRESHOLD = 5;
+const _recentCallTs = [];
+function getAgentCallRatio() {
+  const total = humanCallCount + agentCallCount;
+  return total > 0 ? agentCallCount / total : 0;
+}
+function trackCall(tool) {
+  if (!KNOWN_TOOLS.has(tool)) return;
+  const now = Date.now();
+  lastMcpCallAt = now;
+  toolCallCounts[tool] = (toolCallCounts[tool] ?? 0) + 1;
+  _recentCallTs.push(now);
+  while (_recentCallTs.length > 0 && now - _recentCallTs[0] > AGENT_BURST_WINDOW_MS) {
+    _recentCallTs.shift();
+  }
+  if (_recentCallTs.length >= AGENT_BURST_THRESHOLD) {
+    agentCallCount++;
+  } else {
+    humanCallCount++;
+  }
+}
+function buildCreditBar(used, total) {
+  const pct = Math.min(1, used / total);
+  const filled = Math.round(pct * 10);
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(10 - filled)}] ${Math.round(pct * 100)}%`;
+}
+function setFirstAnalyzeAt(ts) {
+  firstAnalyzeAt = ts;
+}
+function setLastTimeToFirstAnalysisMs(ms) {
+  lastTimeToFirstAnalysisMs = ms;
+}
+function setLastClearAt(ts) {
+  _lastClearAt = ts;
+}
+function getLastClearAt() {
+  return _lastClearAt;
+}
+function withTierGate(gate, handler) {
+  if (gate === "free" || gate === "all") return handler;
+  return async (...args) => {
+    const planId = getActivePlanId();
+    if (!planAllowsGate(planId, gate)) {
+      const currentPlan = getPlan(planId);
+      const requiredPlan = getPlan(minPlanForGate(gate));
+      return {
+        content: [{
+          type: "text",
+          text: [
+            `## Tool requires the ${requiredPlan.name} plan`,
+            "",
+            `You are on **${currentPlan.name}**. This tool unlocks on **${requiredPlan.name}** (${requiredPlan.priceDescription}) and above.`,
+            "",
+            `**Upgrade at:** ${requiredPlan.ctaUrl}`,
+            "",
+            "To check your current plan: call `get_status`.",
+            'To activate a license key: `POST /license { "key": "..." }`'
+          ].join("\n")
+        }]
+      };
+    }
+    return handler(...args);
+  };
+}
+export {
+  KNOWN_TOOLS,
+  agentCallCount,
+  buildCreditBar,
+  entitlementLines,
+  executionUsageLines,
+  firstAnalyzeAt,
+  getActivePlanId,
+  getAgentCallRatio,
+  getLastClearAt,
+  humanCallCount,
+  lastMcpCallAt,
+  lastTimeToFirstAnalysisMs,
+  setFirstAnalyzeAt,
+  setLastClearAt,
+  setLastTimeToFirstAnalysisMs,
+  toolCallCounts,
+  trackCall,
+  withTierGate
+};