planche 0.8.14 → 0.9.0

package/dist/{chunk-XAI7WLQN.js → chunk-SDRLD5PK.js}

@@ -11,6 +11,7 @@ var PRO_FEATURES = [
   "sync",
   "ai_explain"
 ];
+var BATCH_LIMIT = 1e3;
 
 // src/ai-cli.ts
 import { execFile as execFileCb2, spawn } from "child_process";
@@ -728,17 +729,17 @@ var MySqlDriver = class {
     if (USE_STATEMENT.test(sql2)) this.currentDatabase = null;
     if (Array.isArray(results) && fields) {
       const fieldPackets = fields;
-      const mappedFields = fieldPackets.map((field) => ({
-        name: field.name,
-        orgName: field.orgName ?? field.name,
-        type: getTypeName(field.type ?? 253, field.characterSet),
-        table: field.table ?? "",
-        orgTable: field.orgTable ?? "",
-        db: field.db ?? "",
-        maxLength: field.length ?? 0
+      const mappedFields = fieldPackets.map((field3) => ({
+        name: field3.name,
+        orgName: field3.orgName ?? field3.name,
+        type: getTypeName(field3.type ?? 253, field3.characterSet),
+        table: field3.table ?? "",
+        orgTable: field3.orgTable ?? "",
+        db: field3.db ?? "",
+        maxLength: field3.length ?? 0
       }));
       const records = results.map(
-        (row) => fieldPackets.map((field) => row[field.name])
+        (row) => fieldPackets.map((field3) => row[field3.name])
       );
       return { fields: mappedFields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
     }
@@ -942,16 +943,16 @@ var PostgresDriver = class {
     const last = [...results].reverse().find((r) => r.fields.length > 0) ?? results[results.length - 1];
     if (last.fields.length > 0) {
       await this.resolveRelations(last.fields.map((f) => f.tableID));
-      const fields = last.fields.map((field) => {
-        const rel = this.relations.get(field.tableID);
+      const fields = last.fields.map((field3) => {
+        const rel = this.relations.get(field3.tableID);
         return {
-          name: field.name,
-          orgName: rel?.columns.get(field.columnID) ?? field.name,
-          type: this.typeNames[field.dataTypeID] ?? `oid:${field.dataTypeID}`,
+          name: field3.name,
+          orgName: rel?.columns.get(field3.columnID) ?? field3.name,
+          type: this.typeNames[field3.dataTypeID] ?? `oid:${field3.dataTypeID}`,
           table: rel?.table ?? "",
           orgTable: rel?.table ?? "",
           db: rel?.schema ?? "",
-          maxLength: field.dataTypeSize > 0 ? field.dataTypeSize : 0
+          maxLength: field3.dataTypeSize > 0 ? field3.dataTypeSize : 0
         };
       });
       return { fields, records: last.rows, affectedRows: 0, insertId: 0, isResultQuery: true };
@@ -2305,6 +2306,799 @@ var doRemoteDriverFactory = {
   }
 };
 
+// src/drivers/redis.ts
+import { Redis } from "ioredis";
+
+// ../shared/redis-command.ts
+var RedisSyntaxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RedisSyntaxError";
+  }
+};
+var SPACE = /\s/;
+var HEX = /^[0-9a-fA-F]{2}$/;
+var ESCAPES = { n: "\n", r: "\r", t: "	", b: "\b", a: "\x07" };
+function tokenizeRedisCommand(line) {
+  const args = [];
+  let i = 0;
+  const n = line.length;
+  while (true) {
+    while (i < n && SPACE.test(line[i])) i++;
+    if (i >= n) return args;
+    let current = "";
+    let inDouble = false;
+    let inSingle = false;
+    let done = false;
+    while (!done) {
+      if (inDouble) {
+        if (i >= n) throw new RedisSyntaxError("Unbalanced quotes in command");
+        const ch = line[i];
+        if (ch === "\\" && line[i + 1] === "x" && HEX.test(line.slice(i + 2, i + 4))) {
+          current += String.fromCharCode(parseInt(line.slice(i + 2, i + 4), 16));
+          i += 4;
+          continue;
+        }
+        if (ch === "\\" && i + 1 < n) {
+          const next = line[i + 1];
+          current += ESCAPES[next] ?? next;
+          i += 2;
+          continue;
+        }
+        if (ch === '"') {
+          if (i + 1 < n && !SPACE.test(line[i + 1])) throw new RedisSyntaxError("Closing quote must be followed by a space");
+          inDouble = false;
+          done = true;
+          i++;
+          continue;
+        }
+        current += ch;
+        i++;
+      } else if (inSingle) {
+        if (i >= n) throw new RedisSyntaxError("Unbalanced quotes in command");
+        const ch = line[i];
+        if (ch === "\\" && line[i + 1] === "'") {
+          current += "'";
+          i += 2;
+          continue;
+        }
+        if (ch === "'") {
+          if (i + 1 < n && !SPACE.test(line[i + 1])) throw new RedisSyntaxError("Closing quote must be followed by a space");
+          inSingle = false;
+          done = true;
+          i++;
+          continue;
+        }
+        current += ch;
+        i++;
+      } else {
+        if (i >= n) {
+          done = true;
+          continue;
+        }
+        const ch = line[i];
+        if (SPACE.test(ch)) {
+          done = true;
+          continue;
+        }
+        if (ch === '"') inDouble = true;
+        else if (ch === "'") inSingle = true;
+        else current += ch;
+        i++;
+      }
+    }
+    args.push(current);
+  }
+}
+function redisCommandName(args) {
+  const name = (args[0] ?? "").toUpperCase();
+  if (CONTAINER_COMMANDS.has(name) && args.length > 1) return `${name} ${args[1].toUpperCase()}`;
+  return name;
+}
+var CONTAINER_COMMANDS = /* @__PURE__ */ new Set([
+  "ACL",
+  "CLIENT",
+  "CLUSTER",
+  "COMMAND",
+  "CONFIG",
+  "FUNCTION",
+  "LATENCY",
+  "MEMORY",
+  "MODULE",
+  "OBJECT",
+  "PUBSUB",
+  "SCRIPT",
+  "SLOWLOG",
+  "XGROUP",
+  "XINFO"
+]);
+var READ_ONLY_EXTRA = /* @__PURE__ */ new Set([
+  "PING",
+  "ECHO",
+  "INFO",
+  "TIME",
+  "SELECT",
+  "LASTSAVE",
+  "ROLE",
+  "QUIT",
+  "RESET",
+  "COMMAND",
+  "COMMAND INFO",
+  "COMMAND COUNT",
+  "COMMAND DOCS",
+  "COMMAND LIST",
+  "COMMAND GETKEYS",
+  "CLIENT ID",
+  "CLIENT INFO",
+  "CLIENT GETNAME"
+]);
+var SCRIPTED = /* @__PURE__ */ new Set(["EVAL", "EVALSHA", "FCALL", "MULTI", "EXEC"]);
+function isRedisReadOnlyCommand(args, flags) {
+  const name = redisCommandName(args);
+  if (READ_ONLY_EXTRA.has(name)) return true;
+  if (SCRIPTED.has(name) || !flags) return false;
+  if (flags.includes("write") || flags.includes("admin") || flags.includes("pubsub") || flags.includes("blocking")) return false;
+  return flags.includes("readonly");
+}
+
+// src/read-only.ts
+var ReadOnlyViolation = class extends Error {
+  status = 403;
+  constructor(message) {
+    super(message);
+    this.name = "ReadOnlyViolation";
+  }
+};
+var READ_KEYWORDS = /* @__PURE__ */ new Set(["SELECT", "WITH", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "VALUES", "TABLE", "PRAGMA"]);
+function splitStatements(sql2) {
+  const out = [];
+  let cur = "";
+  let i = 0;
+  const n = sql2.length;
+  while (i < n) {
+    const ch = sql2[i];
+    const next = sql2[i + 1];
+    if (ch === "-" && next === "-") {
+      while (i < n && sql2[i] !== "\n") i++;
+      cur += " ";
+      continue;
+    }
+    if (ch === "#") {
+      while (i < n && sql2[i] !== "\n") i++;
+      cur += " ";
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < n && !(sql2[i] === "*" && sql2[i + 1] === "/")) i++;
+      i += 2;
+      cur += " ";
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`" || ch === "[") {
+      const close = ch === "[" ? "]" : ch;
+      i++;
+      while (i < n) {
+        if (sql2[i] === "\\" && close === "'") {
+          i += 2;
+          continue;
+        }
+        if (sql2[i] === close) {
+          if (sql2[i + 1] === close && close !== "]") {
+            i += 2;
+            continue;
+          }
+          break;
+        }
+        i++;
+      }
+      i++;
+      cur += ch === "[" ? " x " : " 'x' ";
+      continue;
+    }
+    if (ch === "$" && next === "$") {
+      const end = sql2.indexOf("$$", i + 2);
+      i = end === -1 ? n : end + 2;
+      cur += " 'x' ";
+      continue;
+    }
+    if (ch === ";") {
+      out.push(cur);
+      cur = "";
+      i++;
+      continue;
+    }
+    cur += ch;
+    i++;
+  }
+  out.push(cur);
+  return out.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function assertReadOnlyStatement(sql2) {
+  const statements = splitStatements(sql2);
+  if (statements.length === 0) return;
+  if (statements.length > 1) throw new ReadOnlyViolation("Read-only profile: one statement per request");
+  const stmt = statements[0];
+  const first = /^[A-Za-z]+/.exec(stmt)?.[0].toUpperCase() ?? "";
+  if (!READ_KEYWORDS.has(first)) throw new ReadOnlyViolation(`Read-only profile: ${first || "this statement"} is not allowed`);
+  if (first === "WITH") {
+    const words = stmt.toUpperCase().match(/\b(INSERT|UPDATE|DELETE|MERGE|REPLACE)\b/);
+    if (words) throw new ReadOnlyViolation(`Read-only profile: ${words[1]} inside WITH is not allowed`);
+  }
+  if (first === "PRAGMA" && /[=(]/.test(stmt)) throw new ReadOnlyViolation("Read-only profile: PRAGMA may only read");
+  if (/\bINTO\s+(OUTFILE|DUMPFILE)\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: INTO OUTFILE is not allowed");
+  if (/\bFOR\s+(UPDATE|SHARE|NO\s+KEY\s+UPDATE|KEY\s+SHARE)\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: locking reads are not allowed");
+  if (/\bLOCK\s+IN\s+SHARE\s+MODE\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: locking reads are not allowed");
+  if (first === "SELECT" && /\bINTO\b/i.test(stmt) && !/\bINTO\s+@/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: SELECT INTO is not allowed");
+}
+
+// src/drivers/redis.ts
+function clusterError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const redirect = /^(MOVED|ASK) \d+ (\S+)/.exec(message);
+  if (redirect) {
+    return new Error(`This key lives on another node of the Redis Cluster (${redirect[2]}). Planche connects to a single node and does not follow cluster redirects yet; connect a profile to ${redirect[2]} to work with it.`);
+  }
+  if (/^CLUSTERDOWN/.test(message)) return new Error(`The Redis Cluster is down: ${message}`);
+  return null;
+}
+function redisDatabaseIndex(name) {
+  const m = name ? /^db(\d{1,5})$/.exec(name) : null;
+  return m ? Number(m[1]) : null;
+}
+function field(name, type = "string") {
+  return { name, orgName: name, type, table: "", orgTable: "", db: "", maxLength: 0 };
+}
+function plainReply(reply) {
+  if (reply === null || reply === void 0) return null;
+  if (Buffer.isBuffer(reply)) return reply.toString("utf8");
+  if (reply instanceof Error) return { error: reply.message };
+  if (Array.isArray(reply)) return reply.map(plainReply);
+  if (typeof reply === "object") {
+    return Object.fromEntries(Object.entries(reply).map(([k, v]) => [k, plainReply(v)]));
+  }
+  return reply;
+}
+function cell(value) {
+  if (value === null || typeof value === "string" || typeof value === "number") return value;
+  return JSON.stringify(value);
+}
+var PAIR_REPLIES = {
+  HGETALL: ["field", "value"],
+  "CONFIG GET": ["parameter", "value"]
+};
+var WITHSCORES = /* @__PURE__ */ new Set(["ZRANGE", "ZREVRANGE", "ZRANGEBYSCORE", "ZREVRANGEBYSCORE", "ZRANDMEMBER", "ZDIFF", "ZINTER", "ZUNION"]);
+var SCAN_COLUMNS = {
+  SCAN: ["key"],
+  SSCAN: ["member"],
+  HSCAN: ["field", "value"],
+  ZSCAN: ["member", "score"]
+};
+function pairs(values, columns) {
+  const rows = [];
+  for (let i = 0; i < values.length; i += columns.length) rows.push(columns.map((_, j) => cell(values[i + j] ?? null)));
+  return rows;
+}
+function replyToResult(args, raw) {
+  const reply = plainReply(raw);
+  const base = { affectedRows: 0, insertId: 0, isResultQuery: true, reply };
+  const name = redisCommandName(args);
+  const upperArgs = args.map((a) => a.toUpperCase());
+  if (Array.isArray(reply)) {
+    const scan = SCAN_COLUMNS[name];
+    if (scan && reply.length === 2 && Array.isArray(reply[1])) {
+      const columns = hscanNoValues(name, upperArgs) ? ["field"] : scan;
+      return { ...base, fields: columns.map((c) => field(c)), records: pairs(reply[1], columns) };
+    }
+    const pair = PAIR_REPLIES[name] ?? (WITHSCORES.has(name) && upperArgs.includes("WITHSCORES") ? ["member", "score"] : void 0) ?? (name === "HRANDFIELD" && upperArgs.includes("WITHVALUES") ? ["field", "value"] : void 0);
+    if (pair && reply.every((v) => !Array.isArray(v))) {
+      return { ...base, fields: pair.map((c) => field(c)), records: pairs(reply, pair) };
+    }
+    return {
+      ...base,
+      fields: [field("#", "int"), field("value")],
+      records: reply.map((v, i) => [i + 1, cell(v)])
+    };
+  }
+  if (reply !== null && typeof reply === "object") {
+    return {
+      ...base,
+      fields: [field("field"), field("value")],
+      records: Object.entries(reply).map(([k, v]) => [k, cell(v)])
+    };
+  }
+  return { ...base, fields: [field("value", typeof reply === "number" ? "int" : "string")], records: [[reply]] };
+}
+function hscanNoValues(name, upperArgs) {
+  return name === "HSCAN" && upperArgs.includes("NOVALUES");
+}
+function toOptions(config) {
+  return {
+    host: config.host,
+    port: config.port,
+    username: config.user || void 0,
+    password: config.password || void 0,
+    db: config.db ?? 0,
+    tls: config.ssl ? { rejectUnauthorized: config.sslVerify === true, servername: config.host } : void 0,
+    // RESP2 works on every server (RESP3 needs Redis 6 and HELLO).
+    protocol: 2,
+    // Integers above 2^53 (INCR counters, IDs) must not lose digits.
+    stringNumbers: true,
+    lazyConnect: true,
+    connectTimeout: 1e4,
+    // The app reconnects from the profile when a connection is lost; a
+    // silently reconnecting socket would forget the selected database.
+    retryStrategy: () => null,
+    maxRetriesPerRequest: 0,
+    enableOfflineQueue: false,
+    connectionName: "planche"
+  };
+}
+async function connect(config) {
+  const client2 = new Redis(toOptions(config));
+  client2.on("error", (err) => console.error("[redis] Connection error:", err.message));
+  try {
+    await client2.connect();
+  } catch (err) {
+    client2.disconnect();
+    throw err;
+  }
+  return client2;
+}
+var RedisDriver = class {
+  constructor(client2, config, clientId, cluster) {
+    this.client = client2;
+    this.config = config;
+    this.clientId = clientId;
+    this.cluster = cluster;
+    this.label = `${config.user ? `${config.user}@` : ""}${config.host}:${config.port}${cluster ? " (cluster node)" : ""}`;
+  }
+  client;
+  config;
+  clientId;
+  cluster;
+  type = "redis";
+  label;
+  /** Open feeds (Pub/Sub, MONITOR), each with the function that closes it. */
+  feeds = /* @__PURE__ */ new Set();
+  /** `COMMAND INFO` flags per command name, for read-only sessions. */
+  flags = /* @__PURE__ */ new Map();
+  /**
+   * Run `sql`, in logical database `database` when one is given. The
+   * connection is shared by every request of this profile (tree, console
+   * tabs), so the `SELECT` and the command go out as one pipeline — one
+   * socket write, with no other request able to land between them. Tracking
+   * the current database instead would race: two requests for different
+   * databases could each see the other's `SELECT`.
+   */
+  async query(sql2, database) {
+    const args = parseCommand(sql2);
+    const db = this.databaseFor(database);
+    try {
+      if (db === null) return replyToResult(args, await this.client.call(args[0], args.slice(1)));
+      const replies = await this.client.pipeline().call("SELECT", String(db)).call(args[0], ...args.slice(1)).exec();
+      const [selectReply, commandReply] = replies ?? [];
+      if (selectReply?.[0]) throw selectReply[0];
+      if (!commandReply) throw new Error("No reply from Redis");
+      if (commandReply[0]) throw commandReply[0];
+      return replyToResult(args, commandReply[1]);
+    } catch (err) {
+      throw clusterError(err) ?? err;
+    }
+  }
+  /** The database index to select, or null for none; a cluster has only db0. */
+  databaseFor(database) {
+    const db = redisDatabaseIndex(database);
+    if (this.cluster && db !== null && db > 0) throw new Error("A Redis Cluster has only db0.");
+    return this.cluster ? null : db;
+  }
+  /**
+   * All statements in one pipeline, behind the same `SELECT` — one socket
+   * write, so another request can neither interleave nor switch the
+   * database midway. A line that does not parse, or a command Redis refuses,
+   * fills its own slot with the error.
+   */
+  async batch(statements, database) {
+    const parsed = statements.map((sql2) => {
+      try {
+        return parseCommand(sql2);
+      } catch (err) {
+        return err instanceof Error ? err : new Error(String(err));
+      }
+    });
+    const pipeline = this.client.pipeline();
+    const db = this.databaseFor(database);
+    if (db !== null) pipeline.call("SELECT", String(db));
+    for (const args of parsed) if (!(args instanceof Error)) pipeline.call(args[0], ...args.slice(1));
+    const replies = await pipeline.exec() ?? [];
+    if (db !== null) {
+      const selected = replies.shift();
+      if (selected?.[0]) throw selected[0];
+    }
+    return parsed.map((args) => {
+      if (args instanceof Error) return args;
+      const [err, reply] = replies.shift() ?? [new Error("No reply from Redis"), null];
+      return err ? clusterError(err) ?? (err instanceof Error ? err : new Error(String(err))) : replyToResult(args, reply);
+    });
+  }
+  async assertReadOnly(sql2) {
+    const args = parseCommand(sql2);
+    const name = args[0].toLowerCase();
+    if (!this.flags.has(name)) {
+      const info = await this.client.call("COMMAND", ["INFO", name]).catch(() => null);
+      const entry = Array.isArray(info) ? info[0] : null;
+      this.flags.set(name, Array.isArray(entry) && Array.isArray(entry[2]) ? entry[2].map((f) => String(f).toLowerCase()) : void 0);
+    }
+    if (!isRedisReadOnlyCommand(args, this.flags.get(name))) {
+      throw new ReadOnlyViolation(`Read-only profile: ${redisCommandName(args)} is not a read command`);
+    }
+  }
+  /**
+   * A live feed on a dedicated connection: Pub/Sub messages or MONITOR's
+   * log. Each feed closes when its signal aborts or the driver closes.
+   */
+  async stream(request, emit, signal) {
+    if (request.kind === "monitor") {
+      const base = new Redis({ ...toOptions(this.config), lazyConnect: true });
+      const monitor = await base.monitor();
+      const close2 = () => {
+        monitor.disconnect();
+        base.disconnect();
+        this.feeds.delete(close2);
+      };
+      this.feeds.add(close2);
+      monitor.on("error", (err) => emit({ type: "error", message: err.message }));
+      monitor.on("monitor", (time, args, source, database) => {
+        emit({ type: "command", time: Math.round(Number(time) * 1e3), db: `db${database}`, client: source, args: args.map(String) });
+      });
+      signal.addEventListener("abort", close2, { once: true });
+      return;
+    }
+    if (request.channels.length === 0 && request.patterns.length === 0) throw new Error("Name at least one channel or pattern");
+    const subscriber = await connect(this.config);
+    const close = () => {
+      subscriber.disconnect();
+      this.feeds.delete(close);
+    };
+    this.feeds.add(close);
+    subscriber.on("message", (channel, message) => emit({ type: "message", time: Date.now(), channel, message }));
+    subscriber.on("pmessage", (pattern, channel, message) => emit({ type: "message", time: Date.now(), channel, pattern, message }));
+    try {
+      if (request.channels.length) await subscriber.subscribe(...request.channels);
+      if (request.patterns.length) await subscriber.psubscribe(...request.patterns);
+    } catch (err) {
+      close();
+      throw err;
+    }
+    signal.addEventListener("abort", close, { once: true });
+  }
+  /**
+   * A blocked command (BLPOP, XREAD BLOCK, WAIT) is released from a second
+   * connection with `CLIENT UNBLOCK`; a long Lua script with `SCRIPT KILL`.
+   */
+  async cancel() {
+    const killer = await connect(this.config);
+    try {
+      if (this.clientId !== null) await killer.call("CLIENT", ["UNBLOCK", String(this.clientId), "ERROR"]).catch(() => void 0);
+      await killer.call("SCRIPT", ["KILL"]).catch(() => void 0);
+    } finally {
+      killer.disconnect();
+    }
+  }
+  async close() {
+    for (const close of [...this.feeds]) close();
+    await this.client.quit().catch(() => this.client.disconnect());
+  }
+};
+var FEED_COMMANDS = /* @__PURE__ */ new Set(["SUBSCRIBE", "PSUBSCRIBE", "SSUBSCRIBE", "MONITOR"]);
+function parseCommand(sql2) {
+  if (/[\r\n]/.test(sql2.trim())) throw new Error("Send one Redis command per request");
+  const args = tokenizeRedisCommand(sql2);
+  if (args.length === 0) throw new Error("Empty command");
+  if (FEED_COMMANDS.has(args[0].toUpperCase())) {
+    throw new Error(`${args[0].toUpperCase()} holds its connection open; use the ${args[0].toUpperCase() === "MONITOR" ? "Monitor" : "Pub/Sub"} tool instead of the console`);
+  }
+  return args;
+}
+var redisDriverFactory = {
+  async open(config) {
+    const client2 = await connect(config);
+    const id = await client2.call("CLIENT", ["ID"]).catch(() => null);
+    const info = await client2.call("INFO", ["cluster"]).catch(() => "");
+    return new RedisDriver(client2, config, id === null ? null : Number(id), /cluster_enabled:1/.test(String(info)));
+  },
+  async test(config) {
+    const client2 = await connect(config);
+    try {
+      await client2.call("PING");
+    } finally {
+      client2.disconnect();
+    }
+  },
+  parseConfig(body) {
+    const host = typeof body.host === "string" ? body.host.trim() : "";
+    if (!host) throw new Error("host is required");
+    const named = typeof body.database === "string" ? redisDatabaseIndex(body.database) ?? Number(body.database) : void 0;
+    const db = Number(body.db ?? named ?? 0);
+    return {
+      driver: "redis",
+      host,
+      port: Number(body.port) || 6379,
+      user: typeof body.user === "string" && body.user ? body.user : void 0,
+      password: typeof body.password === "string" ? body.password : "",
+      db: Number.isInteger(db) && db >= 0 ? db : 0,
+      ssl: body.ssl === true,
+      sslVerify: body.sslVerify === true
+    };
+  }
+};
+
+// src/drivers/elasticsearch.ts
+import http from "http";
+import https from "https";
+
+// ../shared/es-request.ts
+var METHOD_LINE = /^(GET|POST|PUT|DELETE|HEAD)\s+(\S+)\s*$/i;
+var EsRequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EsRequestError";
+  }
+};
+function parseEsRequest(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const first = lines.findIndex((l) => l.trim() !== "" && !isComment(l));
+  if (first === -1) throw new EsRequestError("Empty request");
+  const m = METHOD_LINE.exec(lines[first].trim());
+  if (!m) throw new EsRequestError("A request starts with a method and a path, e.g. GET /_cat/indices");
+  const rawPath = m[2];
+  return {
+    method: m[1].toUpperCase(),
+    path: rawPath.startsWith("/") ? rawPath : `/${rawPath}`,
+    body: lines.slice(first + 1).join("\n").trim()
+  };
+}
+function isComment(line) {
+  const t = line.trimStart();
+  return t.startsWith("#") || t.startsWith("//");
+}
+function pathSegments(path) {
+  return path.split("?")[0].split("/").filter(Boolean).map((s) => decodeURIComponent(s));
+}
+var READ_POST = /* @__PURE__ */ new Set([
+  "_search",
+  "_msearch",
+  "_count",
+  "_mget",
+  "_field_caps",
+  "_explain",
+  "_analyze",
+  "_termvectors",
+  "_mtermvectors",
+  "_rank_eval"
+]);
+var READ_POST_PAIRS = /* @__PURE__ */ new Set(["_validate/query", "_search/template", "_render/template", "_msearch/template"]);
+var SQL_READ = /^\s*(SELECT|SHOW|DESCRIBE|DESC|EXPLAIN)\b/i;
+function isSqlEndpoint(segments) {
+  return segments[0] === "_sql" || segments[0] === "_plugins" && segments[1] === "_sql" || segments[0] === "_opendistro" && segments[1] === "_sql";
+}
+function sqlQuery(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return typeof parsed.query === "string" ? parsed.query : null;
+  } catch {
+    return null;
+  }
+}
+function isEsReadOnlyRequest(request) {
+  if (request.method === "GET" || request.method === "HEAD") return true;
+  if (request.method !== "POST") return false;
+  const segments = pathSegments(request.path);
+  if (isSqlEndpoint(segments)) {
+    const query = sqlQuery(request.body);
+    return query !== null && SQL_READ.test(query);
+  }
+  const last = segments[segments.length - 1] ?? "";
+  const lastTwo = segments.slice(-2).join("/");
+  return READ_POST.has(last) || READ_POST_PAIRS.has(lastTwo);
+}
+function isNdjsonEndpoint(path) {
+  const segments = pathSegments(path);
+  const last = segments[segments.length - 1] ?? "";
+  return last === "_bulk" || last === "_msearch" || segments.slice(-2).join("/") === "_msearch/template";
+}
+
+// src/drivers/elasticsearch.ts
+var REQUEST_TIMEOUT_MS = 6e4;
+function field2(name, type = "string") {
+  return { name, orgName: name, type, table: "", orgTable: "", db: "", maxLength: 0 };
+}
+function cell2(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "object") return JSON.stringify(value);
+  return value;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function objectsToResult(objects, leading = []) {
+  const names = [...leading];
+  for (const obj of objects) for (const key of Object.keys(obj)) if (!names.includes(key)) names.push(key);
+  return {
+    fields: names.map((n) => field2(n)),
+    records: objects.map((obj) => names.map((n) => cell2(obj[n])))
+  };
+}
+function esReplyToResult(request, reply) {
+  const base = { affectedRows: 0, insertId: 0, isResultQuery: true };
+  if (request.method === "HEAD") {
+    return { ...base, fields: [field2("status", "int")], records: [[reply.status]], reply: reply.status };
+  }
+  let body = reply.text;
+  if (reply.contentType.includes("json") && reply.text.trim()) {
+    try {
+      body = JSON.parse(reply.text);
+    } catch {
+      body = reply.text;
+    }
+  }
+  if (typeof body === "string") {
+    const lines = body.split("\n").filter((l) => l.length > 0);
+    return { ...base, fields: [field2("text")], records: lines.map((l) => [l]), reply: body };
+  }
+  const hits = isRecord(body) && isRecord(body.hits) && Array.isArray(body.hits.hits) ? body.hits.hits : null;
+  if (hits) {
+    const rows = hits.filter(isRecord).map((hit) => {
+      const source = isRecord(hit._source) ? hit._source : {};
+      return { _index: hit._index, _id: hit._id, _score: hit._score, ...source };
+    });
+    const table = objectsToResult(rows, ["_index", "_id", "_score"]);
+    return { ...base, ...table, reply: body };
+  }
+  if (Array.isArray(body)) {
+    if (body.every(isRecord)) return { ...base, ...objectsToResult(body), reply: body };
+    return { ...base, fields: [field2("#", "int"), field2("value")], records: body.map((v, i) => [i + 1, cell2(v)]), reply: body };
+  }
+  if (isRecord(body)) {
+    return { ...base, fields: [field2("field"), field2("value")], records: Object.entries(body).map(([k, v]) => [k, cell2(v)]), reply: body };
+  }
+  return { ...base, fields: [field2("value")], records: [[cell2(body)]], reply: body };
+}
+function esErrorMessage(status, text) {
+  try {
+    const parsed = JSON.parse(text);
+    const error = parsed.error;
+    if (isRecord(error)) {
+      const rootCause = Array.isArray(error.root_cause) && isRecord(error.root_cause[0]) ? error.root_cause[0] : null;
+      const reason = error.reason ?? rootCause?.reason;
+      return `${String(error.type ?? status)}: ${String(reason ?? "request failed")}`;
+    }
+    if (typeof error === "string") return error;
+    if (typeof parsed.message === "string") return parsed.message;
+  } catch {
+  }
+  return text.trim() ? `HTTP ${status}: ${text.trim().slice(0, 500)}` : `HTTP ${status}`;
+}
+function authHeader(config) {
+  if (!config.password) return void 0;
+  if (config.user) return `Basic ${Buffer.from(`${config.user}:${config.password}`).toString("base64")}`;
+  return `ApiKey ${config.password}`;
+}
+var ElasticsearchDriver = class {
+  constructor(config) {
+    this.config = config;
+    this.label = `${config.ssl ? "https" : "http"}://${config.host}:${config.port}`;
+  }
+  config;
+  type = "elasticsearch";
+  cancelKind = "abandon";
+  label;
+  inFlight = /* @__PURE__ */ new Set();
+  /** One HTTP exchange; rejects only for transport failures, not for error statuses. */
+  send(request) {
+    const { config } = this;
+    const transport = config.ssl ? https : http;
+    const ndjson = isNdjsonEndpoint(request.path);
+    const body = request.body ? ndjson && !request.body.endsWith("\n") ? `${request.body}
+` : request.body : void 0;
+    const headers = { accept: "application/json" };
+    const auth = authHeader(config);
+    if (auth) headers.authorization = auth;
+    if (body !== void 0) {
+      headers["content-type"] = ndjson ? "application/x-ndjson" : "application/json";
+      headers["content-length"] = String(Buffer.byteLength(body));
+    }
+    return new Promise((resolve3, reject) => {
+      const req = transport.request({
+        host: config.host,
+        port: config.port,
+        method: request.method,
+        path: request.path,
+        headers,
+        timeout: REQUEST_TIMEOUT_MS,
+        ...config.ssl ? { rejectUnauthorized: config.sslVerify === true, servername: config.host } : {}
+      }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          this.inFlight.delete(req);
+          resolve3({ status: res.statusCode ?? 0, contentType: String(res.headers["content-type"] ?? ""), text: Buffer.concat(chunks).toString("utf8") });
+        });
+        res.on("error", reject);
+      });
+      this.inFlight.add(req);
+      req.on("timeout", () => req.destroy(new Error(`No answer within ${REQUEST_TIMEOUT_MS / 1e3}s`)));
+      req.on("error", (err) => {
+        this.inFlight.delete(req);
+        reject(err);
+      });
+      if (body !== void 0) req.write(body);
+      req.end();
+    });
+  }
+  async query(sql2) {
+    const request = parseEsRequest(sql2);
+    const reply = await this.send(request);
+    if (reply.status >= 400 && request.method !== "HEAD") {
+      throw Object.assign(new Error(esErrorMessage(reply.status, reply.text)), { esStatus: reply.status });
+    }
+    return esReplyToResult(request, reply);
+  }
+  async assertReadOnly(sql2) {
+    const request = parseEsRequest(sql2);
+    if (!isEsReadOnlyRequest(request)) {
+      throw new ReadOnlyViolation(`Read-only profile: ${request.method} ${request.path.split("?")[0]} is not a read request`);
+    }
+  }
+  /** Requests are independent HTTP calls: cancelling drops the ones in flight. */
+  async cancel() {
+    for (const req of this.inFlight) req.destroy(new Error("Cancelled"));
+    this.inFlight.clear();
+  }
+  async close() {
+    await this.cancel();
+  }
+};
+async function identify(driver) {
+  const reply = await driver.send({ method: "GET", path: "/", body: "" });
+  if (reply.status === 401 || reply.status === 403) {
+    throw Object.assign(new Error(esErrorMessage(reply.status, reply.text)), { status: 401 });
+  }
+  if (reply.status >= 400) throw new Error(esErrorMessage(reply.status, reply.text));
+  try {
+    const info = JSON.parse(reply.text);
+    const product = info.version?.distribution === "opensearch" ? "OpenSearch" : "Elasticsearch";
+    return `${product} ${info.version?.number ?? ""}`.trim();
+  } catch {
+    throw new Error("The server did not answer like Elasticsearch or OpenSearch");
+  }
+}
+var elasticsearchDriverFactory = {
+  async open(config) {
+    const driver = new ElasticsearchDriver(config);
+    const product = await identify(driver);
+    driver.label = `${product} at ${driver.label}`;
+    return driver;
+  },
+  async test(config) {
+    await identify(new ElasticsearchDriver(config));
+  },
+  parseConfig(body) {
+    const host = typeof body.host === "string" ? body.host.trim() : "";
+    if (!host) throw new Error("host is required");
+    const ssl = body.ssl === true;
+    return {
+      driver: "elasticsearch",
+      host,
+      port: Number(body.port) || (ssl ? 443 : 9200),
+      user: typeof body.user === "string" && body.user ? body.user : void 0,
+      password: typeof body.password === "string" ? body.password : "",
+      ssl,
+      sslVerify: body.sslVerify === true
+    };
+  }
+};
+
 // src/ssh-tunnel.ts
 import { createServer } from "net";
 import { mkdir as mkdir4, readFile as readFile6, appendFile } from "fs/promises";
@@ -2488,9 +3282,9 @@ function keyType(blob) {
   if (!/^[A-Za-z0-9@.-]+$/.test(type)) throw new TunnelError("Malformed host key", 400);
   return type;
 }
-function knownHostsEntryMatches(field, patterns) {
-  if (field.startsWith("|1|")) {
-    const [, , salt, hash] = field.split("|");
+function knownHostsEntryMatches(field3, patterns) {
+  if (field3.startsWith("|1|")) {
+    const [, , salt, hash] = field3.split("|");
     if (!salt || !hash) return false;
     const key = Buffer.from(salt, "base64");
     const want = Buffer.from(hash, "base64");
@@ -2499,7 +3293,7 @@ function knownHostsEntryMatches(field, patterns) {
       return got.length === want.length && timingSafeEqual(got, want);
     });
   }
-  const entries = field.toLowerCase().split(",");
+  const entries = field3.toLowerCase().split(",");
   return patterns.some((p) => hostPatternMatches(entries, p));
 }
 function hostPatterns(host, port) {
@@ -2720,8 +3514,11 @@ var factories = {
   oracle: oracleDriverFactory,
   d1: d1DriverFactory,
   do: doDriverFactory,
-  "do-remote": doRemoteDriverFactory
+  "do-remote": doRemoteDriverFactory,
+  redis: redisDriverFactory,
+  elasticsearch: elasticsearchDriverFactory
 };
+var DRIVER_TYPES = Object.keys(factories);
 function isDriverType(value) {
   return typeof value === "string" && value in factories;
 }
@@ -2754,7 +3551,11 @@ function tunneled(driver, tunnel, label) {
     type: driver.type,
     label,
     query: (sql2, database) => driver.query(sql2, database),
+    batch: driver.batch ? (statements, database) => driver.batch(statements, database) : void 0,
+    stream: driver.stream ? (request, emit, signal) => driver.stream(request, emit, signal) : void 0,
     setReadOnly: driver.setReadOnly ? () => driver.setReadOnly() : void 0,
+    // Forwarded, or a read-only gateway profile over SSH would fall back to the SQL filter.
+    assertReadOnly: driver.assertReadOnly ? (sql2) => driver.assertReadOnly(sql2) : void 0,
     // Forwarded, or a tunnelled connection would report that its engine cannot
     // interrupt a statement when it is only this wrapper that cannot.
     cancel: driver.cancel ? () => driver.cancel() : void 0,
@@ -2771,7 +3572,7 @@ function openDriver(config) {
   return withTunnel(config, async (direct, tunnel) => {
     const driver = await openDirect(direct);
     if (!tunnel || isDirectDriver(config) || !config.ssh) return driver;
-    const label = `${config.user}@${config.host}:${config.port} via ssh ${config.ssh.user}@${config.ssh.host}:${config.ssh.port}`;
+    const label = `${config.user ? `${config.user}@` : ""}${config.host}:${config.port} via ssh ${config.ssh.user}@${config.ssh.host}:${config.ssh.port}`;
     return tunneled(driver, tunnel, label);
   });
 }
@@ -2802,6 +3603,10 @@ function openDirect(config) {
       return factories.do.open(config);
     case "do-remote":
       return factories["do-remote"].open(config);
+    case "redis":
+      return factories.redis.open(config);
+    case "elasticsearch":
+      return factories.elasticsearch.open(config);
   }
 }
 function testDirect(config) {
@@ -2822,6 +3627,10 @@ function testDirect(config) {
       return factories.do.test(config);
     case "do-remote":
       return factories["do-remote"].test(config);
+    case "redis":
+      return factories.redis.test(config);
+    case "elasticsearch":
+      return factories.elasticsearch.test(config);
   }
 }
 
@@ -2970,6 +3779,7 @@ var LOST_CODES = /* @__PURE__ */ new Set([
   "PROTOCOL_ENQUEUE_AFTER_DESTROY",
   // node sockets (pg, mssql/tedious surface these directly)
   "ECONNRESET",
+  "ECONNREFUSED",
   "EPIPE",
   "ETIMEDOUT",
   "ECONNABORTED",
@@ -2998,6 +3808,8 @@ var LOST_MESSAGES = [
   /connection is closed/i,
   // mssql
   /socket hang up/i,
+  /stream isn't writeable/i,
+  // ioredis with the offline queue off
   /ORA-0311[34]\b/,
   /ORA-01012\b/,
   /ORA-12541\b/,
@@ -3017,103 +3829,14 @@ function isConnectionLost(err) {
   return e.originalError !== void 0 && e.originalError !== err && isConnectionLost(e.originalError);
 }
 
-// src/read-only.ts
-var ReadOnlyViolation = class extends Error {
-  status = 403;
-  constructor(message) {
-    super(message);
-    this.name = "ReadOnlyViolation";
-  }
-};
-var READ_KEYWORDS = /* @__PURE__ */ new Set(["SELECT", "WITH", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "VALUES", "TABLE", "PRAGMA"]);
-function splitStatements(sql2) {
-  const out = [];
-  let cur = "";
-  let i = 0;
-  const n = sql2.length;
-  while (i < n) {
-    const ch = sql2[i];
-    const next = sql2[i + 1];
-    if (ch === "-" && next === "-") {
-      while (i < n && sql2[i] !== "\n") i++;
-      cur += " ";
-      continue;
-    }
-    if (ch === "#") {
-      while (i < n && sql2[i] !== "\n") i++;
-      cur += " ";
-      continue;
-    }
-    if (ch === "/" && next === "*") {
-      i += 2;
-      while (i < n && !(sql2[i] === "*" && sql2[i + 1] === "/")) i++;
-      i += 2;
-      cur += " ";
-      continue;
-    }
-    if (ch === "'" || ch === '"' || ch === "`" || ch === "[") {
-      const close = ch === "[" ? "]" : ch;
-      i++;
-      while (i < n) {
-        if (sql2[i] === "\\" && close === "'") {
-          i += 2;
-          continue;
-        }
-        if (sql2[i] === close) {
-          if (sql2[i + 1] === close && close !== "]") {
-            i += 2;
-            continue;
-          }
-          break;
-        }
-        i++;
-      }
-      i++;
-      cur += ch === "[" ? " x " : " 'x' ";
-      continue;
-    }
-    if (ch === "$" && next === "$") {
-      const end = sql2.indexOf("$$", i + 2);
-      i = end === -1 ? n : end + 2;
-      cur += " 'x' ";
-      continue;
-    }
-    if (ch === ";") {
-      out.push(cur);
-      cur = "";
-      i++;
-      continue;
-    }
-    cur += ch;
-    i++;
-  }
-  out.push(cur);
-  return out.map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function assertReadOnlyStatement(sql2) {
-  const statements = splitStatements(sql2);
-  if (statements.length === 0) return;
-  if (statements.length > 1) throw new ReadOnlyViolation("Read-only profile: one statement per request");
-  const stmt = statements[0];
-  const first = /^[A-Za-z]+/.exec(stmt)?.[0].toUpperCase() ?? "";
-  if (!READ_KEYWORDS.has(first)) throw new ReadOnlyViolation(`Read-only profile: ${first || "this statement"} is not allowed`);
-  if (first === "WITH") {
-    const words = stmt.toUpperCase().match(/\b(INSERT|UPDATE|DELETE|MERGE|REPLACE)\b/);
-    if (words) throw new ReadOnlyViolation(`Read-only profile: ${words[1]} inside WITH is not allowed`);
-  }
-  if (first === "PRAGMA" && /[=(]/.test(stmt)) throw new ReadOnlyViolation("Read-only profile: PRAGMA may only read");
-  if (/\bINTO\s+(OUTFILE|DUMPFILE)\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: INTO OUTFILE is not allowed");
-  if (/\bFOR\s+(UPDATE|SHARE|NO\s+KEY\s+UPDATE|KEY\s+SHARE)\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: locking reads are not allowed");
-  if (/\bLOCK\s+IN\s+SHARE\s+MODE\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: locking reads are not allowed");
-  if (first === "SELECT" && /\bINTO\b/i.test(stmt) && !/\bINTO\s+@/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: SELECT INTO is not allowed");
-}
-
 // src/tunneling.ts
 var IDLE_TIMEOUT_MS = Number(process.env.PLANCHE_IDLE_TIMEOUT_MS) || 30 * 60 * 1e3;
 var MAX_CONNECTIONS = Number(process.env.PLANCHE_MAX_CONNECTIONS) || 64;
 var ConnectionManager = class {
   connections = /* @__PURE__ */ new Map();
   lastUsed = /* @__PURE__ */ new Map();
+  /** Live feeds open per connection. */
+  feeds = /* @__PURE__ */ new Map();
   /** Connections opened for a read-only gateway profile: writes are refused before reaching the driver. */
   readOnly = /* @__PURE__ */ new Set();
   constructor() {
@@ -3124,7 +3847,7 @@ var ConnectionManager = class {
   async closeIdle() {
     const cutoff = Date.now() - IDLE_TIMEOUT_MS;
     for (const [id, used] of this.lastUsed) {
-      if (used < cutoff) {
+      if (used < cutoff && !this.feeds.get(id)) {
         console.log(`[ConnectionManager] Closing idle connection: ${id}`);
         await this.disconnect(id).catch(() => void 0);
       }
@@ -3166,19 +3889,86 @@ var ConnectionManager = class {
       throw new Error(`Connection not found: ${connectionId}`);
     }
     this.lastUsed.set(connectionId, Date.now());
-    if (this.readOnly.has(connectionId)) assertReadOnlyStatement(sql2);
+    if (this.readOnly.has(connectionId)) {
+      if (driver.assertReadOnly) await driver.assertReadOnly(sql2);
+      else assertReadOnlyStatement(sql2);
+    }
     try {
       return await driver.query(sql2, database);
     } catch (err) {
       if (!isConnectionLost(err)) throw err;
-      console.log(`[ConnectionManager] Connection lost, evicting: ${connectionId}`);
-      this.connections.delete(connectionId);
-      this.lastUsed.delete(connectionId);
-      this.readOnly.delete(connectionId);
-      await driver.close().catch(() => void 0);
-      throw new ConnectionLostError(`Connection lost: ${err instanceof Error ? err.message : String(err)}`);
+      return this.evictLost(connectionId, driver, err);
     }
   }
+  /**
+   * The socket died (network change, server timeout, sleep): forget the
+   * connection so the client re-opens it from the profile instead of
+   * hitting the same dead driver again.
+   */
+  async evictLost(connectionId, driver, err) {
+    console.log(`[ConnectionManager] Connection lost, evicting: ${connectionId}`);
+    this.connections.delete(connectionId);
+    this.lastUsed.delete(connectionId);
+    this.readOnly.delete(connectionId);
+    await driver.close().catch(() => void 0);
+    throw new ConnectionLostError(`Connection lost: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  /**
+   * Run several statements in order on one connection. On a read-only
+   * session every statement is checked *before* any runs, and one write
+   * refuses the whole batch — a batch must never be a way around the check.
+   */
+  async batch(connectionId, statements, database) {
+    const driver = this.connections.get(connectionId);
+    if (!driver) throw new Error(`Connection not found: ${connectionId}`);
+    this.lastUsed.set(connectionId, Date.now());
+    if (this.readOnly.has(connectionId)) {
+      for (const sql2 of statements) {
+        if (driver.assertReadOnly) await driver.assertReadOnly(sql2);
+        else assertReadOnlyStatement(sql2);
+      }
+    }
+    if (driver.batch) {
+      try {
+        return await driver.batch(statements, database);
+      } catch (err) {
+        if (!isConnectionLost(err)) throw err;
+        return this.evictLost(connectionId, driver, err);
+      }
+    }
+    const results = [];
+    for (const sql2 of statements) {
+      try {
+        results.push(await this.query(connectionId, sql2, database));
+      } catch (err) {
+        if (err instanceof ConnectionLostError) throw err;
+        results.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    return results;
+  }
+  /**
+   * Start a live feed on a connection. On a read-only session only
+   * subscriptions are allowed: MONITOR shows every client's commands, which
+   * is an administrator's view, not a read of the data.
+   */
+  async stream(connectionId, request, emit, signal) {
+    const driver = this.connections.get(connectionId);
+    if (!driver) throw new Error(`Connection not found: ${connectionId}`);
+    if (!driver.stream) throw Object.assign(new Error("This connection has no live feeds"), { status: 400 });
+    if (request.kind === "monitor" && this.readOnly.has(connectionId)) {
+      throw new ReadOnlyViolation("Read-only profile: MONITOR is not available");
+    }
+    this.lastUsed.set(connectionId, Date.now());
+    await driver.stream(request, emit, signal);
+    this.feeds.set(connectionId, (this.feeds.get(connectionId) ?? 0) + 1);
+    signal.addEventListener("abort", () => {
+      const open = (this.feeds.get(connectionId) ?? 1) - 1;
+      if (open > 0) this.feeds.set(connectionId, open);
+      else this.feeds.delete(connectionId);
+      this.lastUsed.set(connectionId, Date.now());
+    }, { once: true });
+  }
   /**
    * Interrupt whatever is running on a connection. Best effort: an engine with
    * no way to interrupt (better-sqlite3 blocks the thread) reports false rather
@@ -3256,6 +4046,8 @@ function errorExtra(err) {
   }
   return {};
 }
+var STREAM_FLUSH_MS = 100;
+var STREAM_BATCH_CAP = 500;
 var errorMessage = (err) => err instanceof Error ? err.message : String(err);
 function secretEquals(given, expected) {
   const a = createHash2("sha256").update(given).digest();
@@ -3386,7 +4178,8 @@ function createAgent(options) {
       version: options.version,
       protocolVersion: PROTOCOL_VERSION,
       activeConnections: manager.activeConnections,
-      uptime: process.uptime()
+      uptime: process.uptime(),
+      drivers: DRIVER_TYPES
     };
     const ai = await aiConfigView();
     body.ai = { configured: ai.configured, model: ai.model, tools: true };
@@ -3468,6 +4261,86 @@ function createAgent(options) {
       fail(res, errorStatus(err), message, errorExtra(err));
     }
   });
+  app.post("/batch", async (req, res) => {
+    const { connectionId, statements, database } = req.body ?? {};
+    if (typeof connectionId !== "string" || !connectionId || !Array.isArray(statements) || !statements.every((s) => typeof s === "string" && s)) {
+      fail(res, 400, "connectionId and a list of statements are required");
+      return;
+    }
+    if (statements.length > BATCH_LIMIT) {
+      fail(res, 400, `At most ${BATCH_LIMIT} statements per batch`);
+      return;
+    }
+    if (!manager.has(connectionId)) {
+      fail(res, 404, `Connection not found: ${connectionId}`);
+      return;
+    }
+    const start = Date.now();
+    try {
+      const outcomes = await manager.batch(connectionId, statements, typeof database === "string" ? database : void 0);
+      const results = outcomes.map((o) => o instanceof Error ? { success: false, message: errorMessage(o) } : { success: true, ...o });
+      const body = { success: true, results, execTime: Date.now() - start };
+      res.json(body);
+    } catch (err) {
+      const message = errorMessage(err);
+      if (err instanceof ConnectionLostError) {
+        fail(res, 404, message);
+        return;
+      }
+      const status = err?.status;
+      fail(res, typeof status === "number" && status >= 400 && status < 600 ? status : 422, message);
+    }
+  });
+  app.post("/stream", async (req, res) => {
+    const { connectionId, kind, channels, patterns } = req.body ?? {};
+    const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.length > 0).slice(0, 100) : [];
+    if (typeof connectionId !== "string" || kind !== "subscribe" && kind !== "monitor") {
+      fail(res, 400, "connectionId and kind (subscribe | monitor) are required");
+      return;
+    }
+    if (!manager.has(connectionId)) {
+      fail(res, 404, `Connection not found: ${connectionId}`);
+      return;
+    }
+    const stop = new AbortController();
+    let pending2 = [];
+    let dropped = 0;
+    const emit = (event) => {
+      if (pending2.length < STREAM_BATCH_CAP) pending2.push(event);
+      else dropped += 1;
+    };
+    try {
+      await manager.stream(connectionId, { kind, channels: strings(channels), patterns: strings(patterns) }, emit, stop.signal);
+    } catch (err) {
+      stop.abort();
+      const status = err?.status;
+      fail(res, typeof status === "number" && status >= 400 && status < 600 ? status : 422, errorMessage(err));
+      return;
+    }
+    res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" });
+    res.write(`data: ${JSON.stringify({ type: "ready" })}
+
+`);
+    const flush = setInterval(() => {
+      const batch = pending2;
+      pending2 = [];
+      if (dropped > 0) {
+        batch.push({ type: "dropped", count: dropped });
+        dropped = 0;
+      }
+      for (const event of batch) res.write(`data: ${JSON.stringify(event)}
+
+`);
+    }, STREAM_FLUSH_MS);
+    const keepAlive = setInterval(() => res.write(": ping\n\n"), 15e3);
+    const end = () => {
+      clearInterval(flush);
+      clearInterval(keepAlive);
+      stop.abort();
+    };
+    req.on("close", end);
+    res.on("close", end);
+  });
   app.post("/query", async (req, res) => {
     try {
       const { connectionId, sql: sql2, database } = req.body ?? {};
@@ -3489,6 +4362,7 @@ function createAgent(options) {
         affectedRows: result.affectedRows,
         insertId: result.insertId,
         isResultQuery: result.isResultQuery,
+        ...result.reply !== void 0 ? { reply: result.reply } : {},
         execTime
       });
     } catch (err) {