mergen-server 1.4.0

package/dist/storage/sqlite/sqlite-event-store.js

@@ -0,0 +1,29 @@
+import { historyStore } from "../../sensor/sqlite-store.js";
+class SqliteEventStore {
+  /** Delegates to historyStore.init() which is already async (sql.js WASM load). */
+  async init() {
+    return historyStore.init();
+  }
+  async push(event, tenantId) {
+    return Promise.resolve(historyStore.push(event, tenantId));
+  }
+  async query(opts) {
+    return Promise.resolve(historyStore.query(opts));
+  }
+  async size() {
+    return Promise.resolve(historyStore.size());
+  }
+  /**
+   * tenantId is accepted for interface conformance but ignored in SQLite mode —
+   * the underlying clear() operates on the whole single-tenant database.
+   */
+  async clear(_tenantId) {
+    return Promise.resolve(historyStore.clear());
+  }
+  async pruneOld() {
+    return Promise.resolve(historyStore.pruneOld());
+  }
+}
+export {
+  SqliteEventStore
+};

package/dist/storage/sqlite/sqlite-incident-store.js

@@ -0,0 +1,34 @@
+import { incidentStore } from "../../sensor/incident-store.js";
+class SqliteIncidentStore {
+  /** Delegates to incidentStore.init() which is already async (sql.js WASM load). */
+  async init() {
+    return incidentStore.init();
+  }
+  async upsert(pid, fields, _tenantId) {
+    return Promise.resolve(incidentStore.upsert(pid, fields));
+  }
+  async get(pid, _tenantId) {
+    return Promise.resolve(incidentStore.get(pid));
+  }
+  async list(status, limit, _tenantId) {
+    return Promise.resolve(incidentStore.list(status, limit));
+  }
+  async addNote(pid, note, author, _tenantId) {
+    return Promise.resolve(incidentStore.addNote(pid, note, author));
+  }
+  async markContextViewed(pid, _tenantId) {
+    return Promise.resolve(incidentStore.markContextViewed(pid));
+  }
+  async coOccurringServices(service, windowMs, limit, _tenantId) {
+    return Promise.resolve(incidentStore.coOccurringServices(service, windowMs, limit));
+  }
+  async updateServiceEdges(service, at, windowMs, _tenantId) {
+    return Promise.resolve(incidentStore.updateServiceEdges(service, at, windowMs));
+  }
+  async getInteractionGraph(service, _tenantId) {
+    return Promise.resolve(incidentStore.getInteractionGraph(service));
+  }
+}
+export {
+  SqliteIncidentStore
+};

package/dist/storage/sqlite/sqlite-override-corpus.js

