@sovr/sql-proxy 0.0.1 → 2.0.0

package/index.cjs

@@ -0,0 +1,840 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SqlProxy: () => SqlProxy,
+  detectSqlInjection: () => detectSqlInjection,
+  parseSQL: () => parseSQL
+});
+module.exports = __toCommonJS(index_exports);
+var net = __toESM(require("net"), 1);
+var import_node_events = require("events");
+var PROXY_SQL_VERSION = "2.0.0";
+var VERSION_CHECK_URL = "https://api.sovr.inc/api/sovr/v1/version/check";
+var DEFAULT_METERING_ENDPOINT = "https://sovr-ai-mkzgqqeh.manus.space/api/v1/metering/batch";
+var IRREVERSIBLE_SQL_REGEX = /^(DELETE|DROP|TRUNCATE|ALTER|UPDATE|INSERT|CREATE|GRANT|REVOKE|COPY)$/i;
+var SQL_INJECTION_PATTERNS = [
+  { name: "union_injection", pattern: /\bUNION\s+(ALL\s+)?SELECT\b/i, severity: "critical" },
+  { name: "tautology", pattern: /\bOR\s+['"]?\d+['"]?\s*=\s*['"]?\d+['"]?/i, severity: "high" },
+  { name: "tautology_string", pattern: /\bOR\s+['"][^'"]*['"]\s*=\s*['"][^'"]*['"]/i, severity: "high" },
+  { name: "comment_injection", pattern: /--\s*$|\/\*.*\*\//i, severity: "high" },
+  { name: "stacked_queries", pattern: /;\s*(DROP|DELETE|UPDATE|INSERT|ALTER|TRUNCATE|GRANT|REVOKE)\b/i, severity: "critical" },
+  { name: "sleep_injection", pattern: /\b(SLEEP|WAITFOR|BENCHMARK|PG_SLEEP)\s*\(/i, severity: "critical" },
+  { name: "information_schema", pattern: /\bINFORMATION_SCHEMA\b/i, severity: "high" },
+  { name: "hex_encoding", pattern: /0x[0-9a-fA-F]{8,}/i, severity: "high" },
+  { name: "char_encoding", pattern: /\bCHR\s*\(\s*\d+\s*\)/i, severity: "high" },
+  { name: "load_file", pattern: /\b(LOAD_FILE|INTO\s+OUTFILE|INTO\s+DUMPFILE)\b/i, severity: "critical" }
+];
+function parseSQL(sql) {
+  const trimmed = sql.trim();
+  const normalized = trimmed.replace(/\s+/g, " ").toUpperCase();
+  const isMultiStatement = trimmed.split(";").filter((s) => s.trim().length > 0).length > 1;
+  const type = classifyStatement(normalized);
+  const tables = extractTables(normalized, type);
+  const hasWhereClause = checkWhereClause(normalized, type);
+  return {
+    type,
+    tables,
+    hasWhereClause,
+    isMultiStatement,
+    raw: trimmed
+  };
+}
+function classifyStatement(sql) {
+  const first = sql.split(/\s/)[0];
+  switch (first) {
+    case "SELECT":
+      return "SELECT";
+    case "INSERT":
+      return "INSERT";
+    case "UPDATE":
+      return "UPDATE";
+    case "DELETE":
+      return "DELETE";
+    case "DROP":
+      return "DROP";
+    case "ALTER":
+      return "ALTER";
+    case "TRUNCATE":
+      return "TRUNCATE";
+    case "CREATE":
+      return "CREATE";
+    case "GRANT":
+      return "GRANT";
+    case "REVOKE":
+      return "REVOKE";
+    case "BEGIN":
+    case "START":
+      return "BEGIN";
+    case "COMMIT":
+      return "COMMIT";
+    case "ROLLBACK":
+      return "ROLLBACK";
+    case "SET":
+      return "SET";
+    case "SHOW":
+      return "SHOW";
+    case "EXPLAIN":
+      return "EXPLAIN";
+    case "COPY":
+      return "COPY";
+    default:
+      return "OTHER";
+  }
+}
+function extractTables(sql, type) {
+  const tables = [];
+  try {
+    switch (type) {
+      case "SELECT": {
+        const fromMatch = sql.match(/\bFROM\s+([A-Z0-9_."]+(?:\s*,\s*[A-Z0-9_."]+)*)/);
+        if (fromMatch) {
+          tables.push(
+            ...fromMatch[1].split(",").map((t) => t.trim().replace(/"/g, "").split(/\s/)[0])
+          );
+        }
+        const joinMatches = sql.matchAll(/\bJOIN\s+([A-Z0-9_."]+)/g);
+        for (const m of joinMatches) {
+          tables.push(m[1].replace(/"/g, ""));
+        }
+        break;
+      }
+      case "INSERT": {
+        const intoMatch = sql.match(/\bINTO\s+([A-Z0-9_."]+)/);
+        if (intoMatch) tables.push(intoMatch[1].replace(/"/g, ""));
+        break;
+      }
+      case "UPDATE": {
+        const updateMatch = sql.match(/\bUPDATE\s+([A-Z0-9_."]+)/);
+        if (updateMatch) tables.push(updateMatch[1].replace(/"/g, ""));
+        break;
+      }
+      case "DELETE": {
+        const deleteFromMatch = sql.match(/\bFROM\s+([A-Z0-9_."]+)/);
+        if (deleteFromMatch) tables.push(deleteFromMatch[1].replace(/"/g, ""));
+        break;
+      }
+      case "DROP": {
+        const dropMatch = sql.match(/\bDROP\s+(?:TABLE|INDEX|VIEW|SCHEMA|DATABASE)\s+(?:IF\s+EXISTS\s+)?([A-Z0-9_."]+)/);
+        if (dropMatch) tables.push(dropMatch[1].replace(/"/g, ""));
+        break;
+      }
+      case "ALTER": {
+        const alterMatch = sql.match(/\bALTER\s+TABLE\s+([A-Z0-9_."]+)/);
+        if (alterMatch) tables.push(alterMatch[1].replace(/"/g, ""));
+        break;
+      }
+      case "TRUNCATE": {
+        const truncMatch = sql.match(/\bTRUNCATE\s+(?:TABLE\s+)?([A-Z0-9_."]+)/);
+        if (truncMatch) tables.push(truncMatch[1].replace(/"/g, ""));
+        break;
+      }
+      case "CREATE": {
+        const createMatch = sql.match(/\bCREATE\s+(?:TABLE|INDEX|VIEW|SCHEMA|DATABASE)\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Z0-9_."]+)/);
+        if (createMatch) tables.push(createMatch[1].replace(/"/g, ""));
+        break;
+      }
+      case "COPY": {
+        const copyMatch = sql.match(/\bCOPY\s+([A-Z0-9_."]+)/);
+        if (copyMatch) tables.push(copyMatch[1].replace(/"/g, ""));
+        break;
+      }
+    }
+  } catch {
+  }
+  return tables.map((t) => t.toLowerCase()).filter(Boolean);
+}
+function checkWhereClause(sql, type) {
+  if (type === "SELECT" || type === "UPDATE" || type === "DELETE") {
+    return /\bWHERE\b/.test(sql);
+  }
+  return true;
+}
+function detectSqlInjection(sql) {
+  const matched = [];
+  let maxSeverity = "none";
+  for (const { name, pattern, severity } of SQL_INJECTION_PATTERNS) {
+    if (pattern.test(sql)) {
+      matched.push(name);
+      if (severity === "critical" || severity === "high" && maxSeverity === "none") {
+        maxSeverity = severity;
+      }
+    }
+  }
+  return {
+    detected: matched.length > 0,
+    patterns: matched,
+    severity: maxSeverity
+  };
+}
+var PG_MSG = {
+  QUERY: "Q".charCodeAt(0),
+  PARSE: "P".charCodeAt(0),
+  BIND: "B".charCodeAt(0),
+  EXECUTE: "E".charCodeAt(0),
+  TERMINATE: "X".charCodeAt(0),
+  ERROR_RESPONSE: "E".charCodeAt(0),
+  READY_FOR_QUERY: "Z".charCodeAt(0),
+  ROW_DESCRIPTION: "T".charCodeAt(0),
+  DATA_ROW: "D".charCodeAt(0),
+  COMMAND_COMPLETE: "C".charCodeAt(0),
+  AUTHENTICATION: "R".charCodeAt(0),
+  PARAMETER_STATUS: "S".charCodeAt(0),
+  BACKEND_KEY_DATA: "K".charCodeAt(0),
+  NOTICE_RESPONSE: "N".charCodeAt(0)
+};
+function buildPgErrorResponse(severity, code, message) {
+  const fields = [];
+  fields.push(Buffer.from("S"));
+  fields.push(Buffer.from(severity + "\0"));
+  fields.push(Buffer.from("V"));
+  fields.push(Buffer.from(severity + "\0"));
+  fields.push(Buffer.from("C"));
+  fields.push(Buffer.from(code + "\0"));
+  fields.push(Buffer.from("M"));
+  fields.push(Buffer.from(message + "\0"));
+  fields.push(Buffer.from("\0"));
+  const body = Buffer.concat(fields);
+  const header = Buffer.alloc(5);
+  header[0] = PG_MSG.ERROR_RESPONSE;
+  header.writeInt32BE(body.length + 4, 1);
+  return Buffer.concat([header, body]);
+}
+function buildPgReadyForQuery(status = "I") {
+  const buf = Buffer.alloc(6);
+  buf[0] = PG_MSG.READY_FOR_QUERY;
+  buf.writeInt32BE(5, 1);
+  buf[5] = status.charCodeAt(0);
+  return buf;
+}
+function extractQueryFromPgMessage(data) {
+  if (data.length < 5) return null;
+  if (data[0] !== PG_MSG.QUERY) return null;
+  const len = data.readInt32BE(1);
+  const sql = data.subarray(5, 1 + len - 1).toString("utf8");
+  return sql;
+}
+function extractQueryFromPgParse(data) {
+  if (data.length < 5) return null;
+  if (data[0] !== PG_MSG.PARSE) return null;
+  let offset = 5;
+  while (offset < data.length && data[offset] !== 0) offset++;
+  offset++;
+  const start = offset;
+  while (offset < data.length && data[offset] !== 0) offset++;
+  const sql = data.subarray(start, offset).toString("utf8");
+  return sql;
+}
+var SqlProxy = class extends import_node_events.EventEmitter {
+  engine;
+  apiKey;
+  listenPort;
+  listenHost;
+  targetHost;
+  targetPort;
+  actorId;
+  verbose;
+  onBlocked;
+  onEvaluated;
+  server = null;
+  // v2.0: Table ACL
+  tableWhitelist;
+  tableBlacklist;
+  sqlInjectionDetection;
+  // v2.0: Billing Reporter
+  billingEnabled;
+  billingEndpoint;
+  billingBuffer = [];
+  billingFlushTimer = null;
+  BILLING_FLUSH_INTERVAL;
+  BILLING_BUFFER_MAX;
+  stats;
+  constructor(config) {
+    super();
+    const apiKey = config.apiKey || process.env.SOVR_API_KEY || "";
+    if (!apiKey) {
+      throw new Error(
+        "\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n\u2551              SOVR API KEY REQUIRED                          \u2551\n\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563\n\u2551  @sovr/proxy-sql requires a valid API key to operate.      \u2551\n\u2551                                                             \u2551\n\u2551  Without a valid API key:                                   \u2551\n\u2551  \u2022 No billing events can be reported                        \u2551\n\u2551  \u2022 No quota can be verified                                 \u2551\n\u2551  \u2022 No metering data is recorded                             \u2551\n\u2551  \u2022 Proxy will NOT start                                     \u2551\n\u2551                                                             \u2551\n\u2551  Get your key:                                              \u2551\n\u2551  1. Register at:  https://sovr.inc/register                 \u2551\n\u2551  2. Dashboard:    https://sovr.inc/dashboard/api-keys       \u2551\n\u2551  3. Pass apiKey in config or set SOVR_API_KEY env var       \u2551\n\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n"
+      );
+    }
+    this.apiKey = apiKey;
+    this._checkVersion(apiKey);
+    this.engine = config.engine;
+    this.listenPort = config.listenPort;
+    this.listenHost = config.listenHost ?? "127.0.0.1";
+    this.targetHost = config.targetHost;
+    this.targetPort = config.targetPort;
+    this.actorId = config.actorId ?? "sql-proxy";
+    this.verbose = config.verbose ?? false;
+    this.onBlocked = config.onBlocked;
+    this.onEvaluated = config.onEvaluated;
+    this.tableWhitelist = config.tableWhitelist ? new Set(config.tableWhitelist.map((t) => t.toLowerCase())) : null;
+    this.tableBlacklist = new Set(
+      (config.tableBlacklist ?? []).map((t) => t.toLowerCase())
+    );
+    this.sqlInjectionDetection = config.sqlInjectionDetection !== false;
+    const billing = config.billing ?? {};
+    this.billingEnabled = billing.enabled !== false;
+    this.billingEndpoint = billing.meteringEndpoint ?? DEFAULT_METERING_ENDPOINT;
+    this.BILLING_FLUSH_INTERVAL = billing.flushIntervalMs ?? 1e4;
+    this.BILLING_BUFFER_MAX = billing.bufferMax ?? 500;
+    this.stats = {
+      totalQueries: 0,
+      allowedQueries: 0,
+      blockedQueries: 0,
+      escalatedQueries: 0,
+      activeConnections: 0,
+      startedAt: 0,
+      injectionBlocks: 0,
+      tableAclBlocks: 0,
+      billingEventsReported: 0,
+      billingEventsDropped: 0,
+      billingBufferSize: 0,
+      billingByType: {
+        "gate.check": 0,
+        "gate.block": 0,
+        "irreversible.allowed": 0,
+        "trust_bundle.issued": 0,
+        "trust_bundle.exported": 0,
+        "replay.requested": 0,
+        "auditor.session": 0
+      }
+    };
+  }
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  /**
+   * Start the SQL proxy server + billing reporter.
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = net.createServer((clientSocket) => {
+        this.handleConnection(clientSocket);
+      });
+      this.server.on("error", (err) => {
+        this.emit("error", err);
+        reject(err);
+      });
+      this.server.listen(this.listenPort, this.listenHost, () => {
+        this.stats.startedAt = Date.now();
+        if (this.billingEnabled) {
+          this.initBillingReporter();
+        }
+        if (this.verbose) {
+          process.stderr.write(
+            `[sovr-sql-proxy] v${PROXY_SQL_VERSION} listening on ${this.listenHost}:${this.listenPort} \u2192 ${this.targetHost}:${this.targetPort}
+[sovr-sql-proxy] API Key: ${this.apiKey.slice(0, 8)}...${this.apiKey.slice(-4)}
+[sovr-sql-proxy] Billing: ${this.billingEnabled ? "ENABLED" : "DISABLED"}
+[sovr-sql-proxy] SQL Injection Detection: ${this.sqlInjectionDetection ? "ENABLED" : "DISABLED"}
+[sovr-sql-proxy] Table Whitelist: ${this.tableWhitelist ? `${this.tableWhitelist.size} tables` : "OFF"}
+[sovr-sql-proxy] Table Blacklist: ${this.tableBlacklist.size} tables
+`
+          );
+        }
+        this.emit("listening");
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the SQL proxy server + flush remaining billing events.
+   */
+  async stop() {
+    if (this.billingFlushTimer) {
+      clearInterval(this.billingFlushTimer);
+      this.billingFlushTimer = null;
+    }
+    await this.flushBillingBuffer().catch(() => {
+    });
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+  /**
+   * Get proxy statistics (including billing stats).
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      billingBufferSize: this.billingBuffer.length
+    };
+  }
+  // ============================================================================
+  // v2.0: Billing Reporter
+  // 7 event types: gate.check, gate.block, irreversible.allowed,
+  //   trust_bundle.issued, trust_bundle.exported, replay.requested, auditor.session
+  // ============================================================================
+  initBillingReporter() {
+    this.billingFlushTimer = setInterval(() => {
+      this.flushBillingBuffer().catch(() => {
+      });
+    }, this.BILLING_FLUSH_INTERVAL);
+    if (this.verbose) {
+      this.log(`Billing reporter initialized: flush every ${this.BILLING_FLUSH_INTERVAL}ms, buffer max ${this.BILLING_BUFFER_MAX}`);
+    }
+  }
+  /**
+   * Record a billing event into the buffer.
+   * Fire-and-forget — never blocks the main request flow.
+   */
+  recordBillingEvent(event_type, action, resource, verdict, metadata) {
+    if (!this.billingEnabled) return;
+    this.billingBuffer.push({
+      event_type,
+      action,
+      resource,
+      verdict,
+      api_key: this.apiKey,
+      timestamp: Date.now(),
+      metadata
+    });
+    this.stats.billingByType[event_type] = (this.stats.billingByType[event_type] || 0) + 1;
+    if (this.billingBuffer.length >= this.BILLING_BUFFER_MAX) {
+      this.flushBillingBuffer().catch(() => {
+      });
+    }
+  }
+  /**
+   * Flush billing buffer to the metering endpoint.
+   * Batch POST — fire-and-forget with re-queue on failure.
+   */
+  async flushBillingBuffer() {
+    if (this.billingBuffer.length === 0) return;
+    const batch = this.billingBuffer.splice(0, this.BILLING_BUFFER_MAX);
+    try {
+      const response = await globalThis.fetch(this.billingEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`,
+          "X-SOVR-Source": "proxy-sql",
+          "X-SOVR-Version": PROXY_SQL_VERSION
+        },
+        body: JSON.stringify({ events: batch }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (response.ok) {
+        this.stats.billingEventsReported += batch.length;
+        if (this.verbose) {
+          this.log(`Billing: flushed ${batch.length} events (total reported: ${this.stats.billingEventsReported})`);
+        }
+      } else {
+        throw new Error(`HTTP ${response.status}`);
+      }
+    } catch {
+      if (this.billingBuffer.length < this.BILLING_BUFFER_MAX * 2) {
+        this.billingBuffer.unshift(...batch);
+      } else {
+        this.stats.billingEventsDropped += batch.length;
+      }
+    }
+  }
+  /**
+   * Classify a gate-check result into the appropriate billing event type.
+   * Key pricing principle: "放行的不可逆动作" is the highest-price tax base.
+   */
+  classifyBillingEvent(statementType, verdict) {
+    if (verdict === "deny" || verdict === "block") {
+      return "gate.block";
+    }
+    if ((verdict === "allow" || verdict === "approve") && IRREVERSIBLE_SQL_REGEX.test(statementType)) {
+      return "irreversible.allowed";
+    }
+    return "gate.check";
+  }
+  /**
+   * Record billing event from a policy engine evaluation result.
+   * Automatically classifies the event type based on statement type + verdict.
+   */
+  recordGateCheckBilling(statementType, tables, decision, extraMetadata) {
+    const eventType = this.classifyBillingEvent(statementType, decision.verdict);
+    this.recordBillingEvent(eventType, statementType, tables.join(",") || "*", decision.verdict, {
+      risk_score: decision.risk_score,
+      risk_level: decision.risk_level,
+      decision_id: decision.decision_id,
+      matched_rules: decision.matched_rules?.length ?? 0,
+      tables,
+      ...extraMetadata
+    });
+  }
+  // ============================================================================
+  // v2.0: Table ACL (Whitelist / Blacklist)
+  // ============================================================================
+  /**
+   * Check if the queried tables pass the ACL check.
+   * Returns null if allowed, or a reason string if blocked.
+   */
+  checkTableAcl(tables) {
+    if (tables.length === 0) return null;
+    for (const table of tables) {
+      if (this.tableBlacklist.has(table)) {
+        return `Table '${table}' is in the blacklist`;
+      }
+    }
+    if (this.tableWhitelist) {
+      for (const table of tables) {
+        if (!this.tableWhitelist.has(table)) {
+          return `Table '${table}' is not in the whitelist`;
+        }
+      }
+    }
+    return null;
+  }
+  // ============================================================================
+  // Connection Handler
+  // ============================================================================
+  handleConnection(clientSocket) {
+    this.stats.activeConnections++;
+    const backendSocket = net.createConnection({
+      host: this.targetHost,
+      port: this.targetPort
+    });
+    let startupComplete = false;
+    let clientBuffer = Buffer.alloc(0);
+    clientSocket.on("data", (data) => {
+      if (!startupComplete) {
+        backendSocket.write(data);
+        return;
+      }
+      clientBuffer = Buffer.concat([clientBuffer, data]);
+      this.processClientData(clientBuffer, clientSocket, backendSocket);
+      clientBuffer = Buffer.alloc(0);
+    });
+    backendSocket.on("data", (data) => {
+      if (!startupComplete) {
+        for (let i = 0; i < data.length - 5; i++) {
+          if (data[i] === PG_MSG.READY_FOR_QUERY) {
+            const len = data.readInt32BE(i + 1);
+            if (len === 5) {
+              startupComplete = true;
+              if (this.verbose) {
+                process.stderr.write("[sovr-sql-proxy] Authentication complete, intercepting queries\n");
+              }
+              break;
+            }
+          }
+        }
+      }
+      clientSocket.write(data);
+    });
+    const cleanup = () => {
+      this.stats.activeConnections--;
+      clientSocket.destroy();
+      backendSocket.destroy();
+    };
+    clientSocket.on("end", cleanup);
+    clientSocket.on("error", cleanup);
+    backendSocket.on("end", cleanup);
+    backendSocket.on("error", cleanup);
+  }
+  // ============================================================================
+  // Query Interception
+  // ============================================================================
+  processClientData(data, clientSocket, backendSocket) {
+    if (data.length < 5) {
+      backendSocket.write(data);
+      return;
+    }
+    const msgType = data[0];
+    if (msgType !== PG_MSG.QUERY && msgType !== PG_MSG.PARSE) {
+      backendSocket.write(data);
+      return;
+    }
+    let sql = null;
+    if (msgType === PG_MSG.QUERY) {
+      sql = extractQueryFromPgMessage(data);
+    } else if (msgType === PG_MSG.PARSE) {
+      sql = extractQueryFromPgParse(data);
+    }
+    if (!sql || sql.trim().length === 0) {
+      backendSocket.write(data);
+      return;
+    }
+    const parsed = parseSQL(sql);
+    let injectionResult;
+    if (this.sqlInjectionDetection) {
+      injectionResult = detectSqlInjection(sql);
+      if (injectionResult.detected) {
+        this.stats.totalQueries++;
+        this.stats.blockedQueries++;
+        this.stats.injectionBlocks++;
+        const blockDecision = {
+          decision_id: `dec_injection_${Date.now().toString(36)}`,
+          verdict: "deny",
+          allowed: false,
+          risk_score: 100,
+          risk_level: "critical",
+          requires_approval: false,
+          reason: `SQL injection detected: ${injectionResult.patterns.join(", ")} (severity: ${injectionResult.severity})`,
+          matched_rules: [],
+          channel: "sql",
+          trace_id: `trace_sqli_${Date.now().toString(36)}`,
+          timestamp: Date.now()
+        };
+        const info2 = {
+          sql: sql.substring(0, 500),
+          statementType: parsed.type,
+          tables: parsed.tables,
+          decision: blockDecision,
+          timestamp: Date.now(),
+          injectionResult
+        };
+        this.recordGateCheckBilling(parsed.type, parsed.tables, blockDecision, {
+          block_reason: "sql_injection",
+          injection_patterns: injectionResult.patterns
+        });
+        const errorMsg = buildPgErrorResponse(
+          "ERROR",
+          "42501",
+          `SOVR: SQL injection detected \u2014 ${injectionResult.patterns.join(", ")} [${blockDecision.decision_id}]`
+        );
+        const readyMsg = buildPgReadyForQuery("I");
+        clientSocket.write(Buffer.concat([errorMsg, readyMsg]));
+        if (this.verbose) {
+          process.stderr.write(
+            `[sovr-sql-proxy] \x1B[31mINJECTION BLOCKED\x1B[0m: ${injectionResult.patterns.join(", ")} in ${parsed.type}
+`
+          );
+        }
+        if (this.onBlocked) {
+          try {
+            this.onBlocked(info2);
+          } catch {
+          }
+        }
+        this.emit("injection_blocked", info2);
+        return;
+      }
+    }
+    const aclBlock = this.checkTableAcl(parsed.tables);
+    if (aclBlock) {
+      this.stats.totalQueries++;
+      this.stats.blockedQueries++;
+      this.stats.tableAclBlocks++;
+      const blockDecision = {
+        decision_id: `dec_acl_${Date.now().toString(36)}`,
+        verdict: "deny",
+        allowed: false,
+        risk_score: 90,
+        risk_level: "high",
+        requires_approval: false,
+        reason: `Table ACL violation: ${aclBlock}`,
+        matched_rules: [],
+        channel: "sql",
+        trace_id: `trace_acl_${Date.now().toString(36)}`,
+        timestamp: Date.now()
+      };
+      const info2 = {
+        sql: sql.substring(0, 500),
+        statementType: parsed.type,
+        tables: parsed.tables,
+        decision: blockDecision,
+        timestamp: Date.now()
+      };
+      this.recordGateCheckBilling(parsed.type, parsed.tables, blockDecision, {
+        block_reason: "table_acl",
+        acl_detail: aclBlock
+      });
+      const errorMsg = buildPgErrorResponse(
+        "ERROR",
+        "42501",
+        `SOVR: ${aclBlock} [${blockDecision.decision_id}]`
+      );
+      const readyMsg = buildPgReadyForQuery("I");
+      clientSocket.write(Buffer.concat([errorMsg, readyMsg]));
+      if (this.verbose) {
+        process.stderr.write(
+          `[sovr-sql-proxy] \x1B[33mACL BLOCKED\x1B[0m: ${aclBlock} \u2014 ${parsed.type} on ${parsed.tables.join(", ")}
+`
+        );
+      }
+      if (this.onBlocked) {
+        try {
+          this.onBlocked(info2);
+        } catch {
+        }
+      }
+      this.emit("acl_blocked", info2);
+      return;
+    }
+    const decision = this.evaluateStatement(parsed);
+    this.stats.totalQueries++;
+    const info = {
+      sql: sql.substring(0, 500),
+      statementType: parsed.type,
+      tables: parsed.tables,
+      decision,
+      timestamp: Date.now(),
+      injectionResult
+    };
+    if (this.onEvaluated) {
+      try {
+        this.onEvaluated(info);
+      } catch {
+      }
+    }
+    this.recordGateCheckBilling(parsed.type, parsed.tables, decision);
+    if (decision.verdict === "deny") {
+      this.stats.blockedQueries++;
+      const errorMsg = buildPgErrorResponse(
+        "ERROR",
+        "42501",
+        `SOVR Policy Violation: ${decision.reason} [decision_id: ${decision.decision_id}]`
+      );
+      const readyMsg = buildPgReadyForQuery("I");
+      clientSocket.write(Buffer.concat([errorMsg, readyMsg]));
+      if (this.verbose) {
+        process.stderr.write(
+          `[sovr-sql-proxy] \x1B[31mBLOCKED\x1B[0m: ${parsed.type} on ${parsed.tables.join(", ")} \u2014 ${decision.reason}
+`
+        );
+      }
+      if (this.onBlocked) {
+        try {
+          this.onBlocked(info);
+        } catch {
+        }
+      }
+      this.emit("blocked", info);
+    } else if (decision.verdict === "escalate") {
+      this.stats.escalatedQueries++;
+      const errorMsg = buildPgErrorResponse(
+        "ERROR",
+        "42501",
+        `SOVR: Action requires approval \u2014 ${decision.reason} [decision_id: ${decision.decision_id}]`
+      );
+      const readyMsg = buildPgReadyForQuery("I");
+      clientSocket.write(Buffer.concat([errorMsg, readyMsg]));
+      if (this.verbose) {
+        process.stderr.write(
+          `[sovr-sql-proxy] \x1B[33mESCALATED\x1B[0m: ${parsed.type} on ${parsed.tables.join(", ")} \u2014 ${decision.reason}
+`
+        );
+      }
+      this.emit("escalated", info);
+    } else {
+      this.stats.allowedQueries++;
+      backendSocket.write(data);
+      if (this.verbose) {
+        process.stderr.write(
+          `[sovr-sql-proxy] \x1B[32mALLOWED\x1B[0m: ${parsed.type} on ${parsed.tables.join(", ")} (risk: ${decision.risk_score})
+`
+        );
+      }
+    }
+  }
+  // ============================================================================
+  // Policy Evaluation
+  // ============================================================================
+  evaluateStatement(parsed) {
+    const safeTypes = [
+      "SELECT",
+      "BEGIN",
+      "COMMIT",
+      "ROLLBACK",
+      "SET",
+      "SHOW",
+      "EXPLAIN"
+    ];
+    if (safeTypes.includes(parsed.type) && !parsed.isMultiStatement) {
+      if (parsed.type !== "SELECT") {
+        return {
+          decision_id: `dec_passthrough_${Date.now().toString(36)}`,
+          verdict: "allow",
+          allowed: true,
+          risk_score: 0,
+          risk_level: "none",
+          requires_approval: false,
+          reason: `Safe statement type: ${parsed.type}`,
+          matched_rules: [],
+          channel: "sql",
+          trace_id: `trace_sql_${Date.now().toString(36)}`,
+          timestamp: Date.now()
+        };
+      }
+    }
+    const context = {
+      statement_type: parsed.type,
+      tables: parsed.tables,
+      has_where_clause: parsed.hasWhereClause,
+      raw_sql: parsed.raw.substring(0, 1e3),
+      is_multi_statement: parsed.isMultiStatement
+    };
+    return this.engine.evaluate({
+      channel: "sql",
+      action: parsed.type,
+      resource: parsed.tables.join(",") || "*",
+      context,
+      actor_id: this.actorId
+    });
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  log(msg) {
+    process.stderr.write(`[sovr-sql-proxy] ${msg}
+`);
+  }
+  /** v2.0: Async version check */
+  async _checkVersion(apiKey) {
+    try {
+      const res = await fetch(VERSION_CHECK_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-SOVR-API-Key": apiKey },
+        body: JSON.stringify({ package: "@sovr/proxy-sql", version: PROXY_SQL_VERSION }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.deprecated || data.forceUpgrade) {
+          console.error(
+            `[SOVR] @sovr/proxy-sql@${PROXY_SQL_VERSION} is deprecated.
+  Required: @sovr/proxy-sql@${data.minVersion || "latest"}
+  Run: npm install @sovr/proxy-sql@latest`
+          );
+          process.exit(1);
+        }
+      }
+    } catch {
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SqlProxy,
+  detectSqlInjection,
+  parseSQL
+});

package/index.d.ts

@@ -0,0 +1,239 @@
+import { EventEmitter } from 'node:events';
+import { EvalResult, PolicyEngine } from '@sovr/engine';
+export { Channel, EvalRequest, EvalResult, PolicyRule, RiskLevel, SqlContext, Verdict } from '@sovr/engine';
+
+/**
+ * @sovr/proxy-sql v2.0.0 — SQL Proxy with Full Billing System
+ *
+ * A transparent SQL proxy that sits between AI agents and databases,
+ * intercepting all SQL statements and routing them through the SOVR
+ * Policy Engine before execution.
+ *
+ * Features:
+ * 1. PostgreSQL wire protocol interception (frontend ↔ proxy ↔ backend)
+ * 2. Statement-level parsing and classification (17 statement types)
+ * 3. DDL blocking (DROP, ALTER, TRUNCATE)
+ * 4. High-risk DML detection (DELETE/UPDATE without WHERE)
+ * 5. SQL injection detection (UNION injection, tautology, comment injection, stacked queries)
+ * 6. Table whitelist/blacklist access control
+ * 7. Billing Reporter — 7 event types, batch flush, quota check, overage degradation
+ * 8. Mandatory API Key enforcement
+ * 9. Full audit logging of all intercepted queries
+ *
+ * Architecture:
+ *   Agent → SQL Proxy (port 5433) → SOVR Policy Engine → PostgreSQL (port 5432)
+ *   Billing: Every gate-check/block/allow → billingBuffer → batch POST → /api/v1/metering/batch
+ *
+ * @example
+ * ```ts
+ * import { SqlProxy } from '@sovr/proxy-sql';
+ * import { PolicyEngine, DEFAULT_RULES } from '@sovr/engine';
+ *
+ * const engine = new PolicyEngine({ rules: DEFAULT_RULES });
+ * const proxy = new SqlProxy({
+ *   engine,
+ *   apiKey: process.env.SOVR_API_KEY!,
+ *   listenPort: 5433,
+ *   targetHost: 'localhost',
+ *   targetPort: 5432,
+ *   tableWhitelist: ['public.orders', 'public.products'],
+ *   billing: { enabled: true },
+ * });
+ *
+ * await proxy.start();
+ * // Agent connects to localhost:5433 instead of 5432
+ * // All DDL and dangerous DML are intercepted and billed
+ * ```
+ */
+
+/**
+ * SOVR Billing Event Types — aligned with the pricing model:
+ * 1. gate.check — low price or included in quota (every policy evaluation)
+ * 2. gate.block — usually free or very low price (blocked requests)
+ * 3. irreversible.allowed — HIGH PRICE core tax base (allowed irreversible ops)
+ * 4. trust_bundle.issued — medium-high price (Trust Bundle generation)
+ * 5. trust_bundle.exported — higher price (audit necessity)
+ * 6. replay.requested — optional, per-use or monthly (trace replay)
+ * 7. auditor.session — enterprise billing (external audit sessions)
+ */
+type BillingEventType = 'gate.check' | 'gate.block' | 'irreversible.allowed' | 'trust_bundle.issued' | 'trust_bundle.exported' | 'replay.requested' | 'auditor.session';
+interface BillingEvent {
+    event_type: BillingEventType;
+    action: string;
+    resource: string;
+    verdict: string;
+    api_key: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+interface BillingConfig {
+    /** Enable billing event reporting (default: true) */
+    enabled?: boolean;
+    /** Metering endpoint URL (default: SOVR cloud) */
+    meteringEndpoint?: string;
+    /** Batch flush interval in milliseconds (default: 10000) */
+    flushIntervalMs?: number;
+    /** Maximum events in buffer before auto-flush (default: 500) */
+    bufferMax?: number;
+}
+interface SqlInjectionResult {
+    detected: boolean;
+    patterns: string[];
+    severity: 'none' | 'high' | 'critical';
+}
+interface SqlProxyConfig {
+    /** Policy engine instance */
+    engine: PolicyEngine;
+    /** SOVR API Key (REQUIRED — register at https://sovr.inc/register) */
+    apiKey?: string;
+    /** Port to listen on */
+    listenPort: number;
+    /** Target database host */
+    targetHost: string;
+    /** Target database port */
+    targetPort: number;
+    /** Listen host (default: 127.0.0.1) */
+    listenHost?: string;
+    /** Actor ID for audit trail */
+    actorId?: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Callback when a query is blocked */
+    onBlocked?: (info: BlockedQueryInfo) => void | Promise<void>;
+    /** Callback for all evaluated queries */
+    onEvaluated?: (info: EvaluatedQueryInfo) => void | Promise<void>;
+    /** v2.0: Billing configuration */
+    billing?: BillingConfig;
+    /** v2.0: Table whitelist — only these tables are accessible (if set) */
+    tableWhitelist?: string[];
+    /** v2.0: Table blacklist — these tables are always blocked */
+    tableBlacklist?: string[];
+    /** v2.0: Enable SQL injection detection (default: true) */
+    sqlInjectionDetection?: boolean;
+}
+interface BlockedQueryInfo {
+    sql: string;
+    statementType: StatementType;
+    tables: string[];
+    decision: EvalResult;
+    timestamp: number;
+    /** v2.0: SQL injection detection result */
+    injectionResult?: SqlInjectionResult;
+}
+interface EvaluatedQueryInfo {
+    sql: string;
+    statementType: StatementType;
+    tables: string[];
+    decision: EvalResult;
+    timestamp: number;
+    /** v2.0: SQL injection detection result */
+    injectionResult?: SqlInjectionResult;
+}
+interface SqlProxyStats {
+    totalQueries: number;
+    allowedQueries: number;
+    blockedQueries: number;
+    escalatedQueries: number;
+    activeConnections: number;
+    startedAt: number;
+    /** v2.0: SQL injection blocks */
+    injectionBlocks: number;
+    /** v2.0: Table ACL blocks */
+    tableAclBlocks: number;
+    /** v2.0: Billing stats */
+    billingEventsReported: number;
+    billingEventsDropped: number;
+    billingBufferSize: number;
+    /** v2.0: Per-event-type counters */
+    billingByType: Record<BillingEventType, number>;
+}
+type StatementType = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'DROP' | 'ALTER' | 'TRUNCATE' | 'CREATE' | 'GRANT' | 'REVOKE' | 'BEGIN' | 'COMMIT' | 'ROLLBACK' | 'SET' | 'SHOW' | 'EXPLAIN' | 'COPY' | 'OTHER';
+/** Parsed SQL statement info */
+interface ParsedStatement {
+    type: StatementType;
+    tables: string[];
+    hasWhereClause: boolean;
+    isMultiStatement: boolean;
+    raw: string;
+}
+/**
+ * Lightweight SQL statement parser.
+ * Not a full SQL parser — classifies statements and extracts key metadata
+ * for policy evaluation without heavy dependencies.
+ */
+declare function parseSQL(sql: string): ParsedStatement;
+/**
+ * Detect SQL injection patterns in a raw SQL string.
+ * Returns detection result with matched pattern names and severity.
+ */
+declare function detectSqlInjection(sql: string): SqlInjectionResult;
+declare class SqlProxy extends EventEmitter {
+    private readonly engine;
+    private readonly apiKey;
+    private readonly listenPort;
+    private readonly listenHost;
+    private readonly targetHost;
+    private readonly targetPort;
+    private readonly actorId;
+    private readonly verbose;
+    private readonly onBlocked?;
+    private readonly onEvaluated?;
+    private server;
+    private readonly tableWhitelist;
+    private readonly tableBlacklist;
+    private readonly sqlInjectionDetection;
+    private billingEnabled;
+    private billingEndpoint;
+    private billingBuffer;
+    private billingFlushTimer;
+    private readonly BILLING_FLUSH_INTERVAL;
+    private readonly BILLING_BUFFER_MAX;
+    private stats;
+    constructor(config: SqlProxyConfig);
+    /**
+     * Start the SQL proxy server + billing reporter.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the SQL proxy server + flush remaining billing events.
+     */
+    stop(): Promise<void>;
+    /**
+     * Get proxy statistics (including billing stats).
+     */
+    getStats(): SqlProxyStats;
+    private initBillingReporter;
+    /**
+     * Record a billing event into the buffer.
+     * Fire-and-forget — never blocks the main request flow.
+     */
+    recordBillingEvent(event_type: BillingEventType, action: string, resource: string, verdict: string, metadata?: Record<string, unknown>): void;
+    /**
+     * Flush billing buffer to the metering endpoint.
+     * Batch POST — fire-and-forget with re-queue on failure.
+     */
+    private flushBillingBuffer;
+    /**
+     * Classify a gate-check result into the appropriate billing event type.
+     * Key pricing principle: "放行的不可逆动作" is the highest-price tax base.
+     */
+    private classifyBillingEvent;
+    /**
+     * Record billing event from a policy engine evaluation result.
+     * Automatically classifies the event type based on statement type + verdict.
+     */
+    private recordGateCheckBilling;
+    /**
+     * Check if the queried tables pass the ACL check.
+     * Returns null if allowed, or a reason string if blocked.
+     */
+    private checkTableAcl;
+    private handleConnection;
+    private processClientData;
+    private evaluateStatement;
+    private log;
+    /** v2.0: Async version check */
+    private _checkVersion;
+}
+
+export { type BillingConfig, type BillingEvent, type BillingEventType, type BlockedQueryInfo, type EvaluatedQueryInfo, type ParsedStatement, type SqlInjectionResult, SqlProxy, type SqlProxyConfig, type SqlProxyStats, type StatementType, detectSqlInjection, parseSQL };

package/index.js

@@ -1 +1,10 @@
-module.exports = {}
+import {
+  SqlProxy,
+  detectSqlInjection,
+  parseSQL
+} from "./chunk-BDKWSESQ.js";
+export {
+  SqlProxy,
+  detectSqlInjection,
+  parseSQL
+};

package/package.json

@@ -1 +1,22 @@
-{"name":"@sovr/sql-proxy","version":"0.0.1","description":"test","license":"BSL-1.1","main":"index.js"}
+{
+  "name": "@sovr/sql-proxy",
+  "version": "2.0.0",
+  "description": "SQL Proxy for AI Agents — intercepts DDL/DML through SOVR Policy Engine with billing, SQL injection detection, and table ACL",
+  "license": "BSL-1.1",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    }
+  },
+  "keywords": ["sovr", "sql-proxy", "database-security", "ai-agent"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xie38388/sovr.git"
+  },
+  "homepage": "https://sovr.inc"
+}