mergen-server 1.4.0

package/dist/sensor/layer3-store.js

@@ -0,0 +1,230 @@
+import { randomBytes } from "crypto";
+import { store } from "./buffer.js";
+const MAX_SNAPSHOTS = 50;
+class Layer3Store {
+  breakpoints = /* @__PURE__ */ new Map();
+  mocks = /* @__PURE__ */ new Map();
+  injectedLogs = /* @__PURE__ */ new Map();
+  pendingCommands = /* @__PURE__ */ new Map();
+  snapshots = [];
+  /** Set a conditional breakpoint */
+  setBreakpoint(condition, eventType, pattern) {
+    const id = randomBytes(8).toString("hex");
+    this.breakpoints.set(id, {
+      id,
+      condition,
+      eventType,
+      pattern,
+      createdAt: Date.now(),
+      hitCount: 0
+    });
+    return id;
+  }
+  /** Remove a breakpoint */
+  removeBreakpoint(id) {
+    return this.breakpoints.delete(id);
+  }
+  /** List all active breakpoints */
+  listBreakpoints() {
+    return Array.from(this.breakpoints.values());
+  }
+  /** Check if event matches any breakpoint. Captures a snapshot on hit. */
+  checkBreakpoint(event) {
+    for (const bp of this.breakpoints.values()) {
+      if (this.matchesBreakpoint(event, bp)) {
+        bp.hitCount++;
+        this._captureSnapshot(bp, event);
+        return bp;
+      }
+    }
+    return null;
+  }
+  _captureSnapshot(bp, triggeringEvent) {
+    const recentLogs = store.getLogs(20);
+    const recentNetwork = store.getNetwork(10);
+    const contextSnaps = store.getContext(1);
+    const summary = triggeringEvent.type === "console" ? (triggeringEvent.args ?? []).map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 200) : triggeringEvent.type === "network" ? `${triggeringEvent.method} ${triggeringEvent.url} \u2192 ${triggeringEvent.status}` : triggeringEvent.type;
+    const snap = {
+      id: randomBytes(8).toString("hex"),
+      capturedAt: Date.now(),
+      trigger: { breakpointId: bp.id, eventType: triggeringEvent.type, summary },
+      recentLogs,
+      recentNetwork,
+      contextSnapshot: contextSnaps[0] ?? null,
+      stack: triggeringEvent.stack
+    };
+    this.snapshots.push(snap);
+    if (this.snapshots.length > MAX_SNAPSHOTS) this.snapshots.shift();
+  }
+  /** Return all captured snapshots, newest first. */
+  listSnapshots() {
+    return [...this.snapshots].reverse();
+  }
+  /** Get a single snapshot by id. */
+  getSnapshot(id) {
+    return this.snapshots.find((s) => s.id === id);
+  }
+  /** Clear all snapshots. */
+  clearSnapshots() {
+    this.snapshots = [];
+  }
+  /** Register a mock response */
+  setMock(url, method, status, body, headers) {
+    const id = randomBytes(8).toString("hex");
+    this.mocks.set(id, {
+      id,
+      url,
+      method: method.toUpperCase(),
+      status,
+      body,
+      headers,
+      createdAt: Date.now(),
+      hitCount: 0
+    });
+    this.queueCommand("SET_MOCK", { id, url, method, status, body, headers });
+    return id;
+  }
+  /** Remove a mock */
+  removeMock(id) {
+    const mock = this.mocks.get(id);
+    if (mock) {
+      this.queueCommand("REMOVE_MOCK", { id });
+      return this.mocks.delete(id);
+    }
+    return false;
+  }
+  /** List all active mocks */
+  listMocks() {
+    return Array.from(this.mocks.values());
+  }
+  /** Check if request should be mocked */
+  getMock(url, method) {
+    for (const mock of this.mocks.values()) {
+      if (this.urlMatches(url, mock.url) && method.toUpperCase() === mock.method) {
+        mock.hitCount++;
+        return mock;
+      }
+    }
+    return null;
+  }
+  /** Inject a temporary log */
+  injectLog(selector, event, expression) {
+    const id = randomBytes(8).toString("hex");
+    this.injectedLogs.set(id, {
+      id,
+      selector,
+      event,
+      expression,
+      createdAt: Date.now(),
+      captured: []
+    });
+    this.queueCommand("INJECT_LOG", { id, selector, event, expression });
+    return id;
+  }
+  /** Remove an injected log */
+  removeInjectedLog(id) {
+    const log = this.injectedLogs.get(id);
+    if (log) {
+      this.queueCommand("REMOVE_LOG", { id });
+      return this.injectedLogs.delete(id);
+    }
+    return false;
+  }
+  /** List all injected logs */
+  listInjectedLogs() {
+    return Array.from(this.injectedLogs.values());
+  }
+  /** Store captured data from injected log */
+  captureLogData(id, data) {
+    const log = this.injectedLogs.get(id);
+    if (log) {
+      log.captured.push({ timestamp: Date.now(), data });
+      if (log.captured.length >= 1) {
+        this.removeInjectedLog(id);
+      }
+    }
+  }
+  /** Queue a command to be sent to extension */
+  queueCommand(type, payload) {
+    const id = randomBytes(8).toString("hex");
+    this.pendingCommands.set(id, { type, payload, queuedAt: Date.now() });
+  }
+  /** Get and clear pending commands for extension polling */
+  getPendingCommands() {
+    const commands = Array.from(this.pendingCommands.values());
+    this.pendingCommands.clear();
+    return commands;
+  }
+  matchesBreakpoint(event, bp) {
+    if (event.type !== bp.eventType) return false;
+    try {
+      const regex = new RegExp(bp.pattern, "i");
+      if (event.type === "console") {
+        const message = event.args?.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ") || "";
+        if (!regex.test(message)) return false;
+      }
+      if (event.type === "network") {
+        if (!regex.test(event.url)) return false;
+      }
+      if (bp.condition) {
+        return this.evaluateCondition(bp.condition, event);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  evaluateCondition(condition, event) {
+    try {
+      const match = condition.match(/(\w+)\s*(===|!==|>|<|>=|<=)\s*(.+)/);
+      if (!match) return true;
+      const [, key, op, value] = match;
+      const actualValue = event[key];
+      let expectedValue = value.trim();
+      if (expectedValue.startsWith("'") || expectedValue.startsWith('"')) {
+        expectedValue = expectedValue.slice(1, -1);
+      } else if (!isNaN(Number(expectedValue))) {
+        expectedValue = Number(expectedValue);
+      }
+      switch (op) {
+        case "===":
+          return actualValue === expectedValue;
+        case "!==":
+          return actualValue !== expectedValue;
+        case ">":
+          return actualValue > expectedValue;
+        case "<":
+          return actualValue < expectedValue;
+        case ">=":
+          return actualValue >= expectedValue;
+        case "<=":
+          return actualValue <= expectedValue;
+        default:
+          return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+  urlMatches(url, pattern) {
+    const regex = new RegExp(
+      "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$",
+      "i"
+    );
+    return regex.test(url);
+  }
+  /** Clear old commands to prevent memory leak */
+  pruneOldCommands() {
+    const MAX_AGE_MS = 6e4;
+    const now = Date.now();
+    for (const [id, cmd] of this.pendingCommands) {
+      if (now - cmd.queuedAt > MAX_AGE_MS) {
+        this.pendingCommands.delete(id);
+      }
+    }
+  }
+}
+const layer3Store = new Layer3Store();
+export {
+  layer3Store
+};

package/dist/sensor/layer4-store.js

@@ -0,0 +1,147 @@
+import { createHash } from "crypto";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const ERROR_INDEX_PATH = join(homedir(), ".mergen", "error-index.json");
+const MAX_ERROR_ENTRIES = 1e3;
+class Layer4Store {
+  errorIndex = /* @__PURE__ */ new Map();
+  constructor() {
+    this.load();
+  }
+  /** Generate fingerprint from error message and stack */
+  fingerprint(message, stack) {
+    const stackLines = stack?.split("\n").slice(0, 3).join("\n") || "";
+    const input = `${message}
+${stackLines}`;
+    return createHash("sha256").update(input).digest("hex").slice(0, 16);
+  }
+  /** Record an error occurrence */
+  recordError(message, stack) {
+    const fp = this.fingerprint(message, stack);
+    const existing = this.errorIndex.get(fp);
+    if (existing) {
+      existing.count++;
+      existing.lastSeen = Date.now();
+    } else {
+      this.errorIndex.set(fp, {
+        fingerprint: fp,
+        message: message.slice(0, 500),
+        stack: stack?.slice(0, 2e3),
+        count: 1,
+        firstSeen: Date.now(),
+        lastSeen: Date.now(),
+        fixes: []
+      });
+    }
+    this.persist();
+    return fp;
+  }
+  /** Link a fix to an error */
+  linkFix(fingerprint, commitSha, description, verdict = "correct") {
+    const entry = this.errorIndex.get(fingerprint);
+    if (!entry) return false;
+    const existing = entry.fixes.find((f) => f.commitSha === commitSha);
+    if (existing) {
+      existing.verdict = verdict;
+      existing.confidence = this.calculateConfidence(verdict);
+    } else {
+      entry.fixes.push({
+        commitSha,
+        description: description.slice(0, 500),
+        linkedAt: Date.now(),
+        verdict,
+        confidence: this.calculateConfidence(verdict)
+      });
+    }
+    this.persist();
+    return true;
+  }
+  /** Get error history for a fingerprint */
+  getError(fingerprint) {
+    return this.errorIndex.get(fingerprint);
+  }
+  /** Search for similar errors */
+  searchErrors(query, limit = 10) {
+    const results = [];
+    const queryLower = query.toLowerCase();
+    for (const entry of this.errorIndex.values()) {
+      const messageLower = entry.message.toLowerCase();
+      if (messageLower.includes(queryLower)) {
+        const score = messageLower === queryLower ? 1 : 0.5;
+        results.push({ entry, score });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score || b.entry.count - a.entry.count).slice(0, limit).map((r) => r.entry);
+  }
+  /** Get top fix for an error */
+  getTopFix(fingerprint) {
+    const entry = this.errorIndex.get(fingerprint);
+    if (!entry || entry.fixes.length === 0) return void 0;
+    return entry.fixes.sort((a, b) => b.confidence - a.confidence)[0];
+  }
+  /** List all errors, sorted by most recent */
+  listErrors(limit = 50) {
+    return Array.from(this.errorIndex.values()).sort((a, b) => b.lastSeen - a.lastSeen).slice(0, limit);
+  }
+  /** Load from disk */
+  load() {
+    try {
+      if (!existsSync(ERROR_INDEX_PATH)) return;
+      const data = JSON.parse(readFileSync(ERROR_INDEX_PATH, "utf-8"));
+      if (Array.isArray(data)) {
+        for (const entry of data) {
+          this.errorIndex.set(entry.fingerprint, entry);
+        }
+      }
+    } catch (err) {
+      console.error("[layer4] Failed to load error index:", err);
+    }
+  }
+  /** Persist to disk */
+  persist() {
+    try {
+      const dir = join(homedir(), ".mergen");
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      if (this.errorIndex.size > MAX_ERROR_ENTRIES) {
+        const sorted = Array.from(this.errorIndex.values()).sort((a, b) => b.lastSeen - a.lastSeen).slice(0, MAX_ERROR_ENTRIES);
+        this.errorIndex.clear();
+        for (const entry of sorted) {
+          this.errorIndex.set(entry.fingerprint, entry);
+        }
+      }
+      const data = Array.from(this.errorIndex.values());
+      writeFileSync(ERROR_INDEX_PATH, JSON.stringify(data, null, 2), "utf-8");
+    } catch (err) {
+      console.error("[layer4] Failed to persist error index:", err);
+    }
+  }
+  calculateConfidence(verdict) {
+    switch (verdict) {
+      case "correct":
+        return 1;
+      case "partial":
+        return 0.6;
+      case "wrong":
+        return 0.2;
+      default:
+        return 0.5;
+    }
+  }
+  /** Get statistics */
+  getStats() {
+    const totalErrors = this.errorIndex.size;
+    const totalFixes = Array.from(this.errorIndex.values()).reduce(
+      (sum, e) => sum + e.fixes.length,
+      0
+    );
+    const avgFixesPerError = totalErrors > 0 ? totalFixes / totalErrors : 0;
+    return { totalErrors, totalFixes, avgFixesPerError };
+  }
+}
+const layer4Store = new Layer4Store();
+export {
+  layer4Store
+};

package/dist/sensor/logger.js

@@ -0,0 +1,13 @@
+import pino from "pino";
+const logger = pino(
+  {
+    name: "mergen",
+    level: process.env.LOG_LEVEL ?? "info"
+  },
+  pino.destination(2)
+  // stderr
+);
+var logger_default = logger;
+export {
+  logger_default as default
+};

package/dist/sensor/otel-exporter.js

@@ -0,0 +1,161 @@
+import { trace, context as otelCtx, TraceFlags } from "@opentelemetry/api";
+import logger from "./logger.js";
+const _m = {
+  errorCount: 0,
+  networkErrorCount: 0,
+  requestCount: 0,
+  requestDurationTotalMs: 0,
+  requestDurationSamples: 0
+};
+function _recordCounters(event) {
+  if (event.type === "console" && event.level === "error") {
+    _m.errorCount++;
+  } else if (event.type === "network") {
+    _m.requestCount++;
+    _m.requestDurationTotalMs += event.duration;
+    _m.requestDurationSamples++;
+    if (event.status >= 400 || event.status === 0 || event.error) _m.networkErrorCount++;
+  }
+}
+function getPrometheusMetrics() {
+  const avg = _m.requestDurationSamples > 0 ? Math.round(_m.requestDurationTotalMs / _m.requestDurationSamples) : 0;
+  return [
+    "# HELP mergen_browser_error_total Total browser console errors since server start",
+    "# TYPE mergen_browser_error_total counter",
+    `mergen_browser_error_total ${_m.errorCount}`,
+    "# HELP mergen_browser_network_error_total Total failed network requests (4xx/5xx/network error)",
+    "# TYPE mergen_browser_network_error_total counter",
+    `mergen_browser_network_error_total ${_m.networkErrorCount}`,
+    "# HELP mergen_browser_request_total Total network requests captured",
+    "# TYPE mergen_browser_request_total counter",
+    `mergen_browser_request_total ${_m.requestCount}`,
+    "# HELP mergen_browser_request_duration_avg_ms Rolling average request duration in milliseconds",
+    "# TYPE mergen_browser_request_duration_avg_ms gauge",
+    `mergen_browser_request_duration_avg_ms ${avg}`
+  ].join("\n") + "\n";
+}
+function getMetricCounters() {
+  return _m;
+}
+let _config = null;
+let _loggerProvider = null;
+let _otelLogger = null;
+function getOtelConfig() {
+  return _config;
+}
+function isOtelEnabled() {
+  return _config?.enabled === true;
+}
+async function createProvider(cfg) {
+  if (_loggerProvider) {
+    await _loggerProvider.shutdown().catch(() => {
+    });
+    _loggerProvider = null;
+    _otelLogger = null;
+  }
+  const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-http");
+  const { LoggerProvider, SimpleLogRecordProcessor } = await import("@opentelemetry/sdk-logs");
+  const resourcesModule = await import("@opentelemetry/resources");
+  const Resource = resourcesModule.Resource;
+  const exporter = new OTLPLogExporter({
+    url: cfg.endpoint,
+    headers: cfg.headers ?? {}
+  });
+  const resource = Resource ? new Resource({
+    "service.name": cfg.serviceName ?? "mergen",
+    "service.version": "1.0.0",
+    "deployment.environment": "development"
+  }) : void 0;
+  _loggerProvider = new LoggerProvider({ resource });
+  _loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(exporter));
+  const { logs } = await import("@opentelemetry/api-logs");
+  logs.setGlobalLoggerProvider(_loggerProvider);
+  _otelLogger = _loggerProvider.getLogger("mergen.browser");
+  logger.info({ endpoint: cfg.endpoint, service: cfg.serviceName ?? "mergen" }, "OTel log exporter configured");
+}
+async function configureOtel(cfg) {
+  _config = cfg;
+  if (cfg.enabled) {
+    await createProvider(cfg);
+  }
+}
+async function disableOtel() {
+  _config = null;
+  if (_loggerProvider) {
+    await _loggerProvider.shutdown().catch(() => {
+    });
+    _loggerProvider = null;
+    _otelLogger = null;
+  }
+  logger.info("OTel log exporter disabled");
+}
+function exportToOtel(event) {
+  _recordCounters(event);
+  if (!_otelLogger || !_config?.enabled) return;
+  try {
+    const severityMap = {
+      error: 16,
+      // SeverityNumber.ERROR
+      warn: 13,
+      // SeverityNumber.WARN
+      log: 9,
+      // SeverityNumber.INFO
+      info: 9,
+      // SeverityNumber.INFO
+      debug: 5
+      // SeverityNumber.DEBUG
+    };
+    const isNetwork = event.type === "network";
+    const isConsole = event.type === "console";
+    const eventUrl = "url" in event ? event.url : void 0;
+    const severityText = isConsole ? event.level ?? "log" : "info";
+    const severityNumber = isConsole ? severityMap[event.level ?? "log"] ?? 9 : 9;
+    const body = isConsole ? event.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ") : isNetwork ? `${event.method} ${event.url} \u2192 ${event.status}` : event.type === "context" ? `context: ${event.url}` : event.type === "diagnostic" ? `${event.source} ${event.file}:${event.line}:${event.column} ${event.message}` : event.type === "terminal" ? `${event.terminalName}: ${event.data}` : event.type === "test_result" ? `${event.runner} ${event.status} ${event.name}` : event.type === "process_exit" ? `${event.process} exited (${event.reason})` : `${event.type} event`;
+    let logContext = void 0;
+    const networkTraceId = isNetwork ? event.traceId : void 0;
+    if (networkTraceId && networkTraceId.length === 32) {
+      try {
+        const spanContext = {
+          traceId: networkTraceId,
+          spanId: networkTraceId.slice(16),
+          // deterministic span ID derived from traceId
+          traceFlags: TraceFlags.SAMPLED,
+          isRemote: true
+        };
+        logContext = trace.setSpanContext(otelCtx.active(), spanContext);
+      } catch {
+      }
+    }
+    _otelLogger.emit({
+      severityNumber,
+      severityText,
+      body,
+      timestamp: new Date(event.timestamp),
+      ...logContext ? { context: logContext } : {},
+      attributes: {
+        ...eventUrl ? { "browser.url": eventUrl } : {},
+        "mergen.event_type": event.type,
+        ...isConsole && event.stack ? { "exception.stacktrace": event.stack } : {},
+        ...isNetwork ? {
+          "http.method": event.method,
+          "http.url": event.url,
+          "http.status_code": event.status,
+          ...event.traceId ? { "trace_id": event.traceId } : {},
+          ...event.tracestate ? { "w3c.tracestate": event.tracestate } : {},
+          ...event.baggage ? { "w3c.baggage": JSON.stringify(event.baggage) } : {}
+        } : {}
+      }
+    });
+  } catch (err) {
+    logger.warn({ err }, "OTel export failed");
+  }
+}
+export {
+  configureOtel,
+  disableOtel,
+  exportToOtel,
+  getMetricCounters,
+  getOtelConfig,
+  getPrometheusMetrics,
+  isOtelEnabled
+};

package/dist/sensor/paths.js

@@ -0,0 +1,71 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+const DATA_DIR = process.env.MERGEN_DATA_DIR ?? path.join(os.homedir(), ".mergen");
+const LICENSE_FILE = path.join(DATA_DIR, "license.json");
+const USAGE_FILE = path.join(DATA_DIR, "usage.json");
+const TEAM_FILE = path.join(DATA_DIR, "team.json");
+const TELEMETRY_FILE = path.join(DATA_DIR, "telemetry.json");
+function getLocalOrGlobal(filename) {
+  try {
+    const localDir = path.join(process.cwd(), ".mergen");
+    if (fs.existsSync(localDir)) {
+      return path.join(localDir, filename);
+    }
+  } catch {
+  }
+  return path.join(DATA_DIR, filename);
+}
+const SECRET_FILE = path.join(DATA_DIR, "secret");
+const HISTORY_DB = path.join(DATA_DIR, "history.db");
+const SESSION_FILE = path.join(DATA_DIR, "session.json");
+const SESSIONS_DIR = path.join(DATA_DIR, "sessions");
+const AUDIT_LOG = path.join(DATA_DIR, "audit.log");
+const AUDIT_DB = path.join(DATA_DIR, "audit.db");
+const TOPOLOGY_FILE = path.join(DATA_DIR, "topology.json");
+const CONFIG_FILE = path.join(DATA_DIR, "config.json");
+const RBAC_FILE = path.join(DATA_DIR, "rbac.json");
+const OVERRIDE_CORPUS_FILE = getLocalOrGlobal("override-corpus.json");
+const SHADOW_LOG_FILE = path.join(DATA_DIR, "shadow-log.json");
+const POSTMORTEMS_DB = path.join(DATA_DIR, "postmortems.db");
+const CI_GATE_HISTORY_FILE = path.join(DATA_DIR, "ci-gate-history.json");
+const PR_SHADOW_FILE = path.join(DATA_DIR, "pr-shadow.json");
+const CALIBRATION_FILE = getLocalOrGlobal("calibration.json");
+const USER_RUNBOOKS_DIR = path.join(DATA_DIR, "runbooks");
+const APPROVALS_FILE = path.join(DATA_DIR, "approval-pending.json");
+const SAFETY_POLICY_FILE = path.join(DATA_DIR, "safety-policy.json");
+const BYPASS_PENDING_FILE = path.join(DATA_DIR, "bypass-pending.json");
+const HITL_HOLDS_FILE = path.join(DATA_DIR, "hitl-holds.json");
+const OIDC_SIGNING_KEY_FILE = path.join(DATA_DIR, "oidc-signing-key.json");
+function zeroRetentionMode() {
+  return process.env.MERGEN_ZERO_RETENTION === "true";
+}
+export {
+  APPROVALS_FILE,
+  AUDIT_DB,
+  AUDIT_LOG,
+  BYPASS_PENDING_FILE,
+  CALIBRATION_FILE,
+  CI_GATE_HISTORY_FILE,
+  CONFIG_FILE,
+  DATA_DIR,
+  HISTORY_DB,
+  HITL_HOLDS_FILE,
+  LICENSE_FILE,
+  OIDC_SIGNING_KEY_FILE,
+  OVERRIDE_CORPUS_FILE,
+  POSTMORTEMS_DB,
+  PR_SHADOW_FILE,
+  RBAC_FILE,
+  SAFETY_POLICY_FILE,
+  SECRET_FILE,
+  SESSIONS_DIR,
+  SESSION_FILE,
+  SHADOW_LOG_FILE,
+  TEAM_FILE,
+  TELEMETRY_FILE,
+  TOPOLOGY_FILE,
+  USAGE_FILE,
+  USER_RUNBOOKS_DIR,
+  zeroRetentionMode
+};