@@ -0,0 +1,75 @@
+import {
+  recordOverride,
+  updateOutcome,
+  hasRecentOverride,
+  dominantOverrideReason,
+  getOverridesForTag,
+  getOverrideById,
+  getAllOverrides,
+  compactCorpus,
+  getRulesForTag,
+  describeTopRule,
+  getOverrideSummary,
+  compileOverrideFromSlackThread,
+  compileOverridesFromSlackThread,
+  getStaleOverrides,
+  getExpiringSoon,
+  markOverrideReviewed,
+  importOverrides
+} from "../../intelligence/override-corpus.js";
+class SqliteOverrideCorpus {
+  async recordOverride(input, _tenantId) {
+    return Promise.resolve(recordOverride(input));
+  }
+  async updateOutcome(id, outcome, _tenantId) {
+    return Promise.resolve(updateOutcome(id, outcome));
+  }
+  async hasRecentOverride(incidentTag, service, dayOfWeek, hourOfDay, _tenantId) {
+    return Promise.resolve(hasRecentOverride(incidentTag, service, dayOfWeek, hourOfDay));
+  }
+  async dominantOverrideReason(incidentTag, service, _tenantId) {
+    return Promise.resolve(dominantOverrideReason(incidentTag, service));
+  }
+  async getOverridesForTag(tag, _tenantId) {
+    return Promise.resolve(getOverridesForTag(tag));
+  }
+  async getOverrideById(id, _tenantId) {
+    return Promise.resolve(getOverrideById(id));
+  }
+  async getAllOverrides(_tenantId) {
+    return Promise.resolve(getAllOverrides());
+  }
+  async compactCorpus(_tenantId) {
+    return Promise.resolve(compactCorpus());
+  }
+  async getRulesForTag(incidentTag, service, _tenantId) {
+    return Promise.resolve(getRulesForTag(incidentTag, service));
+  }
+  async describeTopRule(incidentTag, service, _tenantId) {
+    return Promise.resolve(describeTopRule(incidentTag, service));
+  }
+  async getOverrideSummary(_tenantId) {
+    return Promise.resolve(getOverrideSummary());
+  }
+  async compileOverrideFromSlackThread(slackThread, service, _tenantId) {
+    return Promise.resolve(compileOverrideFromSlackThread(slackThread, service));
+  }
+  async compileOverridesFromSlackThread(slackThread, service, _tenantId) {
+    return Promise.resolve(compileOverridesFromSlackThread(slackThread, service));
+  }
+  async getStaleOverrides(daysThreshold = 60, _tenantId) {
+    return Promise.resolve(getStaleOverrides(daysThreshold));
+  }
+  async getExpiringSoon(windowDays = 14, _tenantId) {
+    return Promise.resolve(getExpiringSoon(windowDays));
+  }
+  async markOverrideReviewed(id, _tenantId) {
+    return Promise.resolve(markOverrideReviewed(id));
+  }
+  async importOverrides(entries, opts, _tenantId) {
+    return Promise.resolve(importOverrides(entries, opts));
+  }
+}
+export {
+  SqliteOverrideCorpus
+};

package/dist/storage/sqlite/sqlite-shadow-log.js

@@ -0,0 +1,36 @@
+import {
+  recordShadow,
+  recordShadowVerdict,
+  updateShadowReasonByPid,
+  getShadowLog,
+  getShadowReport,
+  getShadowSlackDigest,
+  exportShadowCsv
+} from "../../intelligence/shadow-log.js";
+class SqliteShadowLog {
+  async recordShadow(input, _tenantId) {
+    return Promise.resolve(recordShadow(input));
+  }
+  async recordShadowVerdict(id, verdict, opts, _tenantId) {
+    return Promise.resolve(recordShadowVerdict(id, verdict, opts));
+  }
+  async updateShadowReasonByPid(pid, skipReason, _tenantId) {
+    updateShadowReasonByPid(pid, skipReason);
+    return Promise.resolve();
+  }
+  async getShadowEntries(_tenantId) {
+    return Promise.resolve(getShadowLog());
+  }
+  async getShadowReport(windowDays = 30, _tenantId) {
+    return Promise.resolve(getShadowReport(windowDays));
+  }
+  async getShadowSlackDigest(windowDays = 7, _tenantId) {
+    return Promise.resolve(getShadowSlackDigest(windowDays));
+  }
+  async exportShadowCsv(_tenantId) {
+    return Promise.resolve(exportShadowCsv());
+  }
+}
+export {
+  SqliteShadowLog
+};

package/dist/storage/store-factory.js

