@sovr/sql-proxy 2.0.0 → 2.0.1

package/{index.cjs → dist/index.cjs}

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
+// ../sovr/packages/@sovr/proxy-sql/src/index.ts
 var index_exports = {};
 __export(index_exports, {
   SqlProxy: () => SqlProxy,

package/dist/index.js

@@ -0,0 +1,803 @@
+// ../sovr/packages/@sovr/proxy-sql/src/index.ts
+import * as net from "net";
+import { EventEmitter } from "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 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 {
+    }
+  }
+};
+export {
+  SqlProxy,
+  detectSqlInjection,
+  parseSQL
+};

package/package.json

@@ -1,22 +1,18 @@
 {
   "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",
+  "version": "2.0.1",
+  "description": "SQL Proxy for AI Agents",
   "license": "BSL-1.1",
   "type": "module",
-  "main": "./index.js",
-  "types": "./index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "require": "./index.cjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
-  "keywords": ["sovr", "sql-proxy", "database-security", "ai-agent"],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/xie38388/sovr.git"
-  },
+  "repository": {"type": "git", "url": "https://github.com/xie38388/sovr.git"},
   "homepage": "https://sovr.inc"
 }

package/index.js

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