planche 0.8.3 → 0.8.5

package/dist/chunk-2Z2E3JGN.js

@@ -0,0 +1,3733 @@
+// ../shared/contract.ts
+var PROTOCOL_VERSION = 2;
+var PRO_FEATURES = [
+  "ssh_tunnel",
+  "compare_schemas",
+  "compare_data",
+  "copy_table",
+  "federated",
+  "scratchpad",
+  "column_link",
+  "sync",
+  "ai_explain"
+];
+
+// src/ai-cli.ts
+import { execFile as execFileCb2, spawn } from "child_process";
+import { mkdtemp, readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { promisify as promisify2 } from "util";
+
+// src/ai-config.ts
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// ../shared/ai.ts
+var AI_DEFAULT_MODEL = {
+  // Anthropic's most capable general model. Explaining a failure is the paid
+  // half of the product, so the default is not chosen to be cheap.
+  anthropic: "claude-opus-5",
+  // Same API, same models; only where the credential comes from differs.
+  "anthropic-profile": "claude-opus-5",
+  openai: "gpt-4o",
+  gemini: "gemini-2.5-flash",
+  // Not a model but the command to run: the CLI decides the model itself.
+  cli: "claude"
+};
+
+// src/ai-anthropic.ts
+import { execFile as execFileCb } from "child_process";
+import { access } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+import Anthropic from "@anthropic-ai/sdk";
+function toMessages(turns) {
+  const out = [];
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      out.push({ role: "user", content: turn.content });
+      continue;
+    }
+    if (turn.role === "assistant") {
+      const blocks = [];
+      if (turn.content.trim()) blocks.push({ type: "text", text: turn.content });
+      for (const call of turn.toolCalls ?? []) {
+        blocks.push({ type: "tool_use", id: call.id, name: call.name, input: call.input });
+      }
+      if (blocks.length > 0) out.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    const result = {
+      type: "tool_result",
+      tool_use_id: turn.toolCallId,
+      content: turn.content,
+      ...turn.isError ? { is_error: true } : {}
+    };
+    const last = out[out.length - 1];
+    if (last && last.role === "user" && Array.isArray(last.content)) {
+      last.content.push(result);
+    } else {
+      out.push({ role: "user", content: [result] });
+    }
+  }
+  return out;
+}
+var execFile = promisify(execFileCb);
+async function anthropicProfileAvailable() {
+  try {
+    await execFile("ant", ["auth", "status"], { timeout: 1e4 });
+    return true;
+  } catch {
+    try {
+      await access(join(homedir(), ".config", "anthropic"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function runAnthropic(config, req, signal) {
+  const client2 = new Anthropic({
+    ...config.key ? { apiKey: config.key } : {},
+    ...config.baseUrl ? { baseURL: config.baseUrl } : {}
+  });
+  const tools2 = (req.tools ?? []).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  }));
+  try {
+    const response = await client2.messages.create({
+      model: config.model,
+      max_tokens: MAX_TOKENS,
+      system: req.system,
+      messages: toMessages(turnsOf(req)),
+      ...tools2.length > 0 ? { tools: tools2 } : {}
+    }, { signal });
+    const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    const toolCalls = response.content.filter((block) => block.type === "tool_use").map((block) => ({ id: block.id, name: block.name, input: block.input ?? {} }));
+    if (!text && toolCalls.length === 0) throw new AiError(502, "The model returned nothing.");
+    return {
+      text,
+      toolCalls,
+      stop: response.stop_reason === "tool_use" ? "tool_use" : response.stop_reason === "max_tokens" ? "length" : "end"
+    };
+  } catch (err) {
+    if (err instanceof AiError) throw err;
+    const noCredential = 'This machine has no Anthropic credential the SDK could use. Run "ant auth login", or set a key instead.';
+    if (err instanceof Anthropic.AuthenticationError) {
+      throw new AiError(401, config.key ? "The AI key was rejected." : noCredential);
+    }
+    if (!config.key && err instanceof Error && /resolve authentication/i.test(err.message)) {
+      throw new AiError(401, noCredential);
+    }
+    if (err instanceof Anthropic.RateLimitError) throw new AiError(429, "The provider is rate limiting this key.");
+    if (err instanceof Anthropic.BadRequestError) throw new AiError(400, err.message);
+    if (err instanceof Anthropic.APIError) throw new AiError(502, `The provider answered ${err.status}: ${err.message}`);
+    throw new AiError(502, err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/ai-config.ts
+var PLANCHE_DIR = join2(homedir2(), ".planche");
+var AI_FILE = join2(PLANCHE_DIR, "ai.json");
+function envConfig() {
+  const key = process.env.PLANCHE_AI_KEY?.trim() || process.env.ANTHROPIC_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim() || process.env.GEMINI_API_KEY?.trim();
+  if (!key) return null;
+  const named = process.env.PLANCHE_AI_PROVIDER?.trim();
+  const provider = named === "openai" || named === "anthropic" || named === "gemini" || named === "cli" || named === "anthropic-profile" ? named : process.env.GEMINI_API_KEY?.trim() ? "gemini" : process.env.OPENAI_API_KEY?.trim() && !process.env.ANTHROPIC_API_KEY?.trim() ? "openai" : "anthropic";
+  return {
+    provider,
+    model: process.env.PLANCHE_AI_MODEL?.trim() || AI_DEFAULT_MODEL[provider],
+    baseUrl: process.env.PLANCHE_AI_BASE_URL?.trim() || void 0,
+    key
+  };
+}
+var isKeyless = (provider) => provider === "cli" || provider === "anthropic-profile";
+var session = null;
+var cached;
+async function fileConfig() {
+  if (cached !== void 0) return cached;
+  try {
+    const raw = JSON.parse(await readFile(AI_FILE, "utf8"));
+    const provider = raw.provider === "openai" || raw.provider === "gemini" || raw.provider === "cli" || raw.provider === "anthropic-profile" ? raw.provider : "anthropic";
+    const key = typeof raw.key === "string" ? raw.key : "";
+    cached = key || isKeyless(provider) ? {
+      provider,
+      model: typeof raw.model === "string" && raw.model ? raw.model : AI_DEFAULT_MODEL[provider],
+      baseUrl: typeof raw.baseUrl === "string" && raw.baseUrl ? raw.baseUrl : void 0,
+      key
+    } : null;
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+async function aiConfig() {
+  return envConfig() ?? session ?? await fileConfig();
+}
+async function aiConfigView() {
+  const env = envConfig();
+  const file = env ? null : await fileConfig();
+  const config = env ?? session ?? file;
+  const storage = env ? "environment" : session ? "session" : file ? "file" : "none";
+  return {
+    configured: config !== null,
+    provider: config?.provider ?? "anthropic",
+    model: config?.model ?? AI_DEFAULT_MODEL.anthropic,
+    baseUrl: config?.baseUrl,
+    fromEnvironment: env !== null,
+    storage,
+    path: AI_FILE,
+    clis: await installedClis(),
+    anthropicProfile: await anthropicProfileAvailable()
+  };
+}
+function defaultModelFor(provider) {
+  return AI_DEFAULT_MODEL[provider];
+}
+async function saveAiConfig(config, remember) {
+  if (!remember && !isKeyless(config.provider)) {
+    session = config;
+    await forgetStoredConfig();
+    return false;
+  }
+  session = null;
+  await mkdir(PLANCHE_DIR, { recursive: true });
+  const temp = `${AI_FILE}.${process.pid}.tmp`;
+  await writeFile(temp, JSON.stringify(config, null, 2), { mode: 384 });
+  await chmod(temp, 384);
+  await rename(temp, AI_FILE);
+  cached = config;
+  return true;
+}
+async function forgetStoredConfig() {
+  cached = null;
+  try {
+    await unlink(AI_FILE);
+  } catch {
+  }
+}
+async function forgetAiConfig() {
+  session = null;
+  await forgetStoredConfig();
+}
+var aiConfigPath = AI_FILE;
+
+// src/ai-gemini.ts
+var DEFAULT_BASE = "https://generativelanguage.googleapis.com/v1beta";
+function toContents(turns) {
+  const out = [];
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      out.push({ role: "user", parts: [{ text: turn.content }] });
+    } else if (turn.role === "assistant") {
+      const parts = [];
+      if (turn.content.trim()) parts.push({ text: turn.content });
+      for (const call of turn.toolCalls ?? []) parts.push({ functionCall: { name: call.name, args: call.input } });
+      if (parts.length > 0) out.push({ role: "model", parts });
+    } else {
+      const part = {
+        functionResponse: { name: turn.toolCallId, response: { result: turn.content, ...turn.isError ? { error: true } : {} } }
+      };
+      const last = out[out.length - 1];
+      if (last && last.role === "user" && last.parts.every((p) => p.functionResponse)) last.parts.push(part);
+      else out.push({ role: "user", parts: [part] });
+    }
+  }
+  return out;
+}
+async function runGemini(config, req, signal) {
+  const base = (config.baseUrl || DEFAULT_BASE).replace(/\/+$/, "");
+  const url = `${base}/models/${encodeURIComponent(config.model)}:generateContent?key=${encodeURIComponent(config.key)}`;
+  const tools2 = req.tools ?? [];
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      signal,
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        systemInstruction: { parts: [{ text: req.system }] },
+        contents: toContents(turnsOf(req)),
+        ...tools2.length > 0 ? {
+          tools: [
+            {
+              functionDeclarations: tools2.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.inputSchema
+              }))
+            }
+          ]
+        } : {},
+        generationConfig: {
+          // A JSON mime type and function calling cannot both be asked for.
+          ...tools2.length > 0 ? {} : { responseMimeType: "application/json" },
+          maxOutputTokens: MAX_TOKENS
+        }
+      })
+    });
+  } catch (err) {
+    throw new AiError(502, err instanceof Error ? err.message : String(err));
+  }
+  const data = await response.json().catch(() => null);
+  if (!response.ok) {
+    const message = data?.error?.message ?? `${response.status} ${response.statusText}`;
+    if (response.status === 400 || response.status === 401 || response.status === 403) {
+      throw new AiError(401, `The AI key was rejected: ${message}`);
+    }
+    if (response.status === 429) throw new AiError(429, "The provider is rate limiting this key.");
+    throw new AiError(502, `The provider answered ${response.status}: ${message}`);
+  }
+  const candidate = data?.candidates?.[0];
+  const parts = candidate?.content?.parts ?? [];
+  const text = parts.map((p) => p.text ?? "").join("");
+  const toolCalls = parts.filter((p) => typeof p.functionCall?.name === "string").map((p) => ({ id: p.functionCall.name, name: p.functionCall.name, input: p.functionCall.args ?? {} }));
+  if (!text && toolCalls.length === 0) throw new AiError(502, "The model returned nothing.");
+  return {
+    text,
+    toolCalls,
+    stop: toolCalls.length > 0 ? "tool_use" : candidate?.finishReason === "MAX_TOKENS" ? "length" : "end"
+  };
+}
+
+// src/ai-openai.ts
+import OpenAI from "openai";
+function toMessages2(system, turns) {
+  const out = [{ role: "system", content: system }];
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      out.push({ role: "user", content: turn.content });
+    } else if (turn.role === "assistant") {
+      const calls = turn.toolCalls ?? [];
+      out.push({
+        role: "assistant",
+        content: turn.content || null,
+        ...calls.length > 0 ? {
+          tool_calls: calls.map((call) => ({
+            id: call.id,
+            type: "function",
+            function: { name: call.name, arguments: JSON.stringify(call.input) }
+          }))
+        } : {}
+      });
+    } else {
+      out.push({ role: "tool", tool_call_id: turn.toolCallId, content: turn.content });
+    }
+  }
+  return out;
+}
+function parseArguments(raw) {
+  try {
+    const parsed = JSON.parse(raw || "{}");
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function runOpenAI(config, req, signal) {
+  const client2 = new OpenAI({ apiKey: config.key, ...config.baseUrl ? { baseURL: config.baseUrl } : {} });
+  const tools2 = (req.tools ?? []).map((tool) => ({
+    type: "function",
+    function: { name: tool.name, description: tool.description, parameters: tool.inputSchema }
+  }));
+  try {
+    const response = await client2.chat.completions.create({
+      model: config.model,
+      max_completion_tokens: MAX_TOKENS,
+      // JSON mode and tools are mutually exclusive here: forcing a JSON object
+      // leaves the model no way to answer with a call. The one-shot prompts
+      // ask for JSON, a tool run does not.
+      ...tools2.length > 0 ? { tools: tools2 } : { response_format: { type: "json_object" } },
+      messages: toMessages2(req.system, turnsOf(req))
+    }, { signal });
+    const choice = response.choices[0];
+    const text = choice?.message?.content ?? "";
+    const toolCalls = (choice?.message?.tool_calls ?? []).filter((call) => call.type === "function").map((call) => ({ id: call.id, name: call.function.name, input: parseArguments(call.function.arguments) }));
+    if (!text && toolCalls.length === 0) throw new AiError(502, "The model returned nothing.");
+    return {
+      text,
+      toolCalls,
+      stop: choice?.finish_reason === "tool_calls" ? "tool_use" : choice?.finish_reason === "length" ? "length" : "end"
+    };
+  } catch (err) {
+    if (err instanceof AiError) throw err;
+    if (err instanceof OpenAI.APIError) {
+      const status = err.status === 401 || err.status === 429 || err.status === 400 ? err.status : 502;
+      throw new AiError(status, err.status === 401 ? "The AI key was rejected." : err.message);
+    }
+    throw new AiError(502, err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/ai-run.ts
+var AiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "AiError";
+  }
+  status;
+};
+var MAX_TOKENS = 8e3;
+function turnsOf(req) {
+  if (req.messages && req.messages.length > 0) return req.messages;
+  return [{ role: "user", content: req.user ?? "" }];
+}
+async function runPrompt(req, signal) {
+  const config = await aiConfig();
+  if (!config) throw new AiError(501, "No AI key is configured on this agent.");
+  const model = req.model?.trim() || config.model;
+  const run2 = config.provider === "cli" ? runCli : config.provider === "openai" ? runOpenAI : config.provider === "gemini" ? runGemini : runAnthropic;
+  const result = await run2({ ...config, model }, req, signal);
+  return {
+    success: true,
+    text: result.text,
+    model,
+    ...result.toolCalls.length > 0 ? { toolCalls: result.toolCalls } : {},
+    stop: result.stop
+  };
+}
+
+// src/ai-cli.ts
+var execFile2 = promisify2(execFileCb2);
+var CLI_COMMANDS = ["claude", "codex"];
+var TIMEOUT_MS = 18e4;
+var mcp = null;
+function configureCliBridge(url, token) {
+  mcp = { url, token };
+}
+function mcpUrl() {
+  return mcp?.url ?? null;
+}
+function isCliCommand(name) {
+  return CLI_COMMANDS.includes(name);
+}
+async function installedClis() {
+  const found = [];
+  for (const name of CLI_COMMANDS) {
+    try {
+      await execFile2(name, ["--version"], { timeout: 1e4 });
+      found.push(name);
+    } catch {
+    }
+  }
+  return found;
+}
+var STOP_GRACE_MS = 3e3;
+function run(command, args, prompt, signal) {
+  return new Promise((resolve3, reject) => {
+    if (signal?.aborted) {
+      reject(new AiError(499, "Stopped."));
+      return;
+    }
+    const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    let stopped = false;
+    const timer2 = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new AiError(504, `${command} did not answer within ${TIMEOUT_MS / 1e3}s.`));
+    }, TIMEOUT_MS);
+    const onAbort = () => {
+      stopped = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), STOP_GRACE_MS).unref();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const done = () => {
+      clearTimeout(timer2);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    child.stdout.on("data", (d) => out += d);
+    child.stderr.on("data", (d) => err += d);
+    child.on("error", (e) => {
+      done();
+      reject(new AiError(501, `${command} could not be started: ${e.message}`));
+    });
+    child.on("close", (code) => {
+      done();
+      if (stopped) reject(new AiError(499, "Stopped."));
+      else if (code === 0) resolve3(out);
+      else reject(new AiError(502, `${command} exited ${code}: ${err.trim().slice(0, 400) || "no output"}`));
+    });
+    child.stdin.end(prompt);
+  });
+}
+function unwrap(text) {
+  const fenced = text.trim().match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/);
+  return (fenced ? fenced[1] : text).trim();
+}
+async function runCli(config, req, signal) {
+  const command = config.model.trim();
+  const wantsTools = (req.tools?.length ?? 0) > 0;
+  if (wantsTools && command !== "claude") {
+    throw new AiError(400, `${command} cannot be given Planche's tools. Use the claude CLI for the AI panel, or a provider with an API key.`);
+  }
+  if (wantsTools && !mcp) {
+    throw new AiError(501, "This agent cannot offer its tools to a CLI. Restart it, or use a provider with an API key.");
+  }
+  if (!isCliCommand(command)) {
+    throw new AiError(400, `Unknown CLI "${command}". Use one of: ${CLI_COMMANDS.join(", ")}.`);
+  }
+  const turns = turnsOf(req);
+  const prompt = [req.system, "", turns.map((t) => "content" in t ? t.content : "").join("\n\n")].join("\n");
+  let text;
+  if (command === "claude") {
+    if (!wantsTools) {
+      text = await run("claude", ["-p"], prompt, signal);
+    } else {
+      const dir = await mkdtemp(join3(tmpdir(), "planche-mcp-"));
+      const file = join3(dir, "mcp.json");
+      try {
+        await writeFile2(
+          file,
+          JSON.stringify({
+            mcpServers: {
+              planche: { type: "http", url: mcp.url, headers: { Authorization: `Bearer ${mcp.token}` } }
+            }
+          }),
+          { mode: 384 }
+        );
+        text = await run("claude", ["-p", "--strict-mcp-config", "--mcp-config", file], prompt, signal);
+      } finally {
+        await rm(dir, { recursive: true, force: true });
+      }
+    }
+  } else {
+    const dir = await mkdtemp(join3(tmpdir(), "planche-cli-"));
+    const file = join3(dir, "answer.txt");
+    try {
+      await run("codex", ["exec", "--skip-git-repo-check", "-o", file, "-"], prompt, signal);
+      text = await readFile2(file, "utf8");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  }
+  const answer = unwrap(text);
+  if (!answer) throw new AiError(502, `${command} returned nothing.`);
+  return { text: answer, toolCalls: [], stop: "end" };
+}
+
+// src/mcp-token.ts
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { randomBytes } from "crypto";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+var DIR = join4(homedir3(), ".planche");
+var FILE = join4(DIR, "mcp-token");
+var mcpTokenPath = FILE;
+var cached2 = null;
+async function readMcpToken() {
+  if (cached2) return cached2;
+  try {
+    const text = (await readFile3(FILE, "utf8")).trim();
+    cached2 = text || null;
+  } catch {
+    cached2 = null;
+  }
+  return cached2;
+}
+async function ensureMcpToken() {
+  const existing = await readMcpToken();
+  if (existing) return existing;
+  const token = randomBytes(32).toString("base64url");
+  await mkdir2(DIR, { recursive: true, mode: 448 });
+  await writeFile3(FILE, `${token}
+`, { mode: 384 });
+  await chmod2(FILE, 384);
+  cached2 = token;
+  return token;
+}
+async function forgetMcpToken() {
+  cached2 = null;
+  await rm2(FILE, { force: true });
+}
+
+// src/usage.ts
+import { mkdir as mkdir3, readFile as readFile4, rename as rename2, writeFile as writeFile4 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
+var PLANCHE_DIR2 = join5(homedir4(), ".planche");
+var USAGE_FILE = join5(PLANCHE_DIR2, "usage.json");
+var WRITE_DEBOUNCE_MS = 2e3;
+var KNOWN = new Set(PRO_FEATURES);
+var state = null;
+var loading = null;
+var timer = null;
+var writes = Promise.resolve();
+function isProFeature(value) {
+  return typeof value === "string" && KNOWN.has(value);
+}
+var isoNow = () => (/* @__PURE__ */ new Date()).toISOString();
+function empty() {
+  return { version: 1, since: isoNow(), features: {} };
+}
+function parse(raw) {
+  const data = JSON.parse(raw);
+  if (!data || typeof data !== "object") return empty();
+  const features = {};
+  for (const [key, value] of Object.entries(data.features ?? {})) {
+    if (!isProFeature(key) || !value || typeof value !== "object") continue;
+    const entry = value;
+    const count = Number(entry.count);
+    if (!Number.isFinite(count) || count < 0) continue;
+    features[key] = {
+      count: Math.floor(count),
+      first: typeof entry.first === "string" ? entry.first : isoNow(),
+      last: typeof entry.last === "string" ? entry.last : isoNow()
+    };
+  }
+  return { version: 1, since: typeof data.since === "string" ? data.since : isoNow(), features };
+}
+async function load() {
+  if (state) return state;
+  loading ??= (async () => {
+    try {
+      state = parse(await readFile4(USAGE_FILE, "utf8"));
+    } catch {
+      state = empty();
+    }
+    return state;
+  })();
+  return loading;
+}
+async function persist() {
+  if (!state) return;
+  const body = `${JSON.stringify(state, null, 2)}
+`;
+  await mkdir3(PLANCHE_DIR2, { recursive: true, mode: 448 });
+  const tmp = `${USAGE_FILE}.${process.pid}.tmp`;
+  await writeFile4(tmp, body, { mode: 384 });
+  await rename2(tmp, USAGE_FILE);
+}
+function schedule() {
+  if (timer) return;
+  timer = setTimeout(() => {
+    timer = null;
+    void flushUsage();
+  }, WRITE_DEBOUNCE_MS);
+  timer.unref?.();
+}
+function recordUsage(feature) {
+  void (async () => {
+    try {
+      const file = await load();
+      const now = isoNow();
+      const entry = file.features[feature];
+      if (entry) {
+        entry.count += 1;
+        entry.last = now;
+      } else {
+        file.features[feature] = { count: 1, first: now, last: now };
+      }
+      schedule();
+    } catch {
+    }
+  })();
+}
+function flushUsage() {
+  if (timer) {
+    clearTimeout(timer);
+    timer = null;
+  }
+  writes = writes.then(persist).catch(() => {
+  });
+  return writes;
+}
+async function usageSnapshot() {
+  const file = await load().catch(empty);
+  return { success: true, since: file.since, features: { ...file.features } };
+}
+
+// src/gateway.ts
+import { readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// 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"
+};
+var BINARY_CHARSET = 63;
+var BLOB_TO_TEXT = { tinyblob: "tinytext", blob: "text", mediumblob: "mediumtext", longblob: "longtext" };
+function getTypeName(typeId, charset) {
+  const name = MYSQL_TYPES[typeId] ?? "unknown";
+  if (charset !== void 0 && charset !== BINARY_CHARSET) return BLOB_TO_TEXT[name] ?? name;
+  return name;
+}
+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",
+    ssl: config.ssl ? { rejectUnauthorized: config.sslVerify === true } : void 0
+  };
+}
+var USE_STATEMENT = /^\s*USE\s/i;
+var MySqlDriver = class {
+  constructor(connection, config) {
+    this.connection = connection;
+    this.config = config;
+    this.label = `${config.user}@${config.host}:${config.port}`;
+    this.currentDatabase = config.database ?? null;
+  }
+  connection;
+  config;
+  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, field.characterSet),
+        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 setReadOnly() {
+    await this.connection.query("SET SESSION TRANSACTION READ ONLY");
+  }
+  /**
+   * A connection running a statement cannot take another one, so the KILL has
+   * to come down a second connection. `KILL QUERY` ends the statement and
+   * leaves the session — and its open transaction — alone.
+   */
+  async cancel() {
+    const threadId = this.connection.threadId;
+    if (!threadId) return;
+    const killer = await mysql.createConnection(toConnectionOptions(this.config));
+    try {
+      await killer.query(`KILL QUERY ${Number(threadId)}`);
+    } finally {
+      await killer.end().catch(() => void 0);
+    }
+  }
+  async close() {
+    await this.connection.end();
+  }
+};
+var mysqlDriverFactory = {
+  async open(config) {
+    const connection = await mysql.createConnection(toConnectionOptions(config));
+    connection.on("error", (err) => console.error("[mysql] Connection error:", err.message));
+    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,
+      ssl: body.ssl === true,
+      sslVerify: body.sslVerify === 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
+  };
+}
+var SEARCH_PATH_STATEMENT = /^\s*SET\s+(SESSION\s+|LOCAL\s+)?search_path\b/i;
+var quoteIdent = (name) => `"${name.replaceAll('"', '""')}"`;
+var PostgresDriver = class {
+  constructor(client2, config) {
+    this.client = client2;
+    this.config = config;
+    this.label = `${config.user}@${config.host}:${config.port}/${config.database}`;
+  }
+  client;
+  config;
+  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 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);
+      }
+    } 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 setReadOnly() {
+    await this.client.query("SET default_transaction_read_only = on");
+  }
+  /**
+   * `pg_cancel_backend` from a second connection: the busy one cannot carry the
+   * request. It cancels the running statement only, leaving the session open.
+   */
+  async cancel() {
+    const pid = this.client.processID;
+    if (!pid) return;
+    const canceller = new pg.Client(toClientConfig(this.config));
+    try {
+      await canceller.connect();
+      await canceller.query("SELECT pg_cancel_backend($1)", [pid]);
+    } finally {
+      await canceller.end().catch(() => void 0);
+    }
+  }
+  async close() {
+    await this.client.end();
+  }
+};
+var postgresDriverFactory = {
+  async open(config) {
+    const client2 = new pg.Client(toClientConfig(config));
+    await client2.connect();
+    client2.on("error", (err) => console.error("[postgres] Connection error:", err.message));
+    const driver = new PostgresDriver(client2, config);
+    await driver.loadTypeNames();
+    return driver;
+  },
+  async test(config) {
+    const client2 = new pg.Client(toClientConfig(config));
+    await client2.connect();
+    await client2.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
+    };
+  }
+};
+
+// src/drivers/sqlite.ts
+import { createRequire } from "module";
+import { existsSync, realpathSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { basename, dirname, join as join6, relative, resolve, sep } from "path";
+function normalizeDeclaredType(declared) {
+  if (!declared) return null;
+  const base = declared.trim().toLowerCase().replace(/\(.*$/, "").trim();
+  return base || null;
+}
+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";
+}
+var SQLITE_DIR = process.env.PLANCHE_SQLITE_DIR ? resolve(expandHome(process.env.PLANCHE_SQLITE_DIR)) : null;
+var DEFAULT_ROOT = homedir5();
+var DENIED_UNDER_HOME = process.platform === "darwin" ? ["Library"] : process.platform === "win32" ? ["AppData"] : [];
+var ALLOW_ATTACH = process.env.PLANCHE_SQLITE_ATTACH === "1";
+var DB_EXTENSIONS = /\.(db|db3|s3db|sl3|sqlite|sqlite3)$/i;
+function expandHome(path) {
+  return path === "~" || path.startsWith("~/") ? resolve(homedir5(), path.slice(2)) : path;
+}
+function realish(file) {
+  let probe = file;
+  const rest = [];
+  for (; ; ) {
+    try {
+      return rest.length ? join6(realpathSync.native(probe), ...rest) : realpathSync.native(probe);
+    } catch {
+      const parent = dirname(probe);
+      if (parent === probe) return file;
+      rest.unshift(basename(probe));
+      probe = parent;
+    }
+  }
+}
+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:")) throw new Error("SQLite URI filenames are not supported by the agent; give a plain path");
+  const resolved = realish(resolve(SQLITE_DIR ?? process.cwd(), expandHome(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.some((d) => d.toLowerCase() === parts[0].toLowerCase())) 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, .db3, .s3db, .sl3, .sqlite or .sqlite3");
+  }
+  return resolved;
+}
+var ctor = null;
+function sqliteCtor() {
+  ctor ??= createRequire(import.meta.url)("better-sqlite3");
+  return ctor;
+}
+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 (sqliteCtor())(file, {
+    readonly: config.readonly ?? false,
+    fileMustExist: !isMemory && !config.createIfMissing,
+    // A host with another ABI (the Electron shell) supplies its own build of
+    // the binding instead of rebuilding the one installed for Node.
+    nativeBinding: process.env.PLANCHE_SQLITE_BINDING || void 0
+  });
+  db.pragma("trusted_schema = OFF");
+  if (config.readonly) db.pragma("query_only = ON");
+  return db;
+}
+function stripLiteralsAndComments(sql2) {
+  let out = "";
+  let i = 0;
+  while (i < sql2.length) {
+    const c = sql2[i];
+    if (c === "'" || c === '"' || c === "`") {
+      let j = i + 1;
+      while (j < sql2.length) {
+        if (sql2[j] === c) {
+          if (sql2[j + 1] === c) j += 2;
+          else {
+            j++;
+            break;
+          }
+        } else j++;
+      }
+      out += c + c;
+      i = j;
+      continue;
+    }
+    if (c === "[") {
+      const j = sql2.indexOf("]", i);
+      i = j < 0 ? sql2.length : j + 1;
+      out += "[]";
+      continue;
+    }
+    if (c === "-" && sql2[i + 1] === "-") {
+      const j = sql2.indexOf("\n", i);
+      i = j < 0 ? sql2.length : j;
+      out += " ";
+      continue;
+    }
+    if (c === "/" && sql2[i + 1] === "*") {
+      const j = sql2.indexOf("*/", i + 2);
+      i = j < 0 ? sql2.length : j + 2;
+      out += " ";
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function assertNoFileStatements(sql2) {
+  const text = stripLiteralsAndComments(sql2);
+  if (!ALLOW_ATTACH && /\bATTACH\b/i.test(text)) {
+    throw new Error("ATTACH DATABASE is disabled on the agent (set PLANCHE_SQLITE_ATTACH=1 to allow it)");
+  }
+  if (/\bVACUUM\b[^;]*\bINTO\b/i.test(text)) {
+    throw new Error("VACUUM INTO is not available through the agent");
+  }
+  if (/\bPRAGMA\s+temp_store_directory\b/i.test(text)) {
+    throw new Error("PRAGMA temp_store_directory is not available through the agent");
+  }
+}
+var SqliteDriver = class {
+  constructor(db, config) {
+    this.db = db;
+    this.label = config.file;
+  }
+  db;
+  type = "sqlite";
+  label;
+  async query(sql2) {
+    assertNoFileStatements(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 };
+  }
+  async setReadOnly() {
+    this.db.pragma("query_only = 1");
+  }
+  async close() {
+    if (this.db.inTransaction) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+    }
+    this.db.close();
+  }
+};
+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) {
+    return new SqliteDriver(openDatabase(config), config);
+  },
+  async test(config) {
+    const db = openDatabase(config);
+    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");
+    }
+    return {
+      driver: "sqlite",
+      file,
+      createIfMissing: body.createIfMissing === true,
+      readonly: body.readonly === true
+    };
+  }
+};
+
+// 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: config.sslVerify !== 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 cached3 = this.sources.get(text);
+    if (cached3 !== void 0) return cached3;
+    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;
+  }
+  /** The request in flight, so a cancel can interrupt it. */
+  running = null;
+  /** `tedious` sends an attention packet; the statement ends and the pool stays usable. */
+  async cancel() {
+    this.running?.cancel();
+  }
+  async query(text) {
+    const req = this.pool.request();
+    req.arrayRowMode = true;
+    this.running = req;
+    let res;
+    try {
+      res = await req.query(text);
+    } finally {
+      if (this.running === req) this.running = null;
+    }
+    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,
+      sslVerify: body.sslVerify === 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 cached3 = this.columns.get(key);
+    if (cached3 !== void 0) return cached3;
+    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 };
+  }
+  /**
+   * `break()` interrupts the call in progress; the session then needs
+   * `reset()` before it can be used again.
+   */
+  async cancel() {
+    await this.conn.break();
+    await this.conn.reset?.().catch(() => void 0);
+  }
+  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");
+    }
+    if (!/^[A-Za-z0-9._[\]-]{1,253}$/.test(host)) throw new Error("host is not a valid host name");
+    const serviceName = typeof body.serviceName === "string" && body.serviceName ? body.serviceName.trim() : "FREEPDB1";
+    if (!/^[A-Za-z0-9._$#-]{1,128}$/.test(serviceName)) throw new Error("serviceName may only contain letters, digits, . _ $ # -");
+    return {
+      driver: "oracle",
+      host,
+      port: Number(body.port) || 1521,
+      user,
+      password: typeof body.password === "string" ? body.password : "",
+      serviceName
+    };
+  }
+};
+
+// src/drivers/d1.ts
+var API = "https://api.cloudflare.com/client/v4";
+var LOCAL_API = "/cdn-cgi/local/explorer/api";
+var SELECT_STAR = /^\s*SELECT\s+(?:DISTINCT\s+)?\*/i;
+var localRawUrl = (origin, databaseId) => `${origin}${LOCAL_API}/d1/database/${encodeURIComponent(databaseId)}/raw`;
+var LOOPBACK = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1", "0.0.0.0"]);
+function parseDevUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`Not a valid URL: ${raw}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("devUrl must be an http(s) URL");
+  if (!LOOPBACK.has(url.hostname.toLowerCase())) {
+    throw new Error("devUrl must point at a wrangler dev server on this machine (localhost).");
+  }
+  return url.origin;
+}
+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;
+  /** Not readonly: a local database resolves its id lazily (see `resolveUrl`). */
+  url;
+  headers;
+  /** Declared column types per table, for result-source resolution. */
+  columns = /* @__PURE__ */ new Map();
+  /**
+   * D1 is a REST call, not a session: there is no cancel to send, so stopping
+   * means dropping the request the agent is waiting on. The query may still
+   * finish at Cloudflare, which is why this is `abandon` and not `kill`.
+   */
+  cancelKind = "abandon";
+  inFlight = null;
+  async cancel() {
+    this.inFlight?.abort();
+  }
+  /** Local databases resolve their id on first use; the remote ones know it up front. */
+  local;
+  resolving = null;
+  constructor(config) {
+    this.local = config.devUrl ?? null;
+    this.label = `d1:${config.databaseId || this.local || ""}`;
+    if (this.local) {
+      this.headers = { "Content-Type": "application/json" };
+      this.url = config.databaseId ? localRawUrl(this.local, config.databaseId) : "";
+    } else {
+      this.headers = { Authorization: `Bearer ${config.apiToken ?? ""}`, "Content-Type": "application/json" };
+      this.url = `${API}/accounts/${encodeURIComponent(config.accountId ?? "")}/d1/database/${encodeURIComponent(config.databaseId ?? "")}/raw`;
+    }
+  }
+  /**
+   * A local dev server usually binds one database, so the connection form does
+   * not have to ask for a uuid it would only copy from wrangler's config.
+   */
+  async resolveUrl() {
+    if (this.url) return this.url;
+    this.resolving ??= (async () => {
+      const listed = await fetch(`${this.local}${LOCAL_API}/d1/database`, { signal: AbortSignal.timeout(1e4) });
+      if (!listed.ok) throw new D1Error(`No wrangler dev server answering at ${this.local}`, 400);
+      const body = await listed.json();
+      const bound = body.result ?? [];
+      if (bound.length === 0) throw new D1Error("That wrangler dev server has no D1 database bound.", 400);
+      const databases = [...new Map(bound.map((d) => [d.uuid ?? "", d])).values()];
+      if (databases.length > 1) {
+        const choices = databases.map((d) => `${d.name ?? "?"} (${d.uuid ?? "?"})`).join(", ");
+        throw new D1Error(
+          `That dev server binds ${databases.length} databases; put one of these ids in the Database ID field: ${choices}`,
+          400
+        );
+      }
+      this.url = localRawUrl(this.local, databases[0].uuid ?? "");
+      return this.url;
+    })();
+    return this.resolving;
+  }
+  async raw(sql2) {
+    const url = this.url || await this.resolveUrl();
+    let res;
+    try {
+      const controller = new AbortController();
+      this.inFlight = controller;
+      try {
+        res = await fetch(url, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify({ sql: sql2 }),
+          signal: AbortSignal.any([controller.signal, AbortSignal.timeout(6e4)])
+        });
+      } finally {
+        if (this.inFlight === controller) this.inFlight = null;
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new D1Error("Stopped waiting for D1; the query may still finish at Cloudflare.", 400);
+      }
+      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) => 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 cached3 = this.columns.get(table);
+    if (cached3 !== void 0) return cached3;
+    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 names = columns.length > 0 ? columns : known && SELECT_STAR.test(text) ? [...known.keys()] : [];
+    const fields = names.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() : "";
+    const devUrl = typeof body.devUrl === "string" ? body.devUrl.trim() : "";
+    if (devUrl) return { driver: "d1", devUrl: parseDevUrl(devUrl), databaseId: databaseId || void 0 };
+    if (!accountId || !databaseId || !apiToken) {
+      throw new Error("accountId, databaseId and apiToken are required (or devUrl for a local wrangler dev database)");
+    }
+    return { driver: "d1", accountId, databaseId, apiToken };
+  }
+};
+
+// src/drivers/do.ts
+var LOCAL_EXPLORER = "/cdn-cgi/local/explorer/api";
+var CLOUDFLARE_API = "https://api.cloudflare.com/client/v4";
+var MAX_OBJECTS = 5e3;
+var DoError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var DATABASE_LIST2 = /^\s*PRAGMA\s+database_list\s*;?\s*$/i;
+var RESULT_KIND2 = /^\s*(SELECT|WITH|PRAGMA|EXPLAIN|VALUES)\b/i;
+var TRANSACTION = /^\s*(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i;
+var DDL = /^\s*(CREATE|ALTER|DROP)\b/i;
+var HEX_ID = /^[0-9a-f]{64}$/i;
+function singleSourceTable3(sql2) {
+  const m = /\bFROM\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 normalizeDeclaredType3(declared) {
+  if (typeof declared !== "string") return null;
+  const base = declared.trim().toLowerCase().replace(/\(.*$/, "").trim();
+  return base || null;
+}
+function inferTypeFromValue3(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 firstNonNull3(records, index) {
+  for (const row of records) {
+    const value = row[index];
+    if (value !== null && value !== void 0) return value;
+  }
+  return null;
+}
+function closingQuote(sql2, start, close) {
+  let i = start + 1;
+  while (i < sql2.length) {
+    if (sql2[i] === close) {
+      if (sql2[i + 1] === close && close !== "]") {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i += 1;
+  }
+  return sql2.length;
+}
+function skipSpace(sql2, from) {
+  let i = from;
+  while (i < sql2.length && /\s/.test(sql2[i])) i += 1;
+  return i;
+}
+function routeStatement(sql2, known) {
+  let out = "";
+  let target = null;
+  let i = 0;
+  while (i < sql2.length) {
+    const ch = sql2[i];
+    if (ch === "'") {
+      const end = closingQuote(sql2, i, "'");
+      out += sql2.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "-" && sql2[i + 1] === "-") {
+      const end = sql2.indexOf("\n", i);
+      const stop = end === -1 ? sql2.length : end;
+      out += sql2.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    if (ch === "/" && sql2[i + 1] === "*") {
+      const end = sql2.indexOf("*/", i + 2);
+      const stop = end === -1 ? sql2.length : end + 2;
+      out += sql2.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    if (ch === '"' || ch === "`" || ch === "[") {
+      const close = ch === "[" ? "]" : ch;
+      const end = closingQuote(sql2, i, close);
+      const raw = sql2.slice(i, end);
+      const inner = ch === "[" ? raw.slice(1, -1) : raw.slice(1, -1).replaceAll(close + close, close);
+      const dot = skipSpace(sql2, end);
+      if (sql2[dot] === "." && known(inner)) {
+        target ??= inner;
+        i = dot + 1;
+        continue;
+      }
+      out += raw;
+      i = end;
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return { sql: out, target };
+}
+async function fetchJson(url, init, unreachable, abort) {
+  let res;
+  try {
+    const signal = abort ? AbortSignal.any([abort, AbortSignal.timeout(6e4)]) : AbortSignal.timeout(6e4);
+    res = await fetch(url, { ...init, signal });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError" && abort?.aborted) {
+      throw new DoError("Stopped waiting for the request; the query may still finish.", 400);
+    }
+    throw unreachable(err instanceof Error ? err.message : String(err));
+  }
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  return { res, body };
+}
+var LocalTransport = class {
+  label;
+  base;
+  /** The request being waited on, so a stop can drop it. */
+  inFlight = null;
+  abort() {
+    this.inFlight?.abort();
+  }
+  /** Signal for the next request; replaces whatever was tracked before. */
+  track() {
+    this.inFlight = new AbortController();
+    return this.inFlight.signal;
+  }
+  constructor(devUrl) {
+    this.label = `do:${devUrl}`;
+    this.base = `${devUrl.replace(/\/+$/, "")}${LOCAL_EXPLORER}`;
+  }
+  async call(path, body) {
+    const origin = this.base.replace(LOCAL_EXPLORER, "");
+    const { res, body: parsed } = await fetchJson(
+      `${this.base}${path}`,
+      {
+        method: body === void 0 ? "GET" : "POST",
+        headers: body === void 0 ? void 0 : { "Content-Type": "application/json" },
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      },
+      (reason) => new DoError(
+        `Cannot reach a wrangler dev server at ${origin} (${reason}). Run \`wrangler dev\` in your Worker project and try again.`,
+        400
+      ),
+      this.track()
+    );
+    const envelope = parsed && typeof parsed.success === "boolean" && (parsed.result !== void 0 || Array.isArray(parsed.errors)) ? parsed : null;
+    if (!envelope) {
+      throw new DoError(
+        `${origin} answered (HTTP ${res.status}) but is not a wrangler dev server. Check the port, and that \`wrangler dev\` (wrangler 4.x) is what is running there.`,
+        400
+      );
+    }
+    if (!res.ok || !envelope.success) {
+      throw new DoError(errorText(envelope.errors) || `wrangler dev responded ${res.status}`, res.ok ? void 0 : 400);
+    }
+    if (envelope.result === void 0) throw new DoError("wrangler dev returned no result");
+    return envelope.result;
+  }
+  async namespaces() {
+    const list = await this.call("/workers/durable_objects/namespaces");
+    return list.map((ns) => ({ id: ns.id, sqlite: ns.use_sqlite !== false }));
+  }
+  objects(namespaceId) {
+    return this.call(`/workers/durable_objects/namespaces/${encodeURIComponent(namespaceId)}/objects`);
+  }
+  async run(target, sql2) {
+    const selector = target.name ? { durable_object_name: target.name } : { durable_object_id: target.id };
+    const results = await this.call(
+      `/workers/durable_objects/namespaces/${encodeURIComponent(target.namespaceId)}/query`,
+      { ...selector, queries: [{ sql: sql2 }] }
+    );
+    const result = results[0];
+    if (!result) throw new DoError("wrangler dev returned no result");
+    return result;
+  }
+};
+var RemoteTransport = class {
+  label;
+  base;
+  /** The request being waited on, so a stop can drop it. */
+  inFlight = null;
+  abort() {
+    this.inFlight?.abort();
+  }
+  /** Signal for the next request; replaces whatever was tracked before. */
+  track() {
+    this.inFlight = new AbortController();
+    return this.inFlight.signal;
+  }
+  headers;
+  only;
+  constructor(config) {
+    this.label = `do:${config.accountId}${config.namespaceId ? `/${config.namespaceId}` : ""}`;
+    this.base = `${CLOUDFLARE_API}/accounts/${encodeURIComponent(config.accountId)}/workers/durable_objects/namespaces`;
+    this.headers = { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" };
+    this.only = config.namespaceId || void 0;
+  }
+  async call(path, body) {
+    const { res, body: parsed } = await fetchJson(
+      `${this.base}${path}`,
+      {
+        method: body === void 0 ? "GET" : "POST",
+        headers: this.headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      },
+      (reason) => new DoError(`Cannot reach the Cloudflare API: ${reason}`, 400),
+      this.track()
+    );
+    if (res.status === 401 || res.status === 403) {
+      throw new DoError(
+        errorText(parsed?.errors) || "Cloudflare refused the API token. It needs the Workers Scripts Read permission on this account.",
+        401
+      );
+    }
+    if (res.status === 404 || res.status === 405) {
+      throw new DoError(
+        "Cloudflare did not accept this request (HTTP " + res.status + "). The Durable Object query endpoint is unofficial and may have changed; the Data Studio tab in the Cloudflare dashboard still works.",
+        400
+      );
+    }
+    if (!res.ok || !parsed?.success) {
+      throw new DoError(errorText(parsed?.errors) || `Cloudflare API responded ${res.status}`, 400);
+    }
+    return parsed;
+  }
+  async namespaces() {
+    if (this.only) return [{ id: this.only, sqlite: true }];
+    const body = await this.call("");
+    return (body.result ?? []).map((ns) => ({ id: ns.id, sqlite: ns.use_sqlite !== false }));
+  }
+  /**
+   * Cloudflare's listing returns ids and `hasStoredData`, never names. It also
+   * answers an empty page for small `limit` values, so the parameter is left
+   * off and the default page size is used, following `result_info.cursor`.
+   */
+  async objects(namespaceId) {
+    const out = [];
+    let cursor;
+    do {
+      const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : "";
+      const body = await this.call(
+        `/${encodeURIComponent(namespaceId)}/objects${query}`
+      );
+      for (const object of body.result ?? []) out.push({ id: object.id });
+      cursor = body.result_info?.cursor || void 0;
+    } while (cursor && out.length < MAX_OBJECTS);
+    return out;
+  }
+  async run(target, sql2) {
+    if (!target.id) {
+      throw new DoError(
+        `"${target.name}" is a name, and deployed Durable Objects can only be opened by id: idFromName() is a one-way hash and Cloudflare does not resolve it here. Pick an object from the schema tree.`,
+        400
+      );
+    }
+    const body = await this.call(
+      `/${encodeURIComponent(target.namespaceId)}/query`,
+      { durable_object_id: target.id, queries: [{ sql: sql2 }] }
+    );
+    const result = body.result?.results?.[0];
+    if (!result) throw new DoError("Cloudflare returned no result");
+    return result;
+  }
+};
+function errorText(errors) {
+  if (!Array.isArray(errors)) return "";
+  return errors.map((e) => typeof e === "string" ? e : String(e?.message ?? "")).filter(Boolean).join("; ").slice(0, 500);
+}
+var DoDriver = class {
+  constructor(type, transport) {
+    this.type = type;
+    this.transport = transport;
+    this.label = transport.label;
+  }
+  type;
+  transport;
+  label;
+  /** Database name -> the object it addresses, refreshed by every listing. */
+  targets = /* @__PURE__ */ new Map();
+  /** Declared column types per `database table`, for result-source resolution. */
+  columns = /* @__PURE__ */ new Map();
+  /**
+   * These are HTTP calls, not sessions: there is nothing to cancel upstream, so
+   * stopping drops the request the agent waits on. `abandon`, not `kill`.
+   */
+  cancelKind = "abandon";
+  async cancel() {
+    this.transport.abort();
+  }
+  /**
+   * Every object of every SQLite-backed namespace, as app-level database
+   * names. Locally, a `wrangler dev` session registers itself in wrangler's
+   * dev registry, so sessions of other projects show up here too.
+   */
+  async listDatabases() {
+    const namespaces = await this.transport.namespaces();
+    const names = [];
+    this.targets.clear();
+    for (const ns of namespaces) {
+      if (!ns.sqlite) continue;
+      let objects;
+      try {
+        objects = await this.transport.objects(ns.id);
+      } catch {
+        continue;
+      }
+      for (const object of objects) {
+        const ref = object.name || object.id;
+        if (!ref) continue;
+        const database = `${ns.id}/${ref}`;
+        this.targets.set(database, { namespaceId: ns.id, name: object.name, id: object.id });
+        names.push(database);
+      }
+    }
+    return names.sort();
+  }
+  /**
+   * Resolve a database name to the object it addresses. Names are cached by
+   * the last listing; one that was never listed is still usable, so a saved
+   * query tab keeps working — the trailing part is read as an id when it looks
+   * like one and as a name otherwise.
+   */
+  targetFor(database) {
+    const cached3 = this.targets.get(database);
+    if (cached3) return cached3;
+    const slash = database.indexOf("/");
+    if (slash <= 0 || slash === database.length - 1) {
+      throw new DoError(
+        `"${database}" is not a Durable Object. Pick one from the schema tree (they are named "<namespace>/<object>").`,
+        400
+      );
+    }
+    const namespaceId = database.slice(0, slash);
+    const ref = database.slice(slash + 1);
+    return HEX_ID.test(ref) ? { namespaceId, id: ref } : { namespaceId, name: ref };
+  }
+  async tableColumns(database, target, table) {
+    const key = `${database} ${table}`;
+    const cached3 = this.columns.get(key);
+    if (cached3 !== void 0) return cached3;
+    let out = null;
+    try {
+      const info = await this.transport.run(target, `PRAGMA table_info("${table.replaceAll('"', '""')}")`);
+      const cols = info.columns ?? [];
+      const name = cols.indexOf("name");
+      const type = cols.indexOf("type");
+      const rows = info.rows ?? [];
+      if (rows.length > 0 && name >= 0) {
+        out = new Map(rows.map((r) => [String(r[name]), normalizeDeclaredType3(type >= 0 ? r[type] : 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_LIST2.test(sql2)) {
+      const names = await this.listDatabases();
+      return {
+        fields: ["seq", "name", "file"].map((name2) => ({
+          name: name2,
+          orgName: name2,
+          type: name2 === "seq" ? "integer" : "text",
+          table: "",
+          orgTable: "",
+          db: "",
+          maxLength: 0
+        })),
+        records: names.map((name2, seq) => [seq, name2, ""]),
+        affectedRows: 0,
+        insertId: 0,
+        isResultQuery: true
+      };
+    }
+    const routed = routeStatement(sql2, (name2) => this.targets.has(name2) || name2.includes("/"));
+    const text = routed.sql;
+    if (TRANSACTION.test(text)) {
+      throw new DoError(
+        "Durable Object storage does not take transaction statements over this API; every request auto-commits."
+      );
+    }
+    const name = routed.target ?? database;
+    if (!name) {
+      throw new DoError(
+        'No Durable Object selected. Pick one in the schema tree, or qualify the table as "<namespace>/<object>"."<table>".',
+        400
+      );
+    }
+    const target = this.targetFor(name);
+    if (DDL.test(text)) this.columns.clear();
+    const result = await this.transport.run(target, text);
+    const columns = result.columns ?? [];
+    const records = result.rows ?? [];
+    if (columns.length === 0 && !RESULT_KIND2.test(text)) {
+      return {
+        fields: [],
+        records: [],
+        affectedRows: result.meta?.rows_written ?? 0,
+        insertId: 0,
+        isResultQuery: false
+      };
+    }
+    const source = RESULT_KIND2.test(text) ? singleSourceTable3(text) : null;
+    const known = source ? await this.tableColumns(name, target, source) : null;
+    const fields = columns.map((column, index) => {
+      const fromTable = known?.has(column) ?? false;
+      const type = (fromTable ? known?.get(column) : null) ?? inferTypeFromValue3(firstNonNull3(records, index));
+      return {
+        name: column,
+        orgName: column,
+        type,
+        table: fromTable && source ? source : "",
+        orgTable: fromTable && source ? source : "",
+        db: fromTable ? name : "",
+        maxLength: 0
+      };
+    });
+    return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+  }
+  async close() {
+    this.targets.clear();
+    this.columns.clear();
+  }
+};
+var LOOPBACK2 = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1", "0.0.0.0"]);
+function parseDevUrl2(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`Not a valid URL: ${raw}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("devUrl must be an http(s) URL");
+  }
+  if (!LOOPBACK2.has(url.hostname.toLowerCase())) {
+    throw new Error(
+      "devUrl must point at a wrangler dev server on this machine (localhost). Use the deployed Durable Objects connection for objects that are not local."
+    );
+  }
+  return url.origin;
+}
+var doDriverFactory = {
+  async open(config) {
+    const driver = new DoDriver("do", new LocalTransport(config.devUrl));
+    await driver.query("PRAGMA database_list");
+    return driver;
+  },
+  async test(config) {
+    await new DoDriver("do", new LocalTransport(config.devUrl)).query("PRAGMA database_list");
+  },
+  parseConfig(body) {
+    const devUrl = typeof body.devUrl === "string" ? body.devUrl.trim() : "";
+    if (!devUrl) throw new Error("devUrl is required");
+    return { driver: "do", devUrl: parseDevUrl2(devUrl) };
+  }
+};
+var doRemoteDriverFactory = {
+  async open(config) {
+    const driver = new DoDriver("do-remote", new RemoteTransport(config));
+    await driver.query("PRAGMA database_list");
+    return driver;
+  },
+  async test(config) {
+    await new DoDriver("do-remote", new RemoteTransport(config)).query("PRAGMA database_list");
+  },
+  parseConfig(body) {
+    const accountId = typeof body.accountId === "string" ? body.accountId.trim() : "";
+    const apiToken = typeof body.apiToken === "string" ? body.apiToken.trim() : "";
+    const namespaceId = typeof body.namespaceId === "string" ? body.namespaceId.trim() : "";
+    if (!accountId || !apiToken) throw new Error("accountId and apiToken are required");
+    return { driver: "do-remote", accountId, apiToken, ...namespaceId ? { namespaceId } : {} };
+  }
+};
+
+// src/ssh-tunnel.ts
+import { createServer } from "net";
+import { mkdir as mkdir4, readFile as readFile6, appendFile } from "fs/promises";
+import { createHash, createHmac, timingSafeEqual } from "crypto";
+import { homedir as homedir7 } from "os";
+import { basename as basename3, join as join8 } from "path";
+import { Client } from "ssh2";
+
+// src/ssh-config.ts
+import { readFile as readFile5, readdir } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname2, isAbsolute, join as join7, basename as basename2 } from "path";
+var SSH_CONFIG_DISABLED = process.env.PLANCHE_SSH_CONFIG === "none";
+var DEFAULT_SSH_CONFIG = SSH_CONFIG_DISABLED ? "" : process.env.PLANCHE_SSH_CONFIG || join7(homedir6(), ".ssh", "config");
+var DEFAULT_IDENTITY_FILES = ["id_ed25519", "id_ecdsa", "id_rsa", "id_ed25519_sk", "id_ecdsa_sk"].map(
+  (f) => join7(homedir6(), ".ssh", f)
+);
+function expandHome2(path) {
+  return path === "~" || path.startsWith("~/") ? join7(homedir6(), 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;
+}
+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 = basename2(path);
+  if (!/[*?]/.test(base)) return [path];
+  const dir = dirname2(path);
+  try {
+    const re = globToRegExp(base);
+    return (await readdir(dir)).filter((name) => re.test(name)).sort().map((name) => join7(dir, name));
+  } catch {
+    return [];
+  }
+}
+async function loadLines(file, seen) {
+  if (seen.has(file)) return [];
+  seen.add(file);
+  try {
+    return (await readFile5(file, "utf8")).split(/\r?\n/);
+  } catch {
+    return [];
+  }
+}
+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 = expandHome2(inc);
+            const abs = isAbsolute(target) ? target : join7(homedir6(), ".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) {
+            const expanded = expandHome2(f.replace(/%d/g, homedir6()).replace(/%h/g, host));
+            if (expanded.split(/[\\/]/).includes("..")) continue;
+            result.identityFiles.push(expanded);
+          }
+          break;
+        case "identityagent":
+          result.identityAgent ??= value === "none" ? void 0 : expandHome2(value.replace(/%d/g, homedir6()));
+          break;
+        case "proxyjump":
+          result.proxyJump ??= value;
+          break;
+      }
+    }
+  }
+  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 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 };
+  }
+};
+var CONNECT_TIMEOUT_MS = 2e4;
+var PLANCHE_DIR3 = join8(homedir7(), ".planche");
+var PLANCHE_KNOWN_HOSTS = join8(PLANCHE_DIR3, "known_hosts");
+var OPENSSH_KNOWN_HOSTS = join8(homedir7(), ".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) || /^[.-]+$/.test(host)) throw new TunnelError("ssh.host is not a valid host name", 400);
+  if (user.length > 64 || /[\s\x00-\x1f]/.test(user)) throw new TunnelError("ssh.user is not valid", 400);
+  const port = Math.trunc(Number(body.port)) || 22;
+  if (port < 1 || port > 65535) throw new TunnelError("ssh.port must be between 1 and 65535", 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,
+    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 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);
+  const type = blob.subarray(4, 4 + len).toString("ascii");
+  if (!/^[A-Za-z0-9@.-]+$/.test(type)) throw new TunnelError("Malformed host key", 400);
+  return type;
+}
+function knownHostsEntryMatches(field, patterns) {
+  if (field.startsWith("|1|")) {
+    const [, , salt, hash] = field.split("|");
+    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 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 readFile6(file, "utf8")).split(/\r?\n/);
+  } catch {
+    return [];
+  }
+}
+async function lookupHostKey(host, port, blob) {
+  const patterns = hostPatterns(host, port);
+  const type = keyType(blob);
+  const encoded = blob.toString("base64");
+  let sawHost = 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("#")) continue;
+    const fields = line.split(/\s+/);
+    const marker = fields[0].startsWith("@") ? fields.shift() : void 0;
+    const [hosts, lineType, lineKey] = fields;
+    if (!hosts || !lineType || !lineKey) continue;
+    if (!knownHostsEntryMatches(hosts, patterns)) continue;
+    if (marker === "@revoked") {
+      if (lineType === type && lineKey === encoded) throw new TunnelError(`The host key of ${host}:${port} is marked @revoked in known_hosts`, 400);
+      continue;
+    }
+    if (marker === "@cert-authority") continue;
+    sawHost = true;
+    if (lineType === type && lineKey === encoded) return "match";
+  }
+  return sawHost ? "mismatch" : "unknown";
+}
+async function rememberHostKey(host, port, blob) {
+  await mkdir4(PLANCHE_DIR3, { 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);
+  }
+  if (cfg.hostName && (cfg.hostName.length > 253 || !/^[A-Za-z0-9._:[\]-]+$/.test(cfg.hostName))) {
+    throw new TunnelError(`HostName for ${ssh.host} in ~/.ssh/config is not a valid host name`, 400);
+  }
+  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
+    );
+  }
+  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 {
+        resolved.privateKey = await readFile6(file, "utf8");
+        console.log(`[ssh] Using identity file ${file} for ${ssh.host}`);
+        break;
+      } catch {
+      }
+    }
+    if (!resolved.privateKey) {
+      throw new TunnelError(
+        `No private key given and none readable for ${ssh.host} (tried ${candidates.map((f) => basename3(f)).join(", ")} in ~/.ssh)`,
+        400
+      );
+    }
+  }
+  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);
+  }
+}
+async function openSshTunnel(requested, target) {
+  const ssh = await resolveConfig(requested);
+  const client2 = 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((resolve3, reject) => {
+    client2.once("ready", resolve3);
+    client2.once("error", (err) => reject(verifyError ?? describeSshError(err, ssh)));
+    try {
+      client2.connect(connectConfig);
+    } catch (err) {
+      reject(describeSshError(err, ssh));
+    }
+  });
+  client2.on("error", (err) => console.error(`[ssh] ${ssh.host}:${ssh.port}: ${err.message}`));
+  const sockets = /* @__PURE__ */ new Set();
+  let forwardError;
+  const server = createServer((socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+    socket.on("error", () => socket.destroy());
+    client2.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;
+      }
+      stream.on("error", () => socket.destroy());
+      socket.pipe(stream).pipe(socket);
+      stream.once("close", () => socket.destroy());
+      socket.once("close", () => stream.destroy());
+    });
+  });
+  await new Promise((resolve3, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve3());
+  }).catch((err) => {
+    client2.end();
+    throw new TunnelError(`Could not open local tunnel port: ${err.message}`, 400);
+  });
+  const { port } = server.address();
+  let closed = false;
+  const close = () => new Promise((resolve3) => {
+    if (closed) return resolve3();
+    closed = true;
+    for (const s of sockets) s.destroy();
+    server.close(() => {
+      client2.end();
+      resolve3();
+    });
+  });
+  client2.once("close", () => void close());
+  return {
+    host: "127.0.0.1",
+    port,
+    get forwardError() {
+      return forwardError;
+    },
+    close
+  };
+}
+
+// src/drivers/index.ts
+var factories = {
+  mysql: mysqlDriverFactory,
+  postgres: postgresDriverFactory,
+  sqlite: sqliteDriverFactory,
+  mssql: mssqlDriverFactory,
+  oracle: oracleDriverFactory,
+  d1: d1DriverFactory,
+  do: doDriverFactory,
+  "do-remote": doRemoteDriverFactory
+};
+function isDriverType(value) {
+  return typeof value === "string" && value in factories;
+}
+function isDirectDriver(config) {
+  return config.driver === "sqlite" || config.driver === "d1" || config.driver === "do" || config.driver === "do-remote";
+}
+function parseDriverConfig(body) {
+  const driver = body.driver ?? "mysql";
+  if (!isDriverType(driver)) {
+    throw new Error(`Unsupported driver: ${String(driver)}`);
+  }
+  const config = factories[driver].parseConfig(body);
+  if (isDirectDriver(config)) return config;
+  const ssh = parseSshConfig(body.ssh);
+  return ssh ? { ...config, ssh } : config;
+}
+async function withTunnel(config, run2) {
+  if (isDirectDriver(config) || !config.ssh) return run2(config, void 0);
+  const tunnel = await openSshTunnel(config.ssh, { host: config.host, port: config.port });
+  recordUsage("ssh_tunnel");
+  try {
+    return await run2({ ...config, host: tunnel.host, port: tunnel.port, ssh: void 0 }, tunnel);
+  } catch (err) {
+    await tunnel.close();
+    throw tunnel.forwardError ? new TunnelError(tunnel.forwardError, 400) : err;
+  }
+}
+function tunneled(driver, tunnel, label) {
+  return {
+    type: driver.type,
+    label,
+    query: (sql2, database) => driver.query(sql2, database),
+    setReadOnly: driver.setReadOnly ? () => driver.setReadOnly() : void 0,
+    // Forwarded, or a tunnelled connection would report that its engine cannot
+    // interrupt a statement when it is only this wrapper that cannot.
+    cancel: driver.cancel ? () => driver.cancel() : void 0,
+    async close() {
+      try {
+        await driver.close();
+      } finally {
+        await tunnel.close();
+      }
+    }
+  };
+}
+function openDriver(config) {
+  return withTunnel(config, async (direct, tunnel) => {
+    const driver = await openDirect(direct);
+    if (!tunnel || isDirectDriver(config) || !config.ssh) return driver;
+    const label = `${config.user}@${config.host}:${config.port} via ssh ${config.ssh.user}@${config.ssh.host}:${config.ssh.port}`;
+    return tunneled(driver, tunnel, label);
+  });
+}
+function testDriver(config) {
+  return withTunnel(config, async (direct, tunnel) => {
+    try {
+      await testDirect(direct);
+    } finally {
+      await tunnel?.close();
+    }
+  });
+}
+function openDirect(config) {
+  switch (config.driver) {
+    case "mysql":
+      return factories.mysql.open(config);
+    case "postgres":
+      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);
+    case "do":
+      return factories.do.open(config);
+    case "do-remote":
+      return factories["do-remote"].open(config);
+  }
+}
+function testDirect(config) {
+  switch (config.driver) {
+    case "mysql":
+      return factories.mysql.test(config);
+    case "postgres":
+      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);
+    case "do":
+      return factories.do.test(config);
+    case "do-remote":
+      return factories["do-remote"].test(config);
+  }
+}
+
+// src/gateway.ts
+function loadGatewayConfig(file) {
+  const path = resolve2(file);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new Error(`Cannot read gateway config ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const data = raw;
+  if (!data || typeof data !== "object" || !Array.isArray(data.profiles) || data.profiles.length === 0) {
+    throw new Error(`Gateway config ${path} needs a non-empty "profiles" array`);
+  }
+  const names = /* @__PURE__ */ new Set();
+  const profiles = data.profiles.map((entry, i) => {
+    const e = entry ?? {};
+    const name = typeof e.name === "string" ? e.name.trim() : "";
+    if (!name) throw new Error(`Gateway profile #${i + 1} has no "name"`);
+    if (names.has(name)) throw new Error(`Gateway profile name is not unique: ${name}`);
+    names.add(name);
+    const { name: _n, readOnly, ...driver } = e;
+    void _n;
+    let config;
+    try {
+      config = parseDriverConfig(driver);
+    } catch (err) {
+      throw new Error(`Gateway profile "${name}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return { name, readOnly: readOnly !== false, config };
+  });
+  return { name: typeof data.name === "string" && data.name.trim() ? data.name.trim() : "Planche gateway", profiles };
+}
+function describeProfile(entry) {
+  const c = entry.config;
+  const database = "database" in c && typeof c.database === "string" ? c.database : c.driver === "oracle" ? c.serviceName : void 0;
+  return { name: entry.name, driver: c.driver, readOnly: entry.readOnly, ...database ? { database } : {} };
+}
+
+// src/server.ts
+import express from "express";
+import { createHash as createHash2, randomUUID as randomUUID2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+
+// src/bridge.ts
+var CALL_TIMEOUT_MS = 12e4;
+var client = null;
+var tools = [];
+var pending = /* @__PURE__ */ new Map();
+var nextId = 0;
+function bridgeTools() {
+  return tools;
+}
+function attachBridge(res) {
+  client?.end();
+  client = res;
+  res.on("close", () => {
+    if (client !== res) return;
+    client = null;
+    tools = [];
+  });
+}
+function setBridgeTools(next) {
+  tools = next;
+}
+function callThroughBridge(name, input) {
+  const target = client;
+  if (!target) {
+    return Promise.resolve({ content: "Planche is not open in a browser, so its tools cannot run.", isError: true });
+  }
+  const id = `call-${++nextId}`;
+  return new Promise((resolve3) => {
+    const timer2 = setTimeout(() => {
+      pending.delete(id);
+      resolve3({ content: `The app did not answer "${name}" within ${CALL_TIMEOUT_MS / 1e3}s.`, isError: true });
+    }, CALL_TIMEOUT_MS);
+    pending.set(id, { resolve: resolve3, timer: timer2 });
+    target.write(`data: ${JSON.stringify({ id, name, input })}
+
+`);
+  });
+}
+function resolveBridgeCall(id, content, isError) {
+  const waiting = pending.get(id);
+  if (!waiting) return;
+  pending.delete(id);
+  clearTimeout(waiting.timer);
+  waiting.resolve({ content, isError });
+}
+
+// src/mcp.ts
+var FALLBACK_PROTOCOL = "2025-06-18";
+async function handleMcp(req, res) {
+  const msg = req.body ?? {};
+  const reply = (result) => res.json({ jsonrpc: "2.0", id: msg.id, result });
+  switch (msg.method) {
+    case "initialize":
+      reply({
+        protocolVersion: typeof msg.params?.protocolVersion === "string" ? msg.params.protocolVersion : FALLBACK_PROTOCOL,
+        capabilities: { tools: {} },
+        serverInfo: { name: "planche", version: "1" }
+      });
+      return;
+    case "tools/list":
+      reply({
+        tools: bridgeTools().map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        }))
+      });
+      return;
+    case "tools/call": {
+      const name = typeof msg.params?.name === "string" ? msg.params.name : "";
+      const args = msg.params?.arguments ?? {};
+      const { content, isError } = await callThroughBridge(name, args);
+      reply({ content: [{ type: "text", text: content }], isError });
+      return;
+    }
+    default:
+      if (msg.id === void 0) {
+        res.status(202).end();
+        return;
+      }
+      reply({});
+  }
+}
+
+// src/tunneling.ts
+import { randomUUID } from "crypto";
+
+// src/drivers/connection-lost.ts
+var ConnectionLostError = class extends Error {
+  status = 404;
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionLostError";
+  }
+};
+var LOST_CODES = /* @__PURE__ */ new Set([
+  // mysql2
+  "PROTOCOL_CONNECTION_LOST",
+  "PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR",
+  "PROTOCOL_ENQUEUE_AFTER_QUIT",
+  "PROTOCOL_ENQUEUE_AFTER_DESTROY",
+  // node sockets (pg, mssql/tedious surface these directly)
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "ECONNABORTED",
+  "ENETUNREACH",
+  "EHOSTUNREACH",
+  "ENETDOWN",
+  // mssql
+  "ESOCKET",
+  "ECLOSE",
+  "ENOTOPEN",
+  // pg: admin_shutdown / crash_shutdown / cannot_connect_now
+  "57P01",
+  "57P02",
+  "57P03"
+]);
+var LOST_MESSAGES = [
+  /connection is in closed state/i,
+  // mysql2 "Can't add new command when connection is in closed state"
+  /connection lost/i,
+  /connection terminated/i,
+  // pg
+  /client has encountered a connection error/i,
+  // pg
+  /client was closed and is not queryable/i,
+  // pg
+  /connection is closed/i,
+  // mssql
+  /socket hang up/i,
+  /ORA-0311[34]\b/,
+  /ORA-01012\b/,
+  /ORA-12541\b/,
+  /ORA-03135\b/,
+  /NJS-500\b/,
+  /NJS-521\b/
+  // oracle
+];
+function isConnectionLost(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (typeof e.code === "string" && LOST_CODES.has(e.code)) return true;
+  if (e.fatal === true) return true;
+  if (typeof e.errorNum === "number" && [3113, 3114, 1012, 12541, 3135].includes(e.errorNum)) return true;
+  const message = typeof e.message === "string" ? e.message : "";
+  if (LOST_MESSAGES.some((re) => re.test(message))) return true;
+  return e.originalError !== void 0 && e.originalError !== err && isConnectionLost(e.originalError);
+}
+
+// src/read-only.ts
+var ReadOnlyViolation = class extends Error {
+  status = 403;
+  constructor(message) {
+    super(message);
+    this.name = "ReadOnlyViolation";
+  }
+};
+var READ_KEYWORDS = /* @__PURE__ */ new Set(["SELECT", "WITH", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "VALUES", "TABLE", "PRAGMA"]);
+function splitStatements(sql2) {
+  const out = [];
+  let cur = "";
+  let i = 0;
+  const n = sql2.length;
+  while (i < n) {
+    const ch = sql2[i];
+    const next = sql2[i + 1];
+    if (ch === "-" && next === "-") {
+      while (i < n && sql2[i] !== "\n") i++;
+      cur += " ";
+      continue;
+    }
+    if (ch === "#") {
+      while (i < n && sql2[i] !== "\n") i++;
+      cur += " ";
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < n && !(sql2[i] === "*" && sql2[i + 1] === "/")) i++;
+      i += 2;
+      cur += " ";
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`" || ch === "[") {
+      const close = ch === "[" ? "]" : ch;
+      i++;
+      while (i < n) {
+        if (sql2[i] === "\\" && close === "'") {
+          i += 2;
+          continue;
+        }
+        if (sql2[i] === close) {
+          if (sql2[i + 1] === close && close !== "]") {
+            i += 2;
+            continue;
+          }
+          break;
+        }
+        i++;
+      }
+      i++;
+      cur += ch === "[" ? " x " : " 'x' ";
+      continue;
+    }
+    if (ch === "$" && next === "$") {
+      const end = sql2.indexOf("$$", i + 2);
+      i = end === -1 ? n : end + 2;
+      cur += " 'x' ";
+      continue;
+    }
+    if (ch === ";") {
+      out.push(cur);
+      cur = "";
+      i++;
+      continue;
+    }
+    cur += ch;
+    i++;
+  }
+  out.push(cur);
+  return out.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function assertReadOnlyStatement(sql2) {
+  const statements = splitStatements(sql2);
+  if (statements.length === 0) return;
+  if (statements.length > 1) throw new ReadOnlyViolation("Read-only profile: one statement per request");
+  const stmt = statements[0];
+  const first = /^[A-Za-z]+/.exec(stmt)?.[0].toUpperCase() ?? "";
+  if (!READ_KEYWORDS.has(first)) throw new ReadOnlyViolation(`Read-only profile: ${first || "this statement"} is not allowed`);
+  if (first === "WITH") {
+    const words = stmt.toUpperCase().match(/\b(INSERT|UPDATE|DELETE|MERGE|REPLACE)\b/);
+    if (words) throw new ReadOnlyViolation(`Read-only profile: ${words[1]} inside WITH is not allowed`);
+  }
+  if (first === "PRAGMA" && /[=(]/.test(stmt)) throw new ReadOnlyViolation("Read-only profile: PRAGMA may only read");
+  if (/\bINTO\s+(OUTFILE|DUMPFILE)\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: INTO OUTFILE is not allowed");
+  if (/\bFOR\s+(UPDATE|SHARE|NO\s+KEY\s+UPDATE|KEY\s+SHARE)\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: locking reads are not allowed");
+  if (/\bLOCK\s+IN\s+SHARE\s+MODE\b/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: locking reads are not allowed");
+  if (first === "SELECT" && /\bINTO\b/i.test(stmt) && !/\bINTO\s+@/i.test(stmt)) throw new ReadOnlyViolation("Read-only profile: SELECT INTO is not allowed");
+}
+
+// src/tunneling.ts
+var IDLE_TIMEOUT_MS = Number(process.env.PLANCHE_IDLE_TIMEOUT_MS) || 30 * 60 * 1e3;
+var MAX_CONNECTIONS = Number(process.env.PLANCHE_MAX_CONNECTIONS) || 64;
+var ConnectionManager = class {
+  connections = /* @__PURE__ */ new Map();
+  lastUsed = /* @__PURE__ */ new Map();
+  /** Connections opened for a read-only gateway profile: writes are refused before reaching the driver. */
+  readOnly = /* @__PURE__ */ new Set();
+  constructor() {
+    const timer2 = setInterval(() => void this.closeIdle(), 6e4);
+    timer2.unref();
+  }
+  /** Close connections idle for longer than `IDLE_TIMEOUT_MS`. */
+  async closeIdle() {
+    const cutoff = Date.now() - IDLE_TIMEOUT_MS;
+    for (const [id, used] of this.lastUsed) {
+      if (used < cutoff) {
+        console.log(`[ConnectionManager] Closing idle connection: ${id}`);
+        await this.disconnect(id).catch(() => void 0);
+      }
+    }
+  }
+  /**
+   * Open a new connection and return a unique connection ID.
+   */
+  async connect(config, options = {}) {
+    if (this.connections.size >= MAX_CONNECTIONS) {
+      throw new Error(`Too many open connections (${MAX_CONNECTIONS}); disconnect some first`);
+    }
+    const driver = await openDriver(config);
+    if (options.readOnly && driver.setReadOnly) {
+      try {
+        await driver.setReadOnly();
+      } catch (err) {
+        await driver.close().catch(() => void 0);
+        throw err;
+      }
+    }
+    const connectionId = randomUUID();
+    this.connections.set(connectionId, driver);
+    this.lastUsed.set(connectionId, Date.now());
+    if (options.readOnly) this.readOnly.add(connectionId);
+    console.log(`[ConnectionManager] New ${driver.type} connection: ${connectionId} -> ${driver.label}`);
+    return connectionId;
+  }
+  has(connectionId) {
+    return this.connections.has(connectionId);
+  }
+  /**
+   * Execute a SQL query on an existing connection.
+   * Optionally switch database before executing (drivers that support it).
+   */
+  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());
+    if (this.readOnly.has(connectionId)) assertReadOnlyStatement(sql2);
+    try {
+      return await driver.query(sql2, database);
+    } catch (err) {
+      if (!isConnectionLost(err)) throw err;
+      console.log(`[ConnectionManager] Connection lost, evicting: ${connectionId}`);
+      this.connections.delete(connectionId);
+      this.lastUsed.delete(connectionId);
+      this.readOnly.delete(connectionId);
+      await driver.close().catch(() => void 0);
+      throw new ConnectionLostError(`Connection lost: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  /**
+   * Interrupt whatever is running on a connection. Best effort: an engine with
+   * no way to interrupt (better-sqlite3 blocks the thread) reports false rather
+   * than claiming a cancel that did not happen. The connection stays open —
+   * the point is to free it, not to drop it.
+   */
+  async cancel(connectionId) {
+    const driver = this.connections.get(connectionId);
+    if (!driver) throw new Error(`Connection not found: ${connectionId}`);
+    if (!driver.cancel) return { cancelled: false, abandoned: false };
+    await driver.cancel();
+    return { cancelled: true, abandoned: driver.cancelKind === "abandon" };
+  }
+  /**
+   * Close and remove a connection.
+   */
+  async disconnect(connectionId) {
+    const driver = this.connections.get(connectionId);
+    if (!driver) {
+      throw new Error(`Connection not found: ${connectionId}`);
+    }
+    await driver.close();
+    this.connections.delete(connectionId);
+    this.lastUsed.delete(connectionId);
+    this.readOnly.delete(connectionId);
+    console.log(`[ConnectionManager] Disconnected: ${connectionId}`);
+  }
+  /**
+   * Validate a config by opening and immediately closing a connection.
+   */
+  async testConnection(config) {
+    await testDriver(config);
+    return true;
+  }
+  /**
+   * Get the number of active connections.
+   */
+  get activeConnections() {
+    return this.connections.size;
+  }
+  /**
+   * Close all connections (for graceful shutdown).
+   */
+  async disconnectAll() {
+    const promises = Array.from(this.connections.entries()).map(
+      async ([id, driver]) => {
+        try {
+          await driver.close();
+          console.log(`[ConnectionManager] Disconnected: ${id}`);
+        } catch {
+        }
+      }
+    );
+    await Promise.all(promises);
+    this.connections.clear();
+    this.lastUsed.clear();
+    this.readOnly.clear();
+  }
+};
+
+// src/server.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join9 } from "path";
+function errorStatus(err) {
+  const status = err?.status;
+  return typeof status === "number" && status >= 400 && status < 600 ? status : 400;
+}
+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 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 = /* @__PURE__ */ new Map();
+  lockedUntil = /* @__PURE__ */ new Map();
+  /** Keyed by peer address so one local process cannot lock the browser out. */
+  locked(peer) {
+    return Date.now() < (this.lockedUntil.get(peer) ?? 0);
+  }
+  fail(peer) {
+    const now = Date.now();
+    const recent = (this.failures.get(peer) ?? []).filter((t) => now - t < this.windowMs);
+    recent.push(now);
+    if (recent.length >= this.max) {
+      this.lockedUntil.set(peer, now + this.lockMs);
+      this.failures.delete(peer);
+      console.warn(`[agent] Too many bad tokens from ${peer}; refusing its authentication for ${this.lockMs / 1e3}s`);
+    } else {
+      this.failures.set(peer, recent);
+    }
+    if (this.failures.size > 1e3) this.failures.clear();
+  }
+};
+function accessControl(allowed) {
+  return (req, res, next) => {
+    const origin = req.headers.origin;
+    if (origin === void 0) {
+      next();
+      return;
+    }
+    if (!allowed.has(origin)) {
+      fail(res, 403, `Origin not allowed: ${origin}`);
+      return;
+    }
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
+    res.setHeader("Access-Control-Max-Age", "600");
+    if (req.headers["access-control-request-private-network"] === "true") {
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
+    }
+    if (req.headers["access-control-request-local-network"] === "true") {
+      res.setHeader("Access-Control-Allow-Local-Network", "true");
+    }
+    if (req.method === "OPTIONS") {
+      res.sendStatus(204);
+      return;
+    }
+    next();
+  };
+}
+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();
+  const pairThrottle = new AuthThrottle();
+  let pairing = options.pairingCode;
+  let lastPairOffer = 0;
+  app.set("env", "production");
+  app.disable("x-powered-by");
+  app.disable("etag");
+  const peerOf = (req) => req.socket.remoteAddress ?? "unknown";
+  const authorized = (req) => {
+    const peer = peerOf(req);
+    if (throttle.locked(peer)) return false;
+    const given = bearerOf(req.headers.authorization);
+    if (given === null) return false;
+    const ok = secretEquals(given, options.authToken);
+    if (!ok) throttle.fail(peer);
+    return ok;
+  };
+  if (options.logRequests) {
+    app.use((req, _res, next) => {
+      const hasAuth = !!req.headers.authorization;
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${req.method} ${req.url} (auth: ${hasAuth})`);
+      next();
+    });
+  }
+  app.use((req, res, next) => {
+    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));
+  if (options.appDir) serveApp(app, options.appDir, options.shell);
+  const PAIR_OFFER_INTERVAL_MS = 6e4;
+  function offerPairing(req) {
+    if (!options.onUnpaired) return false;
+    const origin = req.headers.origin;
+    if (typeof origin !== "string" || !allowedOrigins.has(origin.replace(/\/+$/, ""))) return false;
+    const now = Date.now();
+    if (pairing && now <= pairing.expiresAt) return false;
+    if (now - lastPairOffer < PAIR_OFFER_INTERVAL_MS) return false;
+    lastPairOffer = now;
+    pairing = { code: randomUUID2(), expiresAt: now + 10 * 60 * 1e3 };
+    options.onUnpaired(pairing, origin);
+    return true;
+  }
+  app.get("/health", async (req, res) => {
+    const body = {
+      success: true,
+      name: "planche",
+      version: options.version,
+      protocolVersion: PROTOCOL_VERSION,
+      activeConnections: manager.activeConnections,
+      uptime: process.uptime()
+    };
+    const ai = await aiConfigView();
+    body.ai = { configured: ai.configured, model: ai.model, tools: true };
+    if (options.install) body.install = options.install;
+    if (options.gateway) body.gateway = { name: options.gateway.name, profiles: options.gateway.profiles.length };
+    if (req.headers.authorization !== void 0) {
+      body.authorized = authorized(req);
+    }
+    if (body.authorized !== true) void offerPairing(req);
+    res.json(body);
+  });
+  app.post("/pair", express.json({ limit: "1kb" }), (req, res) => {
+    if (pairThrottle.locked(peerOf(req))) {
+      fail(res, 429, "Too many failed pairing 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)) {
+      pairThrottle.fail(peerOf(req));
+      const printed = offerPairing(req);
+      fail(res, 401, printed ? "Pairing code is invalid or has expired; a fresh link has been printed in the agent's terminal" : "Pairing code is invalid or has expired; open the pairing link shown in the agent's terminal");
+      return;
+    }
+    pairing = void 0;
+    const body = { success: true, token: options.authToken };
+    res.json(body);
+  });
+  async function mcpAuthorized(req) {
+    if (req.path !== "/mcp") return false;
+    const given = bearerOf(req.headers.authorization);
+    const expected = await readMcpToken();
+    if (!given || !expected) return false;
+    return secretEquals(given, expected);
+  }
+  app.use((req, res, next) => {
+    if (throttle.locked(peerOf(req))) {
+      fail(res, 429, "Too many failed authentication attempts; try again shortly");
+      return;
+    }
+    if (authorized(req)) {
+      next();
+      return;
+    }
+    void mcpAuthorized(req).then((ok) => {
+      if (ok) {
+        next();
+        return;
+      }
+      fail(res, 401, "Unauthorized: invalid or missing auth token");
+    });
+  });
+  app.use(express.json({ limit: options.bodyLimit }));
+  app.get("/profiles", (_req, res) => {
+    if (!options.gateway) {
+      fail(res, 404, "Not a gateway");
+      return;
+    }
+    const body = { success: true, gateway: options.gateway.name, profiles: options.gateway.profiles.map(describeProfile) };
+    res.json(body);
+  });
+  const resolveConnect = (body) => {
+    const b = body ?? {};
+    if (options.gateway) {
+      if (typeof b.profile !== "string") throw Object.assign(new Error("Gateway mode: choose a profile (POST { profile })"), { status: 403 });
+      const entry = options.gateway.profiles.find((p) => p.name === b.profile);
+      if (!entry) throw Object.assign(new Error(`Unknown gateway profile: ${b.profile}`), { status: 404 });
+      return { config: entry.config, readOnly: entry.readOnly };
+    }
+    return { config: parseDriverConfig(b), readOnly: false };
+  };
+  app.post("/connect", async (req, res) => {
+    try {
+      const { config, readOnly } = resolveConnect(req.body);
+      const connectionId = await manager.connect(config, { readOnly });
+      res.json({ success: true, connectionId, message: "Connection Successful" });
+    } catch (err) {
+      const message = errorMessage(err);
+      console.error("[connect] Error:", message);
+      fail(res, errorStatus(err), message, errorExtra(err));
+    }
+  });
+  app.post("/query", async (req, res) => {
+    try {
+      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;
+      }
+      if (!manager.has(connectionId)) {
+        fail(res, 404, `Connection not found: ${connectionId}`);
+        return;
+      }
+      const start = Date.now();
+      const result = await manager.query(connectionId, sql2, typeof database === "string" ? database : void 0);
+      const execTime = Date.now() - start;
+      res.json({
+        success: true,
+        fields: result.fields,
+        records: result.records,
+        affectedRows: result.affectedRows,
+        insertId: result.insertId,
+        isResultQuery: result.isResultQuery,
+        execTime
+      });
+    } catch (err) {
+      const message = errorMessage(err);
+      console.error("[query] Error:", message);
+      if (err instanceof ConnectionLostError) {
+        fail(res, 404, message);
+        return;
+      }
+      fail(res, 422, message);
+    }
+  });
+  app.post("/usage", (req, res) => {
+    const feature = (req.body ?? {}).feature;
+    if (isProFeature(feature)) recordUsage(feature);
+    res.json({ success: true });
+  });
+  app.get("/usage", async (_req, res) => {
+    await flushUsage();
+    res.json(await usageSnapshot());
+  });
+  app.get("/ai/config", async (_req, res) => {
+    res.json({ success: true, ...await aiConfigView() });
+  });
+  app.put("/ai/config", async (req, res) => {
+    const current = await aiConfigView();
+    if (current.fromEnvironment) {
+      fail(res, 409, "This agent's AI settings come from its environment and cannot be changed from the app.");
+      return;
+    }
+    const body = req.body ?? {};
+    const provider = body.provider === "openai" || body.provider === "gemini" || body.provider === "cli" || body.provider === "anthropic-profile" ? body.provider : "anthropic";
+    const keyless = isKeyless(provider);
+    const key = typeof body.key === "string" ? body.key.trim() : "";
+    if (!key && !keyless) {
+      fail(res, 400, "key is required");
+      return;
+    }
+    const model = typeof body.model === "string" && body.model.trim() ? body.model.trim() : defaultModelFor(provider);
+    if (provider === "cli" && !isCliCommand(model)) {
+      fail(res, 400, `model must name an installed CLI: ${CLI_COMMANDS.join(", ")}`);
+      return;
+    }
+    const baseUrl = typeof body.baseUrl === "string" ? body.baseUrl.trim() : "";
+    if (baseUrl && !/^https?:\/\//i.test(baseUrl)) {
+      fail(res, 400, "baseUrl must be an http(s) URL");
+      return;
+    }
+    const written = await saveAiConfig({
+      provider,
+      model,
+      baseUrl: baseUrl || void 0,
+      key
+    }, body.remember === true);
+    console.log(
+      provider === "cli" ? `[agent] AI answers will come from the local "${model}" CLI; no key is held. The choice is kept in ${aiConfigPath}.` : provider === "anthropic-profile" ? `[agent] AI answers will use this machine's own Anthropic credential; no key is held. The choice is kept in ${aiConfigPath}.` : written ? `[agent] AI key saved to ${aiConfigPath} (owner-only). Remove it with "Forget key" in Settings, or by deleting that file.` : "[agent] AI key accepted for this session only; it is not written to disk."
+    );
+    res.json({ success: true, ...await aiConfigView() });
+  });
+  app.delete("/ai/config", async (_req, res) => {
+    await forgetAiConfig();
+    res.json({ success: true, ...await aiConfigView() });
+  });
+  app.post("/ai/run", async (req, res) => {
+    const body = req.body ?? {};
+    const hasTurns = Array.isArray(body.messages) && body.messages.length > 0;
+    const hasUser = typeof body.user === "string" && body.user.trim() !== "";
+    if (typeof body.system !== "string" || !hasTurns && !hasUser) {
+      fail(res, 400, "system and one of user/messages are required");
+      return;
+    }
+    const stop = new AbortController();
+    res.on("close", () => {
+      if (!res.writableFinished) stop.abort();
+    });
+    try {
+      const answer = await runPrompt({
+        system: body.system,
+        ...hasUser ? { user: body.user } : {},
+        ...hasTurns ? { messages: body.messages } : {},
+        ...Array.isArray(body.tools) && body.tools.length > 0 ? { tools: body.tools } : {},
+        model: typeof body.model === "string" ? body.model : void 0
+      }, stop.signal);
+      if (!stop.signal.aborted) res.json(answer);
+    } catch (err) {
+      if (stop.signal.aborted) return;
+      const e = err instanceof AiError ? err : new AiError(502, String(err));
+      fail(res, e.status, e.message);
+    }
+  });
+  app.post("/mcp", async (req, res) => {
+    await handleMcp(req, res);
+  });
+  app.get("/bridge/events", (req, res) => {
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-store",
+      connection: "keep-alive"
+    });
+    res.write(": open\n\n");
+    attachBridge(res);
+  });
+  app.post("/bridge/tools", (req, res) => {
+    const tools2 = req.body?.tools;
+    if (!Array.isArray(tools2)) {
+      fail(res, 400, "tools must be an array");
+      return;
+    }
+    setBridgeTools(tools2);
+    res.json({ success: true });
+  });
+  app.post("/bridge/result", (req, res) => {
+    const { id, content, isError } = req.body ?? {};
+    if (typeof id !== "string") {
+      fail(res, 400, "id is required");
+      return;
+    }
+    resolveBridgeCall(id, typeof content === "string" ? content : "", isError === true);
+    res.json({ success: true });
+  });
+  app.post("/mcp/setup", async (_req, res) => {
+    const url = mcpUrl();
+    if (!url) {
+      fail(res, 503, "The agent is not listening yet.");
+      return;
+    }
+    const body = { success: true, url, token: await ensureMcpToken(), path: mcpTokenPath };
+    console.log(`[agent] MCP token handed to the app; stored at ${mcpTokenPath} (owner-only).`);
+    res.json(body);
+  });
+  app.delete("/mcp/setup", async (_req, res) => {
+    await forgetMcpToken();
+    console.log(`[agent] MCP token revoked; ${mcpTokenPath} removed.`);
+    res.json({ success: true });
+  });
+  app.post("/cancel", async (req, res) => {
+    try {
+      const connectionId = req.body?.connectionId;
+      if (typeof connectionId !== "string" || !connectionId) {
+        fail(res, 400, "connectionId is required");
+        return;
+      }
+      const { cancelled, abandoned } = await manager.cancel(connectionId);
+      const body = {
+        success: true,
+        cancelled,
+        abandoned,
+        message: !cancelled ? "This engine cannot interrupt a running statement" : abandoned ? "Stopped waiting for the request; the query may still finish upstream" : "Cancel sent"
+      };
+      res.json(body);
+    } catch (err) {
+      fail(res, errorStatus(err), errorMessage(err));
+    }
+  });
+  app.post("/disconnect", async (req, res) => {
+    try {
+      const { connectionId } = req.body ?? {};
+      if (typeof connectionId !== "string" || !connectionId) {
+        fail(res, 400, "connectionId is required");
+        return;
+      }
+      if (!manager.has(connectionId)) {
+        fail(res, 404, `Connection not found: ${connectionId}`);
+        return;
+      }
+      await manager.disconnect(connectionId);
+      res.json({ success: true, message: "Disconnected" });
+    } catch (err) {
+      const message = errorMessage(err);
+      console.error("[disconnect] Error:", message);
+      fail(res, 500, message);
+    }
+  });
+  app.post("/test-connection", async (req, res) => {
+    try {
+      await manager.testConnection(resolveConnect(req.body).config);
+      res.json({ success: true, message: "Connection test successful" });
+    } catch (err) {
+      const message = errorMessage(err);
+      console.error("[test-connection] Error:", 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 };
+}
+function serveApp(app, appDir, shell) {
+  const csp = [
+    "default-src 'self'",
+    "script-src 'self' 'wasm-unsafe-eval'",
+    "connect-src 'self'",
+    "img-src 'self' data: blob:",
+    "style-src 'self' 'unsafe-inline'",
+    "font-src 'self' data:",
+    "worker-src 'self' blob:",
+    "child-src 'self' blob:",
+    "object-src 'none'",
+    "base-uri 'none'",
+    "form-action 'none'",
+    "frame-ancestors 'none'"
+  ].join("; ");
+  const indexFile = join9(appDir, "index.html");
+  const indexHtml = existsSync2(indexFile) ? readFileSync2(indexFile, "utf8").replace("<head>", '<head>\n    <meta name="planche-agent" content="same-origin" />' + (shell ? `
+    <meta name="planche-shell" content="${shell}" />` : "")) : null;
+  const headers = (res) => {
+    res.setHeader("Content-Security-Policy", csp);
+    res.setHeader("X-Frame-Options", "DENY");
+    res.setHeader("Referrer-Policy", "no-referrer");
+    res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+  };
+  app.get(["/", "/index.html"], (_req, res) => {
+    if (!indexHtml) {
+      fail(res, 404, "App not bundled");
+      return;
+    }
+    headers(res);
+    res.type("html").send(indexHtml);
+  });
+  app.use(express.static(appDir, {
+    index: false,
+    setHeaders: (res, path) => {
+      if (path.endsWith(".html")) headers(res);
+      if (/\/assets\//.test(path)) res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+    }
+  }));
+}
+
+export {
+  PROTOCOL_VERSION,
+  configureCliBridge,
+  mcpTokenPath,
+  ensureMcpToken,
+  forgetMcpToken,
+  flushUsage,
+  loadGatewayConfig,
+  createAgent
+};