planche 0.2.0 → 0.4.0

package/README.md

@@ -1,7 +1,8 @@
 # planche
 
 Local agent for [Planche](https://planche.dev), a browser-based SQL client for
-MySQL, MariaDB, PostgreSQL and SQLite.
+MySQL, MariaDB, PostgreSQL, SQLite, SQL Server, Oracle, Neon, Supabase and
+Cloudflare D1.
 
 Browsers cannot open TCP connections to a database, so Planche runs this small
 agent on your machine. The app in your browser talks to the agent over
@@ -90,7 +91,14 @@ database connections open and forwards queries with the matching driver
 - **SQLite** — opens a file on your disk by path. Set `PLANCHE_SQLITE_DIR` to
   limit which files can be opened. (Small SQLite files can also be opened
   directly in the browser without the agent.)
-- **SSH tunnel** — MySQL and PostgreSQL profiles can go through an SSH jump
+- **SQL Server** — same model as PostgreSQL: the connection is bound to one
+  database and the app's "database" is a schema (`dbo`, ...). `USE` works in
+  the editor because every statement runs on the same session; scripts may
+  contain `GO` lines.
+- **Oracle** — thin-mode driver, no Instant Client needed. Schemas (users) are
+  the app's "databases", switched with `ALTER SESSION SET CURRENT_SCHEMA`.
+  PL/SQL blocks end with a `/` line as in SQL*Plus.
+- **SSH tunnel** — MySQL, PostgreSQL, SQL Server and Oracle profiles can go through an SSH jump
   host (password, private key, or the local `ssh-agent`). The agent opens the
   tunnel with `ssh2` on a loopback port and points the driver at it. The host
   may be a `Host` alias from `~/.ssh/config`: `HostName`, `Port`, `User` and

package/dist/index.js

@@ -80,13 +80,13 @@ var MySqlDriver = class {
    * dropping temporary tables and user variables.
    */
   currentDatabase;
-  async query(sql, database) {
+  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(sql);
-    if (USE_STATEMENT.test(sql)) this.currentDatabase = null;
+    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) => ({
@@ -209,7 +209,7 @@ function toClientConfig(config) {
     user: config.user,
     password: config.password,
     database: config.database,
-    ssl: config.ssl ? { rejectUnauthorized: false } : void 0,
+    ssl: config.ssl ? { rejectUnauthorized: config.sslVerify === true } : void 0,
     types
   };
 }
@@ -269,13 +269,13 @@ var PostgresDriver = class {
     } catch {
     }
   }
-  async query(sql, database) {
+  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: sql, rowMode: "array" });
-    if (SEARCH_PATH_STATEMENT.test(sql)) this.currentSchema = null;
+    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) {
@@ -332,7 +332,8 @@ var postgresDriverFactory = {
       user,
       password: typeof body.password === "string" ? body.password : "",
       database: typeof body.database === "string" && body.database ? body.database : "postgres",
-      ssl: body.ssl === true
+      ssl: body.ssl === true,
+      sslVerify: body.sslVerify === true
     };
   }
 };
@@ -385,13 +386,13 @@ var SqliteDriver = class {
   db;
   type = "sqlite";
   label;
-  async query(sql) {
+  async query(sql2) {
     let statement;
     try {
-      statement = this.db.prepare(sql);
+      statement = this.db.prepare(sql2);
     } catch (err) {
       if (err instanceof RangeError && /more than one statement/i.test(err.message)) {
-        this.db.exec(sql);
+        this.db.exec(sql2);
         return { fields: [], records: [], affectedRows: 0, insertId: 0, isResultQuery: false };
       }
       throw err;
@@ -466,6 +467,460 @@ var sqliteDriverFactory = {
   }
 };
 
+// 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
+  };
+}
+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}`;
+  }
+  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;
+  }
+  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
+    };
+  }
+  async close() {
+    await this.pool.close();
+  }
+};
+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) : ""}`;
+}
+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'"
+];
+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 OracleDriver = class {
+  constructor(conn, config) {
+    this.conn = conn;
+    this.label = `${config.user}@${config.host}:${config.port}/${config.serviceName}`;
+    this.currentSchema = config.user.toUpperCase();
+  }
+  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);
+  }
+  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;
+    }
+    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;
+    }
+    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 };
+  }
+  async close() {
+    await this.conn.close();
+  }
+};
+function connectionAttributes(config) {
+  return {
+    user: config.user,
+    password: config.password,
+    connectString: `${config.host}:${config.port}/${config.serviceName}`
+  };
+}
+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 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;
+}
+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 {
+      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();
+    } catch {
+    }
+    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;
+  }
+  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
+      };
+    });
+    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/ssh-tunnel.ts
 import { createServer } from "net";
 import { mkdir, readFile as readFile2, appendFile } from "fs/promises";
