planche 0.4.1 → 0.5.0

package/dist/index.js

@@ -8,584 +8,510 @@ import { parseArgs } from "util";
 
 // src/server.ts
 import express from "express";
-import { timingSafeEqual } from "crypto";
+import { createHash as createHash2, timingSafeEqual as timingSafeEqual2 } from "crypto";
 
 // ../shared/contract.ts
 var PROTOCOL_VERSION = 2;
 
-// src/tunneling.ts
-import { randomUUID } from "crypto";
+// src/ssh-tunnel.ts
+import { createServer } from "net";
+import { mkdir, readFile as readFile2, appendFile } from "fs/promises";
+import { createHash, createHmac, timingSafeEqual } from "crypto";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join2 } from "path";
+import { Client } from "ssh2";
 
-// src/drivers/mysql.ts
-import mysql from "mysql2/promise";
-var MYSQL_TYPES = {
-  0: "decimal",
-  1: "tinyint",
-  2: "smallint",
-  3: "int",
-  4: "float",
-  5: "double",
-  6: "null",
-  7: "timestamp",
-  8: "bigint",
-  9: "mediumint",
-  10: "date",
-  11: "time",
-  12: "datetime",
-  13: "year",
-  14: "newdate",
-  15: "varchar",
-  16: "bit",
-  245: "json",
-  246: "newdecimal",
-  247: "enum",
-  248: "set",
-  249: "tinyblob",
-  250: "mediumblob",
-  251: "longblob",
-  252: "blob",
-  253: "varstring",
-  254: "string",
-  255: "geometry"
-};
-function getTypeName(typeId) {
-  return MYSQL_TYPES[typeId] ?? "unknown";
+// src/ssh-config.ts
+import { readFile, readdir } from "fs/promises";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, basename } from "path";
+var SSH_CONFIG_DISABLED = process.env.PLANCHE_SSH_CONFIG === "none";
+var DEFAULT_SSH_CONFIG = SSH_CONFIG_DISABLED ? "" : process.env.PLANCHE_SSH_CONFIG || join(homedir(), ".ssh", "config");
+var DEFAULT_IDENTITY_FILES = ["id_ed25519", "id_ecdsa", "id_rsa", "id_ed25519_sk", "id_ecdsa_sk"].map(
+  (f) => join(homedir(), ".ssh", f)
+);
+function expandHome(path) {
+  return path === "~" || path.startsWith("~/") ? join(homedir(), path.slice(1)) : path;
 }
-function toConnectionOptions(config) {
-  return {
-    host: config.host,
-    port: config.port,
-    user: config.user,
-    password: config.password,
-    database: config.database || void 0,
-    dateStrings: true,
-    charset: config.charset || "utf8mb4"
-  };
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
 }
-var USE_STATEMENT = /^\s*USE\s/i;
-var MySqlDriver = class {
-  constructor(connection, config) {
-    this.connection = connection;
-    this.label = `${config.user}@${config.host}:${config.port}`;
-    this.currentDatabase = config.database ?? null;
-  }
-  connection;
-  type = "mysql";
-  label;
-  /**
-   * Default schema the session is currently in, or null when unknown (after
-   * the client ran its own `USE`). Tracked so the schema is switched with a
-   * plain `USE` only when it actually changes: `changeUser()` would reset the
-   * whole session on every call, silently rolling back open transactions and
-   * dropping temporary tables and user variables.
-   */
-  currentDatabase;
-  async query(sql2, database) {
-    if (database && database !== this.currentDatabase) {
-      await this.connection.query(`USE ${mysql.escapeId(database)}`);
-      this.currentDatabase = database;
-    }
-    const [results, fields] = await this.connection.query(sql2);
-    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),
-        table: field.table ?? "",
-        orgTable: field.orgTable ?? "",
-        db: field.db ?? "",
-        maxLength: field.length ?? 0
-      }));
-      const records = results.map(
-        (row) => fieldPackets.map((field) => row[field.name])
-      );
-      return { fields: mappedFields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
-    }
-    const header = results;
-    return {
-      fields: [],
-      records: [],
-      affectedRows: header.affectedRows ?? 0,
-      insertId: header.insertId ?? 0,
-      isResultQuery: false
-    };
-  }
-  async close() {
-    await this.connection.end();
-  }
-};
-var mysqlDriverFactory = {
-  async open(config) {
-    const connection = await mysql.createConnection(toConnectionOptions(config));
-    return new MySqlDriver(connection, config);
-  },
-  async test(config) {
-    const connection = await mysql.createConnection({
-      ...toConnectionOptions(config),
-      database: void 0
-    });
-    await connection.end();
-  },
-  parseConfig(body) {
-    const host = typeof body.host === "string" ? body.host.trim() : "";
-    const user = typeof body.user === "string" ? body.user : "";
-    if (!host || !user) {
-      throw new Error("host and user are required");
-    }
-    return {
-      driver: "mysql",
-      host,
-      port: Number(body.port) || 3306,
-      user,
-      password: typeof body.password === "string" ? body.password : "",
-      database: typeof body.database === "string" && body.database ? body.database : void 0,
-      charset: typeof body.charset === "string" && body.charset ? body.charset : void 0
-    };
+function hostPatternMatches(patterns, host) {
+  let matched = false;
+  for (const raw of patterns) {
+    const negated = raw.startsWith("!");
+    const pattern = negated ? raw.slice(1) : raw;
+    if (!globToRegExp(pattern).test(host)) continue;
+    if (negated) return false;
+    matched = true;
   }
-};
-
-// src/drivers/postgres.ts
-import pg from "pg";
-var TEXT_OIDS = [
-  20,
-  // int8
-  1700,
-  // numeric
-  1082,
-  // date
-  1114,
-  // timestamp
-  1184,
-  // timestamptz
-  1083,
-  // time
-  1266,
-  // timetz
-  1186
-  // interval
-];
-var types = new pg.TypeOverrides();
-for (const oid of TEXT_OIDS) types.setTypeParser(oid, (value) => value);
-var BUILTIN_TYPES = {
-  16: "bool",
-  17: "bytea",
-  18: "char",
-  19: "name",
-  20: "int8",
-  21: "int2",
-  23: "int4",
-  25: "text",
-  26: "oid",
-  114: "json",
-  142: "xml",
-  700: "float4",
-  701: "float8",
-  1042: "bpchar",
-  1043: "varchar",
-  1082: "date",
-  1083: "time",
-  1114: "timestamp",
-  1184: "timestamptz",
-  1186: "interval",
-  1266: "timetz",
-  1700: "numeric",
-  2950: "uuid",
-  3802: "jsonb",
-  1560: "bit",
-  1562: "varbit",
-  600: "point",
-  869: "inet",
-  650: "cidr",
-  829: "macaddr",
-  1007: "_int4",
-  1009: "_text"
-};
-function toClientConfig(config) {
-  return {
-    host: config.host,
-    port: config.port,
-    user: config.user,
-    password: config.password,
-    database: config.database,
-    ssl: config.ssl ? { rejectUnauthorized: config.sslVerify === true } : void 0,
-    types
-  };
+  return matched;
 }
-var SEARCH_PATH_STATEMENT = /^\s*SET\s+(SESSION\s+|LOCAL\s+)?search_path\b/i;
-var quoteIdent = (name) => `"${name.replaceAll('"', '""')}"`;
-var PostgresDriver = class {
-  constructor(client, config) {
-    this.client = client;
-    this.label = `${config.user}@${config.host}:${config.port}/${config.database}`;
+function tokenize(line) {
+  const tokens = [];
+  const re = /"([^"]*)"|(\S+)/g;
+  let m;
+  while (m = re.exec(line)) tokens.push(m[1] ?? m[2]);
+  return tokens;
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) return void 0;
+  const eq = trimmed.match(/^([A-Za-z]+)\s*=\s*(.*)$/);
+  const [keyword, rest] = eq ? [eq[1], eq[2]] : [trimmed.split(/\s+/, 1)[0], trimmed.slice(trimmed.split(/\s+/, 1)[0].length)];
+  return { keyword: keyword.toLowerCase(), args: tokenize(rest) };
+}
+async function expandGlob(path) {
+  const base = basename(path);
+  if (!/[*?]/.test(base)) return [path];
+  const dir = dirname(path);
+  try {
+    const re = globToRegExp(base);
+    return (await readdir(dir)).filter((name) => re.test(name)).sort().map((name) => join(dir, name));
+  } catch {
+    return [];
   }
-  client;
-  type = "postgres";
-  label;
-  /**
-   * Schema currently first in `search_path`, or null when unknown (after the
-   * client set it itself). The app's "database" for a Postgres connection is
-   * a schema of the bound database, switched with `SET search_path`.
-   */
-  currentSchema = null;
-  typeNames = { ...BUILTIN_TYPES };
-  /**
-   * Result fields name their source only by OID (`tableID` / `columnID`);
-   * the frontend needs schema/table/column names to decide whether a grid is
-   * editable and to build UPDATEs, so they are resolved here and cached.
-   */
-  relations = /* @__PURE__ */ new Map();
-  async loadTypeNames() {
-    try {
-      const res = await this.client.query(
-        "SELECT oid, typname FROM pg_type WHERE typtype IN ('b', 'e', 'd', 'r')"
-      );
-      for (const row of res.rows) this.typeNames[Number(row.oid)] = row.typname;
-    } catch {
-    }
+}
+async function loadLines(file, seen) {
+  if (seen.has(file)) return [];
+  seen.add(file);
+  try {
+    return (await readFile(file, "utf8")).split(/\r?\n/);
+  } catch {
+    return [];
   }
-  async resolveRelations(tableIds) {
-    const missing = [...new Set(tableIds)].filter((id) => id > 0 && !this.relations.has(id));
-    if (missing.length === 0) return;
-    try {
-      const res = await this.client.query(
-        `SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname
-         FROM pg_class c
-         JOIN pg_namespace n ON n.oid = c.relnamespace
-         JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
-         WHERE c.oid = ANY($1::oid[])`,
-        [missing]
-      );
-      for (const row of res.rows) {
-        const oid = Number(row.oid);
-        let rel = this.relations.get(oid);
-        if (!rel) {
-          rel = { schema: row.nspname, table: row.relname, columns: /* @__PURE__ */ new Map() };
-          this.relations.set(oid, rel);
-        }
-        rel.columns.set(Number(row.attnum), row.attname);
+}
+async function resolveSshHost(host, file = DEFAULT_SSH_CONFIG) {
+  const result = { identityFiles: [] };
+  if (!file) return result;
+  const seen = /* @__PURE__ */ new Set();
+  async function walk(path, active) {
+    let blockActive = active;
+    for (const line of await loadLines(path, seen)) {
+      const d = parseLine(line);
+      if (!d) continue;
+      switch (d.keyword) {
+        case "host":
+          blockActive = hostPatternMatches(d.args, host);
+          continue;
+        case "match":
+          blockActive = d.args.length === 1 && d.args[0].toLowerCase() === "all";
+          continue;
+        case "include":
+          for (const inc of d.args) {
+            const target = expandHome(inc);
+            const abs = isAbsolute(target) ? target : join(homedir(), ".ssh", target);
+            for (const expanded of await expandGlob(abs)) await walk(expanded, blockActive);
+          }
+          continue;
+      }
+      if (!blockActive) continue;
+      const value = d.args[0];
+      if (value === void 0) continue;
+      switch (d.keyword) {
+        case "hostname":
+          result.hostName ??= value.replace(/%h/g, host);
+          break;
+        case "port":
+          result.port ??= Number(value) || void 0;
+          break;
+        case "user":
+          result.user ??= value;
+          break;
+        case "identityfile":
+          for (const f of d.args) result.identityFiles.push(expandHome(f.replace(/%d/g, homedir()).replace(/%h/g, host)));
+          break;
+        case "identityagent":
+          result.identityAgent ??= value === "none" ? void 0 : expandHome(value.replace(/%d/g, homedir()));
+          break;
+        case "proxyjump":
+          result.proxyJump ??= value;
+          break;
       }
-    } catch {
-    }
-  }
-  async query(sql2, database) {
-    if (database && database !== this.currentSchema) {
-      await this.client.query(`SET search_path TO ${quoteIdent(database)}, public`);
-      this.currentSchema = database;
-    }
-    const result = await this.client.query({ text: sql2, rowMode: "array" });
-    if (SEARCH_PATH_STATEMENT.test(sql2)) this.currentSchema = null;
-    const results = Array.isArray(result) ? result : [result];
-    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);
-        return {
-          name: field.name,
-          orgName: rel?.columns.get(field.columnID) ?? field.name,
-          type: this.typeNames[field.dataTypeID] ?? `oid:${field.dataTypeID}`,
-          table: rel?.table ?? "",
-          orgTable: rel?.table ?? "",
-          db: rel?.schema ?? "",
-          maxLength: field.dataTypeSize > 0 ? field.dataTypeSize : 0
-        };
-      });
-      return { fields, records: last.rows, affectedRows: 0, insertId: 0, isResultQuery: true };
     }
-    return {
-      fields: [],
-      records: [],
-      affectedRows: results.reduce((sum, r) => sum + (r.rowCount ?? 0), 0),
-      insertId: 0,
-      isResultQuery: false
-    };
   }
-  async close() {
-    await this.client.end();
+  await walk(file, true);
+  return result;
+}
+
+// src/ssh-tunnel.ts
+var TunnelError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "TunnelError";
   }
+  status;
 };