@@ -0,0 +1,55 @@
+import { SqliteEventStore } from "./sqlite/sqlite-event-store.js";
+import { SqliteIncidentStore } from "./sqlite/sqlite-incident-store.js";
+import { SqliteOverrideCorpus } from "./sqlite/sqlite-override-corpus.js";
+import { SqliteApprovalStore } from "./sqlite/sqlite-approval-store.js";
+import { SqliteShadowLog } from "./sqlite/sqlite-shadow-log.js";
+import { SqliteBlunderStore } from "./sqlite/sqlite-blunder-store.js";
+import { SqliteGateHistoryStore } from "./sqlite/sqlite-ci-gate-history.js";
+import { SqliteActionLedger } from "./sqlite/sqlite-action-ledger.js";
+async function createStores() {
+  const cloudMode = process.env.MERGEN_CLOUD_MODE === "true";
+  if (cloudMode) {
+    const [
+      { PgEventStore },
+      { PgIncidentStore },
+      { PgOverrideCorpus },
+      { PgApprovalStore },
+      { PgShadowLog },
+      { PgBlunderStore },
+      { PgGateHistoryStore },
+      { PgActionLedger }
+    ] = await Promise.all([
+      import("./pg/pg-event-store.js"),
+      import("./pg/pg-incident-store.js"),
+      import("./pg/pg-override-corpus.js"),
+      import("./pg/pg-approval-store.js"),
+      import("./pg/pg-shadow-log.js"),
+      import("./pg/pg-blunder-store.js"),
+      import("./pg/pg-ci-gate-history.js"),
+      import("./pg/pg-action-ledger.js")
+    ]);
+    return {
+      events: new PgEventStore(),
+      incidents: new PgIncidentStore(),
+      overrides: new PgOverrideCorpus(),
+      approvals: new PgApprovalStore(),
+      shadowLog: new PgShadowLog(),
+      blunders: new PgBlunderStore(),
+      gateHistory: new PgGateHistoryStore(),
+      actionLedger: new PgActionLedger()
+    };
+  }
+  return {
+    events: new SqliteEventStore(),
+    incidents: new SqliteIncidentStore(),
+    overrides: new SqliteOverrideCorpus(),
+    approvals: new SqliteApprovalStore(),
+    shadowLog: new SqliteShadowLog(),
+    blunders: new SqliteBlunderStore(),
+    gateHistory: new SqliteGateHistoryStore(),
+    actionLedger: new SqliteActionLedger()
+  };
+}
+export {
+  createStores
+};

package/dist/storage/store-registry.js

@@ -0,0 +1,31 @@
+import { SqliteEventStore } from "./sqlite/sqlite-event-store.js";
+import { SqliteIncidentStore } from "./sqlite/sqlite-incident-store.js";
+import { SqliteOverrideCorpus } from "./sqlite/sqlite-override-corpus.js";
+import { SqliteApprovalStore } from "./sqlite/sqlite-approval-store.js";
+import { SqliteShadowLog } from "./sqlite/sqlite-shadow-log.js";
+import { SqliteBlunderStore } from "./sqlite/sqlite-blunder-store.js";
+import { SqliteGateHistoryStore } from "./sqlite/sqlite-ci-gate-history.js";
+import { SqliteActionLedger } from "./sqlite/sqlite-action-ledger.js";
+let _stores = null;
+function setStores(s) {
+  _stores = s;
+}
+function getStores() {
+  if (!_stores) {
+    _stores = {
+      events: new SqliteEventStore(),
+      incidents: new SqliteIncidentStore(),
+      overrides: new SqliteOverrideCorpus(),
+      approvals: new SqliteApprovalStore(),
+      shadowLog: new SqliteShadowLog(),
+      blunders: new SqliteBlunderStore(),
+      gateHistory: new SqliteGateHistoryStore(),
+      actionLedger: new SqliteActionLedger()
+    };
+  }
+  return _stores;
+}
+export {
+  getStores,
+  setStores
+};

package/dist/update-checker.js