@@ -811,7 +1266,10 @@ async function openSshTunnel(requested, target) {
 var factories = {
   mysql: mysqlDriverFactory,
   postgres: postgresDriverFactory,
-  sqlite: sqliteDriverFactory
+  sqlite: sqliteDriverFactory,
+  mssql: mssqlDriverFactory,
+  oracle: oracleDriverFactory,
+  d1: d1DriverFactory
 };
 function isDriverType(value) {
   return typeof value === "string" && value in factories;
@@ -822,12 +1280,12 @@ function parseDriverConfig(body) {
     throw new Error(`Unsupported driver: ${String(driver)}`);
   }
   const config = factories[driver].parseConfig(body);
-  if (config.driver === "sqlite") return config;
+  if (config.driver === "sqlite" || config.driver === "d1") return config;
   const ssh = parseSshConfig(body.ssh);
   return ssh ? { ...config, ssh } : config;
 }
 async function withTunnel(config, run) {
-  if (config.driver === "sqlite" || !config.ssh) return run(config, void 0);
+  if (config.driver === "sqlite" || config.driver === "d1" || !config.ssh) return run(config, void 0);
   const tunnel = await openSshTunnel(config.ssh, { host: config.host, port: config.port });
   try {
     return await run({ ...config, host: tunnel.host, port: tunnel.port, ssh: void 0 }, tunnel);
@@ -840,7 +1298,7 @@ function tunneled(driver, tunnel, label) {
   return {
     type: driver.type,
     label,
-    query: (sql, database) => driver.query(sql, database),
+    query: (sql2, database) => driver.query(sql2, database),
     async close() {
       try {
         await driver.close();
@@ -853,7 +1311,7 @@ function tunneled(driver, tunnel, label) {
 function openDriver(config) {
   return withTunnel(config, async (direct, tunnel) => {
     const driver = await openDirect(direct);
-    if (!tunnel || config.driver === "sqlite" || !config.ssh) return driver;
+    if (!tunnel || config.driver === "sqlite" || config.driver === "d1" || !config.ssh) return driver;
     const label = `${config.user}@${config.host}:${config.port} via ssh ${config.ssh.user}@${config.ssh.host}:${config.ssh.port}`;
     return tunneled(driver, tunnel, label);
   });
@@ -875,6 +1333,12 @@ function openDirect(config) {
       return factories.postgres.open(config);
     case "sqlite":
       return factories.sqlite.open(config);
+    case "mssql":
+      return factories.mssql.open(config);
+    case "oracle":
+      return factories.oracle.open(config);
+    case "d1":
+      return factories.d1.open(config);
   }
 }
 function testDirect(config) {
@@ -885,6 +1349,12 @@ function testDirect(config) {
       return factories.postgres.test(config);
     case "sqlite":
       return factories.sqlite.test(config);
+    case "mssql":
+      return factories.mssql.test(config);
+    case "oracle":
+      return factories.oracle.test(config);
+    case "d1":
+      return factories.d1.test(config);
   }
 }
 
@@ -925,13 +1395,13 @@ var ConnectionManager = class {
    * Execute a SQL query on an existing connection.
    * Optionally switch database before executing (drivers that support it).
    */
-  async query(connectionId, sql, database) {
+  async query(connectionId, sql2, database) {
     const driver = this.connections.get(connectionId);
     if (!driver) {
       throw new Error(`Connection not found: ${connectionId}`);
     }
     this.lastUsed.set(connectionId, Date.now());
-    return driver.query(sql, database);
+    return driver.query(sql2, database);
   }
   /**
    * Close and remove a connection.
@@ -1073,8 +1543,8 @@ function createAgent(options) {
   });
   app.post("/query", async (req, res) => {
     try {
-      const { connectionId, sql, database } = req.body;
-      if (typeof connectionId !== "string" || typeof sql !== "string" || !connectionId || !sql) {
+      const { connectionId, sql: sql2, database } = req.body;
+      if (typeof connectionId !== "string" || typeof sql2 !== "string" || !connectionId || !sql2) {
         fail(res, 400, "connectionId and sql are required");
         return;
       }
@@ -1083,7 +1553,7 @@ function createAgent(options) {
         return;
       }
       const start = Date.now();
-      const result = await manager.query(connectionId, sql, database);
+      const result = await manager.query(connectionId, sql2, database);
       const execTime = Date.now() - start;
       res.json({
         success: true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "planche",
-  "version": "0.2.0",
-  "description": "Local agent for Planche — lets the browser-based Planche SQL client reach MySQL/MariaDB/PostgreSQL/SQLite databases from your machine.",
+  "version": "0.4.0",
+  "description": "Local agent for Planche — lets the browser-based Planche SQL client reach MySQL/MariaDB/PostgreSQL/SQLite/SQL Server/Oracle/Neon/Supabase/Cloudflare D1 databases from your machine.",
   "license": "MIT",
   "homepage": "https://planche.dev",
   "repository": {
@@ -28,6 +28,13 @@
     "postgres",
     "postgresql",
     "sqlite",
+    "mssql",
+    "sqlserver",
+    "oracle",
+    "neon",
+    "supabase",
+    "cloudflare-d1",
+    "d1",
     "sql",
     "client",
     "gui"
@@ -42,14 +49,18 @@
   "dependencies": {
     "better-sqlite3": "^12.11.1",
     "express": "^5.1.0",
+    "mssql": "^12.7.0",
     "mysql2": "^3.14.1",
+    "oracledb": "^7.0.1",
     "pg": "^8.23.0",
     "ssh2": "^1.17.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^9.6.0",
     "@types/express": "^5.0.0",
+    "@types/mssql": "^12.3.0",
     "@types/node": "^24.0.0",
+    "@types/oracledb": "^7.0.2",
     "@types/pg": "^8.23.1",
     "@types/ssh2": "^1.15.5",
     "tsup": "^8.5.0",