-var postgresDriverFactory = {
-  async open(config) {
-    const client = new pg.Client(toClientConfig(config));
-    await client.connect();
-    const driver = new PostgresDriver(client, config);
-    await driver.loadTypeNames();
-    return driver;
-  },
-  async test(config) {
-    const client = new pg.Client(toClientConfig(config));
-    await client.connect();
-    await client.end();
-  },
-  parseConfig(body) {
-    const host = typeof body.host === "string" ? body.host.trim() : "";
-    const user = typeof body.user === "string" ? body.user : "";
-    if (!host || !user) {
-      throw new Error("host and user are required");
-    }
-    return {
-      driver: "postgres",
-      host,
-      port: Number(body.port) || 5432,
-      user,
-      password: typeof body.password === "string" ? body.password : "",
-      database: typeof body.database === "string" && body.database ? body.database : "postgres",
-      ssl: body.ssl === true,
-      sslVerify: body.sslVerify === true
-    };
+var HostKeyError = class extends TunnelError {
+  hostKey;
+  constructor(host, port, type, fingerprint2) {
+    super(`The SSH host key of ${host}:${port} is not known yet (${type} ${fingerprint2}). Verify the fingerprint and accept it to continue.`, 409);
+    this.name = "HostKeyError";
+    this.hostKey = { host, port, type, fingerprint: fingerprint2 };
   }
 };
-
-// src/drivers/sqlite.ts
-import Database from "better-sqlite3";
-import { existsSync } from "fs";
-import { isAbsolute, resolve, sep } from "path";
-function normalizeDeclaredType(declared) {
-  if (!declared) return null;
-  const base = declared.trim().toLowerCase().replace(/\(.*$/, "").trim();
-  return base || null;
+var CONNECT_TIMEOUT_MS = 2e4;
+var PLANCHE_DIR = join2(homedir2(), ".planche");
+var PLANCHE_KNOWN_HOSTS = join2(PLANCHE_DIR, "known_hosts");
+var OPENSSH_KNOWN_HOSTS = join2(homedir2(), ".ssh", "known_hosts");
+function parseSshConfig(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "object") throw new TunnelError("ssh must be an object", 400);
+  const body = value;
+  const host = typeof body.host === "string" ? body.host.trim() : "";
+  const user = typeof body.user === "string" ? body.user.trim() : "";
+  const auth = body.auth;
+  if (!host) throw new TunnelError("ssh.host is required", 400);
+  if (host.length > 253 || !/^[A-Za-z0-9._:[\]-]+$/.test(host)) throw new TunnelError("ssh.host is not a valid host name", 400);
+  if (auth !== "password" && auth !== "key" && auth !== "agent") {
+    throw new TunnelError("ssh.auth must be one of password, key, agent", 400);
+  }
+  const str = (v) => typeof v === "string" && v ? v : void 0;
+  const config = {
+    host,
+    port: Number(body.port) || 22,
+    user,
+    auth,
+    password: auth === "password" ? str(body.password) ?? "" : void 0,
+    privateKey: auth === "key" ? str(body.privateKey) : void 0,
+    passphrase: auth === "key" ? str(body.passphrase) : void 0,
+    acceptHostKey: typeof body.acceptHostKey === "string" && /^SHA256:[A-Za-z0-9+/]{43}$/.test(body.acceptHostKey) ? body.acceptHostKey : void 0
+  };
+  return config;
 }
-function inferTypeFromValue(value) {
-  if (value === null || value === void 0) return "null";
-  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "real";
-  if (typeof value === "bigint") return "bigint";
-  if (Buffer.isBuffer(value)) return "blob";
-  return "text";
+function keyType(blob) {
+  if (blob.length < 4) throw new TunnelError("Malformed host key", 400);
+  const len = blob.readUInt32BE(0);
+  if (len <= 0 || len > 64 || blob.length < 4 + len) throw new TunnelError("Malformed host key", 400);
+  return blob.subarray(4, 4 + len).toString("ascii");
 }
-var SQLITE_DIR = process.env.PLANCHE_SQLITE_DIR ? resolve(process.env.PLANCHE_SQLITE_DIR) : null;
-function resolveFile(file) {
-  if (file === ":memory:") return file;
-  if (file.startsWith("file:")) {
-    if (SQLITE_DIR) throw new Error("URI filenames are disabled while PLANCHE_SQLITE_DIR is set");
-    return file;
+function knownHostsEntryMatches(field, patterns) {
+  if (field.startsWith("|1|")) {
+    const [, , salt, hash] = field.split("|");
+    if (!salt || !hash) return false;
+    const key = Buffer.from(salt, "base64");
+    const want = Buffer.from(hash, "base64");
+    return patterns.some((p) => {
+      const got = createHmac("sha1", key).update(p).digest();
+      return got.length === want.length && timingSafeEqual(got, want);
+    });
   }
-  const resolved = isAbsolute(file) ? file : resolve(SQLITE_DIR ?? process.cwd(), file);
-  if (SQLITE_DIR && resolved !== SQLITE_DIR && !resolved.startsWith(SQLITE_DIR + sep)) {
-    throw new Error(`SQLite file must be inside ${SQLITE_DIR}`);
+  const entries = field.toLowerCase().split(",");
+  return patterns.some((p) => hostPatternMatches(entries, p));
+}
+function hostPatterns(host, port) {
+  const h = host.toLowerCase();
+  return port === 22 ? [h, `[${h}]:22`] : [`[${h}]:${port}`];
+}
+async function readKnownHosts(file) {
+  try {
+    return (await readFile2(file, "utf8")).split(/\r?\n/);
+  } catch {
+    return [];
   }
-  return resolved;
 }
-function openDatabase(config) {
-  const file = resolveFile(config.file);
-  const isMemory = file === ":memory:";
-  if (!isMemory && !config.createIfMissing && !existsSync(file)) {
-    throw new Error(`SQLite file not found: ${file}`);
+async function lookupHostKey(host, port, blob) {
+  const patterns = hostPatterns(host, port);
+  const type = keyType(blob);
+  const encoded = blob.toString("base64");
+  let sawType = false;
+  const lines = [...await readKnownHosts(OPENSSH_KNOWN_HOSTS), ...await readKnownHosts(PLANCHE_KNOWN_HOSTS)];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("@")) continue;
+    const [hosts, lineType, lineKey] = line.split(/\s+/);
+    if (!hosts || !lineType || !lineKey) continue;
+    if (!knownHostsEntryMatches(hosts, patterns)) continue;
+    if (lineType !== type) continue;
+    if (lineKey === encoded) return "match";
+    sawType = true;
   }
-  return new Database(file, {
-    readonly: config.readonly ?? false,
-    fileMustExist: !isMemory && !config.createIfMissing
-  });
+  return sawType ? "mismatch" : "unknown";
 }
-var SqliteDriver = class {
-  constructor(db, config) {
-    this.db = db;
-    this.label = resolveFile(config.file);
+async function rememberHostKey(host, port, blob) {
+  await mkdir(PLANCHE_DIR, { recursive: true, mode: 448 });
+  const name = port === 22 ? host.toLowerCase() : `[${host.toLowerCase()}]:${port}`;
+  await appendFile(PLANCHE_KNOWN_HOSTS, `${name} ${keyType(blob)} ${blob.toString("base64")}
+`, { mode: 384 });
+}
+function fingerprint(blob) {
+  return "SHA256:" + createHash("sha256").update(blob).digest("base64").replace(/=+$/, "");
+}
+async function resolveConfig(ssh) {
+  const cfg = await resolveSshHost(ssh.host);
+  if (cfg.proxyJump) {
+    throw new TunnelError(`ProxyJump (${cfg.proxyJump}) configured for ${ssh.host} in ~/.ssh/config is not supported`, 400);
   }
-  db;
-  type = "sqlite";
-  label;
-  async query(sql2) {
-    let statement;
-    try {
-      statement = this.db.prepare(sql2);
-    } catch (err) {
-      if (err instanceof RangeError && /more than one statement/i.test(err.message)) {
-        this.db.exec(sql2);
-        return { fields: [], records: [], affectedRows: 0, insertId: 0, isResultQuery: false };
-      }
-      throw err;
-    }
-    if (!statement.reader) {
-      const info = statement.run();
-      return {
-        fields: [],
-        records: [],
-        affectedRows: info.changes,
-        insertId: Number(info.lastInsertRowid),
-        isResultQuery: false
-      };
-    }
-    const columns = statement.columns();
-    const records = statement.raw(true).all();
-    const fields = columns.map((col, index) => {
-      const declared = normalizeDeclaredType(col.type);
-      const type = declared ?? inferTypeFromValue(firstNonNull(records, index));
-      return {
-        name: col.name,
-        orgName: col.column ?? col.name,
-        type,
-        table: col.table ?? "",
-        orgTable: col.table ?? "",
-        db: col.database ?? "",
-        maxLength: 0
-      };
-    });
-    return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+  const resolved = {
+    ...ssh,
+    host: cfg.hostName ?? ssh.host,
+    port: ssh.port === 22 && cfg.port ? cfg.port : ssh.port,
+    user: ssh.user || cfg.user || ""
+  };
+  if (!resolved.user) {
+    throw new TunnelError(
+      SSH_CONFIG_DISABLED ? "ssh.user is required" : `ssh.user is required (no User for ${ssh.host} in ~/.ssh/config)`,
+      400
+    );
   }
-  async close() {
-    if (this.db.inTransaction) {
+  if (resolved.auth === "key" && !resolved.privateKey) {
+    if (SSH_CONFIG_DISABLED) {
+      throw new TunnelError("ssh.privateKey is required (the agent runs with PLANCHE_SSH_CONFIG=none)", 400);
+    }
+    const candidates = cfg.identityFiles.length ? cfg.identityFiles : DEFAULT_IDENTITY_FILES;
+    for (const file of candidates) {
       try {
-        this.db.exec("ROLLBACK");
+        resolved.privateKey = await readFile2(file, "utf8");
+        console.log(`[ssh] Using identity file ${file} for ${ssh.host}`);
+        break;
       } catch {
       }
     }
-    this.db.close();
+    if (!resolved.privateKey) {
+      throw new TunnelError(
+        `No private key given and none readable for ${ssh.host} (tried ${candidates.map((f) => basename2(f)).join(", ")} in ~/.ssh)`,
+        400
+      );
+    }
   }
-};
-function firstNonNull(records, index) {
-  for (const row of records) {
-    const value = row[index];
-    if (value !== null && value !== void 0) return value;
+  return { ...resolved, identityAgent: cfg.identityAgent };
+}
+function toConnectConfig(ssh) {
+  const base = {
+    host: ssh.host,
+    port: ssh.port,
+    username: ssh.user,
+    readyTimeout: CONNECT_TIMEOUT_MS,
+    keepaliveInterval: 3e4
+  };
+  switch (ssh.auth) {
+    case "password":
+      return { ...base, password: ssh.password ?? "", tryKeyboard: true };
+    case "key":
+      return { ...base, privateKey: ssh.privateKey, passphrase: ssh.passphrase };
+    case "agent": {
+      const agent = process.env.SSH_AUTH_SOCK || ssh.identityAgent || (process.platform === "win32" ? "pageant" : void 0);
+      if (!agent) throw new TunnelError("No ssh-agent found (SSH_AUTH_SOCK is not set)", 400);
+      return { ...base, agent };
+    }
+  }
+}
+function describeSshError(err, ssh) {
+  const target = `${ssh.user}@${ssh.host}:${ssh.port}`;
+  if (err instanceof TunnelError) return err;
+  switch (err.level) {
+    case "client-authentication":
+      return new TunnelError(`SSH authentication failed for ${target}`, 401);
+    case "client-timeout":
+      return new TunnelError(`SSH connection to ${target} timed out`, 400);
+    default:
+      return new TunnelError(`SSH connection to ${target} failed: ${err.message}`, 400);
   }
-  return null;
 }
-var sqliteDriverFactory = {
-  async open(config) {
-    return new SqliteDriver(openDatabase(config), config);
-  },
-  async test(config) {
-    const db = openDatabase(config);
+async function openSshTunnel(requested, target) {
+  const ssh = await resolveConfig(requested);
+  const client = new Client();
+  const connectConfig = toConnectConfig(ssh);
+  let verifyError;
+  connectConfig.hostVerifier = (key, verified) => {
+    lookupHostKey(ssh.host, ssh.port, key).then(async (result) => {
+      const fp = fingerprint(key);
+      if (result === "mismatch") {
+        verifyError = new TunnelError(
+          `Host key for ${ssh.host}:${ssh.port} has changed (${fp}). Remove the old entry from ~/.ssh/known_hosts or ~/.planche/known_hosts if this is expected.`,
+          400
+        );
+        verified(false);
+        return;
+      }
+      if (result === "unknown") {
+        if (ssh.acceptHostKey !== fp) {
+          verifyError = new HostKeyError(ssh.host, ssh.port, keyType(key), fp);
+          verified(false);
+          return;
+        }
+        console.log(`[ssh] Host key for ${ssh.host}:${ssh.port} (${fp}) accepted by the user, saved to ~/.planche/known_hosts`);
+        await rememberHostKey(ssh.host, ssh.port, key).catch((e) => console.warn(`[ssh] Could not save host key: ${e.message}`));
+      }
+      verified(true);
+    }).catch((err) => {
+      verifyError = err instanceof TunnelError ? err : new TunnelError(`Host key verification failed: ${err instanceof Error ? err.message : String(err)}`, 400);
+      verified(false);
+    });
+  };
+  await new Promise((resolve2, reject) => {
+    client.once("ready", resolve2);
+    client.once("error", (err) => reject(verifyError ?? describeSshError(err, ssh)));
     try {
-      db.prepare("SELECT 1").get();
-    } finally {
-      db.close();
-    }
-  },
-  parseConfig(body) {
-    const file = typeof body.file === "string" ? body.file.trim() : "";
-    if (!file) {
-      throw new Error("file is required");
+      client.connect(connectConfig);
+    } catch (err) {
+      reject(describeSshError(err, ssh));
     }
-    return {
-      driver: "sqlite",
-      file,
-      createIfMissing: body.createIfMissing === true,
-      readonly: body.readonly === true
-    };
-  }
-};
+  });
+  const sockets = /* @__PURE__ */ new Set();
+  let forwardError;
+  const server = createServer((socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+    client.forwardOut(socket.localAddress ?? "127.0.0.1", socket.localPort ?? 0, target.host, target.port, (err, stream) => {
+      if (err) {
+        const local = /^(localhost|127\.0\.0\.1|::1)$/i.test(target.host);
+        const hint = local ? `"${target.host}" is resolved on the jump host itself; use the database's real address (e.g. the RDS endpoint) as the database host` : "is the database reachable from the jump host, and does it allow TCP forwarding?";
+        forwardError = `SSH port forwarding to ${target.host}:${target.port} failed: ${err.message} (${hint})`;
+        console.error(`[ssh] ${forwardError}`);
+        socket.destroy();
+        return;
+      }
+      socket.pipe(stream).pipe(socket);
+      stream.once("close", () => socket.destroy());
+      socket.once("close", () => stream.destroy());
+    });
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve2());
+  }).catch((err) => {
+    client.end();
+    throw new TunnelError(`Could not open local tunnel port: ${err.message}`, 400);
+  });
+  const { port } = server.address();
+  let closed = false;
+  const close = () => new Promise((resolve2) => {
+    if (closed) return resolve2();
+    closed = true;
+    for (const s of sockets) s.destroy();
+    server.close(() => {
+      client.end();
+      resolve2();
+    });
+  });
+  client.once("close", () => void close());
+  return {
+    host: "127.0.0.1",
+    port,
+    get forwardError() {
+      return forwardError;
+    },
+    close
+  };
+}
 
-// src/drivers/mssql.ts
-import sql from "mssql";
-function toPoolConfig(config) {
+// src/tunneling.ts
+import { randomUUID } from "crypto";
+
+// src/drivers/mysql.ts
+import mysql from "mysql2/promise";
+var MYSQL_TYPES = {
+  0: "decimal",
+  1: "tinyint",
+  2: "smallint",
+  3: "int",
+  4: "float",
+  5: "double",
+  6: "null",
+  7: "timestamp",
+  8: "bigint",
+  9: "mediumint",
+  10: "date",
+  11: "time",
+  12: "datetime",
+  13: "year",
+  14: "newdate",
+  15: "varchar",
+  16: "bit",
+  245: "json",
+  246: "newdecimal",
+  247: "enum",
+  248: "set",
+  249: "tinyblob",
+  250: "mediumblob",
+  251: "longblob",
+  252: "blob",
+  253: "varstring",
+  254: "string",
+  255: "geometry"
+};
+function getTypeName(typeId) {
+  return MYSQL_TYPES[typeId] ?? "unknown";
+}
+function toConnectionOptions(config) {
   return {
-    server: config.host,
+    host: config.host,
     port: config.port,
     user: config.user,
     password: config.password,
-    database: config.database,
-    // One physical connection: manual transactions and USE need session affinity.
-    pool: { min: 1, max: 1, idleTimeoutMillis: 24 * 60 * 60 * 1e3 },
-    options: {
-      encrypt: config.ssl === true,
-      trustServerCertificate: true,
-      // Keep date/time values as sent by the server rather than shifting to UTC.
-      useUTC: false,
-      enableArithAbort: true
-    },
-    requestTimeout: 0
+    database: config.database || void 0,
+    dateStrings: true,
+    charset: config.charset || "utf8mb4"
   };
 }
-var pad = (n, width = 2) => String(n).padStart(width, "0");
-function formatDate(d) {
-  const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
-  const ms = d.getMilliseconds();
-  return `${date} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}${ms ? "." + pad(ms, 3) : ""}`;
-}
-function normalizeValue(value) {
-  if (value instanceof Date) return formatDate(value);
-  if (Buffer.isBuffer(value)) return value.toString("hex");
-  return value;
-}
-var RESULT_QUERY = /^\s*(?:WITH|SELECT|\()/i;
-var MssqlDriver = class {
-  constructor(pool, config) {
-    this.pool = pool;
-    this.label = `${config.user}@${config.host}:${config.port}/${config.database}`;
+var USE_STATEMENT = /^\s*USE\s/i;
+var MySqlDriver = class {
+  constructor(connection, config) {
+    this.connection = connection;
+    this.label = `${config.user}@${config.host}:${config.port}`;
+    this.currentDatabase = config.database ?? null;
   }
-  pool;
-  type = "mssql";
+  connection;
+  type = "mysql";
   label;
-  /** Source columns per SQL text; `sys.dm_exec_describe_first_result_set` is not free. */
-  sources = /* @__PURE__ */ new Map();
   /**
-   * The `mssql` driver does not report which table a result column comes
-   * from; ask the server to describe the statement instead so the grid can
-   * decide whether it is editable and address rows by primary key.
+   * Default schema the session is currently in, or null when unknown (after
+   * the client ran its own `USE`). Tracked so the schema is switched with a
+   * plain `USE` only when it actually changes: `changeUser()` would reset the
+   * whole session on every call, silently rolling back open transactions and
+   * dropping temporary tables and user variables.
    */
-  async describe(text) {
-    const cached = this.sources.get(text);
-    if (cached !== void 0) return cached;
-    let result = null;
-    try {
-      const req = this.pool.request();
-      req.input("sql", sql.NVarChar(sql.MAX), text);
-      const res = await req.query(
-        "SELECT name, source_schema, source_table, source_column, system_type_name FROM sys.dm_exec_describe_first_result_set(@sql, NULL, 1) WHERE is_hidden = 0 ORDER BY column_ordinal"
-      );
-      result = res.recordset.map((r) => ({
-        schema: r.source_schema ?? "",
-        table: r.source_table ?? "",
-        column: r.source_column ?? "",
-        type: (r.system_type_name ?? "").toLowerCase()
-      }));
-    } catch {
-      result = null;
-    }
-    if (this.sources.size > 200) this.sources.clear();
-    this.sources.set(text, result);
-    return result;
-  }
-  async query(text) {
-    const req = this.pool.request();
-    req.arrayRowMode = true;
-    const res = await req.query(text);
-    const sets = res.recordsets;
-    const last = sets.length > 0 ? sets[sets.length - 1] : void 0;
-    const columns = last?.columns;
-    if (last && columns) {
-      const meta = Object.values(columns).sort((a, b) => a.index - b.index);
-      const sources = RESULT_QUERY.test(text) ? await this.describe(text) : null;
-      const fields = meta.map((col, i) => {
-        const src = sources && sources.length === meta.length ? sources[i] : void 0;
-        const typeName = col.type?.declaration ?? "";
-        return {
-          name: col.name,
-          orgName: src?.column || col.name,
-          type: src?.type || typeName.toLowerCase(),
-          table: src?.table ?? "",
-          orgTable: src?.table ?? "",
-          db: src?.schema ?? "",
-          maxLength: typeof col.length === "number" ? col.length : 0
-        };
-      });
-      const records = last.map((row) => row.map(normalizeValue));
-      return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+  currentDatabase;
+  async query(sql2, database) {
+    if (database && database !== this.currentDatabase) {
+      await this.connection.query(`USE ${mysql.escapeId(database)}`);
+      this.currentDatabase = database;
     }
+    const [results, fields] = await this.connection.query(sql2);
+    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),
+        table: field.table ?? "",
+        orgTable: field.orgTable ?? "",
+        db: field.db ?? "",
+        maxLength: field.length ?? 0
+      }));
+      const records = results.map(
+        (row) => fieldPackets.map((field) => row[field.name])
+      );
+      return { fields: mappedFields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+    }
+    const header = results;
     return {
       fields: [],
       records: [],
-      affectedRows: res.rowsAffected.reduce((sum, n) => sum + n, 0),
-      insertId: 0,
+      affectedRows: header.affectedRows ?? 0,
+      insertId: header.insertId ?? 0,
       isResultQuery: false
     };
   }
   async close() {
-    await this.pool.close();
+    await this.connection.end();
   }
 };
-var mssqlDriverFactory = {
+var mysqlDriverFactory = {
   async open(config) {
-    const pool = new sql.ConnectionPool(toPoolConfig(config));
-    await pool.connect();
-    return new MssqlDriver(pool, config);
+    const connection = await mysql.createConnection(toConnectionOptions(config));
+    return new MySqlDriver(connection, config);
   },
   async test(config) {
-    const pool = new sql.ConnectionPool(toPoolConfig(config));
-    await pool.connect();
-    await pool.close();
+    const connection = await mysql.createConnection({
+      ...toConnectionOptions(config),
+      database: void 0
+    });
+    await connection.end();
   },
   parseConfig(body) {
     const host = typeof body.host === "string" ? body.host.trim() : "";
@@ -594,146 +520,189 @@ var mssqlDriverFactory = {
       throw new Error("host and user are required");
     }
     return {
-      driver: "mssql",
+      driver: "mysql",
       host,
-      port: Number(body.port) || 1433,
+      port: Number(body.port) || 3306,
       user,
       password: typeof body.password === "string" ? body.password : "",
-      database: typeof body.database === "string" && body.database ? body.database : "master",
-      ssl: body.ssl === true
+      database: typeof body.database === "string" && body.database ? body.database : void 0,
+      charset: typeof body.charset === "string" && body.charset ? body.charset : void 0
     };
   }
 };
 
-// src/drivers/oracle.ts
-import oracledb from "oracledb";
-oracledb.autoCommit = true;
-oracledb.fetchAsString = [oracledb.CLOB];
-var fetchTypeHandler = (meta) => meta.dbType === oracledb.DB_TYPE_NUMBER ? { type: oracledb.STRING } : void 0;
-var pad2 = (n, width = 2) => String(n).padStart(width, "0");
-function formatDate2(d) {
-  const ms = d.getMilliseconds();
-  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}${ms ? "." + pad2(ms, 3) : ""}`;
-}
-function normalizeValue2(value) {
-  if (value instanceof Date) return formatDate2(value);
-  if (Buffer.isBuffer(value)) return value.toString("hex");
-  return value;
-}
-var SESSION_FORMATS = [
-  "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'",
-  "ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF3'",
-  "ALTER SESSION SET NLS_TIMESTAMP_TZ_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF3 TZH:TZM'"
+// src/drivers/postgres.ts
+import pg from "pg";
+var TEXT_OIDS = [
+  20,
+  // int8
+  1700,
+  // numeric
+  1082,
+  // date
+  1114,
+  // timestamp
+  1184,
+  // timestamptz
+  1083,
+  // time
+  1266,
+  // timetz
+  1186
+  // interval
 ];
-var quoteIdent2 = (name) => `"${name.replaceAll('"', '""')}"`;
-var PLSQL = /^\s*(BEGIN|DECLARE|CREATE\s+(OR\s+REPLACE\s+)?((NON)?EDITIONABLE\s+)?(PROCEDURE|FUNCTION|TRIGGER|PACKAGE|TYPE)\b)/i;
-function normalizeStatement(sql2) {
-  const trimmed = sql2.trim().replace(/\n\/\s*$/, "");
-  if (PLSQL.test(trimmed)) return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
-  return trimmed.replace(/;\s*$/, "");
-}
-var SET_SCHEMA = /^\s*ALTER\s+SESSION\s+SET\s+CURRENT_SCHEMA\b/i;
-var START_TX = /^\s*SET\s+TRANSACTION\b/i;
-var END_TX = /^\s*(COMMIT|ROLLBACK)\b/i;
-function singleSourceTable(sql2) {
-  const m = /\bFROM\s+("?[\w$#]+"?)(?:\s*\.\s*("?[\w$#]+"?))?([\s\S]*)$/i.exec(sql2);
-  if (!m) return null;
-  const rest = m[3].replace(/\b(WHERE|ORDER\s+BY|GROUP\s+BY|HAVING|FETCH|OFFSET|UNION|MINUS|INTERSECT|FOR\s+UPDATE)\b[\s\S]*$/i, "");
-  if (/,|\bJOIN\b|\(/i.test(rest) || rest.trim().split(/\s+/).filter(Boolean).length > 2) return null;
-  const unquote = (v) => v.startsWith('"') ? v.slice(1, -1).replaceAll('""', '"') : v.toUpperCase();
-  return m[2] ? { schema: unquote(m[1]), table: unquote(m[2]) } : { table: unquote(m[1]) };
+var types = new pg.TypeOverrides();
+for (const oid of TEXT_OIDS) types.setTypeParser(oid, (value) => value);
+var BUILTIN_TYPES = {
+  16: "bool",
+  17: "bytea",
+  18: "char",
+  19: "name",
+  20: "int8",
+  21: "int2",
+  23: "int4",
+  25: "text",
+  26: "oid",
+  114: "json",
+  142: "xml",
+  700: "float4",
+  701: "float8",
+  1042: "bpchar",
+  1043: "varchar",
+  1082: "date",
+  1083: "time",
+  1114: "timestamp",
+  1184: "timestamptz",
+  1186: "interval",
+  1266: "timetz",
+  1700: "numeric",
+  2950: "uuid",
+  3802: "jsonb",
+  1560: "bit",
+  1562: "varbit",
+  600: "point",
+  869: "inet",
+  650: "cidr",
+  829: "macaddr",
+  1007: "_int4",
+  1009: "_text"
+};
+function toClientConfig(config) {
+  return {
+    host: config.host,
+    port: config.port,
+    user: config.user,
+    password: config.password,
+    database: config.database,
+    ssl: config.ssl ? { rejectUnauthorized: config.sslVerify === true } : void 0,
+    types
+  };
 }
-var OracleDriver = class {
-  constructor(conn, config) {
-    this.conn = conn;
-    this.label = `${config.user}@${config.host}:${config.port}/${config.serviceName}`;
-    this.currentSchema = config.user.toUpperCase();
+var SEARCH_PATH_STATEMENT = /^\s*SET\s+(SESSION\s+|LOCAL\s+)?search_path\b/i;
+var quoteIdent = (name) => `"${name.replaceAll('"', '""')}"`;
+var PostgresDriver = class {
+  constructor(client, config) {
+    this.client = client;
+    this.label = `${config.user}@${config.host}:${config.port}/${config.database}`;
   }
-  conn;
-  type = "oracle";
+  client;
+  type = "postgres";
   label;
-  currentSchema;
-  manualTx = false;
-  /** Column names per `OWNER.TABLE`, for result-source resolution. */
-  columns = /* @__PURE__ */ new Map();
-  async init() {
-    for (const stmt of SESSION_FORMATS) await this.conn.execute(stmt);
+  /**
+   * Schema currently first in `search_path`, or null when unknown (after the
+   * client set it itself). The app's "database" for a Postgres connection is
+   * a schema of the bound database, switched with `SET search_path`.
+   */
+  currentSchema = null;
+  typeNames = { ...BUILTIN_TYPES };
+  /**
+   * Result fields name their source only by OID (`tableID` / `columnID`);
+   * the frontend needs schema/table/column names to decide whether a grid is
+   * editable and to build UPDATEs, so they are resolved here and cached.
+   */
+  relations = /* @__PURE__ */ new Map();
+  async loadTypeNames() {
+    try {
+      const res = await this.client.query(
+        "SELECT oid, typname FROM pg_type WHERE typtype IN ('b', 'e', 'd', 'r')"
+      );
+      for (const row of res.rows) this.typeNames[Number(row.oid)] = row.typname;
+    } catch {
+    }
   }
-  async tableColumns(schema, table) {
-    const key = `${schema}.${table}`;
-    const cached = this.columns.get(key);
-    if (cached !== void 0) return cached;
-    let out = null;
+  async resolveRelations(tableIds) {
+    const missing = [...new Set(tableIds)].filter((id) => id > 0 && !this.relations.has(id));
+    if (missing.length === 0) return;
     try {
-      const res = await this.conn.execute(
-        "SELECT column_name FROM all_tab_columns WHERE owner = :o AND table_name = :t",
-        { o: schema, t: table },
-        { outFormat: oracledb.OUT_FORMAT_ARRAY }
+      const res = await this.client.query(
+        `SELECT c.oid, n.nspname, c.relname, a.attnum, a.attname
+         FROM pg_class c
+         JOIN pg_namespace n ON n.oid = c.relnamespace
+         JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
+         WHERE c.oid = ANY($1::oid[])`,
+        [missing]
       );
-      out = res.rows && res.rows.length > 0 ? new Set(res.rows.map((r) => r[0])) : null;
+      for (const row of res.rows) {
+        const oid = Number(row.oid);
+        let rel = this.relations.get(oid);
+        if (!rel) {
+          rel = { schema: row.nspname, table: row.relname, columns: /* @__PURE__ */ new Map() };
+          this.relations.set(oid, rel);
+        }
+        rel.columns.set(Number(row.attnum), row.attname);
+      }
     } catch {
-      out = null;
     }
-    if (this.columns.size > 200) this.columns.clear();
-    this.columns.set(key, out);
-    return out;
   }
   async query(sql2, database) {
     if (database && database !== this.currentSchema) {
-      await this.conn.execute(`ALTER SESSION SET CURRENT_SCHEMA = ${quoteIdent2(database)}`);
+      await this.client.query(`SET search_path TO ${quoteIdent(database)}, public`);
       this.currentSchema = database;
     }
-    const text = normalizeStatement(sql2);
-    if (START_TX.test(text)) this.manualTx = true;
-    const res = await this.conn.execute(text, [], {
-      outFormat: oracledb.OUT_FORMAT_ARRAY,
-      fetchTypeHandler,
-      autoCommit: !this.manualTx
-    });
-    if (SET_SCHEMA.test(text)) this.currentSchema = null;
-    if (END_TX.test(text)) this.manualTx = false;
-    if (res.metaData && res.metaData.length > 0) {
-      const source = singleSourceTable(text);
-      const schema = source?.schema ?? this.currentSchema ?? "";
-      const known = source && schema ? await this.tableColumns(schema, source.table) : null;
-      const fields = res.metaData.map((col) => {
-        const fromTable = known?.has(col.name) ?? false;
+    const result = await this.client.query({ text: sql2, rowMode: "array" });
+    if (SEARCH_PATH_STATEMENT.test(sql2)) this.currentSchema = null;
+    const results = Array.isArray(result) ? result : [result];
+    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);
         return {
-          name: col.name,
-          orgName: col.name,
-          type: (col.dbTypeName ?? "").toLowerCase(),
-          table: fromTable ? source.table : "",
-          orgTable: fromTable ? source.table : "",
-          db: fromTable ? schema : "",
-          maxLength: col.byteSize ?? 0
+          name: field.name,
+          orgName: rel?.columns.get(field.columnID) ?? field.name,
+          type: this.typeNames[field.dataTypeID] ?? `oid:${field.dataTypeID}`,
+          table: rel?.table ?? "",
+          orgTable: rel?.table ?? "",
+          db: rel?.schema ?? "",
+          maxLength: field.dataTypeSize > 0 ? field.dataTypeSize : 0
         };
       });
-      const records = (res.rows ?? []).map((row) => row.map(normalizeValue2));
-      return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+      return { fields, records: last.rows, affectedRows: 0, insertId: 0, isResultQuery: true };
     }
-    return { fields: [], records: [], affectedRows: res.rowsAffected ?? 0, insertId: 0, isResultQuery: false };
+    return {
+      fields: [],
+      records: [],
+      affectedRows: results.reduce((sum, r) => sum + (r.rowCount ?? 0), 0),
+      insertId: 0,
+      isResultQuery: false
+    };
   }
   async close() {
-    await this.conn.close();
+    await this.client.end();
   }
 };
-function connectionAttributes(config) {
-  return {
-    user: config.user,
-    password: config.password,
-    connectString: `${config.host}:${config.port}/${config.serviceName}`
-  };
-}
-var oracleDriverFactory = {
+var postgresDriverFactory = {
   async open(config) {
-    const conn = await oracledb.getConnection(connectionAttributes(config));
-    const driver = new OracleDriver(conn, config);
-    await driver.init();
+    const client = new pg.Client(toClientConfig(config));
+    await client.connect();
+    const driver = new PostgresDriver(client, config);
+    await driver.loadTypeNames();
     return driver;
   },
   async test(config) {
-    const conn = await oracledb.getConnection(connectionAttributes(config));
-    await conn.close();
+    const client = new pg.Client(toClientConfig(config));
+    await client.connect();
+    await client.end();
   },
   parseConfig(body) {
     const host = typeof body.host === "string" ? body.host.trim() : "";
@@ -742,525 +711,647 @@ var oracleDriverFactory = {
       throw new Error("host and user are required");
     }
     return {
-      driver: "oracle",
+      driver: "postgres",
       host,
-      port: Number(body.port) || 1521,
+      port: Number(body.port) || 5432,
       user,
       password: typeof body.password === "string" ? body.password : "",
-      serviceName: typeof body.serviceName === "string" && body.serviceName ? body.serviceName : "FREEPDB1"
+      database: typeof body.database === "string" && body.database ? body.database : "postgres",
+      ssl: body.ssl === true,
+      sslVerify: body.sslVerify === true
     };
   }
 };
 
-// src/drivers/d1.ts
-var API = "https://api.cloudflare.com/client/v4";
-var D1Error = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-  }
-  status;
-};
-var SCHEMA_PRAGMA = /^\s*PRAGMA\s+(?:"main"|main|'main'|\[main\])\s*\.\s*/i;
-var DATABASE_LIST = /^\s*PRAGMA\s+database_list\s*;?\s*$/i;
-var RESULT_KIND = /^\s*(SELECT|WITH|PRAGMA|EXPLAIN|VALUES)\b/i;
-function singleSourceTable2(sql2) {
-  const m = /\bFROM\s+(?:"?main"?\s*\.\s*)?("[^"]+"|`[^`]+`|\[[^\]]+\]|[\w$]+)([\s\S]*)$/i.exec(sql2);
-  if (!m) return null;
-  const rest = m[2].replace(/\b(WHERE|ORDER\s+BY|GROUP\s+BY|HAVING|LIMIT|OFFSET|UNION|EXCEPT|INTERSECT|WINDOW)\b[\s\S]*$/i, "");
-  if (/,|\bJOIN\b|\(/i.test(rest) || rest.trim().split(/\s+/).filter(Boolean).length > 2) return null;
-  const raw = m[1];
-  const first = raw[0];
-  if (first === '"') return raw.slice(1, -1).replaceAll('""', '"');
-  if (first === "`") return raw.slice(1, -1).replaceAll("``", "`");
-  if (first === "[") return raw.slice(1, -1);
-  return raw;
-}
-function normalizeDeclaredType2(declared) {
-  if (typeof declared !== "string") return null;
+// src/drivers/sqlite.ts
+import Database from "better-sqlite3";
+import { existsSync, realpathSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename3, dirname as dirname2, join as join3, relative, resolve, sep } from "path";
+function normalizeDeclaredType(declared) {
+  if (!declared) return null;
   const base = declared.trim().toLowerCase().replace(/\(.*$/, "").trim();
   return base || null;
 }
-function inferTypeFromValue2(value) {
+function inferTypeFromValue(value) {
   if (value === null || value === void 0) return "null";
   if (typeof value === "number") return Number.isInteger(value) ? "integer" : "real";
-  if (Array.isArray(value)) return "blob";
+  if (typeof value === "bigint") return "bigint";
+  if (Buffer.isBuffer(value)) return "blob";
   return "text";
 }
-function firstNonNull2(records, index) {
-  for (const row of records) {
-    const value = row[index];
-    if (value !== null && value !== void 0) return value;
-  }
-  return null;
+var SQLITE_DIR = process.env.PLANCHE_SQLITE_DIR ? resolve(expandHome2(process.env.PLANCHE_SQLITE_DIR)) : null;
+var DEFAULT_ROOT = homedir3();
+var DENIED_UNDER_HOME = process.platform === "darwin" ? ["Library"] : process.platform === "win32" ? ["AppData"] : [];
+var ALLOW_URI = process.env.PLANCHE_SQLITE_URI === "1";
+var ALLOW_ATTACH = process.env.PLANCHE_SQLITE_ATTACH === "1";
+var DB_EXTENSIONS = /\.(db|db3|s3db|sl3|sqlite|sqlite3)$/i;
+function expandHome2(path) {
+  return path === "~" || path.startsWith("~/") ? resolve(homedir3(), path.slice(2)) : path;
 }
-var D1Driver = class {
-  type = "d1";
-  label;
-  url;
-  headers;
-  /** Declared column types per table, for result-source resolution. */
-  columns = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.label = `d1:${config.databaseId}`;
-    this.url = `${API}/accounts/${encodeURIComponent(config.accountId)}/d1/database/${encodeURIComponent(config.databaseId)}/raw`;
-    this.headers = { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" };
-  }
-  async raw(sql2) {
-    let res;
+function realish(file) {
+  let probe = file;
+  const rest = [];
+  for (; ; ) {
     try {
-      res = await fetch(this.url, { method: "POST", headers: this.headers, body: JSON.stringify({ sql: sql2 }) });
-    } catch (err) {
-      throw new D1Error(`Cannot reach the Cloudflare API: ${err instanceof Error ? err.message : String(err)}`, 400);
-    }
-    let body = null;
-    try {
-      body = await res.json();
+      return rest.length ? join3(realpathSync.native(probe), ...rest) : realpathSync.native(probe);
     } catch {
+      const parent = dirname2(probe);
+      if (parent === probe) return file;
+      rest.unshift(basename3(probe));
+      probe = parent;
     }
-    if (!res.ok || !body?.success) {
-      const message = body?.errors?.map((e) => e.message).join("; ") || `Cloudflare API responded ${res.status}`;
-      throw new D1Error(message, res.status === 401 || res.status === 403 ? 401 : res.ok ? void 0 : 400);
-    }
-    const result = body.result?.[0];
-    if (!result) throw new D1Error("Cloudflare API returned no result");
-    return result;
   }
-  async tableColumns(table) {
-    const cached = this.columns.get(table);
-    if (cached !== void 0) return cached;
-    let out = null;
-    try {
-      const info = await this.raw(`PRAGMA table_info("${table.replaceAll('"', '""')}")`);
-      const cols = info.results?.columns ?? [];
-      const name = cols.indexOf("name");
-      const type = cols.indexOf("type");
-      const rows = info.results?.rows ?? [];
-      if (rows.length > 0 && name >= 0) {
-        out = new Map(rows.map((r) => [String(r[name]), normalizeDeclaredType2(type >= 0 ? r[type] : null)]));
-      }
-    } catch {
-      out = null;
-    }
-    if (this.columns.size > 200) this.columns.clear();
-    this.columns.set(table, out);
-    return out;
+}
+function isInside(path, root) {
+  return path === root || path.startsWith(root + sep);
+}
+function resolveFile(file, forCreate = false) {
+  if (file === ":memory:") return file;
+  if (file.startsWith("file:")) {
+    if (!ALLOW_URI || SQLITE_DIR) throw new Error("SQLite URI filenames are disabled (set PLANCHE_SQLITE_URI=1 on the agent to allow them)");
+    return file;
+  }
+  const resolved = realish(resolve(SQLITE_DIR ?? process.cwd(), expandHome2(file)));
+  if (SQLITE_DIR) {
+    if (!isInside(resolved, realish(SQLITE_DIR))) throw new Error("SQLite file is outside the directory allowed by PLANCHE_SQLITE_DIR");
+  } else {
+    const root = realish(DEFAULT_ROOT);
+    if (!isInside(resolved, root)) throw new Error("SQLite files outside your home directory need PLANCHE_SQLITE_DIR on the agent");
+    const parts = relative(root, resolved).split(sep);
+    if (parts.some((part) => part.startsWith("."))) throw new Error("SQLite files in hidden directories need PLANCHE_SQLITE_DIR on the agent");
+    if (DENIED_UNDER_HOME.includes(parts[0])) throw new Error(`SQLite files under ~/${parts[0]} need PLANCHE_SQLITE_DIR on the agent`);
+  }
+  if (forCreate && !DB_EXTENSIONS.test(resolved)) {
+    throw new Error("A new SQLite file must end with .db, .sqlite or .sqlite3");
+  }
+  return resolved;
+}
+function openDatabase(config) {
+  const file = resolveFile(config.file, config.createIfMissing === true);
+  const isMemory = file === ":memory:";
+  if (!isMemory && !config.createIfMissing && !existsSync(file)) {
+    throw new Error(`SQLite file not found: ${config.file}`);
+  }
+  const db = new Database(file, {
+    readonly: config.readonly ?? false,
+    fileMustExist: !isMemory && !config.createIfMissing
+  });
+  db.pragma("trusted_schema = OFF");
+  return db;
+}
+var ATTACH = /\bATTACH\b/i;
+function stripLiteralsAndComments(sql2) {
+  return sql2.replace(/'(?:[^']|'')*'/g, "''").replace(/"(?:[^"]|"")*"/g, '""').replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function assertNoAttach(sql2) {
+  if (!ALLOW_ATTACH && ATTACH.test(stripLiteralsAndComments(sql2))) {
+    throw new Error("ATTACH DATABASE is disabled on the agent (set PLANCHE_SQLITE_ATTACH=1 to allow it)");
+  }
+}
+var SqliteDriver = class {
+  constructor(db, config) {
+    this.db = db;
+    this.label = config.file;
   }
+  db;
+  type = "sqlite";
+  label;
   async query(sql2) {
-    if (DATABASE_LIST.test(sql2)) {
-      return {
-        fields: [
-          { name: "seq", orgName: "seq", type: "integer", table: "", orgTable: "", db: "", maxLength: 0 },
-          { name: "name", orgName: "name", type: "text", table: "", orgTable: "", db: "", maxLength: 0 },
-          { name: "file", orgName: "file", type: "text", table: "", orgTable: "", db: "", maxLength: 0 }
-        ],
-        records: [[0, "main", ""]],
-        affectedRows: 0,
-        insertId: 0,
-        isResultQuery: true
-      };
-    }
-    const text = sql2.replace(SCHEMA_PRAGMA, "PRAGMA ");
-    if (/^\s*(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(text)) {
-      throw new D1Error("Cloudflare D1 does not support transaction statements over the API; every request auto-commits.");
+    assertNoAttach(sql2);
+    let statement;
+    try {
+      statement = this.db.prepare(sql2);
+    } catch (err) {
+      if (err instanceof RangeError && /more than one statement/i.test(err.message)) {
+        this.db.exec(sql2);
+        return { fields: [], records: [], affectedRows: 0, insertId: 0, isResultQuery: false };
+      }
+      throw err;
     }
-    if (this.isDdl(text)) this.columns.clear();
-    const result = await this.raw(text);
-    const columns = result.results?.columns ?? [];
-    const records = result.results?.rows ?? [];
-    if (columns.length === 0 && !RESULT_KIND.test(text)) {
+    if (!statement.reader) {
+      const info = statement.run();
       return {
         fields: [],
         records: [],
-        affectedRows: result.meta?.changes ?? 0,
-        insertId: result.meta?.last_row_id ?? 0,
+        affectedRows: info.changes,
+        insertId: Number(info.lastInsertRowid),
         isResultQuery: false
       };
     }
-    const source = RESULT_KIND.test(text) ? singleSourceTable2(text) : null;
-    const known = source ? await this.tableColumns(source) : null;
-    const fields = columns.map((name, index) => {
-      const fromTable = known?.has(name) ?? false;
-      const type = (fromTable ? known?.get(name) : null) ?? inferTypeFromValue2(firstNonNull2(records, index));
+    const columns = statement.columns();
+    const records = statement.raw(true).all();
+    const fields = columns.map((col, index) => {
+      const declared = normalizeDeclaredType(col.type);
+      const type = declared ?? inferTypeFromValue(firstNonNull(records, index));
       return {
-        name,
-        orgName: name,
+        name: col.name,
+        orgName: col.column ?? col.name,
         type,
-        table: fromTable && source ? source : "",
-        orgTable: fromTable && source ? source : "",
-        db: fromTable ? "main" : "",
+        table: col.table ?? "",
+        orgTable: col.table ?? "",
+        db: col.database ?? "",
         maxLength: 0
       };
     });
     return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
   }
-  isDdl(sql2) {
-    return /^\s*(CREATE|ALTER|DROP)\b/i.test(sql2);
-  }
   async close() {
-    this.columns.clear();
+    if (this.db.inTransaction) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+    }
+    this.db.close();
   }
 };
-var d1DriverFactory = {
+function firstNonNull(records, index) {
+  for (const row of records) {
+    const value = row[index];
+    if (value !== null && value !== void 0) return value;
+  }
+  return null;
+}
+var sqliteDriverFactory = {
   async open(config) {
-    const driver = new D1Driver(config);
-    await driver.raw("SELECT 1");
-    return driver;
+    return new SqliteDriver(openDatabase(config), config);
   },
   async test(config) {
-    await new D1Driver(config).raw("SELECT 1");
+    const db = openDatabase(config);
+    try {
+      db.prepare("SELECT 1").get();
+    } finally {
+      db.close();
+    }
   },
   parseConfig(body) {
-    const accountId = typeof body.accountId === "string" ? body.accountId.trim() : "";
-    const databaseId = typeof body.databaseId === "string" ? body.databaseId.trim() : "";
-    const apiToken = typeof body.apiToken === "string" ? body.apiToken.trim() : "";
-    if (!accountId || !databaseId || !apiToken) {
-      throw new Error("accountId, databaseId and apiToken are required");
+    const file = typeof body.file === "string" ? body.file.trim() : "";
+    if (!file) {
+      throw new Error("file is required");
     }
-    return { driver: "d1", accountId, databaseId, apiToken };
+    return {
+      driver: "sqlite",
+      file,
+      createIfMissing: body.createIfMissing === true,
+      readonly: body.readonly === true
+    };
   }
 };
 
-// src/ssh-tunnel.ts
-import { createServer } from "net";
-import { mkdir, readFile as readFile2, appendFile } from "fs/promises";
-import { createHash } from "crypto";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-import { Client } from "ssh2";
-
-// src/ssh-config.ts
-import { readFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, isAbsolute as isAbsolute2, join } from "path";
-var SSH_CONFIG_DISABLED = process.env.PLANCHE_SSH_CONFIG === "none";
-var DEFAULT_SSH_CONFIG = SSH_CONFIG_DISABLED ? "" : process.env.PLANCHE_SSH_CONFIG || join(homedir(), ".ssh", "config");
-var DEFAULT_IDENTITY_FILES = ["id_ed25519", "id_ecdsa", "id_rsa", "id_ed25519_sk", "id_ecdsa_sk"].map(
-  (f) => join(homedir(), ".ssh", f)
-);
-function expandHome(path) {
-  return path === "~" || path.startsWith("~/") ? join(homedir(), path.slice(1)) : path;
-}
-function globToRegExp(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`, "i");
-}
-function hostPatternMatches(patterns, host) {
-  let matched = false;
-  for (const raw of patterns) {
-    const negated = raw.startsWith("!");
-    const pattern = negated ? raw.slice(1) : raw;
-    if (!globToRegExp(pattern).test(host)) continue;
-    if (negated) return false;
-    matched = true;
-  }
-  return matched;
+// src/drivers/mssql.ts
+import sql from "mssql";
+function toPoolConfig(config) {
+  return {
+    server: config.host,
+    port: config.port,
+    user: config.user,
+    password: config.password,
+    database: config.database,
+    // One physical connection: manual transactions and USE need session affinity.
+    pool: { min: 1, max: 1, idleTimeoutMillis: 24 * 60 * 60 * 1e3 },
+    options: {
+      encrypt: config.ssl === true,
+      trustServerCertificate: true,
+      // Keep date/time values as sent by the server rather than shifting to UTC.
+      useUTC: false,
+      enableArithAbort: true
+    },
+    requestTimeout: 0
+  };
 }
-function tokenize(line) {
-  const tokens = [];
-  const re = /"([^"]*)"|(\S+)/g;
-  let m;
-  while (m = re.exec(line)) tokens.push(m[1] ?? m[2]);
-  return tokens;
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+function formatDate(d) {
+  const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+  const ms = d.getMilliseconds();
+  return `${date} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}${ms ? "." + pad(ms, 3) : ""}`;
 }
-function parseLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed || trimmed.startsWith("#")) return void 0;
-  const eq = trimmed.match(/^([A-Za-z]+)\s*=\s*(.*)$/);
-  const [keyword, rest] = eq ? [eq[1], eq[2]] : [trimmed.split(/\s+/, 1)[0], trimmed.slice(trimmed.split(/\s+/, 1)[0].length)];
-  return { keyword: keyword.toLowerCase(), args: tokenize(rest) };
+function normalizeValue(value) {
+  if (value instanceof Date) return formatDate(value);
+  if (Buffer.isBuffer(value)) return value.toString("hex");
+  return value;
 }
-async function loadLines(file, seen) {
-  if (seen.has(file)) return [];
-  seen.add(file);
-  try {
-    return (await readFile(file, "utf8")).split(/\r?\n/);
-  } catch {
-    return [];
+var RESULT_QUERY = /^\s*(?:WITH|SELECT|\()/i;
+var MssqlDriver = class {
+  constructor(pool, config) {
+    this.pool = pool;
+    this.label = `${config.user}@${config.host}:${config.port}/${config.database}`;
   }
-}
-async function resolveSshHost(host, file = DEFAULT_SSH_CONFIG) {
-  const result = { identityFiles: [] };
-  if (!file) return result;
-  const seen = /* @__PURE__ */ new Set();
-  async function walk(path, active) {
-    let blockActive = active;
-    for (const line of await loadLines(path, seen)) {
-      const d = parseLine(line);
-      if (!d) continue;
-      switch (d.keyword) {
-        case "host":
-          blockActive = hostPatternMatches(d.args, host);
-          continue;
-        case "match":
-          blockActive = d.args.length === 1 && d.args[0].toLowerCase() === "all";
-          continue;
-        case "include":
-          for (const inc of d.args) {
-            const target = expandHome(inc);
-            await walk(isAbsolute2(target) ? target : join(dirname(file), target), blockActive);
-          }
-          continue;
-      }
-      if (!blockActive) continue;
-      const value = d.args[0];
-      if (value === void 0) continue;
-      switch (d.keyword) {
-        case "hostname":
-          result.hostName ??= value.replace(/%h/g, host);
-          break;
-        case "port":
-          result.port ??= Number(value) || void 0;
-          break;
-        case "user":
-          result.user ??= value;
-          break;
-        case "identityfile":
-          for (const f of d.args) result.identityFiles.push(expandHome(f.replace(/%d/g, homedir()).replace(/%h/g, host)));
-          break;
-        case "identityagent":
-          result.identityAgent ??= value === "none" ? void 0 : expandHome(value.replace(/%d/g, homedir()));
-          break;
-        case "proxyjump":
-          result.proxyJump ??= value;
-          break;
-      }
+  pool;
+  type = "mssql";
+  label;
+  /** Source columns per SQL text; `sys.dm_exec_describe_first_result_set` is not free. */
+  sources = /* @__PURE__ */ new Map();
+  /**
+   * The `mssql` driver does not report which table a result column comes
+   * from; ask the server to describe the statement instead so the grid can
+   * decide whether it is editable and address rows by primary key.
+   */
+  async describe(text) {
+    const cached = this.sources.get(text);
+    if (cached !== void 0) return cached;
+    let result = null;
+    try {
+      const req = this.pool.request();
+      req.input("sql", sql.NVarChar(sql.MAX), text);
+      const res = await req.query(
+        "SELECT name, source_schema, source_table, source_column, system_type_name FROM sys.dm_exec_describe_first_result_set(@sql, NULL, 1) WHERE is_hidden = 0 ORDER BY column_ordinal"
+      );
+      result = res.recordset.map((r) => ({
+        schema: r.source_schema ?? "",
+        table: r.source_table ?? "",
+        column: r.source_column ?? "",
+        type: (r.system_type_name ?? "").toLowerCase()
+      }));
+    } catch {
+      result = null;
     }
+    if (this.sources.size > 200) this.sources.clear();
+    this.sources.set(text, result);
+    return result;
   }
-  await walk(file, true);
-  return result;
-}
-
-// src/ssh-tunnel.ts
-var TunnelError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "TunnelError";
+  async query(text) {
+    const req = this.pool.request();
+    req.arrayRowMode = true;
+    const res = await req.query(text);
+    const sets = res.recordsets;
+    const last = sets.length > 0 ? sets[sets.length - 1] : void 0;
+    const columns = last?.columns;
+    if (last && columns) {
+      const meta = Object.values(columns).sort((a, b) => a.index - b.index);
+      const sources = RESULT_QUERY.test(text) ? await this.describe(text) : null;
+      const fields = meta.map((col, i) => {
+        const src = sources && sources.length === meta.length ? sources[i] : void 0;
+        const typeName = col.type?.declaration ?? "";
+        return {
+          name: col.name,
+          orgName: src?.column || col.name,
+          type: src?.type || typeName.toLowerCase(),
+          table: src?.table ?? "",
+          orgTable: src?.table ?? "",
+          db: src?.schema ?? "",
+          maxLength: typeof col.length === "number" ? col.length : 0
+        };
+      });
+      const records = last.map((row) => row.map(normalizeValue));
+      return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+    }
+    return {
+      fields: [],
+      records: [],
+      affectedRows: res.rowsAffected.reduce((sum, n) => sum + n, 0),
+      insertId: 0,
+      isResultQuery: false
+    };
   }
-  status;
-};
-var CONNECT_TIMEOUT_MS = 2e4;
-var PLANCHE_DIR = join2(homedir2(), ".planche");
-var PLANCHE_KNOWN_HOSTS = join2(PLANCHE_DIR, "known_hosts");
-var OPENSSH_KNOWN_HOSTS = join2(homedir2(), ".ssh", "known_hosts");
-function parseSshConfig(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "object") throw new TunnelError("ssh must be an object", 400);
-  const body = value;
-  const host = typeof body.host === "string" ? body.host.trim() : "";
-  const user = typeof body.user === "string" ? body.user.trim() : "";
-  const auth = body.auth;
-  if (!host) throw new TunnelError("ssh.host is required", 400);
-  if (auth !== "password" && auth !== "key" && auth !== "agent") {
-    throw new TunnelError("ssh.auth must be one of password, key, agent", 400);
+  async close() {
+    await this.pool.close();
   }
-  const str = (v) => typeof v === "string" && v ? v : void 0;
-  const config = {
-    host,
-    port: Number(body.port) || 22,
-    user,
-    auth,
-    password: auth === "password" ? str(body.password) ?? "" : void 0,
-    privateKey: auth === "key" ? str(body.privateKey) : void 0,
-    passphrase: auth === "key" ? str(body.passphrase) : void 0
-  };
-  return config;
-}
-function keyType(blob) {
-  const len = blob.readUInt32BE(0);
-  return blob.subarray(4, 4 + len).toString("ascii");
-}
-function hostPatterns(host, port) {
-  const h = host.toLowerCase();
-  return port === 22 ? [h, `[${h}]:22`] : [`[${h}]:${port}`];
-}
-async function readKnownHosts(file) {
-  try {
-    return (await readFile2(file, "utf8")).split(/\r?\n/);
-  } catch {
-    return [];
+};
+var mssqlDriverFactory = {
+  async open(config) {
+    const pool = new sql.ConnectionPool(toPoolConfig(config));
+    await pool.connect();
+    return new MssqlDriver(pool, config);
+  },
+  async test(config) {
+    const pool = new sql.ConnectionPool(toPoolConfig(config));
+    await pool.connect();
+    await pool.close();
+  },
+  parseConfig(body) {
+    const host = typeof body.host === "string" ? body.host.trim() : "";
+    const user = typeof body.user === "string" ? body.user : "";
+    if (!host || !user) {
+      throw new Error("host and user are required");
+    }
+    return {
+      driver: "mssql",
+      host,
+      port: Number(body.port) || 1433,
+      user,
+      password: typeof body.password === "string" ? body.password : "",
+      database: typeof body.database === "string" && body.database ? body.database : "master",
+      ssl: body.ssl === true
+    };
   }
+};
+
+// src/drivers/oracle.ts
+import oracledb from "oracledb";
+oracledb.autoCommit = true;
+oracledb.fetchAsString = [oracledb.CLOB];
+var fetchTypeHandler = (meta) => meta.dbType === oracledb.DB_TYPE_NUMBER ? { type: oracledb.STRING } : void 0;
+var pad2 = (n, width = 2) => String(n).padStart(width, "0");
+function formatDate2(d) {
+  const ms = d.getMilliseconds();
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}${ms ? "." + pad2(ms, 3) : ""}`;
 }
-async function lookupHostKey(host, port, blob) {
-  const patterns = hostPatterns(host, port);
-  const type = keyType(blob);
-  const encoded = blob.toString("base64");
-  let sawType = false;
-  const lines = [...await readKnownHosts(OPENSSH_KNOWN_HOSTS), ...await readKnownHosts(PLANCHE_KNOWN_HOSTS)];
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#") || line.startsWith("@") || line.startsWith("|")) continue;
-    const [hosts, lineType, lineKey] = line.split(/\s+/);
-    if (!hosts || !lineType || !lineKey) continue;
-    if (!hosts.toLowerCase().split(",").some((h) => patterns.includes(h))) continue;
-    if (lineType !== type) continue;
-    if (lineKey === encoded) return "match";
-    sawType = true;
-  }
-  return sawType ? "mismatch" : "unknown";
+function normalizeValue2(value) {
+  if (value instanceof Date) return formatDate2(value);
+  if (Buffer.isBuffer(value)) return value.toString("hex");
+  return value;
 }
-async function rememberHostKey(host, port, blob) {
-  await mkdir(PLANCHE_DIR, { recursive: true, mode: 448 });
-  const name = port === 22 ? host.toLowerCase() : `[${host.toLowerCase()}]:${port}`;
-  await appendFile(PLANCHE_KNOWN_HOSTS, `${name} ${keyType(blob)} ${blob.toString("base64")}
-`, { mode: 384 });
+var SESSION_FORMATS = [
+  "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'",
+  "ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF3'",
+  "ALTER SESSION SET NLS_TIMESTAMP_TZ_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF3 TZH:TZM'"
+];
+var quoteIdent2 = (name) => `"${name.replaceAll('"', '""')}"`;
+var PLSQL = /^\s*(BEGIN|DECLARE|CREATE\s+(OR\s+REPLACE\s+)?((NON)?EDITIONABLE\s+)?(PROCEDURE|FUNCTION|TRIGGER|PACKAGE|TYPE)\b)/i;
+function normalizeStatement(sql2) {
+  const trimmed = sql2.trim().replace(/\n\/\s*$/, "");
+  if (PLSQL.test(trimmed)) return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+  return trimmed.replace(/;\s*$/, "");
 }
-function fingerprint(blob) {
-  return "SHA256:" + createHash("sha256").update(blob).digest("base64").replace(/=+$/, "");
+var SET_SCHEMA = /^\s*ALTER\s+SESSION\s+SET\s+CURRENT_SCHEMA\b/i;
+var START_TX = /^\s*SET\s+TRANSACTION\b/i;
+var END_TX = /^\s*(COMMIT|ROLLBACK)\b/i;
+function singleSourceTable(sql2) {
+  const m = /\bFROM\s+("?[\w$#]+"?)(?:\s*\.\s*("?[\w$#]+"?))?([\s\S]*)$/i.exec(sql2);
+  if (!m) return null;
+  const rest = m[3].replace(/\b(WHERE|ORDER\s+BY|GROUP\s+BY|HAVING|FETCH|OFFSET|UNION|MINUS|INTERSECT|FOR\s+UPDATE)\b[\s\S]*$/i, "");
+  if (/,|\bJOIN\b|\(/i.test(rest) || rest.trim().split(/\s+/).filter(Boolean).length > 2) return null;
+  const unquote = (v) => v.startsWith('"') ? v.slice(1, -1).replaceAll('""', '"') : v.toUpperCase();
+  return m[2] ? { schema: unquote(m[1]), table: unquote(m[2]) } : { table: unquote(m[1]) };
 }
-async function resolveConfig(ssh) {
-  const cfg = await resolveSshHost(ssh.host);
-  if (cfg.proxyJump) {
-    throw new TunnelError(`ProxyJump (${cfg.proxyJump}) configured for ${ssh.host} in ~/.ssh/config is not supported`, 400);
+var OracleDriver = class {
+  constructor(conn, config) {
+    this.conn = conn;
+    this.label = `${config.user}@${config.host}:${config.port}/${config.serviceName}`;
+    this.currentSchema = config.user.toUpperCase();
   }
-  const resolved = {
-    ...ssh,
-    host: cfg.hostName ?? ssh.host,
-    port: ssh.port === 22 && cfg.port ? cfg.port : ssh.port,
-    user: ssh.user || cfg.user || ""
-  };
-  if (!resolved.user) {
-    throw new TunnelError(
-      SSH_CONFIG_DISABLED ? "ssh.user is required" : `ssh.user is required (no User for ${ssh.host} in ~/.ssh/config)`,
-      400
-    );
+  conn;
+  type = "oracle";
+  label;
+  currentSchema;
+  manualTx = false;
+  /** Column names per `OWNER.TABLE`, for result-source resolution. */
+  columns = /* @__PURE__ */ new Map();
+  async init() {
+    for (const stmt of SESSION_FORMATS) await this.conn.execute(stmt);
   }
-  if (resolved.auth === "key" && !resolved.privateKey) {
-    if (SSH_CONFIG_DISABLED) {
-      throw new TunnelError("ssh.privateKey is required (the agent runs with PLANCHE_SSH_CONFIG=none)", 400);
+  async tableColumns(schema, table) {
+    const key = `${schema}.${table}`;
+    const cached = this.columns.get(key);
+    if (cached !== void 0) return cached;
+    let out = null;
+    try {
+      const res = await this.conn.execute(
+        "SELECT column_name FROM all_tab_columns WHERE owner = :o AND table_name = :t",
+        { o: schema, t: table },
+        { outFormat: oracledb.OUT_FORMAT_ARRAY }
+      );
+      out = res.rows && res.rows.length > 0 ? new Set(res.rows.map((r) => r[0])) : null;
+    } catch {
+      out = null;
     }
-    const candidates = cfg.identityFiles.length ? cfg.identityFiles : DEFAULT_IDENTITY_FILES;
-    for (const file of candidates) {
-      try {
-        resolved.privateKey = await readFile2(file, "utf8");
-        console.log(`[ssh] Using identity file ${file} for ${ssh.host}`);
-        break;
-      } catch {
-      }
+    if (this.columns.size > 200) this.columns.clear();
+    this.columns.set(key, out);
+    return out;
+  }
+  async query(sql2, database) {
+    if (database && database !== this.currentSchema) {
+      await this.conn.execute(`ALTER SESSION SET CURRENT_SCHEMA = ${quoteIdent2(database)}`);
+      this.currentSchema = database;
     }
-    if (!resolved.privateKey) {
-      throw new TunnelError(
-        `No private key given and none readable for ${ssh.host} (tried ${candidates.join(", ")})`,
-        400
-      );
+    const text = normalizeStatement(sql2);
+    if (START_TX.test(text)) this.manualTx = true;
+    const res = await this.conn.execute(text, [], {
+      outFormat: oracledb.OUT_FORMAT_ARRAY,
+      fetchTypeHandler,
+      autoCommit: !this.manualTx
+    });
+    if (SET_SCHEMA.test(text)) this.currentSchema = null;
+    if (END_TX.test(text)) this.manualTx = false;
+    if (res.metaData && res.metaData.length > 0) {
+      const source = singleSourceTable(text);
+      const schema = source?.schema ?? this.currentSchema ?? "";
+      const known = source && schema ? await this.tableColumns(schema, source.table) : null;
+      const fields = res.metaData.map((col) => {
+        const fromTable = known?.has(col.name) ?? false;
+        return {
+          name: col.name,
+          orgName: col.name,
+          type: (col.dbTypeName ?? "").toLowerCase(),
+          table: fromTable ? source.table : "",
+          orgTable: fromTable ? source.table : "",
+          db: fromTable ? schema : "",
+          maxLength: col.byteSize ?? 0
+        };
+      });
+      const records = (res.rows ?? []).map((row) => row.map(normalizeValue2));
+      return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
     }
+    return { fields: [], records: [], affectedRows: res.rowsAffected ?? 0, insertId: 0, isResultQuery: false };
   }
-  if (resolved.auth === "agent" && cfg.identityAgent && !process.env.SSH_AUTH_SOCK) {
-    process.env.SSH_AUTH_SOCK = cfg.identityAgent;
+  async close() {
+    await this.conn.close();
   }
-  return resolved;
-}
-function toConnectConfig(ssh) {
-  const base = {
-    host: ssh.host,
-    port: ssh.port,
-    username: ssh.user,
-    readyTimeout: CONNECT_TIMEOUT_MS,
-    keepaliveInterval: 3e4
+};
+function connectionAttributes(config) {
+  return {
+    user: config.user,
+    password: config.password,
+    connectString: `${config.host}:${config.port}/${config.serviceName}`
   };
-  switch (ssh.auth) {
-    case "password":
-      return { ...base, password: ssh.password ?? "", tryKeyboard: true };
-    case "key":
-      return { ...base, privateKey: ssh.privateKey, passphrase: ssh.passphrase };
-    case "agent": {
-      const agent = process.env.SSH_AUTH_SOCK || (process.platform === "win32" ? "pageant" : void 0);
-      if (!agent) throw new TunnelError("No ssh-agent found (SSH_AUTH_SOCK is not set)", 400);
-      return { ...base, agent };
+}
+var oracleDriverFactory = {
+  async open(config) {
+    const conn = await oracledb.getConnection(connectionAttributes(config));
+    const driver = new OracleDriver(conn, config);
+    await driver.init();
+    return driver;
+  },
+  async test(config) {
+    const conn = await oracledb.getConnection(connectionAttributes(config));
+    await conn.close();
+  },
+  parseConfig(body) {
+    const host = typeof body.host === "string" ? body.host.trim() : "";
+    const user = typeof body.user === "string" ? body.user : "";
+    if (!host || !user) {
+      throw new Error("host and user are required");
     }
+    return {
+      driver: "oracle",
+      host,
+      port: Number(body.port) || 1521,
+      user,
+      password: typeof body.password === "string" ? body.password : "",
+      serviceName: typeof body.serviceName === "string" && body.serviceName ? body.serviceName : "FREEPDB1"
+    };
+  }
+};
+
+// src/drivers/d1.ts
+var API = "https://api.cloudflare.com/client/v4";
+var D1Error = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
   }
+  status;
+};
+var SCHEMA_PRAGMA = /^\s*PRAGMA\s+(?:"main"|main|'main'|\[main\])\s*\.\s*/i;
+var DATABASE_LIST = /^\s*PRAGMA\s+database_list\s*;?\s*$/i;
+var RESULT_KIND = /^\s*(SELECT|WITH|PRAGMA|EXPLAIN|VALUES)\b/i;
+function singleSourceTable2(sql2) {
+  const m = /\bFROM\s+(?:"?main"?\s*\.\s*)?("[^"]+"|`[^`]+`|\[[^\]]+\]|[\w$]+)([\s\S]*)$/i.exec(sql2);
+  if (!m) return null;
+  const rest = m[2].replace(/\b(WHERE|ORDER\s+BY|GROUP\s+BY|HAVING|LIMIT|OFFSET|UNION|EXCEPT|INTERSECT|WINDOW)\b[\s\S]*$/i, "");
+  if (/,|\bJOIN\b|\(/i.test(rest) || rest.trim().split(/\s+/).filter(Boolean).length > 2) return null;
+  const raw = m[1];
+  const first = raw[0];
+  if (first === '"') return raw.slice(1, -1).replaceAll('""', '"');
+  if (first === "`") return raw.slice(1, -1).replaceAll("``", "`");
+  if (first === "[") return raw.slice(1, -1);
+  return raw;
+}
+function normalizeDeclaredType2(declared) {
+  if (typeof declared !== "string") return null;
+  const base = declared.trim().toLowerCase().replace(/\(.*$/, "").trim();
+  return base || null;
 }
-function describeSshError(err, ssh) {
-  const target = `${ssh.user}@${ssh.host}:${ssh.port}`;
-  if (err instanceof TunnelError) return err;
-  switch (err.level) {
-    case "client-authentication":
-      return new TunnelError(`SSH authentication failed for ${target}`, 401);
-    case "client-timeout":
-      return new TunnelError(`SSH connection to ${target} timed out`, 400);
-    default:
-      return new TunnelError(`SSH connection to ${target} failed: ${err.message}`, 400);
+function inferTypeFromValue2(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "real";
+  if (Array.isArray(value)) return "blob";
+  return "text";
+}
+function firstNonNull2(records, index) {
+  for (const row of records) {
+    const value = row[index];
+    if (value !== null && value !== void 0) return value;
   }
+  return null;
 }
-async function openSshTunnel(requested, target) {
-  const ssh = await resolveConfig(requested);
-  const client = new Client();
-  const connectConfig = toConnectConfig(ssh);
-  let verifyError;
-  connectConfig.hostVerifier = (key, verified) => {
-    void lookupHostKey(ssh.host, ssh.port, key).then(async (result) => {
-      if (result === "mismatch") {
-        verifyError = new TunnelError(
-          `Host key for ${ssh.host}:${ssh.port} has changed (${fingerprint(key)}). Remove the old entry from ~/.ssh/known_hosts or ${PLANCHE_KNOWN_HOSTS} if this is expected.`,
-          400
-        );
-        verified(false);
-        return;
-      }
-      if (result === "unknown") {
-        console.log(`[ssh] Trusting new host key for ${ssh.host}:${ssh.port} (${fingerprint(key)}), saved to ${PLANCHE_KNOWN_HOSTS}`);
-        await rememberHostKey(ssh.host, ssh.port, key).catch((e) => console.warn(`[ssh] Could not save host key: ${e.message}`));
-      }
-      verified(true);
-    });
-  };
-  await new Promise((resolve2, reject) => {
-    client.once("ready", resolve2);
-    client.once("error", (err) => reject(verifyError ?? describeSshError(err, ssh)));
+var D1Driver = class {
+  type = "d1";
+  label;
+  url;
+  headers;
+  /** Declared column types per table, for result-source resolution. */
+  columns = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.label = `d1:${config.databaseId}`;
+    this.url = `${API}/accounts/${encodeURIComponent(config.accountId)}/d1/database/${encodeURIComponent(config.databaseId)}/raw`;
+    this.headers = { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" };
+  }
+  async raw(sql2) {
+    let res;
     try {
-      client.connect(connectConfig);
+      res = await fetch(this.url, { method: "POST", headers: this.headers, body: JSON.stringify({ sql: sql2 }) });
     } catch (err) {
-      reject(describeSshError(err, ssh));
+      throw new D1Error(`Cannot reach the Cloudflare API: ${err instanceof Error ? err.message : String(err)}`, 400);
     }
-  });
-  const sockets = /* @__PURE__ */ new Set();
-  let forwardError;
-  const server = createServer((socket) => {
-    sockets.add(socket);
-    socket.once("close", () => sockets.delete(socket));
-    client.forwardOut(socket.localAddress ?? "127.0.0.1", socket.localPort ?? 0, target.host, target.port, (err, stream) => {
-      if (err) {
-        const local = /^(localhost|127\.0\.0\.1|::1)$/i.test(target.host);
-        const hint = local ? `"${target.host}" is resolved on the jump host itself; use the database's real address (e.g. the RDS endpoint) as the database host` : "is the database reachable from the jump host, and does it allow TCP forwarding?";
-        forwardError = `SSH port forwarding to ${target.host}:${target.port} failed: ${err.message} (${hint})`;
-        console.error(`[ssh] ${forwardError}`);
-        socket.destroy();
-        return;
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+    }
+    if (!res.ok || !body?.success) {
+      const message = (body?.errors?.map((e) => String(e.message)).join("; ") || `Cloudflare API responded ${res.status}`).slice(0, 500);
+      throw new D1Error(message, res.status === 401 || res.status === 403 ? 401 : res.ok ? void 0 : 400);
+    }
+    const result = body.result?.[0];
+    if (!result) throw new D1Error("Cloudflare API returned no result");
+    return result;
+  }
+  async tableColumns(table) {
+    const cached = this.columns.get(table);
+    if (cached !== void 0) return cached;
+    let out = null;
+    try {
+      const info = await this.raw(`PRAGMA table_info("${table.replaceAll('"', '""')}")`);
+      const cols = info.results?.columns ?? [];
+      const name = cols.indexOf("name");
+      const type = cols.indexOf("type");
+      const rows = info.results?.rows ?? [];
+      if (rows.length > 0 && name >= 0) {
+        out = new Map(rows.map((r) => [String(r[name]), normalizeDeclaredType2(type >= 0 ? r[type] : null)]));
       }
-      socket.pipe(stream).pipe(socket);
-      stream.once("close", () => socket.destroy());
-      socket.once("close", () => stream.destroy());
-    });
-  });
-  await new Promise((resolve2, reject) => {
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve2());
-  }).catch((err) => {
-    client.end();
-    throw new TunnelError(`Could not open local tunnel port: ${err.message}`, 400);
-  });
-  const { port } = server.address();
-  let closed = false;
-  const close = () => new Promise((resolve2) => {
-    if (closed) return resolve2();
-    closed = true;
-    for (const s of sockets) s.destroy();
-    server.close(() => {
-      client.end();
-      resolve2();
+    } catch {
+      out = null;
+    }
+    if (this.columns.size > 200) this.columns.clear();
+    this.columns.set(table, out);
+    return out;
+  }
+  async query(sql2) {
+    if (DATABASE_LIST.test(sql2)) {
+      return {
+        fields: [
+          { name: "seq", orgName: "seq", type: "integer", table: "", orgTable: "", db: "", maxLength: 0 },
+          { name: "name", orgName: "name", type: "text", table: "", orgTable: "", db: "", maxLength: 0 },
+          { name: "file", orgName: "file", type: "text", table: "", orgTable: "", db: "", maxLength: 0 }
+        ],
+        records: [[0, "main", ""]],
+        affectedRows: 0,
+        insertId: 0,
+        isResultQuery: true
+      };
+    }
+    const text = sql2.replace(SCHEMA_PRAGMA, "PRAGMA ");
+    if (/^\s*(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(text)) {
+      throw new D1Error("Cloudflare D1 does not support transaction statements over the API; every request auto-commits.");
+    }
+    if (this.isDdl(text)) this.columns.clear();
+    const result = await this.raw(text);
+    const columns = result.results?.columns ?? [];
+    const records = result.results?.rows ?? [];
+    if (columns.length === 0 && !RESULT_KIND.test(text)) {
+      return {
+        fields: [],
+        records: [],
+        affectedRows: result.meta?.changes ?? 0,
+        insertId: result.meta?.last_row_id ?? 0,
+        isResultQuery: false
+      };
+    }
+    const source = RESULT_KIND.test(text) ? singleSourceTable2(text) : null;
+    const known = source ? await this.tableColumns(source) : null;
+    const fields = columns.map((name, index) => {
+      const fromTable = known?.has(name) ?? false;
+      const type = (fromTable ? known?.get(name) : null) ?? inferTypeFromValue2(firstNonNull2(records, index));
+      return {
+        name,
+        orgName: name,
+        type,
+        table: fromTable && source ? source : "",
+        orgTable: fromTable && source ? source : "",
+        db: fromTable ? "main" : "",
+        maxLength: 0
+      };
     });
-  });
-  client.once("close", () => void close());
-  return {
-    host: "127.0.0.1",
-    port,
-    get forwardError() {
-      return forwardError;
-    },
-    close
-  };
-}
+    return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+  }
+  isDdl(sql2) {
+    return /^\s*(CREATE|ALTER|DROP)\b/i.test(sql2);
+  }
+  async close() {
+    this.columns.clear();
+  }
+};
+var d1DriverFactory = {
+  async open(config) {
+    const driver = new D1Driver(config);
+    await driver.raw("SELECT 1");
+    return driver;
+  },
+  async test(config) {
+    await new D1Driver(config).raw("SELECT 1");
+  },
+  parseConfig(body) {
+    const accountId = typeof body.accountId === "string" ? body.accountId.trim() : "";
+    const databaseId = typeof body.databaseId === "string" ? body.databaseId.trim() : "";
+    const apiToken = typeof body.apiToken === "string" ? body.apiToken.trim() : "";
+    if (!accountId || !databaseId || !apiToken) {
+      throw new Error("accountId, databaseId and apiToken are required");
+    }
+    return { driver: "d1", accountId, databaseId, apiToken };
+  }
+};
 
 // src/drivers/index.ts
 var factories = {
@@ -1453,16 +1544,50 @@ function errorStatus(err) {
   const status = err?.status;
   return typeof status === "number" && status >= 400 && status < 600 ? status : 400;
 }
-function fail(res, status, message) {
-  res.status(status).json({ success: false, message });
+function fail(res, status, message, extra = {}) {
+  res.status(status).json({ success: false, message, ...extra });
+}
+function errorExtra(err) {
+  if (err instanceof HostKeyError) {
+    const body = { code: "host-key-unknown", hostKey: err.hostKey };
+    return body;
+  }
+  return {};
 }
 var errorMessage = (err) => err instanceof Error ? err.message : String(err);
-function tokenMatches(header, expected) {
-  if (!header?.startsWith("Bearer ")) return false;
-  const given = Buffer.from(header.slice(7));
-  const want = Buffer.from(expected);
-  return given.length === want.length && timingSafeEqual(given, want);
+function secretEquals(given, expected) {
+  const a = createHash2("sha256").update(given).digest();
+  const b = createHash2("sha256").update(expected).digest();
+  return timingSafeEqual2(a, b);
 }
+function bearerOf(header) {
+  return header?.startsWith("Bearer ") ? header.slice(7) : null;
+}
+var AuthThrottle = class {
+  constructor(max = 10, windowMs = 6e4, lockMs = 3e4) {
+    this.max = max;
+    this.windowMs = windowMs;
+    this.lockMs = lockMs;
+  }
+  max;
+  windowMs;
+  lockMs;
+  failures = [];
+  lockedUntil = 0;
+  locked() {
+    return Date.now() < this.lockedUntil;
+  }
+  fail() {
+    const now = Date.now();
+    this.failures = this.failures.filter((t) => now - t < this.windowMs);
+    this.failures.push(now);
+    if (this.failures.length >= this.max) {
+      this.lockedUntil = now + this.lockMs;
+      this.failures = [];
+      console.warn(`[agent] Too many bad tokens; refusing authentication for ${this.lockMs / 1e3}s`);
+    }
+  }
+};
 function accessControl(allowed) {
   return (req, res, next) => {
     const origin = req.headers.origin;
@@ -1496,6 +1621,20 @@ function createAgent(options) {
   const app = express();
   const manager = new ConnectionManager();
   const allowedOrigins = new Set(options.allowedOrigins.map((o) => o.replace(/\/+$/, "")));
+  const allowedHosts = options.allowedHosts ? new Set(options.allowedHosts.map((h) => h.toLowerCase())) : null;
+  const throttle = new AuthThrottle();
+  let pairing = options.pairingCode;
+  app.set("env", "production");
+  app.disable("x-powered-by");
+  app.disable("etag");
+  const authorized = (header) => {
+    if (throttle.locked()) return false;
+    const given = bearerOf(header);
+    if (given === null) return false;
+    const ok = secretEquals(given, options.authToken);
+    if (!ok) throttle.fail();
+    return ok;
+  };
   if (options.logRequests) {
     app.use((req, _res, next) => {
       const hasAuth = !!req.headers.authorization;
@@ -1503,19 +1642,19 @@ function createAgent(options) {
       next();
     });
   }
-  app.use(accessControl(allowedOrigins));
-  app.use(express.json({ limit: options.bodyLimit }));
   app.use((req, res, next) => {
-    if (req.path === "/health") {
-      next();
-      return;
-    }
-    if (!tokenMatches(req.headers.authorization, options.authToken)) {
-      fail(res, 401, "Unauthorized: invalid or missing auth token");
-      return;
+    res.setHeader("Cache-Control", "no-store");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    if (allowedHosts) {
+      const host = req.headers.host?.toLowerCase();
+      if (!host || !allowedHosts.has(host)) {
+        fail(res, 403, "Invalid Host header");
+        return;
+      }
     }
     next();
   });
+  app.use(accessControl(allowedOrigins));
   app.get("/health", (req, res) => {
     const body = {
       success: true,
@@ -1526,10 +1665,41 @@ function createAgent(options) {
       uptime: process.uptime()
     };
     if (req.headers.authorization !== void 0) {
-      body.authorized = tokenMatches(req.headers.authorization, options.authToken);
+      if (throttle.locked()) {
+        fail(res, 429, "Too many failed authentication attempts; try again shortly");
+        return;
+      }
+      body.authorized = authorized(req.headers.authorization);
+    }
+    res.json(body);
+  });
+  app.post("/pair", express.json({ limit: "1kb" }), (req, res) => {
+    if (throttle.locked()) {
+      fail(res, 429, "Too many failed authentication attempts; try again shortly");
+      return;
+    }
+    const code = typeof req.body?.code === "string" ? req.body.code : "";
+    if (!pairing || Date.now() > pairing.expiresAt || !code || !secretEquals(code, pairing.code)) {
+      throttle.fail();
+      fail(res, 401, "Pairing code is invalid or has expired; restart the agent for a new link");
+      return;
     }
+    pairing = void 0;
+    const body = { success: true, token: options.authToken };
     res.json(body);
   });
+  app.use((req, res, next) => {
+    if (throttle.locked()) {
+      fail(res, 429, "Too many failed authentication attempts; try again shortly");
+      return;
+    }
+    if (!authorized(req.headers.authorization)) {
+      fail(res, 401, "Unauthorized: invalid or missing auth token");
+      return;
+    }
+    next();
+  });
+  app.use(express.json({ limit: options.bodyLimit }));
   app.post("/connect", async (req, res) => {
     try {
       const config = parseDriverConfig(req.body ?? {});
@@ -1538,7 +1708,7 @@ function createAgent(options) {
     } catch (err) {
       const message = errorMessage(err);
       console.error("[connect] Error:", message);
-      fail(res, errorStatus(err), message);
+      fail(res, errorStatus(err), message, errorExtra(err));
     }
   });
   app.post("/query", async (req, res) => {
@@ -1596,9 +1766,17 @@ function createAgent(options) {
     } catch (err) {
       const message = errorMessage(err);
       console.error("[test-connection] Error:", message);
-      fail(res, errorStatus(err), message);
+      fail(res, errorStatus(err), message, errorExtra(err));
     }
   });
+  app.use((_req, res) => fail(res, 404, "Not found"));
+  app.use((err, _req, res, _next) => {
+    const e = err;
+    const status = e?.type === "entity.too.large" ? 413 : typeof e?.status === "number" && e.status >= 400 && e.status < 600 ? e.status : 400;
+    console.error("[agent] Request error:", e?.message ?? String(err));
+    if (res.headersSent) return;
+    fail(res, status, status === 413 ? "Request body too large" : status === 400 ? "Malformed request" : "Request failed");
+  });
   return { app, manager };
 }
 
@@ -1623,6 +1801,7 @@ Options:
       --app <url>      Web app to open (default: ${DEFAULT_APP_URL}, env PLANCHE_APP_URL)
       --origin <url>   Extra browser origin allowed to use the agent (repeatable,
                        env PLANCHE_ALLOWED_ORIGINS as a comma-separated list)
+      --allow-remote   Required with a non-loopback --addr (see README: no TLS)
       --no-open        Do not open the browser
       --verbose        Log every request
   -v, --version        Print the version
@@ -1634,13 +1813,17 @@ function splitList(value) {
 }
 function originOf(url) {
   try {
-    return new URL(url).origin;
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+    return parsed.origin === "null" ? null : parsed.origin;
   } catch {
     return null;
   }
 }
+var LOOPBACK_ADDRS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+var MIN_TOKEN_LENGTH = 16;
 function openInBrowser(url) {
-  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url.replace(/&/g, "^&")]] : ["xdg-open", [url]];
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
   try {
     spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => void 0).unref();
   } catch {
@@ -1664,6 +1847,7 @@ function main() {
         origin: { type: "string", multiple: true },
         open: { type: "boolean" },
         verbose: { type: "boolean" },
+        "allow-remote": { type: "boolean" },
         version: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       },
@@ -1693,37 +1877,59 @@ function main() {
   const bodyLimit = process.env.PLANCHE_BODY_LIMIT || "50mb";
   const appOrigin = originOf(appUrl);
   if (!appOrigin) {
-    console.error(`Invalid --app URL: ${appUrl}`);
+    console.error(`Invalid --app URL (http or https only): ${appUrl}`);
+    process.exit(2);
+  }
+  const loopback = LOOPBACK_ADDRS.has(addr);
+  if (!loopback) {
+    if (!flags["allow-remote"]) {
+      console.error(`Refusing to bind to ${addr}: the agent speaks plain HTTP, so database passwords and SSH keys would cross the network unencrypted.`);
+      console.error("Put it behind a TLS reverse proxy or an SSH port forward, then pass --allow-remote together with --token (or PLANCHE_AUTH_TOKEN).");
+      process.exit(2);
+    }
+    if (!flags.token && !process.env.PLANCHE_AUTH_TOKEN) {
+      console.error("--allow-remote needs an explicit --token / PLANCHE_AUTH_TOKEN.");
+      process.exit(2);
+    }
+  }
+  if ((flags.token || process.env.PLANCHE_AUTH_TOKEN) && authToken.length < MIN_TOKEN_LENGTH) {
+    console.error(`The auth token must be at least ${MIN_TOKEN_LENGTH} characters (got ${authToken.length}). Generate one with: openssl rand -base64 24`);
     process.exit(2);
   }
-  const allowedOrigins = [
-    appOrigin,
-    ...DEV_ORIGINS,
-    ...flags.origin ?? [],
-    ...splitList(process.env.PLANCHE_ALLOWED_ORIGINS)
-  ];
+  const extraOrigins = [...flags.origin ?? [], ...splitList(process.env.PLANCHE_ALLOWED_ORIGINS)];
+  for (const o of extraOrigins) {
+    if (originOf(o) !== o.replace(/\/+$/, "")) {
+      console.error(`Invalid --origin (expected scheme://host[:port]): ${o}`);
+      process.exit(2);
+    }
+  }
+  const devApp = LOOPBACK_ADDRS.has(new URL(appUrl).hostname);
+  const allowedOrigins = [appOrigin, ...devApp ? DEV_ORIGINS : [], ...extraOrigins];
+  const pairingCode = { code: randomUUID2(), expiresAt: Date.now() + 10 * 60 * 1e3 };
+  const agentUrl = `http://${addr}:${port}`;
   const { app, manager } = createAgent({
     authToken,
     allowedOrigins,
     bodyLimit,
     version: VERSION,
-    logRequests: flags.verbose ?? false
+    logRequests: flags.verbose ?? false,
+    allowedHosts: loopback ? [`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`] : void 0,
+    pairingCode
   });
-  const agentUrl = `http://${addr}:${port}`;
-  const pairUrl = `${appUrl}/#agent=${encodeURIComponent(agentUrl)}&token=${encodeURIComponent(authToken)}`;
+  const pairUrl = `${appUrl}/#agent=${encodeURIComponent(agentUrl)}&pair=${encodeURIComponent(pairingCode.code)}`;
   const server = app.listen(port, addr, () => {
     const line = "-".repeat(72);
     console.log(line);
     console.log(`Planche agent ${VERSION} listening on ${agentUrl}`);
     console.log(line);
-    console.log(`Open the app with:
+    console.log(`Open the app with (link valid for 10 minutes, single use):
 
   ${pairUrl}
 `);
-    console.log(tokenFromEnv ? "Auth token: (from PLANCHE_AUTH_TOKEN)" : `Auth token: ${authToken}`);
+    console.log(tokenFromEnv ? "Auth token: (from PLANCHE_AUTH_TOKEN)" : `Auth token (for manual setup): ${authToken}`);
     console.log(`Allowed origins: ${allowedOrigins.join(", ")}`);
-    if (!["127.0.0.1", "localhost", "::1"].includes(addr)) {
-      console.log(`WARNING: bound to ${addr} \u2014 anyone who can reach this port and knows the token can use your databases.`);
+    if (!loopback) {
+      console.error(`WARNING: bound to ${addr} without TLS \u2014 anyone who can reach this port and knows the token can use your databases, and anyone on the path can read the traffic.`);
     }
     console.log(line);
     if (shouldOpen) openInBrowser(pairUrl);