@@ -0,0 +1,107 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+const UPDATE_CHECK_INTERVAL = 24 * 60 * 60 * 1e3;
+const GITHUB_API = "https://api.github.com/repos/omertt27/Mergen/releases/latest";
+const CACHE_DIR = resolve(homedir(), ".mergen");
+const CACHE_FILE = resolve(CACHE_DIR, "update-check.json");
+async function checkForUpdates(currentVersion) {
+  if (process.env.NO_UPDATE_NOTIFIER === "1" || process.env.NO_UPDATE_NOTIFIER === "true") {
+    return null;
+  }
+  if (process.env.CI === "true" || process.env.CI === "1") {
+    return null;
+  }
+  try {
+    const cache = readCache();
+    const now = Date.now();
+    if (cache && now - cache.lastCheck < UPDATE_CHECK_INTERVAL) {
+      if (cache.latestVersion && !cache.notified && isNewer(cache.latestVersion, currentVersion)) {
+        markNotified(cache.latestVersion);
+        return cache.latestVersion;
+      }
+      return null;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const response = await fetch(GITHUB_API, {
+      signal: controller.signal,
+      headers: { "User-Agent": "Mergen-Update-Checker" }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const latestVersion = data.tag_name.replace(/^v/, "");
+    writeCache({
+      lastCheck: now,
+      latestVersion,
+      notified: false
+    });
+    if (isNewer(latestVersion, currentVersion)) {
+      markNotified(latestVersion);
+      return latestVersion;
+    }
+    return null;
+  } catch (err) {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const latestParts = latest.split(".").map(Number);
+  const currentParts = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const l = latestParts[i] || 0;
+    const c = currentParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+}
+function readCache() {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const content = readFileSync(CACHE_FILE, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), "utf8");
+  } catch {
+  }
+}
+function markNotified(version) {
+  const cache = readCache();
+  if (cache && cache.latestVersion === version) {
+    writeCache({ ...cache, notified: true });
+  }
+}
+function formatUpdateMessage(currentVersion, latestVersion) {
+  return `
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502                                                         \u2502
+\u2502   \u{1F4E6} Mergen update available: ${currentVersion} \u2192 ${latestVersion}         \u2502
+\u2502                                                         \u2502
+\u2502   Update now:                                           \u2502
+\u2502   $ npx mergen-server@latest                            \u2502
+\u2502                                                         \u2502
+\u2502   Or globally:                                          \u2502
+\u2502   $ npm install -g mergen-server@latest                 \u2502
+\u2502                                                         \u2502
+\u2502   Changelog:                                            \u2502
+\u2502   https://github.com/omertt27/Mergen/releases          \u2502
+\u2502                                                         \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+`;
+}
+export {
+  checkForUpdates,
+  formatUpdateMessage
+};

package/dist/workers/autopilot-worker.js

@@ -0,0 +1,28 @@
+import { Worker } from "bullmq";
+import { bullConnection } from "./queues.js";
+import { runIncidentAutopilotLocal } from "../intelligence/incident-autopilot.js";
+import logger from "../sensor/logger.js";
+function startAutopilotWorker() {
+  const worker = new Worker(
+    "mergen-autopilot",
+    async (job) => {
+      const { service, pid, firedAt, tenantId, cwd } = job.data;
+      logger.info({ pid, service }, "autopilot-worker: processing job");
+      await runIncidentAutopilotLocal({ service, pid, firedAt, tenantId, cwd });
+    },
+    {
+      connection: bullConnection(),
+      concurrency: 3
+    }
+  );
+  worker.on("completed", (job) => {
+    logger.info({ jobId: job.id, pid: job.data.pid }, "autopilot-worker: job completed");
+  });
+  worker.on("failed", (job, err) => {
+    logger.error({ jobId: job?.id, pid: job?.data.pid, err }, "autopilot-worker: job failed");
+  });
+  return worker;
+}
+export {
+  startAutopilotWorker
+};

package/dist/workers/notification-worker.js

@@ -0,0 +1,28 @@
+import { Worker } from "bullmq";
+import { bullConnection } from "./queues.js";
+import logger from "../sensor/logger.js";
+function startNotificationWorker() {
+  const worker = new Worker(
+    "mergen-notifications",
+    async (job) => {
+      const { pid, text, threadTs, channel } = job.data;
+      const { postThreadReply, postSimpleWebhookNotification } = await import("../intelligence/slack.js");
+      if (threadTs) {
+        await postThreadReply(pid, text);
+      } else {
+        await postSimpleWebhookNotification(channel ?? pid, text);
+      }
+    },
+    {
+      connection: bullConnection(),
+      concurrency: 10
+    }
+  );
+  worker.on("failed", (job, err) => {
+    logger.error({ jobId: job?.id, pid: job?.data.pid, err }, "notification-worker: job failed");
+  });
+  return worker;
+}
+export {
+  startNotificationWorker
+};

package/dist/workers/queues.js

@@ -0,0 +1,58 @@
+import { Redis } from "ioredis";
+import { Queue } from "bullmq";
+function bullConnection() {
+  return getRedisConnection();
+}
+let _connection = null;
+function getRedisConnection() {
+  if (!_connection) {
+    const url = process.env.MERGEN_REDIS_URL;
+    if (!url) throw new Error("MERGEN_REDIS_URL is not set");
+    _connection = new Redis(url, { maxRetriesPerRequest: null });
+  }
+  return _connection;
+}
+function closeRedisConnection() {
+  if (_connection) {
+    const c = _connection;
+    _connection = null;
+    return c.quit().then(() => void 0);
+  }
+  return Promise.resolve();
+}
+let _autopilotQueue = null;
+let _notificationQueue = null;
+function getAutopilotQueue() {
+  if (!_autopilotQueue) {
+    _autopilotQueue = new Queue("mergen-autopilot", {
+      connection: bullConnection(),
+      defaultJobOptions: {
+        attempts: 1,
+        removeOnComplete: { count: 1e3, age: 86400 },
+        removeOnFail: { count: 500 }
+      }
+    });
+  }
+  return _autopilotQueue;
+}
+function getNotificationQueue() {
+  if (!_notificationQueue) {
+    _notificationQueue = new Queue("mergen-notifications", {
+      connection: bullConnection(),
+      defaultJobOptions: {
+        attempts: 3,
+        backoff: { type: "exponential", delay: 2e3 },
+        removeOnComplete: { count: 500 },
+        removeOnFail: { count: 200 }
+      }
+    });
+  }
+  return _notificationQueue;
+}
+export {
+  bullConnection,
+  closeRedisConnection,
+  getAutopilotQueue,
+  getNotificationQueue,
+  getRedisConnection
+};

package/dist/workers/validation-worker.js

@@ -0,0 +1,24 @@
+import { Worker } from "bullmq";
+import { bullConnection } from "./queues.js";
+import logger from "../sensor/logger.js";
+function startValidationWorker() {
+  const worker = new Worker(
+    "mergen-validation",
+    async (job) => {
+      const { service, pid, command, beforeCount, fixAppliedAt, tenantId } = job.data;
+      const { runPostFixValidation } = await import("../intelligence/incident-autopilot.js");
+      await runPostFixValidation({ service, pid, command, beforeCount, fixAppliedAt, tenantId });
+    },
+    {
+      connection: bullConnection(),
+      concurrency: 5
+    }
+  );
+  worker.on("failed", (job, err) => {
+    logger.error({ jobId: job?.id, pid: job?.data.pid, err }, "validation-worker: job failed");
+  });
+  return worker;
+}
+export {
+  startValidationWorker
+};

package/dist/workers/worker-registry.js

@@ -0,0 +1,18 @@
+import { startAutopilotWorker } from "./autopilot-worker.js";
+import { startNotificationWorker } from "./notification-worker.js";
+import logger from "../sensor/logger.js";
+const _workers = [];
+async function startWorkers() {
+  _workers.push(startAutopilotWorker());
+  _workers.push(startNotificationWorker());
+  logger.info({ count: _workers.length }, "workers: all BullMQ workers started");
+}
+async function stopWorkers() {
+  await Promise.all(_workers.map((w) => w.close()));
+  _workers.length = 0;
+  logger.info("workers: all BullMQ workers stopped");
+}
+export {
+  startWorkers,
+  stopWorkers
+};

package/package.json

@@ -0,0 +1,123 @@
+{
+  "name": "mergen-server",
+  "version": "1.4.0",
+  "description": "Mergen — AI operations layer for backend & infrastructure. Triages production incidents autonomously: OpenTelemetry + PagerDuty → causal analysis → executes fix at ≥85% confidence → validates → posts to Slack thread. MCP server for Claude Code, Cursor, Windsurf, VS Code.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mergen-server": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/__tests__/**",
+    "sdk/**",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "incident-management",
+    "autonomous-triage",
+    "sre",
+    "devops",
+    "platform-engineering",
+    "opentelemetry",
+    "otlp",
+    "pagerduty",
+    "observability",
+    "on-call",
+    "mttr",
+    "backend",
+    "infrastructure",
+    "claude",
+    "cursor",
+    "windsurf"
+  ],
+  "homepage": "https://github.com/omertt27/Mergen#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/omertt27/Mergen.git",
+    "directory": "server"
+  },
+  "bugs": {
+    "url": "https://github.com/omertt27/Mergen/issues"
+  },
+  "license": "MIT",
+  "author": "omertt27",
+  "engines": {
+    "node": ">=18.17"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepack": "mkdir -p sdk && cp ../sdk/node.js sdk/ && cp ../sdk/mergen-inject.js sdk/ && cp ../sdk/vite-plugin.ts sdk/ && cp ../sdk/webpack-plugin.js sdk/",
+    "postpack": "rm -rf sdk",
+    "build": "node scripts/build-fast.mjs && node scripts/build-cli.mjs",
+    "build:tsc": "node --max-old-space-size=12288 node_modules/.bin/tsc && node scripts/build-cli.mjs",
+    "build:server": "node --max-old-space-size=12288 node_modules/.bin/tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx watch src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "check:arch": "node scripts/check-arch.mjs",
+    "test:coverage": "vitest run --coverage",
+    "test:ci": "vitest run --config vitest.config.ci.ts",
+    "test:ci:coverage": "vitest run --config vitest.config.ci.ts --coverage",
+    "eval": "node ../scripts/eval.mjs",
+    "eval:fast": "node ../scripts/eval.mjs --model gpt-4o-mini",
+    "eval:regression": "vitest run evals",
+    "eval:update-baseline": "node ../scripts/update-eval-baseline.mjs",
+    "eval:seed-corpus": "node ../scripts/seed-corpus.mjs",
+    "benchmark": "node scripts/benchmark/run.mjs",
+    "benchmark:fp": "node scripts/benchmark/false-positive.mjs",
+    "benchmark:perf": "node --expose-gc scripts/benchmark/performance.mjs",
+    "benchmark:policy": "node scripts/benchmark/resource-policy.mjs",
+    "benchmark:incidents": "node scripts/benchmark/incident-replay.mjs",
+    "benchmark:all": "node scripts/benchmark/suite.mjs"
+  },
+  "dependencies": {
+    "@aws-sdk/client-sts": "^3.1079.0",
+    "@lemonsqueezy/lemonsqueezy.js": "^4.0.0",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.218.0",
+    "@opentelemetry/sdk-logs": "^0.218.0",
+    "bash-parser": "^0.5.0",
+    "bullmq": "^5.0.0",
+    "debug": "^4.4.0",
+    "express": "^4.22.1",
+    "fast-glob": "3.3.3",
+    "helmet": "^8.0.0",
+    "ioredis": "^5.0.0",
+    "jose": "^6.2.2",
+    "lru-cache": "11.3.5",
+    "node-sql-parser": "^5.4.0",
+    "openid-client": "^6.8.4",
+    "pino": "10.3.1",
+    "postgres": "^3.0.0",
+    "source-map": "0.7.4",
+    "sql.js": "^1.14.1",
+    "stripe": "^22.2.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/express": "4.17.21",
+    "@types/node": "20.11.5",
+    "@types/sql.js": "^1.4.11",
+    "@vitest/coverage-v8": "^4.1.9",
+    "eslint": "^9.39.4",
+    "expect-type": "^0.19.0",
+    "rolldown": "^1.1.0",
+    "tsx": "^4.21.0",
+    "typescript": "5.3.3",
+    "typescript-eslint": "^8.62.1",
+    "vitest": "^4.1.9"
+  }
+}