@youtyan/code-viewer 0.7.0 → 0.8.0

package/dist/code-viewer.js

@@ -10340,6 +10340,42 @@ function throwIfAborted(signal, message = "operation aborted") {
   if (signal?.aborted)
     throw abortError(message);
 }
+function waitForAbortableResource(promise, signal, dispose, message = "operation aborted") {
+  const disposeSafely = (resource) => {
+    try {
+      dispose(resource);
+    } catch {}
+  };
+  if (!signal)
+    return promise;
+  if (signal.aborted) {
+    promise.then(disposeSafely, () => {
+      return;
+    });
+    return Promise.reject(abortError(message));
+  }
+  return new Promise((resolve2, reject) => {
+    let aborted = false;
+    const onAbort = () => {
+      aborted = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError(message));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((resource) => {
+      signal.removeEventListener("abort", onAbort);
+      if (aborted) {
+        disposeSafely(resource);
+        return;
+      }
+      resolve2(resource);
+    }, (error) => {
+      signal.removeEventListener("abort", onAbort);
+      if (!aborted)
+        reject(error);
+    });
+  });
+}
 function isAbortLikeError(err, signal, extraTokens = []) {
   if (signal?.aborted)
     return true;
@@ -10796,6 +10832,8 @@ var init_sql_capture = __esm(() => {
 
 // web-src/server/database/adapters/docker.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
+import mysql from "mysql2/promise";
+import pg from "pg";
 function dockerDatabasesCacheKey(serviceName, kind, cwd) {
   return `${serviceName}\x00${kind}\x00${cwd}`;
 }
@@ -10821,55 +10859,211 @@ function setDockerSchemasCache(key, value, ttlMs, now = Date.now()) {
 function fallbackDockerDatabases(defaultDb) {
   return defaultDb ? [defaultDb] : [];
 }
-function buildExecArgs(config, sql) {
+function buildExecInvocation(config, sql) {
+  if (!config.containerName) {
+    throw new Error("direct SQL connections use the built-in driver");
+  }
   if (config.kind === "postgresql") {
-    return [
+    return {
+      args: [
+        dockerCommand(),
+        "exec",
+        "-i",
+        "-e",
+        `PGPASSWORD=${config.password}`,
+        config.containerName,
+        "psql",
+        "-U",
+        config.user,
+        "-d",
+        config.database,
+        "-X",
+        "-q",
+        "-t",
+        "-A",
+        "-F",
+        "\t",
+        "-R",
+        PG_RECORD_SEPARATOR,
+        "-v",
+        "ON_ERROR_STOP=1",
+        "-c",
+        sql
+      ],
+      env: process.env
+    };
+  }
+  return {
+    args: [
       dockerCommand(),
       "exec",
       "-i",
       "-e",
-      `PGPASSWORD=${config.password}`,
+      `MYSQL_PWD=${config.password}`,
       config.containerName,
-      "psql",
-      "-U",
+      "mysql",
+      "-u",
       config.user,
-      "-d",
       config.database,
-      "-X",
-      "-q",
-      "-t",
-      "-A",
-      "-F",
-      "\t",
-      "-R",
-      PG_RECORD_SEPARATOR,
-      "-v",
-      "ON_ERROR_STOP=1",
-      "-c",
+      "--batch",
+      "--default-character-set=utf8mb4",
+      "-e",
       sql
-    ];
+    ],
+    env: process.env
+  };
+}
+function sqlDriverValue(value, nullValue) {
+  if (value === null || value === undefined)
+    return nullValue;
+  if (value instanceof Date)
+    return value.toISOString();
+  if (value instanceof Uint8Array)
+    return Buffer.from(value).toString("hex");
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function pgDriverResult(raw) {
+  const results = Array.isArray(raw) ? raw : [raw];
+  const reversed = [...results].reverse();
+  const result = reversed.find((item) => !!item && typeof item === "object" && Array.isArray(item.fields) && item.fields.length > 0) ?? reversed.find((item) => !!item && typeof item === "object" && Array.isArray(item.rows) && item.rows.length > 0) ?? raw;
+  if (!result || typeof result !== "object")
+    return { columns: [], rows: [] };
+  const fields = Array.isArray(result.fields) ? result.fields : [];
+  const rows = Array.isArray(result.rows) ? result.rows : [];
+  return {
+    columns: fields.map((field) => String(field.name ?? "")),
+    rows: rows.map((row) => row.map((value) => sqlDriverValue(value, "\\N")))
+  };
+}
+function mysqlDriverResult(raw) {
+  if (!Array.isArray(raw) || raw.length < 2)
+    return { columns: [], rows: [] };
+  const [allRows, allFields] = raw;
+  let rows = allRows;
+  let fields = allFields;
+  if (Array.isArray(allFields) && allFields.length > 0 && Array.isArray(allFields[0])) {
+    const fieldSets = allFields;
+    const rowSets = Array.isArray(allRows) ? allRows : [];
+    let index = -1;
+    for (let i = fieldSets.length - 1;i >= 0; i--) {
+      if (Array.isArray(fieldSets[i])) {
+        index = i;
+        break;
+      }
+    }
+    fields = index >= 0 ? fieldSets[index] : [];
+    rows = index >= 0 ? rowSets[index] : [];
   }
-  return [
-    dockerCommand(),
-    "exec",
-    "-i",
-    "-e",
-    `MYSQL_PWD=${config.password}`,
-    config.containerName,
-    "mysql",
-    "-u",
-    config.user,
-    config.database,
-    "--batch",
-    "--default-character-set=utf8mb4",
-    "-e",
-    sql
-  ];
+  const fieldList = Array.isArray(fields) ? fields.filter(Boolean) : [];
+  const rowList = Array.isArray(rows) ? rows : [];
+  return {
+    columns: fieldList.map((field) => String(field.name ?? "")),
+    rows: rowList.map((row) => row.map((value) => sqlDriverValue(value, "NULL")))
+  };
+}
+function createSqlDriverExecutor(config) {
+  if (!config.host || !config.port) {
+    throw new Error("direct SQL connection requires host and port");
+  }
+  if (config.kind === "postgresql") {
+    const pool2 = createPgPoolImpl({
+      host: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+      ssl: config.tls,
+      max: 4,
+      connectionTimeoutMillis: 1e4,
+      query_timeout: 1e4
+    });
+    return {
+      async exec(sql, signal) {
+        throwIfAborted(signal, "query aborted");
+        const client = await waitForAbortableResource(pool2.connect(), signal, (lateClient) => lateClient.release(true), "query aborted");
+        let released = false;
+        const abort = () => {
+          if (released)
+            return;
+          released = true;
+          client.release(true);
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+        try {
+          throwIfAborted(signal, "query aborted");
+          return pgDriverResult(await client.query({ text: sql, rowMode: "array" }));
+        } catch (error) {
+          if (signal?.aborted)
+            throw abortError("query aborted");
+          throw error;
+        } finally {
+          signal?.removeEventListener("abort", abort);
+          if (!released)
+            client.release();
+        }
+      },
+      close() {
+        pool2.end().catch(() => {
+          return;
+        });
+      }
+    };
+  }
+  const pool = createMysqlPoolImpl({
+    host: config.host,
+    port: config.port,
+    user: config.user,
+    password: config.password,
+    database: config.database,
+    ssl: config.tls ? {} : undefined,
+    waitForConnections: true,
+    connectionLimit: 4,
+    connectTimeout: 1e4,
+    multipleStatements: true,
+    rowsAsArray: true,
+    supportBigNumbers: true,
+    bigNumberStrings: true,
+    dateStrings: true
+  });
+  return {
+    async exec(sql, signal) {
+      throwIfAborted(signal, "query aborted");
+      const connection = await waitForAbortableResource(pool.getConnection(), signal, (lateConnection) => lateConnection.destroy(), "query aborted");
+      let released = false;
+      const abort = () => {
+        if (released)
+          return;
+        released = true;
+        connection.destroy();
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      try {
+        throwIfAborted(signal, "query aborted");
+        return mysqlDriverResult(await connection.query({ sql, rowsAsArray: true, timeout: 1e4 }));
+      } catch (error) {
+        if (signal?.aborted)
+          throw abortError("query aborted");
+        throw error;
+      } finally {
+        signal?.removeEventListener("abort", abort);
+        if (!released)
+          connection.release();
+      }
+    },
+    close() {
+      pool.end().catch(() => {
+        return;
+      });
+    }
+  };
 }
 function execInContainer(config, sql, timeoutMs = 1e4) {
-  const args = buildExecArgs(config, sql);
+  const { args, env } = buildExecInvocation(config, sql);
   const proc = spawnSyncImpl2(args[0], args.slice(1), {
     encoding: "utf8",
+    env,
     timeout: timeoutMs,
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -10895,11 +11089,12 @@ async function readStreamText(stream) {
   text += decoder.decode();
   return text;
 }
-async function execWithBunSpawn(spawnFn, args, timeoutMs, signal) {
+async function execWithBunSpawn(spawnFn, args, env, timeoutMs, signal) {
   throwIfAborted(signal, "query aborted");
   let proc;
   try {
     proc = spawnFn(args, {
+      env,
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe"
@@ -10946,10 +11141,11 @@ async function execWithBunSpawn(spawnFn, args, timeoutMs, signal) {
     signal?.removeEventListener("abort", abort);
   }
 }
-function execWithNodeSpawn(args, timeoutMs, signal) {
+function execWithNodeSpawn(args, env, timeoutMs, signal) {
   return spawnTextAsync({
     command: args[0],
     args: args.slice(1),
+    env,
     timeoutMs,
     signal,
     killSignal: "SIGKILL",
@@ -10966,10 +11162,11 @@ async function execInContainerAsync(config, sql, timeoutMs = 1e4, signal) {
     throwIfDockerCommandUnavailableResult(result);
     return result;
   }
-  const args = buildExecArgs(config, sql);
+  const { args, env } = buildExecInvocation(config, sql);
   const bunSpawn = globalThis.Bun?.spawn;
-  result = bunSpawn ? await execWithBunSpawn(bunSpawn, args, timeoutMs, signal) : await execWithNodeSpawn(args, timeoutMs, signal);
-  throwIfDockerCommandUnavailableResult(result);
+  result = bunSpawn ? await execWithBunSpawn(bunSpawn, args, env, timeoutMs, signal) : await execWithNodeSpawn(args, env, timeoutMs, signal);
+  if (config.containerName)
+    throwIfDockerCommandUnavailableResult(result);
   return result;
 }
 function stripFinalLineBreak(text) {
@@ -11107,8 +11304,13 @@ function observeBackgroundRejection(promise) {
   });
   return promise;
 }
-function createDockerAdapter(config) {
+function createSqlCliAdapter(config) {
+  const driver = config.containerName ? null : createSqlDriverExecutor(config);
   async function execAsync(sql, signal) {
+    if (driver) {
+      recordSql(sql);
+      return driver.exec(sql, signal);
+    }
     const result = await execInContainerAsync(config, sql, 1e4, signal);
     if (result.code !== 0) {
       throw new Error(result.stderr.trim() || "query failed");
@@ -11544,6 +11746,7 @@ function createDockerAdapter(config) {
     close() {
       columnCache.clear();
       tableMetaCache.invalidate();
+      driver?.close();
     },
     async* iterateForSnapshot(table, signal) {
       const columns = await adapter.getColumnsAsync(table, signal);
@@ -11713,7 +11916,7 @@ async function openDockerAdapterAsync(serviceName, kind, env, cwd, overrideDatab
     ...kind === "postgresql" && schema ? { schema } : {}
   });
 }
-var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES, SUPABASE_LOCAL_DB_USER = "postgres", SUPABASE_LOCAL_DB_PASSWORD = "postgres", SUPABASE_LOCAL_DB_NAME = "postgres";
+var createPgPoolImpl = (config) => new pg.Pool(config), createMysqlPoolImpl = (config) => mysql.createPool(config), COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES, createDockerAdapter, SUPABASE_LOCAL_DB_USER = "postgres", SUPABASE_LOCAL_DB_PASSWORD = "postgres", SUPABASE_LOCAL_DB_NAME = "postgres";
 var init_docker = __esm(() => {
   init_mutate();
   init_sql_snapshot();
@@ -11735,6 +11938,7 @@ var init_docker = __esm(() => {
     "geometrycollection",
     "geomcollection"
   ]);
+  createDockerAdapter = createSqlCliAdapter;
 });
 
 // web-src/server/database/adapters/elasticsearch.ts
@@ -11743,8 +11947,13 @@ __export(exports_elasticsearch, {
   quoteCurlConfigString: () => quoteCurlConfigString,
   openElasticsearchAdapterAsync: () => openElasticsearchAdapterAsync,
   isReadOnlyEsPath: () => isReadOnlyEsPath,
-  canonicalizeEsSnapshotContainer: () => canonicalizeEsSnapshotContainer
+  createElasticsearchAdapter: () => createElasticsearchAdapter,
+  canonicalizeEsSnapshotContainer: () => canonicalizeEsSnapshotContainer,
+  __setEsFetchForTest: () => __setEsFetchForTest
 });
+function __setEsFetchForTest(fetchForTest) {
+  esFetchImpl = fetchForTest ?? globalThis.fetch;
+}
 function isReadOnlyEsPath(rawPath) {
   const path = rawPath.split("?")[0].replace(/\/+$/, "");
   const segments = path.split("/").filter(Boolean);
@@ -11764,13 +11973,11 @@ function quoteCurlConfigString(value) {
 }
 function buildEsRequestInvocation(config, method, path, body) {
   const hasPassword = !!config.password;
-  const url = `http://localhost:9200${path.startsWith("/") ? "" : "/"}${path}`;
-  const curlConfig = hasPassword ? `user = ${quoteCurlConfigString(`elastic:${config.password}`)}
+  const endpoint = config.endpoint?.replace(/\/$/, "") || "http://localhost:9200";
+  const url = `${endpoint}${path.startsWith("/") ? "" : "/"}${path}`;
+  const curlConfig = hasPassword ? `user = ${quoteCurlConfigString(`${config.username || "elastic"}:${config.password}`)}
 ` : undefined;
-  const args = [
-    "exec",
-    "-i",
-    config.containerName,
+  const curlArgs = [
     "curl",
     "-s",
     "-S",
@@ -11786,13 +11993,64 @@ __ES_STATUS__:%{http_code}
     ...hasPassword ? ["-K", "-"] : [],
     ...body !== undefined ? ["--data-binary", JSON.stringify(body)] : []
   ];
-  return { args, input: curlConfig };
+  if (!config.containerName) {
+    throw new Error("direct Elasticsearch connections use the built-in HTTP client");
+  }
+  return {
+    command: dockerCommand(),
+    args: ["exec", "-i", config.containerName, ...curlArgs],
+    input: curlConfig
+  };
 }
 async function execEsRequestAsync(config, method, path, body, timeoutMs = 15000, signal) {
   throwIfAborted(signal, "elasticsearch request aborted");
+  if (!config.containerName) {
+    const endpoint = config.endpoint?.replace(/\/$/, "") || "http://localhost:9200";
+    const url = `${endpoint}${path.startsWith("/") ? "" : "/"}${path}`;
+    const controller = new AbortController;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const abort = () => controller.abort();
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+      const headers = new Headers({ "Content-Type": "application/json" });
+      if (config.password) {
+        headers.set("Authorization", `Basic ${Buffer.from(`${config.username || "elastic"}:${config.password}`).toString("base64")}`);
+      }
+      const response = await esFetchImpl(url, {
+        method,
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: controller.signal,
+        redirect: "error"
+      });
+      const text = await response.text();
+      return {
+        code: 0,
+        stdout: `${text}
+__ES_STATUS__:${response.status}
+`,
+        stderr: ""
+      };
+    } catch (error) {
+      if (signal?.aborted)
+        throw new Error("elasticsearch request aborted");
+      return {
+        code: 1,
+        stdout: "",
+        stderr: timedOut ? `elasticsearch request timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error)
+      };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
   const invocation = buildEsRequestInvocation(config, method, path, body);
   const result = await spawnTextAsync({
-    command: dockerCommand(),
+    command: invocation.command,
     args: invocation.args,
     env: process.env,
     input: invocation.input,
@@ -11802,7 +12060,8 @@ async function execEsRequestAsync(config, method, path, body, timeoutMs = 15000,
     timeoutMessage: `elasticsearch request timed out after ${timeoutMs}ms`,
     rejectOnError: false
   });
-  throwIfDockerCommandUnavailableResult(result);
+  if (config.containerName)
+    throwIfDockerCommandUnavailableResult(result);
   return result;
 }
 function parseEsResponse(stdout) {
@@ -11829,7 +12088,7 @@ function createElasticsearchAdapter(config) {
   async function callJsonAsync(method, path, body, label, signal) {
     const r = await execEsRequestAsync(config, method, path, body, 15000, signal);
     if (r.code !== 0) {
-      throw new Error(r.stderr.trim() || `${label}: curl exit ${r.code}`);
+      throw new Error(r.stderr.trim() || `${label}: request failed`);
     }
     const { status, body: text } = parseEsResponse(r.stdout);
     if (status < 200 || status >= 300) {
@@ -11914,7 +12173,7 @@ function createElasticsearchAdapter(config) {
     }
     const r = await execEsRequestAsync(config, "GET", `/${encodeURIComponent(opts.index)}/_doc/${encodeURIComponent(opts.id)}`, undefined, 15000, opts.signal);
     if (r.code !== 0) {
-      throw new Error(r.stderr.trim() || `_doc: curl exit ${r.code}`);
+      throw new Error(r.stderr.trim() || "_doc: request failed");
     }
     const { status, body: text } = parseEsResponse(r.stdout);
     if (status === 404) {
@@ -12013,7 +12272,7 @@ function createElasticsearchAdapter(config) {
     const r = await execEsRequestAsync(config, input.method, input.path, input.body, 15000, signal);
     const elapsedMs = Date.now() - start;
     if (r.code !== 0) {
-      throw new Error(r.stderr.trim() || `query: curl exit ${r.code}`);
+      throw new Error(r.stderr.trim() || "query: request failed");
     }
     const { status, body: text } = parseEsResponse(r.stdout);
     let body = text;
@@ -12099,10 +12358,11 @@ async function openElasticsearchAdapterAsync(serviceName, env, cwd, signal) {
   const password = env.ELASTIC_PASSWORD || "";
   return createElasticsearchAdapter({ containerName, password });
 }
-var ES_QUERY_ALLOWED_SUBPATHS, ES_DEFAULT_SIZE = 200;
+var esFetchImpl, ES_QUERY_ALLOWED_SUBPATHS, ES_DEFAULT_SIZE = 200;
 var init_elasticsearch = __esm(() => {
   init_docker_utils();
   init_spawn_runner();
+  esFetchImpl = globalThis.fetch;
   ES_QUERY_ALLOWED_SUBPATHS = new Set([
     "_search",
     "_count",
@@ -12119,9 +12379,14 @@ var exports_redis = {};
 __export(exports_redis, {
   openRedisExplorerAsync: () => openRedisExplorerAsync,
   createRedisAdapter: () => createRedisAdapter,
-  canonicalizeRedisSnapshotContainer: () => canonicalizeRedisSnapshotContainer
+  canonicalizeRedisSnapshotContainer: () => canonicalizeRedisSnapshotContainer,
+  __setRedisClientFactoryForTest: () => __setRedisClientFactoryForTest
 });
 import { createHash as createHash3 } from "node:crypto";
+import { createClient } from "@redis/client";
+function __setRedisClientFactoryForTest(factory) {
+  createRedisClientImpl = factory ?? ((options) => createClient(options));
+}
 function canonicalizeRedisSnapshotContainer(container) {
   const { db, pattern } = parseSnapshotContainer(container);
   return JSON.stringify({ db, pattern });
@@ -12139,20 +12404,25 @@ function parseSnapshotContainer(container) {
 }
 function buildRedisCliInvocation(config, args) {
   const hasPassword = !!config.password;
-  const dockerArgs = [
-    "exec",
-    "-i",
-    ...hasPassword ? ["-e", "REDISCLI_AUTH"] : [],
-    config.containerName,
-    "redis-cli",
-    "-3",
-    ...args
-  ];
   const spawnEnv = hasPassword ? { ...process.env, REDISCLI_AUTH: config.password } : process.env;
-  return { args: dockerArgs, env: spawnEnv };
+  if (!config.containerName) {
+    throw new Error("direct Redis connections use the built-in driver");
+  }
+  return {
+    args: [
+      "exec",
+      "-i",
+      ...hasPassword ? ["-e", "REDISCLI_AUTH"] : [],
+      config.containerName,
+      "redis-cli",
+      "-3",
+      ...args
+    ],
+    env: spawnEnv
+  };
 }
-async function execRedisCliAsync(config, args, timeoutMs = 1e4, signal) {
-  throwIfAborted(signal, "redis-cli aborted");
+async function execRedisCliProcessAsync(config, args, timeoutMs = 1e4, signal) {
+  throwIfAborted(signal, "redis request aborted");
   const invocation = buildRedisCliInvocation(config, args);
   const result = await spawnTextAsync({
     command: dockerCommand(),
@@ -12160,13 +12430,115 @@ async function execRedisCliAsync(config, args, timeoutMs = 1e4, signal) {
     env: invocation.env,
     timeoutMs,
     signal,
-    abortMessage: "redis-cli aborted",
-    timeoutMessage: `redis-cli timed out after ${timeoutMs}ms`,
+    abortMessage: "redis request aborted",
+    timeoutMessage: `redis request timed out after ${timeoutMs}ms`,
     rejectOnError: false
   });
-  throwIfDockerCommandUnavailableResult(result);
+  if (config.containerName)
+    throwIfDockerCommandUnavailableResult(result);
   return result;
 }
+function redisReplyText(reply) {
+  if (reply === null || reply === undefined)
+    return "";
+  if (reply instanceof Uint8Array)
+    return Buffer.from(reply).toString("utf8");
+  if (Array.isArray(reply))
+    return JSON.stringify(reply);
+  if (typeof reply === "object")
+    return JSON.stringify(reply);
+  return String(reply);
+}
+function createRedisDriverExecutor(config) {
+  if (!config.host || !config.port) {
+    throw new Error("direct Redis connection requires host and port");
+  }
+  const clients = new Map;
+  function clientForDatabase(database) {
+    const existing = clients.get(database);
+    if (existing)
+      return existing;
+    const socket = config.tls ? {
+      host: config.host,
+      port: config.port,
+      tls: true,
+      connectTimeout: 1e4
+    } : {
+      host: config.host,
+      port: config.port,
+      connectTimeout: 1e4
+    };
+    const client = createRedisClientImpl({
+      username: config.username || undefined,
+      password: config.password || undefined,
+      database,
+      socket
+    });
+    client.on("error", () => {});
+    const entry = { client, connected: client.connect() };
+    clients.set(database, entry);
+    return entry;
+  }
+  return {
+    async exec(args, timeoutMs = 1e4, signal) {
+      throwIfAborted(signal, "redis request aborted");
+      let database = 0;
+      let command = args;
+      if (args[0] === "-n" && args.length >= 3) {
+        database = Number(args[1]) || 0;
+        command = args.slice(2);
+      }
+      const entry = clientForDatabase(database);
+      let connectDisposed = false;
+      const disposeConnectingClient = () => {
+        if (connectDisposed)
+          return;
+        connectDisposed = true;
+        if (clients.get(database) === entry)
+          clients.delete(database);
+        entry.client.destroy();
+      };
+      const abortConnect = () => disposeConnectingClient();
+      signal?.addEventListener("abort", abortConnect, { once: true });
+      const timeoutController = new AbortController;
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        timeoutController.abort();
+      }, timeoutMs);
+      const abort = () => timeoutController.abort();
+      signal?.addEventListener("abort", abort, { once: true });
+      let connected = false;
+      try {
+        await waitForAbortableResource(entry.connected.then(() => entry.client), signal, disposeConnectingClient, "redis request aborted");
+        connected = true;
+        signal?.removeEventListener("abort", abortConnect);
+        throwIfAborted(signal, "redis request aborted");
+        const reply = await entry.client.withAbortSignal(timeoutController.signal).sendCommand(command);
+        return { stdout: redisReplyText(reply), stderr: "", code: 0 };
+      } catch (error) {
+        if (!connected)
+          disposeConnectingClient();
+        if (signal?.aborted)
+          throw abortError("redis request aborted");
+        return {
+          stdout: "",
+          stderr: timedOut ? `redis request timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error),
+          code: 1
+        };
+      } finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abortConnect);
+        signal?.removeEventListener("abort", abort);
+      }
+    },
+    close() {
+      for (const { client } of clients.values())
+        client.destroy();
+      clients.clear();
+    }
+  };
+}
 function parseInfoKeyspace(stdout) {
   const counts = new Map;
   for (const line of stdout.split(/\r?\n/)) {
@@ -12201,6 +12573,8 @@ function decodeHexItem(hex) {
   return { binaryBase64: buf.toString("base64") };
 }
 function createRedisAdapter(config) {
+  const driver = config.containerName ? null : createRedisDriverExecutor(config);
+  const execRedisCliAsync = (_config, args, timeoutMs = 1e4, signal) => driver ? driver.exec(args, timeoutMs, signal) : execRedisCliProcessAsync(config, args, timeoutMs, signal);
   function parseDatabasesResult(result) {
     if (result.code !== 0) {
       throw new Error(result.stderr.trim() || "INFO keyspace failed");
@@ -12691,7 +13065,9 @@ function createRedisAdapter(config) {
     deleteKeyAsync,
     iterateForSnapshot,
     listSnapshotContainers,
-    close() {}
+    close() {
+      driver?.close();
+    }
   };
 }
 async function openRedisExplorerAsync(serviceName, env, cwd, signal) {
@@ -12699,7 +13075,7 @@ async function openRedisExplorerAsync(serviceName, env, cwd, signal) {
   const password = env.REDIS_PASSWORD || "";
   return createRedisAdapter({ containerName, password });
 }
-var DEFAULT_DATABASES = 16, REDIS_STRING_BYTE_LIMIT = 65536, REDIS_COLLECTION_LIMIT = 200, SCAN_WITH_TYPES_LUA = `local s = redis.call('SCAN', ARGV[1], 'MATCH', ARGV[2], 'COUNT', ARGV[3]); local types = {}; for i, k in ipairs(s[2]) do types[i] = redis.call('TYPE', k).ok end; return cjson.encode({cursor=s[1], keys=s[2], types=types})`, LUA_TOHEX_PRELUDE = `local function tohex(s) local t = {} for i = 1, #s do t[i] = string.format('%02x', string.byte(s, i)) end return table.concat(t) end`, TYPE_OR_STRING_LUA, LUA_HEX_KEY_PRELUDE = `local function tohex(s) local t = {} for i = 1, #s do t[i] = string.format('%02x', string.byte(s, i)) end return table.concat(t) end local function fromhex(h) local b = {} for i = 1, #h, 2 do b[#b+1] = string.char(tonumber(string.sub(h, i, i+1), 16)) end return table.concat(b) end`, SCAN_HEX_KEYS_LUA;
+var createRedisClientImpl = (options) => createClient(options), DEFAULT_DATABASES = 16, REDIS_STRING_BYTE_LIMIT = 65536, REDIS_COLLECTION_LIMIT = 200, SCAN_WITH_TYPES_LUA = `local s = redis.call('SCAN', ARGV[1], 'MATCH', ARGV[2], 'COUNT', ARGV[3]); local types = {}; for i, k in ipairs(s[2]) do types[i] = redis.call('TYPE', k).ok end; return cjson.encode({cursor=s[1], keys=s[2], types=types})`, LUA_TOHEX_PRELUDE = `local function tohex(s) local t = {} for i = 1, #s do t[i] = string.format('%02x', string.byte(s, i)) end return table.concat(t) end`, TYPE_OR_STRING_LUA, LUA_HEX_KEY_PRELUDE = `local function tohex(s) local t = {} for i = 1, #s do t[i] = string.format('%02x', string.byte(s, i)) end return table.concat(t) end local function fromhex(h) local b = {} for i = 1, #h, 2 do b[#b+1] = string.char(tonumber(string.sub(h, i, i+1), 16)) end return table.concat(b) end`, SCAN_HEX_KEYS_LUA;
 var init_redis = __esm(() => {
   init_docker_utils();
   init_spawn_runner();
@@ -15779,185 +16155,33 @@ function asAsyncDoc(source) {
   };
 }
 
-// web-src/server/database/connection-pool.ts
-function setAdapterFactory(f) {
-  factory = f;
+// web-src/server/database/adapters/dynamodb.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { createHash as createHash5, createHmac as createHmac2 } from "node:crypto";
+function createDynamoDbRequestDeadline() {
+  const timeoutMs = dynamoDbRequestTimeoutMs;
+  return { expiresAt: Date.now() + timeoutMs, timeoutMs };
 }
-function evictOldest() {
-  let oldestKey = null;
-  let oldestTime = Infinity;
-  for (const [key, entry] of pool) {
-    if (entry.lastUsed < oldestTime) {
-      oldestTime = entry.lastUsed;
-      oldestKey = key;
-    }
-  }
-  if (oldestKey) {
-    const entry = pool.get(oldestKey);
-    if (entry) {
-      clearTimeout(entry.timer);
-      try {
-        entry.adapter.close();
-      } catch {}
-      pool.delete(oldestKey);
-    }
-  }
+function createDynamoDbDockerCurlDeadline() {
+  const timeoutMs = dynamoDbDockerCurlTimeoutMs;
+  return { expiresAt: Date.now() + timeoutMs, timeoutMs };
 }
-function scheduleEviction(key, entry) {
-  clearTimeout(entry.timer);
-  entry.timer = setTimeout(() => {
-    const current = pool.get(key);
-    if (current === entry) {
-      try {
-        current.adapter.close();
-      } catch {}
-      pool.delete(key);
-    }
-  }, IDLE_TIMEOUT_MS);
+function createDynamoDbTransportDeadline(config) {
+  return config.dockerContainerName ? createDynamoDbDockerCurlDeadline() : createDynamoDbRequestDeadline();
 }
-async function getConnection(resolvedPath) {
-  if (!factory) {
-    throw new Error("No adapter factory configured");
-  }
-  const existing = pool.get(resolvedPath);
-  if (existing) {
-    existing.lastUsed = Date.now();
-    scheduleEviction(resolvedPath, existing);
-    return existing.adapter;
-  }
-  if (pool.size >= MAX_CONNECTIONS) {
-    evictOldest();
-  }
-  const adapter = await factory.open(resolvedPath);
-  const entry = {
-    adapter,
-    path: resolvedPath,
-    lastUsed: Date.now(),
-    timer: setTimeout(() => {
-      return;
-    }, 0)
-  };
-  pool.set(resolvedPath, entry);
-  scheduleEviction(resolvedPath, entry);
-  return adapter;
+function dynamoDbTimeoutError(deadline) {
+  return new DynamoDbHttpError(503, `DynamoDB request timed out after ${deadline?.timeoutMs ?? dynamoDbRequestTimeoutMs}ms`);
 }
-function closeConnection(resolvedPath) {
-  const entry = pool.get(resolvedPath);
-  if (!entry)
-    return false;
-  clearTimeout(entry.timer);
-  try {
-    entry.adapter.close();
-  } catch {}
-  pool.delete(resolvedPath);
-  return true;
+function remainingDynamoDbTimeoutMs(deadline) {
+  if (!deadline)
+    return dynamoDbRequestTimeoutMs;
+  return Math.max(0, deadline.expiresAt - Date.now());
 }
-var MAX_CONNECTIONS = 8, IDLE_TIMEOUT_MS, pool, factory = null;
-var init_connection_pool = __esm(() => {
-  IDLE_TIMEOUT_MS = 5 * 60 * 1000;
-  pool = new Map;
-});
-
-// web-src/server/database/global-search.ts
-function isTextLikeType(type) {
-  const upper = type.toUpperCase();
-  return upper.includes("CHAR") || upper.includes("TEXT") || upper.includes("VARCHAR") || upper.includes("CLOB") || upper.includes("STRING") || upper === "JSON" || upper === "JSONB" || upper === "XML" || upper === "UUID";
+function hmac2(key, value) {
+  return createHmac2("sha256", key).update(value, "utf8").digest();
 }
-function escapeLikeTerm(term) {
-  return term.replace(/=/g, "==").replace(/%/g, "=%").replace(/_/g, "=_");
-}
-async function searchTableAsync(adapter, table, columns, term, maxHits, includeNonText, pkColumns, signal) {
-  const kind = adapter.kind;
-  const searchCols = includeNonText ? columns.filter((c) => c.type.toUpperCase() !== "BLOB" && c.type.toUpperCase() !== "BYTEA") : columns.filter((c) => isTextLikeType(c.type));
-  if (searchCols.length === 0)
-    return [];
-  const escapedTerm = escapeLikeTerm(term);
-  const tbl = sanitizeIdentifier(table, kind);
-  const hits = [];
-  const db = asAsync(adapter);
-  for (const col of searchCols) {
-    if (signal?.aborted)
-      break;
-    if (hits.length >= maxHits)
-      break;
-    const colId = sanitizeIdentifier(col.name, kind);
-    const castCol = kind === "mysql" ? `CAST(${colId} AS CHAR)` : `CAST(${colId} AS TEXT)`;
-    let sql;
-    const remaining = maxHits - hits.length;
-    if (kind === "sqlite") {
-      sql = `SELECT * FROM ${tbl} WHERE ${castCol} LIKE ? ESCAPE '='`;
-    } else {
-      const likeVal = escapeSqlString(`%${escapedTerm}%`);
-      sql = `SELECT * FROM ${tbl} WHERE ${castCol} LIKE ${likeVal} ESCAPE '='`;
-    }
-    try {
-      const params = kind === "sqlite" ? [`%${escapedTerm}%`] : undefined;
-      const result = await db.readonlyQuery(sql, params, remaining, signal);
-      for (const row of result.rows) {
-        const colIdx = result.columns.indexOf(col.name);
-        const valueRaw = colIdx >= 0 ? serializeDbValue(row[colIdx]) : null;
-        const valueStr = valueRaw == null ? "" : String(valueRaw);
-        const preview = valueStr.length > 200 ? `${valueStr.slice(0, 200)}...` : valueStr;
-        let rowKeyJson;
-        if (pkColumns.length > 0) {
-          const keyObj = {};
-          for (const pk of pkColumns) {
-            const pkIdx = result.columns.indexOf(pk);
-            if (pkIdx >= 0)
-              keyObj[pk] = serializeDbValue(row[pkIdx]);
-          }
-          rowKeyJson = JSON.stringify(keyObj);
-        }
-        hits.push({
-          table,
-          column: col.name,
-          rowKeyJson,
-          valuePreview: preview,
-          rowPreview: serializeDbRow(row)
-        });
-      }
-    } catch (err) {
-      if (isAbortLikeError(err, signal))
-        throw err;
-    }
-  }
-  return hits;
-}
-function getPrimaryKeyColumnsFromColumns(columns) {
-  return columns.filter((c) => c.primaryKey).map((c) => c.name);
-}
-var init_global_search = __esm(() => {
-  init_serialize();
-  init_sql_utils();
-});
-
-// web-src/server/database/adapters/dynamodb.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
-import { createHash as createHash5, createHmac as createHmac2 } from "node:crypto";
-function createDynamoDbRequestDeadline() {
-  const timeoutMs = dynamoDbRequestTimeoutMs;
-  return { expiresAt: Date.now() + timeoutMs, timeoutMs };
-}
-function createDynamoDbDockerCurlDeadline() {
-  const timeoutMs = dynamoDbDockerCurlTimeoutMs;
-  return { expiresAt: Date.now() + timeoutMs, timeoutMs };
-}
-function createDynamoDbTransportDeadline(config) {
-  return config.dockerContainerName ? createDynamoDbDockerCurlDeadline() : createDynamoDbRequestDeadline();
-}
-function dynamoDbTimeoutError(deadline) {
-  return new DynamoDbHttpError(503, `DynamoDB request timed out after ${deadline?.timeoutMs ?? dynamoDbRequestTimeoutMs}ms`);
-}
-function remainingDynamoDbTimeoutMs(deadline) {
-  if (!deadline)
-    return dynamoDbRequestTimeoutMs;
-  return Math.max(0, deadline.expiresAt - Date.now());
-}
-function hmac2(key, value) {
-  return createHmac2("sha256", key).update(value, "utf8").digest();
-}
-function sha2562(value) {
-  return createHash5("sha256").update(value, "utf8").digest("hex");
+function sha2562(value) {
+  return createHash5("sha256").update(value, "utf8").digest("hex");
 }
 function amzDate2(date = new Date) {
   const iso = date.toISOString().replace(/[:-]|\.\d{3}/g, "");
@@ -16393,6 +16617,416 @@ var init_dynamodb = __esm(() => {
   dynamoDbDockerCurlTimeoutMs = DEFAULT_DYNAMODB_DOCKER_CURL_TIMEOUT_MS;
 });
 
+// web-src/server/database/connection-pool.ts
+function setAdapterFactory(f) {
+  factory = f;
+}
+function evictOldest() {
+  let oldestKey = null;
+  let oldestTime = Infinity;
+  for (const [key, entry] of pool) {
+    if (entry.lastUsed < oldestTime) {
+      oldestTime = entry.lastUsed;
+      oldestKey = key;
+    }
+  }
+  if (oldestKey) {
+    const entry = pool.get(oldestKey);
+    if (entry) {
+      clearTimeout(entry.timer);
+      try {
+        entry.adapter.close();
+      } catch {}
+      pool.delete(oldestKey);
+    }
+  }
+}
+function scheduleEviction(key, entry) {
+  clearTimeout(entry.timer);
+  entry.timer = setTimeout(() => {
+    const current = pool.get(key);
+    if (current === entry) {
+      try {
+        current.adapter.close();
+      } catch {}
+      pool.delete(key);
+    }
+  }, IDLE_TIMEOUT_MS);
+}
+async function getConnection(resolvedPath) {
+  if (!factory) {
+    throw new Error("No adapter factory configured");
+  }
+  const existing = pool.get(resolvedPath);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    scheduleEviction(resolvedPath, existing);
+    return existing.adapter;
+  }
+  if (pool.size >= MAX_CONNECTIONS) {
+    evictOldest();
+  }
+  const adapter = await factory.open(resolvedPath);
+  const entry = {
+    adapter,
+    path: resolvedPath,
+    lastUsed: Date.now(),
+    timer: setTimeout(() => {
+      return;
+    }, 0)
+  };
+  pool.set(resolvedPath, entry);
+  scheduleEviction(resolvedPath, entry);
+  return adapter;
+}
+function closeConnection(resolvedPath) {
+  const entry = pool.get(resolvedPath);
+  if (!entry)
+    return false;
+  clearTimeout(entry.timer);
+  try {
+    entry.adapter.close();
+  } catch {}
+  pool.delete(resolvedPath);
+  return true;
+}
+var MAX_CONNECTIONS = 8, IDLE_TIMEOUT_MS, pool, factory = null;
+var init_connection_pool = __esm(() => {
+  IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+  pool = new Map;
+});
+
+// web-src/server/database/connections-store.ts
+import { randomUUID } from "node:crypto";
+import { chmod } from "node:fs/promises";
+import { join as join11 } from "node:path";
+function secretKey(cwd, id) {
+  return `${cwd}\x00${id}`;
+}
+function extractSecrets(value) {
+  return {
+    ...typeof value.user === "string" ? { user: value.user } : {},
+    ...typeof value.username === "string" ? { username: value.username } : {},
+    ...typeof value.accessKeyId === "string" ? { accessKeyId: value.accessKeyId } : {},
+    ...typeof value.password === "string" ? { password: value.password } : {},
+    ...typeof value.secretAccessKey === "string" ? { secretAccessKey: value.secretAccessKey } : {},
+    ...typeof value.sessionToken === "string" ? { sessionToken: value.sessionToken } : {}
+  };
+}
+function withRuntimeSecrets(cwd, connection) {
+  return {
+    ...connection,
+    ...runtimeSecrets.get(secretKey(cwd, connection.id)) ?? {}
+  };
+}
+function connectionsFilePath(root) {
+  return join11(root, ".code-viewer", CONNECTIONS_FILE_NAME);
+}
+function emptyState() {
+  return { version: 1, connections: [] };
+}
+function requiredString(value, maxLength = MAX_VALUE_LENGTH) {
+  return typeof value === "string" && value.length <= maxLength ? value : "";
+}
+function optionalString2(value, maxLength = MAX_VALUE_LENGTH) {
+  const normalized = requiredString(value, maxLength);
+  return normalized || undefined;
+}
+function validPort(value) {
+  const port = Number(value);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
+}
+function validEndpoint(value) {
+  const raw = requiredString(value, MAX_VALUE_LENGTH);
+  if (!raw)
+    return null;
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password) {
+      return null;
+    }
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function sanitizeConnection(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const input = raw;
+  const id = requiredString(input.id, 80);
+  const name = requiredString(input.name, MAX_NAME_LENGTH).trim();
+  if (!/^connection:[a-f0-9-]{16,64}$/.test(id) || !name)
+    return null;
+  const base = { id, name };
+  if (input.kind === "postgresql" || input.kind === "mysql") {
+    const host = requiredString(input.host, MAX_HOST_LENGTH).trim();
+    const port = validPort(input.port);
+    const user = requiredString(input.user).trim();
+    const database = requiredString(input.database).trim();
+    if (!host || !port || !database)
+      return null;
+    return {
+      ...base,
+      kind: input.kind,
+      host,
+      port,
+      user,
+      password: requiredString(input.password),
+      database,
+      ...optionalString2(input.schema)?.trim() ? { schema: optionalString2(input.schema)?.trim() } : {},
+      tls: input.tls === true
+    };
+  }
+  if (input.kind === "redis") {
+    const host = requiredString(input.host, MAX_HOST_LENGTH).trim();
+    const port = validPort(input.port);
+    if (!host || !port)
+      return null;
+    return {
+      ...base,
+      kind: "redis",
+      host,
+      port,
+      ...optionalString2(input.username)?.trim() ? { username: optionalString2(input.username)?.trim() } : {},
+      password: requiredString(input.password),
+      tls: input.tls === true
+    };
+  }
+  if (input.kind === "elasticsearch") {
+    const endpoint = validEndpoint(input.endpoint);
+    if (!endpoint)
+      return null;
+    return {
+      ...base,
+      kind: "elasticsearch",
+      endpoint,
+      ...optionalString2(input.username)?.trim() ? { username: optionalString2(input.username)?.trim() } : {},
+      password: requiredString(input.password)
+    };
+  }
+  if (input.kind === "s3" || input.kind === "dynamodb") {
+    const endpoint = validEndpoint(input.endpoint);
+    const region = requiredString(input.region).trim();
+    const accessKeyId = requiredString(input.accessKeyId).trim();
+    if (!endpoint || !region)
+      return null;
+    return {
+      ...base,
+      kind: input.kind,
+      endpoint,
+      region,
+      accessKeyId,
+      secretAccessKey: requiredString(input.secretAccessKey),
+      ...optionalString2(input.sessionToken) ? { sessionToken: optionalString2(input.sessionToken) } : {}
+    };
+  }
+  return null;
+}
+function validateDatastoreConnection(raw, fallbackId = "connection:0000000000000000") {
+  const input = raw && typeof raw === "object" ? raw : {};
+  const connection = sanitizeConnection({
+    ...input,
+    id: typeof input.id === "string" && input.id ? input.id : fallbackId
+  });
+  if (!connection || (connection.kind === "postgresql" || connection.kind === "mysql") && !connection.user || (connection.kind === "s3" || connection.kind === "dynamodb") && !connection.accessKeyId) {
+    throw new Error("invalid datastore connection");
+  }
+  return connection;
+}
+function sanitizeState(raw) {
+  if (!raw || typeof raw !== "object")
+    return emptyState();
+  const input = raw;
+  if (input.version !== 1 || !Array.isArray(input.connections)) {
+    return emptyState();
+  }
+  const seen = new Set;
+  const connections = [];
+  for (const candidate of input.connections) {
+    if (connections.length >= MAX_CONNECTIONS2)
+      break;
+    const connection = sanitizeConnection(candidate);
+    if (!connection || seen.has(connection.id))
+      continue;
+    seen.add(connection.id);
+    connections.push(connection);
+  }
+  return { version: 1, connections };
+}
+async function protectFile(cwd) {
+  await chmod(connectionsFilePath(cwd), 384).catch(() => {
+    return;
+  });
+}
+async function loadDatastoreConnections(cwd) {
+  return (await store.load(cwd)).connections.map((connection) => withRuntimeSecrets(cwd, connection));
+}
+async function findDatastoreConnection(cwd, id) {
+  return (await loadDatastoreConnections(cwd)).find((entry) => entry.id === id) ?? null;
+}
+async function saveDatastoreConnection(cwd, raw) {
+  const input = raw && typeof raw === "object" ? raw : {};
+  const requestedId = typeof input.id === "string" ? input.id : "";
+  const id = requestedId || `connection:${randomUUID()}`;
+  const result = await store.update(cwd, (state) => {
+    const storedExisting = state.connections.find((entry) => entry.id === id);
+    const existing = storedExisting ? withRuntimeSecrets(cwd, storedExisting) : undefined;
+    const merged = sanitizeConnection({
+      ...existing ?? {},
+      ...input,
+      id,
+      password: input.password === undefined && existing && "password" in existing ? existing.password : input.password,
+      secretAccessKey: input.secretAccessKey === undefined && existing && "secretAccessKey" in existing ? existing.secretAccessKey : input.secretAccessKey,
+      sessionToken: input.sessionToken === undefined && existing && "sessionToken" in existing ? existing.sessionToken : input.sessionToken
+    });
+    if (!merged || (merged.kind === "postgresql" || merged.kind === "mysql") && !merged.user || (merged.kind === "s3" || merged.kind === "dynamodb") && !merged.accessKeyId) {
+      throw new Error("invalid datastore connection");
+    }
+    const connections = state.connections.filter((entry) => entry.id !== id);
+    if (!storedExisting && connections.length >= MAX_CONNECTIONS2) {
+      throw new Error("too many datastore connections");
+    }
+    connections.push(merged);
+    return {
+      state: { version: 1, connections },
+      result: merged
+    };
+  });
+  runtimeSecrets.set(secretKey(cwd, result.id), extractSecrets(result));
+  await protectFile(cwd);
+  return result;
+}
+async function deleteDatastoreConnection(cwd, id) {
+  const deleted = await store.update(cwd, (state) => {
+    const connections = state.connections.filter((entry) => entry.id !== id);
+    return {
+      state: { version: 1, connections },
+      result: connections.length !== state.connections.length
+    };
+  });
+  runtimeSecrets.delete(secretKey(cwd, id));
+  await protectFile(cwd);
+  return deleted;
+}
+function connectionToFileInfo(connection) {
+  return {
+    id: connection.id,
+    path: "saved connection",
+    name: connection.name,
+    sizeBytes: 0,
+    kind: connection.kind,
+    savedConnection: true
+  };
+}
+function publicConnection(connection) {
+  const {
+    password: _password,
+    user: _user,
+    username: _username,
+    accessKeyId: _accessKeyId,
+    ...withoutPassword
+  } = connection;
+  const {
+    secretAccessKey: _secret,
+    sessionToken: _token,
+    ...safe
+  } = withoutPassword;
+  return safe;
+}
+var CONNECTIONS_FILE_NAME = "datastore-connections.json", MAX_CONNECTIONS2 = 64, MAX_JSON_BYTES, MAX_NAME_LENGTH = 120, MAX_HOST_LENGTH = 253, MAX_VALUE_LENGTH = 4096, runtimeSecrets, store;
+var init_connections_store = __esm(() => {
+  init_json_store();
+  MAX_JSON_BYTES = 256 * 1024;
+  runtimeSecrets = new Map;
+  store = createJsonFileStore({
+    filePath: connectionsFilePath,
+    empty: emptyState,
+    sanitize: sanitizeState,
+    maxBytes: MAX_JSON_BYTES,
+    backupSuffix: "bak",
+    sizeErrorMessage: "datastore connections state too large",
+    serialize: (state) => `${JSON.stringify({
+      version: 1,
+      connections: state.connections.map(publicConnection)
+    }, null, 2)}
+`
+  });
+});
+
+// web-src/server/database/global-search.ts
+function isTextLikeType(type) {
+  const upper = type.toUpperCase();
+  return upper.includes("CHAR") || upper.includes("TEXT") || upper.includes("VARCHAR") || upper.includes("CLOB") || upper.includes("STRING") || upper === "JSON" || upper === "JSONB" || upper === "XML" || upper === "UUID";
+}
+function escapeLikeTerm(term) {
+  return term.replace(/=/g, "==").replace(/%/g, "=%").replace(/_/g, "=_");
+}
+async function searchTableAsync(adapter, table, columns, term, maxHits, includeNonText, pkColumns, signal) {
+  const kind = adapter.kind;
+  const searchCols = includeNonText ? columns.filter((c) => c.type.toUpperCase() !== "BLOB" && c.type.toUpperCase() !== "BYTEA") : columns.filter((c) => isTextLikeType(c.type));
+  if (searchCols.length === 0)
+    return [];
+  const escapedTerm = escapeLikeTerm(term);
+  const tbl = sanitizeIdentifier(table, kind);
+  const hits = [];
+  const db = asAsync(adapter);
+  for (const col of searchCols) {
+    if (signal?.aborted)
+      break;
+    if (hits.length >= maxHits)
+      break;
+    const colId = sanitizeIdentifier(col.name, kind);
+    const castCol = kind === "mysql" ? `CAST(${colId} AS CHAR)` : `CAST(${colId} AS TEXT)`;
+    let sql;
+    const remaining = maxHits - hits.length;
+    if (kind === "sqlite") {
+      sql = `SELECT * FROM ${tbl} WHERE ${castCol} LIKE ? ESCAPE '='`;
+    } else {
+      const likeVal = escapeSqlString(`%${escapedTerm}%`);
+      sql = `SELECT * FROM ${tbl} WHERE ${castCol} LIKE ${likeVal} ESCAPE '='`;
+    }
+    try {
+      const params = kind === "sqlite" ? [`%${escapedTerm}%`] : undefined;
+      const result = await db.readonlyQuery(sql, params, remaining, signal);
+      for (const row of result.rows) {
+        const colIdx = result.columns.indexOf(col.name);
+        const valueRaw = colIdx >= 0 ? serializeDbValue(row[colIdx]) : null;
+        const valueStr = valueRaw == null ? "" : String(valueRaw);
+        const preview = valueStr.length > 200 ? `${valueStr.slice(0, 200)}...` : valueStr;
+        let rowKeyJson;
+        if (pkColumns.length > 0) {
+          const keyObj = {};
+          for (const pk of pkColumns) {
+            const pkIdx = result.columns.indexOf(pk);
+            if (pkIdx >= 0)
+              keyObj[pk] = serializeDbValue(row[pkIdx]);
+          }
+          rowKeyJson = JSON.stringify(keyObj);
+        }
+        hits.push({
+          table,
+          column: col.name,
+          rowKeyJson,
+          valuePreview: preview,
+          rowPreview: serializeDbRow(row)
+        });
+      }
+    } catch (err) {
+      if (isAbortLikeError(err, signal))
+        throw err;
+    }
+  }
+  return hits;
+}
+function getPrimaryKeyColumnsFromColumns(columns) {
+  return columns.filter((c) => c.primaryKey).map((c) => c.name);
+}
+var init_global_search = __esm(() => {
+  init_serialize();
+  init_sql_utils();
+});
+
 // web-src/server/database/handle-shared.ts
 function createDockerAdapterCache(maxEntries = DEFAULT_MAX_DOCKER_ADAPTER_CACHE, idleMs = DEFAULT_DOCKER_ADAPTER_IDLE_MS) {
   const cache = new Map;
@@ -16642,6 +17276,24 @@ async function resolveDockerExplorerAsync(cwd, dbParam, kind, cache, openFn, omi
   }
   return { dbId: dbParam, explorer };
 }
+async function resolveDatastoreExplorerAsync(cwd, dbParam, kind, cache, openDocker, openSaved, omitDirNames, signal) {
+  if (dbParam?.startsWith("connection:")) {
+    const connection = await findDatastoreConnection(cwd, dbParam);
+    if (!connection || connection.kind !== kind) {
+      return textError(`${kind} connection not found`, 404);
+    }
+    try {
+      const explorer = await waitForCallerAbort(cache.getOrOpenAsync(dbParam, () => openSaved(connection)), signal, `${kind} open aborted`);
+      return { dbId: dbParam, explorer };
+    } catch (err) {
+      if (isAbortLikeError(err, signal)) {
+        return textError(`${kind} open aborted`, 503);
+      }
+      throw err;
+    }
+  }
+  return resolveDockerExplorerAsync(cwd, dbParam, kind, cache, openDocker, omitDirNames, signal);
+}
 async function dispatchRoutes(req, url, routes, sideEffectAllowed, wrap = (res) => res, handleRouteError) {
   if (!Object.prototype.hasOwnProperty.call(routes, url.pathname))
     return null;
@@ -16688,6 +17340,7 @@ function handleError(prefix, action, err, signal) {
 var DEFAULT_MAX_DOCKER_ADAPTER_CACHE = 8, DEFAULT_DOCKER_ADAPTER_IDLE_MS, MAX_LOGGED_ERROR_BODY = 500, logQueue;
 var init_handle_shared = __esm(() => {
   init_docker_utils();
+  init_connections_store();
   init_discovery();
   DEFAULT_DOCKER_ADAPTER_IDLE_MS = 5 * 60 * 1000;
   logQueue = Promise.resolve();
@@ -16703,7 +17356,12 @@ function closeDynamoDbAdapter(dbId) {
   dynamoDbAdapterCache.close(dbId);
 }
 function resolveDynamoDb(cwd, dbParam, signal, omitDirNames) {
-  return resolveDockerExplorerAsync(cwd, dbParam, "dynamodb", dynamoDbAdapterCache, (info) => openDynamoDbExplorerAsync(info), omitDirNames, signal);
+  return resolveDatastoreExplorerAsync(cwd, dbParam, "dynamodb", dynamoDbAdapterCache, (info) => openDynamoDbExplorerAsync(info), (connection) => {
+    if (connection.kind !== "dynamodb") {
+      throw new Error("invalid DynamoDB connection");
+    }
+    return createDynamoDbAdapter(connection);
+  }, omitDirNames, signal);
 }
 function dynamoDbErrorResponse(err, action, signal) {
   if (isAbortLikeError(err, signal)) {
@@ -16944,7 +17602,12 @@ function closeElasticsearchAdapter(dbId) {
   esAdapterCache.close(dbId);
 }
 function resolveEs(cwd, dbParam, signal, omitDirNames) {
-  return resolveDockerExplorerAsync(cwd, dbParam, "elasticsearch", esAdapterCache, (info) => openElasticsearchAdapterAsync(info.serviceName, info.env, info.composeDir), omitDirNames, signal);
+  return resolveDatastoreExplorerAsync(cwd, dbParam, "elasticsearch", esAdapterCache, (info) => openElasticsearchAdapterAsync(info.serviceName, info.env, info.composeDir), (connection) => {
+    if (connection.kind !== "elasticsearch") {
+      throw new Error("invalid Elasticsearch connection");
+    }
+    return createElasticsearchAdapter(connection);
+  }, omitDirNames, signal);
 }
 async function handleIndices(req, cwd, url, omitDirNames) {
   const r = await resolveEs(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
@@ -17189,7 +17852,11 @@ function closeRedisAdapter(dbId) {
   redisAdapterCache.close(dbId);
 }
 function resolveRedis(cwd, dbParam, signal, omitDirNames) {
-  return resolveDockerExplorerAsync(cwd, dbParam, "redis", redisAdapterCache, (info) => openRedisExplorerAsync(info.serviceName, info.env, info.composeDir), omitDirNames, signal);
+  return resolveDatastoreExplorerAsync(cwd, dbParam, "redis", redisAdapterCache, (info) => openRedisExplorerAsync(info.serviceName, info.env, info.composeDir), (connection) => {
+    if (connection.kind !== "redis")
+      throw new Error("invalid Redis connection");
+    return createRedisAdapter(connection);
+  }, omitDirNames, signal);
 }
 async function handleDatabases(req, cwd, url, omitDirNames) {
   const r = await resolveRedis(cwd, url.searchParams.get("db"), req.signal, omitDirNames);
@@ -17381,7 +18048,11 @@ function closeS3Adapter(dbId) {
   s3AdapterCache.close(dbId);
 }
 function resolveS3(cwd, dbParam, signal, omitDirNames) {
-  return resolveDockerExplorerAsync(cwd, dbParam, "s3", s3AdapterCache, (info) => openS3ExplorerAsync(info), omitDirNames, signal);
+  return resolveDatastoreExplorerAsync(cwd, dbParam, "s3", s3AdapterCache, (info) => openS3ExplorerAsync(info), (connection) => {
+    if (connection.kind !== "s3")
+      throw new Error("invalid S3 connection");
+    return createS3Adapter(connection);
+  }, omitDirNames, signal);
 }
 function validateBucket(value) {
   if (!value)
@@ -17831,11 +18502,11 @@ var init_handle_s3 = __esm(() => {
 });
 
 // web-src/server/database/query-history.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function historyFilePath(root) {
-  return join11(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
+  return join12(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
 }
-function emptyState() {
+function emptyState2() {
   return { version: 1, entries: [] };
 }
 function serializeHistoryState(state) {
@@ -17845,14 +18516,14 @@ function serializeHistoryState(state) {
   };
   let content = `${JSON.stringify(normalized, null, 2)}
 `;
-  while (normalized.entries.length > 1 && Buffer.byteLength(content, "utf8") > MAX_JSON_BYTES) {
+  while (normalized.entries.length > 1 && Buffer.byteLength(content, "utf8") > MAX_JSON_BYTES2) {
     normalized.entries.pop();
     content = `${JSON.stringify(normalized, null, 2)}
 `;
   }
   return content;
 }
-function optionalString2(value, maxLen) {
+function optionalString3(value, maxLen) {
   if (typeof value !== "string")
     return;
   if (!value || value.length > maxLen || value.includes("\x00"))
@@ -17883,16 +18554,16 @@ function sanitizeEntry(raw) {
   if (!raw || typeof raw !== "object")
     return null;
   const entry = raw;
-  const id = optionalString2(entry.id, MAX_ID_LEN);
-  const dbId = optionalString2(entry.dbId, MAX_DB_ID_LEN);
-  const sql = optionalString2(entry.sql, MAX_SQL_LEN);
+  const id = optionalString3(entry.id, MAX_ID_LEN);
+  const dbId = optionalString3(entry.dbId, MAX_DB_ID_LEN);
+  const sql = optionalString3(entry.sql, MAX_SQL_LEN);
   if (!id || !dbId || !sql)
     return null;
   const columns = Array.isArray(entry.columns) ? entry.columns.filter((col) => typeof col === "string" && !!col).map((col) => col.slice(0, MAX_COLUMN_LEN)).slice(0, MAX_COLUMNS) : [];
   const rowsPreview = sanitizeRows(entry.rowsPreview);
-  const schema = optionalString2(entry.schema, MAX_SCHEMA_LEN);
-  const title = optionalString2(entry.title, MAX_TEXT_LEN);
-  const body = optionalString2(entry.body, MAX_TEXT_LEN);
+  const schema = optionalString3(entry.schema, MAX_SCHEMA_LEN);
+  const title = optionalString3(entry.title, MAX_TEXT_LEN);
+  const body = optionalString3(entry.body, MAX_TEXT_LEN);
   return {
     id,
     dbId,
@@ -17906,17 +18577,17 @@ function sanitizeEntry(raw) {
     savedRows: finiteNumber(entry.savedRows) ?? rowsPreview.length,
     truncated: typeof entry.truncated === "boolean" ? entry.truncated : false,
     elapsedMs: finiteNumber(entry.elapsedMs) ?? 0,
-    executedAt: optionalString2(entry.executedAt, 64) ?? new Date(0).toISOString(),
+    executedAt: optionalString3(entry.executedAt, 64) ?? new Date(0).toISOString(),
     executedBy: entry.executedBy === "ai" ? "ai" : "user",
     source: entry.source === "cli" ? "cli" : "browser"
   };
 }
 function sanitizeHistoryState(raw) {
   if (!raw || typeof raw !== "object")
-    return emptyState();
+    return emptyState2();
   const entriesRaw = raw.entries;
   if (!Array.isArray(entriesRaw))
-    return emptyState();
+    return emptyState2();
   const entries = [];
   for (const entry of entriesRaw) {
     if (entries.length >= MAX_ENTRIES2)
@@ -17955,7 +18626,7 @@ function deleteQueryHistoryEntry(state, id) {
 }
 function clearQueryHistory(state, dbId, schema) {
   if (!dbId)
-    return emptyState();
+    return emptyState2();
   return {
     version: 1,
     entries: state.entries.filter((e) => {
@@ -17967,14 +18638,14 @@ function clearQueryHistory(state, dbId, schema) {
     })
   };
 }
-var CODE_VIEWER_DIR3 = ".code-viewer", HISTORY_FILE_NAME = "query-history.json", MAX_ENTRIES2 = 200, MAX_PREVIEW_ROWS = 100, MAX_JSON_BYTES = 1e6, MAX_ID_LEN = 128, MAX_DB_ID_LEN = 2048, MAX_SCHEMA_LEN = 512, MAX_SQL_LEN = 64000, MAX_TEXT_LEN = 64000, MAX_COLUMN_LEN = 512, MAX_COLUMNS = 500, historyStore;
+var CODE_VIEWER_DIR3 = ".code-viewer", HISTORY_FILE_NAME = "query-history.json", MAX_ENTRIES2 = 200, MAX_PREVIEW_ROWS = 100, MAX_JSON_BYTES2 = 1e6, MAX_ID_LEN = 128, MAX_DB_ID_LEN = 2048, MAX_SCHEMA_LEN = 512, MAX_SQL_LEN = 64000, MAX_TEXT_LEN = 64000, MAX_COLUMN_LEN = 512, MAX_COLUMNS = 500, historyStore;
 var init_query_history = __esm(() => {
   init_json_store();
   historyStore = createJsonFileStore({
     filePath: historyFilePath,
-    empty: emptyState,
+    empty: emptyState2,
     sanitize: sanitizeHistoryState,
-    maxBytes: MAX_JSON_BYTES,
+    maxBytes: MAX_JSON_BYTES2,
     backupSuffix: "corrupt",
     serialize: serializeHistoryState
   });
@@ -17983,9 +18654,9 @@ var init_query_history = __esm(() => {
 // web-src/server/database/snapshot-store.ts
 import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function getStoreDb(cwd) {
-  const dbPath = join12(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
+  const dbPath = join13(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
   if (storeDb && storeDbPath === dbPath)
     return storeDb;
   if (storeDb) {
@@ -17993,7 +18664,7 @@ async function getStoreDb(cwd) {
       storeDb.close();
     } catch {}
   }
-  mkdirSync3(join12(cwd, CODE_VIEWER_DIR4), { recursive: true });
+  mkdirSync3(join13(cwd, CODE_VIEWER_DIR4), { recursive: true });
   const DbClass = await loadSqliteClass();
   storeDb = new DbClass(dbPath);
   storeDbPath = dbPath;
@@ -18599,11 +19270,11 @@ var init_snapshot_runner = __esm(() => {
 });
 
 // web-src/server/database/tabs-store.ts
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function tabsFilePath(root) {
-  return join13(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
+  return join14(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
 }
-function emptyState2() {
+function emptyState3() {
   return { version: 1, tabs: [], activeTabId: null };
 }
 function isValidCssSize(s) {
@@ -18725,10 +19396,10 @@ function sanitizeDynamodb(v) {
 }
 function sanitize(input) {
   if (!input || typeof input !== "object")
-    return emptyState2();
+    return emptyState3();
   const obj = input;
   if (obj.version !== 1)
-    return emptyState2();
+    return emptyState3();
   const rawTabs = Array.isArray(obj.tabs) ? obj.tabs : [];
   const seenIds = new Set;
   const tabs = [];
@@ -18796,7 +19467,7 @@ async function loadTabsAsync(cwd) {
 async function saveTabsAsync(cwd, state) {
   return tabsStore.save(cwd, state);
 }
-var CODE_VIEWER_DIR5 = ".code-viewer", TABS_FILE_NAME = "tabs.json", MAX_TABS = 64, MAX_JSON_BYTES2 = 1e6, MAX_SQL_DRAFT_LEN = 16000, MAX_ES_QUERY_LEN = 16000, MAX_TAB_ID_LEN = 128, MAX_DB_ID_LEN2 = 2048, MAX_SCHEMA_NAME_LEN = 512, MAX_TABLE_NAME_LEN2 = 512, MAX_REDIS_KEY_LEN = 1024, MAX_REDIS_KEY_FILTER_LEN = 512, MAX_INDEX_NAME_LEN = 256, MAX_S3_BUCKET_LEN = 256, MAX_S3_KEY_LEN = 2048, MAX_S3_QUERY_LEN = 2048, MAX_DYNAMODB_TABLE_LEN = 255, MAX_DYNAMODB_EXPRESSION_LEN = 4096, MAX_DYNAMODB_ATTRIBUTE_VALUES_LEN = 16000, MAX_DYNAMODB_ITEM_KEY_LEN = 4096, MAX_CSS_SIZE_LEN = 16, VALID_VIEWS, tabsStore;
+var CODE_VIEWER_DIR5 = ".code-viewer", TABS_FILE_NAME = "tabs.json", MAX_TABS = 64, MAX_JSON_BYTES3 = 1e6, MAX_SQL_DRAFT_LEN = 16000, MAX_ES_QUERY_LEN = 16000, MAX_TAB_ID_LEN = 128, MAX_DB_ID_LEN2 = 2048, MAX_SCHEMA_NAME_LEN = 512, MAX_TABLE_NAME_LEN2 = 512, MAX_REDIS_KEY_LEN = 1024, MAX_REDIS_KEY_FILTER_LEN = 512, MAX_INDEX_NAME_LEN = 256, MAX_S3_BUCKET_LEN = 256, MAX_S3_KEY_LEN = 2048, MAX_S3_QUERY_LEN = 2048, MAX_DYNAMODB_TABLE_LEN = 255, MAX_DYNAMODB_EXPRESSION_LEN = 4096, MAX_DYNAMODB_ATTRIBUTE_VALUES_LEN = 16000, MAX_DYNAMODB_ITEM_KEY_LEN = 4096, MAX_CSS_SIZE_LEN = 16, VALID_VIEWS, tabsStore;
 var init_tabs_store = __esm(() => {
   init_json_store();
   VALID_VIEWS = new Set([
@@ -18809,9 +19480,9 @@ var init_tabs_store = __esm(() => {
   ]);
   tabsStore = createJsonFileStore({
     filePath: tabsFilePath,
-    empty: emptyState2,
+    empty: emptyState3,
     sanitize,
-    maxBytes: MAX_JSON_BYTES2,
+    maxBytes: MAX_JSON_BYTES3,
     backupSuffix: "bak",
     sizeErrorMessage: "tabs state too large"
   });
@@ -18839,6 +19510,10 @@ function ensureInit() {
   initialized = true;
 }
 async function getAdapter(r, _cwd, signal) {
+  if (r.saved) {
+    const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
+    return dockerAdapterCache.getOrOpenAsync(cacheKey, () => createSqlCliAdapter({ ...r.saved, schema: r.schema }));
+  }
   if (r.docker) {
     const docker = r.docker;
     const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
@@ -18886,6 +19561,24 @@ async function resolveSupabaseSchema(info, requestedSchema, signal) {
 async function resolveDb(cwd, dbParam, omitDirNames, schemaParam, signal) {
   if (!dbParam)
     return textError("missing db parameter", 400);
+  if (dbParam.startsWith("connection:")) {
+    const connection = await findDatastoreConnection(cwd, dbParam);
+    if (!connection)
+      return textError("datastore connection not found", 404);
+    if (connection.kind !== "postgresql" && connection.kind !== "mysql") {
+      return textError(`${connection.kind} must use its datastore routes`, 400);
+    }
+    const requestedSchema = normalizeSchemaParam(schemaParam);
+    if (requestedSchema instanceof Response)
+      return requestedSchema;
+    const schema = connection.kind === "postgresql" ? requestedSchema || connection.schema || "public" : undefined;
+    return {
+      resolved: dbParam,
+      dbId: dbParam,
+      saved: connection,
+      ...schema ? { schema } : {}
+    };
+  }
   if (dbParam.startsWith("supabase:")) {
     const parsed = parseSupabaseDbId(dbParam);
     if (!parsed)
@@ -18993,10 +19686,11 @@ async function expandDockerServicesForFiles(dockerServices, listDockerDatabases,
 }
 async function createDbFilesResponse(cwd, omitDirNames, signal, deps = DEFAULT_DB_FILE_DISCOVERY_DEPS) {
   ensureInit();
-  const [sqliteSettled, dockerSettled, supabaseSettled] = await Promise.allSettled([
+  const [sqliteSettled, dockerSettled, supabaseSettled, connectionsSettled] = await Promise.allSettled([
     deps.discoverSqliteFiles(cwd, omitDirNames, signal),
     deps.discoverDockerDatabases(cwd, omitDirNames, signal),
-    deps.discoverSupabaseCliProjects(cwd, omitDirNames, signal)
+    deps.discoverSupabaseCliProjects(cwd, omitDirNames, signal),
+    (deps.loadConnections ?? loadDatastoreConnections)(cwd)
   ]);
   if (sqliteSettled.status === "rejected") {
     throw sqliteSettled.reason;
@@ -19004,11 +19698,15 @@ async function createDbFilesResponse(cwd, omitDirNames, signal, deps = DEFAULT_D
   if (supabaseSettled.status === "rejected") {
     throw supabaseSettled.reason;
   }
+  if (connectionsSettled.status === "rejected") {
+    throw connectionsSettled.reason;
+  }
   if (dockerSettled.status === "rejected" && isAbortLikeError(dockerSettled.reason, signal)) {
     throw dockerSettled.reason;
   }
   const sqliteFiles = sqliteSettled.value;
   const supabaseProjects = supabaseSettled.value;
+  const savedConnections = connectionsSettled.value;
   const dockerServices = dockerSettled.status === "fulfilled" ? dockerSettled.value : [];
   const dockerErrors = [];
   if (dockerSettled.status === "rejected") {
@@ -19027,7 +19725,8 @@ async function createDbFilesResponse(cwd, omitDirNames, signal, deps = DEFAULT_D
         kind: "sqlite"
       })),
       ...dockerEntries.map(toFileInfo),
-      ...supabaseProjects.map(toFileInfo)
+      ...supabaseProjects.map(toFileInfo),
+      ...savedConnections.map(connectionToFileInfo)
     ],
     ...dockerTruncated ? { truncated: true } : {},
     ...dockerErrors.length > 0 ? { dockerError: dockerErrors.join("; ") } : {}
@@ -19052,6 +19751,26 @@ async function createDbSchemasResponse(cwd, dbParam, schemaParam, omitDirNames,
     };
     return { ok: true, value: body2 };
   }
+  if (r.saved?.kind === "postgresql") {
+    try {
+      const adapter = await getAdapter(r, cwd, signal);
+      const { result, executedSql: executedSql2 } = await captureSql(() => adapter.executeReadonlyQueryAsync("SELECT schema_name FROM information_schema.schemata ORDER BY schema_name", undefined, 1000, signal));
+      return {
+        ok: true,
+        value: {
+          dbId: r.dbId,
+          schemas: result.rows.map((row) => ({ name: String(row[0]) })),
+          selectedSchema: r.schema,
+          executedSql: executedSql2
+        }
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        response: handleError("database", "list schemas", err, signal)
+      };
+    }
+  }
   if (!r.docker || r.docker.kind !== "postgresql") {
     const body2 = { dbId: r.dbId, schemas: [] };
     return { ok: true, value: body2 };
@@ -20054,6 +20773,118 @@ async function handleTabsPut(cwd, req) {
 async function handleDbUiGet(cwd) {
   return jsonLoadResponse(() => loadDbUiState(cwd), "db UI", "failed to load db UI state");
 }
+function closeSavedConnection(id, kind) {
+  if (kind === "postgresql" || kind === "mysql") {
+    dockerAdapterCache.close(id);
+    dockerAdapterCache.closePrefix(`${id}\x00`);
+    return;
+  }
+  DOCKER_CLOSE_REGISTRY[kind]?.(id);
+}
+async function handleConnections(cwd, req) {
+  if (req.method === "GET") {
+    const connections = await loadDatastoreConnections(cwd);
+    return json({ connections: connections.map(publicConnection) });
+  }
+  const body = await parseBoundedJsonBody(req, 65536, "connection payload too large");
+  if (body instanceof Response)
+    return body;
+  if (req.method === "PUT") {
+    try {
+      const connection = await saveDatastoreConnection(cwd, body);
+      closeSavedConnection(connection.id, connection.kind);
+      return json({ connection: publicConnection(connection) });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "invalid datastore connection";
+      return textError(message, message === "too many datastore connections" ? 409 : 400);
+    }
+  }
+  const id = body && typeof body === "object" && "id" in body ? body.id : undefined;
+  if (typeof id !== "string" || !id.startsWith("connection:")) {
+    return textError("invalid datastore connection id", 400);
+  }
+  const existing = await findDatastoreConnection(cwd, id);
+  if (!existing)
+    return textError("datastore connection not found", 404);
+  await deleteDatastoreConnection(cwd, id);
+  closeSavedConnection(id, existing.kind);
+  return json({ ok: true });
+}
+async function probeDatastoreConnection(connection, signal) {
+  if (connection.kind === "postgresql" || connection.kind === "mysql") {
+    const adapter2 = createSqlCliAdapter(connection);
+    try {
+      await adapter2.getTablesAsync(signal);
+    } finally {
+      adapter2.close();
+    }
+    return;
+  }
+  if (connection.kind === "redis") {
+    const adapter2 = createRedisAdapter(connection);
+    try {
+      await adapter2.listDatabasesAsync(signal);
+    } finally {
+      adapter2.close();
+    }
+    return;
+  }
+  if (connection.kind === "elasticsearch") {
+    const adapter2 = createElasticsearchAdapter(connection);
+    try {
+      await adapter2.listIndicesAsync(signal);
+    } finally {
+      adapter2.close();
+    }
+    return;
+  }
+  if (connection.kind === "s3") {
+    const adapter2 = createS3Adapter(connection);
+    try {
+      await adapter2.listBuckets(signal);
+    } finally {
+      adapter2.close();
+    }
+    return;
+  }
+  if (connection.kind !== "dynamodb") {
+    throw new Error("invalid datastore connection");
+  }
+  const adapter = createDynamoDbAdapter(connection);
+  try {
+    await adapter.listTablesAsync({ limit: 1, signal });
+  } finally {
+    adapter.close();
+  }
+}
+async function handleConnectionTest(cwd, req) {
+  const body = await parseBoundedJsonBody(req, 65536, "connection payload too large");
+  if (body instanceof Response)
+    return body;
+  const input = body && typeof body === "object" ? body : {};
+  let existing = null;
+  if (typeof input.id === "string") {
+    existing = await findDatastoreConnection(cwd, input.id);
+    if (!existing)
+      return textError("datastore connection not found", 404);
+  }
+  try {
+    const connection = validateDatastoreConnection({
+      ...existing ?? {},
+      ...input
+    });
+    await probeDatastoreConnection(connection, req.signal);
+    return json({ ok: true });
+  } catch (err) {
+    if (isAbortLikeError(err, req.signal)) {
+      return textError("connection test aborted", 503);
+    }
+    if (err instanceof Error && err.message === "invalid datastore connection") {
+      return textError(err.message, 400);
+    }
+    return textError("connection failed", 400);
+  }
+}
 async function handleDbUiPatch(cwd, req) {
   const body = await parseBoundedJsonBody(req, MAX_DB_UI_BODY_BYTES, "db UI body too large");
   if (body instanceof Response)
@@ -20074,6 +20905,12 @@ async function handleClose(cwd, req, omitDirNames) {
     return body;
   if (!body.db)
     return textError("missing db", 400);
+  if (body.db.startsWith("connection:")) {
+    const connection = await findDatastoreConnection(cwd, body.db);
+    if (connection)
+      closeSavedConnection(body.db, connection.kind);
+    return json({ ok: true });
+  }
   if (body.db.startsWith("docker:")) {
     const parsed = parseDockerDbId(body.db);
     if (!parsed)
@@ -20174,6 +21011,16 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
       methods: ["GET"],
       handler: () => handleFiles(cwd, omitDirNames, req.signal)
     },
+    "/_db/connections": {
+      methods: ["GET", "PUT", "DELETE"],
+      sideEffect: (requestMethod) => requestMethod !== "GET",
+      handler: () => handleConnections(cwd, req)
+    },
+    "/_db/connections/test": {
+      methods: ["POST"],
+      sideEffect: true,
+      handler: () => handleConnectionTest(cwd, req)
+    },
     "/_db/schemas": {
       methods: ["GET"],
       handler: () => handleSchemas(cwd, url, omitDirNames, req.signal)
@@ -20294,9 +21141,14 @@ var init_handle = __esm(() => {
   init_state_store();
   init_docker();
   init_docker_utils();
+  init_dynamodb();
+  init_elasticsearch();
+  init_redis();
+  init_s3();
   init_sql_capture();
   init_sqlite();
   init_connection_pool();
+  init_connections_store();
   init_discovery();
   init_global_search();
   init_handle_dynamodb();
@@ -20314,7 +21166,8 @@ var init_handle = __esm(() => {
     discoverSqliteFiles: discoverSqliteFilesAsync,
     discoverDockerDatabases: discoverDockerDatabasesAsync,
     listDockerDatabases: listDockerDatabasesAsync,
-    discoverSupabaseCliProjects: discoverSupabaseCliProjectsAsync
+    discoverSupabaseCliProjects: discoverSupabaseCliProjectsAsync,
+    loadConnections: loadDatastoreConnections
   };
   searchJobs = new Map;
   snapshotJobs = new Map;
@@ -20356,7 +21209,7 @@ var init_handle = __esm(() => {
 
 // web-src/server/doctor.ts
 import { accessSync as accessSync2, constants as constants2, readFileSync as readFileSync6, statSync as statSync5 } from "node:fs";
-import { dirname as dirname4, join as join14, relative as relative5 } from "node:path";
+import { dirname as dirname4, join as join15, relative as relative5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function statusWorse(a, b) {
   const rank = { ok: 0, warn: 1, error: 2 };
@@ -20450,7 +21303,7 @@ function findCodeViewerPackageJson() {
       cursor = dirname4(process.argv[1] || ".");
     }
     for (let depth = 0;depth < 8; depth += 1) {
-      const candidate = join14(cursor, "package.json");
+      const candidate = join15(cursor, "package.json");
       try {
         const raw = readFileSync6(candidate, "utf8");
         const pkg = JSON.parse(raw);
@@ -20546,7 +21399,7 @@ async function checkSqlite(cwd) {
   return { id: "sqlite", title: "SQLite driver", rows };
 }
 async function trySnapshotDbOpen(cwd) {
-  const dbPath = join14(cwd, SNAPSHOT_DB_REL);
+  const dbPath = join15(cwd, SNAPSHOT_DB_REL);
   try {
     statSync5(dbPath);
   } catch {
@@ -20567,7 +21420,7 @@ async function trySnapshotDbOpen(cwd) {
   }
 }
 function checkSnapshotStore(cwd) {
-  const dbPath = join14(cwd, SNAPSHOT_DB_REL);
+  const dbPath = join15(cwd, SNAPSHOT_DB_REL);
   const dir = dirname4(dbPath);
   let dirStatus = "ok";
   let dirDetail = dir;
@@ -21571,7 +22424,7 @@ function normalizeNewDirectoryName(name) {
 
 // web-src/server/cache.ts
 import { lstatSync as lstatSync3 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function cacheFresh(cached, now = Date.now(), ttlMs = CACHE_TTL_MS) {
   return !!cached && now - cached.storedAt <= ttlMs;
 }
@@ -21586,7 +22439,7 @@ function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MA
 }
 function worktreeFileSignature(path, cwd) {
   try {
-    const stats = lstatSync3(join15(cwd, path));
+    const stats = lstatSync3(join16(cwd, path));
     const inode = "ino" in stats ? stats.ino : 0;
     return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
   } catch {
@@ -21632,12 +22485,12 @@ function startDevAssetReload(options) {
 var init_dev_assets = () => {};
 
 // web-src/server/journal.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function dailyJournalFilePath(root) {
-  return join16(root, CODE_VIEWER_DIR, DAILY_JOURNAL_FILE_NAME);
+  return join17(root, CODE_VIEWER_DIR, DAILY_JOURNAL_FILE_NAME);
 }
 function journalTasksFilePath(root) {
-  return join16(root, CODE_VIEWER_DIR, JOURNAL_TASKS_FILE_NAME);
+  return join17(root, CODE_VIEWER_DIR, JOURNAL_TASKS_FILE_NAME);
 }
 function emptyDailyJournalState() {
   return { version: 1, entries: [] };
@@ -21650,7 +22503,7 @@ function makeJournalId(prefix) {
   const time = Date.now().toString(36);
   return `${prefix}-${time}${random}`;
 }
-function optionalString3(value, maxLen) {
+function optionalString4(value, maxLen) {
   if (typeof value !== "string")
     return;
   if (value.includes("\x00"))
@@ -21676,12 +22529,12 @@ function normalizeJournalEntry(raw) {
   if (!raw || typeof raw !== "object")
     return null;
   const entry = raw;
-  const id = optionalString3(entry.id, 128);
+  const id = optionalString4(entry.id, 128);
   const date = isIsoDate(entry.date) ? entry.date : undefined;
   const body = optionalBody(entry.body, JOURNAL_ENTRY_BODY_MAX_BYTES);
   if (!id || !date || body === undefined)
     return null;
-  const title = optionalString3(entry.title, JOURNAL_TITLE_MAX_CHARS);
+  const title = optionalString4(entry.title, JOURNAL_TITLE_MAX_CHARS);
   return {
     id,
     date,
@@ -21689,8 +22542,8 @@ function normalizeJournalEntry(raw) {
     body,
     labels: normalizeJournalLabels(entry.labels),
     source: normalizeSource(entry.source),
-    created_at: optionalString3(entry.created_at, 64) ?? new Date(0).toISOString(),
-    updated_at: optionalString3(entry.updated_at, 64) ?? new Date(0).toISOString()
+    created_at: optionalString4(entry.created_at, 64) ?? new Date(0).toISOString(),
+    updated_at: optionalString4(entry.updated_at, 64) ?? new Date(0).toISOString()
   };
 }
 function normalizeDailyJournalState(raw) {
@@ -21714,13 +22567,13 @@ function normalizeTaskNote(raw) {
   if (!raw || typeof raw !== "object")
     return null;
   const note = raw;
-  const id = optionalString3(note.id, 128);
+  const id = optionalString4(note.id, 128);
   const body = optionalBody(note.body, JOURNAL_TASK_NOTE_MAX_BYTES);
   if (!id || body === undefined)
     return null;
   return {
     id,
-    at: optionalString3(note.at, 64) ?? new Date(0).toISOString(),
+    at: optionalString4(note.at, 64) ?? new Date(0).toISOString(),
     body,
     source: normalizeSource(note.source)
   };
@@ -21729,9 +22582,9 @@ function normalizeTaskClaim(raw) {
   if (!raw || typeof raw !== "object")
     return;
   const claim = raw;
-  const by = optionalString3(claim.by, 128);
-  const claimedAt = optionalString3(claim.claimed_at, 64);
-  const leaseExpiresAt = optionalString3(claim.lease_expires_at, 64);
+  const by = optionalString4(claim.by, 128);
+  const claimedAt = optionalString4(claim.claimed_at, 64);
+  const leaseExpiresAt = optionalString4(claim.lease_expires_at, 64);
   if (!by || !claimedAt || !leaseExpiresAt)
     return;
   return {
@@ -21744,8 +22597,8 @@ function normalizeJournalTask(raw) {
   if (!raw || typeof raw !== "object")
     return null;
   const task = raw;
-  const id = optionalString3(task.id, 128);
-  const title = optionalString3(task.title, JOURNAL_TITLE_MAX_CHARS);
+  const id = optionalString4(task.id, 128);
+  const title = optionalString4(task.title, JOURNAL_TITLE_MAX_CHARS);
   if (!id || !title)
     return null;
   const status = isJournalTaskStatus(task.status) ? task.status : "todo";
@@ -21753,8 +22606,8 @@ function normalizeJournalTask(raw) {
   const body = optionalBody(task.body, JOURNAL_TASK_BODY_MAX_BYTES) ?? "";
   const dueDate = isIsoDate(task.due_date) ? task.due_date : undefined;
   const sourceDate = isIsoDate(task.source_date) ? task.source_date : undefined;
-  const journalEntryId = optionalString3(task.journal_entry_id, 128);
-  const completedAt = optionalString3(task.completed_at, 64);
+  const journalEntryId = optionalString4(task.journal_entry_id, 128);
+  const completedAt = optionalString4(task.completed_at, 64);
   const notes = Array.isArray(task.notes) ? task.notes.slice(0, MAX_NOTES_PER_TASK).map(normalizeTaskNote).filter((note) => note !== null) : [];
   const claim = normalizeTaskClaim(task.claim);
   return {
@@ -21764,8 +22617,8 @@ function normalizeJournalTask(raw) {
     status,
     priority,
     labels: normalizeJournalLabels(task.labels),
-    created_at: optionalString3(task.created_at, 64) ?? new Date(0).toISOString(),
-    updated_at: optionalString3(task.updated_at, 64) ?? new Date(0).toISOString(),
+    created_at: optionalString4(task.created_at, 64) ?? new Date(0).toISOString(),
+    updated_at: optionalString4(task.updated_at, 64) ?? new Date(0).toISOString(),
     ...dueDate ? { due_date: dueDate } : {},
     ...sourceDate ? { source_date: sourceDate } : {},
     ...journalEntryId ? { journal_entry_id: journalEntryId } : {},
@@ -21846,7 +22699,7 @@ function addDailyJournalEntry(state, input, now, makeId3 = makeJournalId) {
   const valid = validateEntryInput(input);
   if (valid.ok === false)
     return valid;
-  const title = optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS);
+  const title = optionalString4(input.title, JOURNAL_TITLE_MAX_CHARS);
   const entry = {
     id: makeId3("j"),
     date: input.date,
@@ -21877,7 +22730,7 @@ function updateDailyJournalEntry(state, id, patch, now) {
     next.date = patch.date;
   }
   if (patch.title !== undefined) {
-    const title = optionalString3(patch.title, JOURNAL_TITLE_MAX_CHARS);
+    const title = optionalString4(patch.title, JOURNAL_TITLE_MAX_CHARS);
     if (title)
       next.title = title;
     else
@@ -21910,7 +22763,7 @@ function deleteDailyJournalEntry(state, id) {
   };
 }
 function validateTaskInput(input) {
-  if (!optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS))
+  if (!optionalString4(input.title, JOURNAL_TITLE_MAX_CHARS))
     return { ok: false, error: "title is required" };
   if (input.body !== undefined && optionalBody(input.body, JOURNAL_TASK_BODY_MAX_BYTES) === undefined)
     return { ok: false, error: "body is too large" };
@@ -21955,7 +22808,7 @@ function addJournalTask(state, input, now, makeId3 = makeJournalId) {
   const status = input.status || anchor?.status || "todo";
   const task = {
     id: makeId3("t"),
-    title: optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS) || "Untitled task",
+    title: optionalString4(input.title, JOURNAL_TITLE_MAX_CHARS) || "Untitled task",
     body: input.body || "",
     status,
     priority: input.priority || "p2",
@@ -21980,7 +22833,7 @@ function updateJournalTask(state, id, patch, now) {
     return { ok: false, error: "task not found" };
   const next = { ...task, updated_at: now };
   if (patch.title !== undefined) {
-    const title = optionalString3(patch.title, JOURNAL_TITLE_MAX_CHARS);
+    const title = optionalString4(patch.title, JOURNAL_TITLE_MAX_CHARS);
     if (!title)
       return { ok: false, error: "title is required" };
     next.title = title;
@@ -22022,7 +22875,7 @@ function updateJournalTask(state, id, patch, now) {
       return { ok: false, error: "source date must be YYYY-MM-DD" };
   }
   if (patch.journal_entry_id !== undefined) {
-    const journalEntryId = optionalString3(patch.journal_entry_id, 128);
+    const journalEntryId = optionalString4(patch.journal_entry_id, 128);
     if (journalEntryId)
       next.journal_entry_id = journalEntryId;
     else
@@ -22072,10 +22925,10 @@ function linkGithubIssueTask(state, input, now, makeId3 = makeJournalId) {
   if (!Number.isInteger(input.issue_number) || input.issue_number < 1) {
     return { ok: false, error: "issue number must be a positive integer" };
   }
-  const title = optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS) || `GitHub issue #${input.issue_number}`;
-  const repo = optionalString3(input.repo, 120);
-  const issueUrl = optionalString3(input.url, 240);
-  const memoLabel = optionalString3(input.memo_label, 80);
+  const title = optionalString4(input.title, JOURNAL_TITLE_MAX_CHARS) || `GitHub issue #${input.issue_number}`;
+  const repo = optionalString4(input.repo, 120);
+  const issueUrl = optionalString4(input.url, 240);
+  const memoLabel = optionalString4(input.memo_label, 80);
   const requiredLabels = githubIssueRequiredLabels(input.issue_number, repo, input.labels);
   const linkLabel = journalIssueLabel(input.issue_number);
   const repoLabel = journalIssueRepoLabel(repo);
@@ -22153,7 +23006,7 @@ function claimJournalTask(state, id, input, now) {
       ok: false,
       error: "only todo or expired doing tasks can be claimed"
     };
-  const by = optionalString3(input.by, 128) || "ai";
+  const by = optionalString4(input.by, 128) || "ai";
   const wipLimit = input.wip_limit;
   if (wipLimit !== undefined && wipLimit > 0) {
     const activeDoing = state.tasks.filter((item) => {
@@ -22198,7 +23051,7 @@ function completeJournalTask(state, id, input, now, makeId3 = makeJournalId) {
   const activeClaim = task.claim && Number.isFinite(Date.parse(task.claim.lease_expires_at)) && Date.parse(task.claim.lease_expires_at) > nowMs;
   if (!activeClaim)
     return { ok: false, error: "task must be claimed before completion" };
-  const by = optionalString3(input.by, 128);
+  const by = optionalString4(input.by, 128);
   if (!by)
     return { ok: false, error: "task completion requires claim owner" };
   if (task.claim?.by !== by)
@@ -22270,7 +23123,7 @@ var init_journal2 = __esm(() => {
 
 // web-src/server/search-service.ts
 import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "node:fs";
-import { join as join17, relative as relative6 } from "node:path";
+import { join as join18, relative as relative6 } from "node:path";
 async function rgAvailableAsync(cwd) {
   if (rgAvailableCache !== null)
     return rgAvailableCache;
@@ -22299,7 +23152,7 @@ function safeWorktreePath(env, path) {
     return null;
   if (isGitInternalPath(path))
     return null;
-  const full = join17(env.cwd, path);
+  const full = join18(env.cwd, path);
   if (!existsSync7(full))
     return null;
   let realCwd;
@@ -22491,7 +23344,7 @@ var init_search_service = __esm(() => {
 
 // web-src/server/mcp.ts
 import { readFileSync as readFileSync8 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function defaultMcpTools(options = {}) {
   return [
     {
@@ -23965,7 +24818,7 @@ var init_mcp = __esm(() => {
   init_search_cli();
   init_search_service();
   init_status_cli();
-  PACKAGE_VERSION = JSON.parse(readFileSync8(join18(ROOT, "package.json"), "utf8")).version;
+  PACKAGE_VERSION = JSON.parse(readFileSync8(join19(ROOT, "package.json"), "utf8")).version;
   MCP_SERVER_INFO = {
     name: "code-viewer",
     title: "code-viewer",
@@ -24061,7 +24914,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname5, extname as extname2, join as join19, relative as relative7 } from "node:path";
+import { basename as basename3, dirname as dirname5, extname as extname2, join as join20, relative as relative7 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2;i < process.argv.length; i++) {
@@ -24183,7 +25036,7 @@ Examples:
 }
 function warnIfLegacyConfigPresent() {
   try {
-    if (existsSync8(join19(cwd, ".code-viewer.json"))) {
+    if (existsSync8(join20(cwd, ".code-viewer.json"))) {
       console.warn("[code-viewer] .code-viewer.json is no longer used; configure scope and upload from Viewer Settings instead. The file can be safely removed.");
     }
   } catch {}
@@ -24290,7 +25143,7 @@ function staticFile(pathname) {
   const spec = map[pathname];
   if (!spec)
     return null;
-  const full = join19(WEB_ROOT, spec[0]);
+  const full = join20(WEB_ROOT, spec[0]);
   if (!existsSync8(full))
     return text("not found", 404);
   return new Response(readFileSync9(full), {
@@ -24541,7 +25394,7 @@ function safeWorktreePath2(path) {
   return safeWorktreePath(currentSearchEnv(), path);
 }
 function worktreePath(path) {
-  return join19(cwd, path);
+  return join20(cwd, path);
 }
 function safeOpenWorktreePath(path) {
   if (path === "") {
@@ -24830,7 +25683,7 @@ async function handleLog(url) {
 }
 function blamePathKey(p) {
   try {
-    const st = statSync6(join19(cwd, p));
+    const st = statSync6(join20(cwd, p));
     return `${st.mtimeMs}:${st.size}`;
   } catch {
     return "missing";
@@ -25363,7 +26216,7 @@ async function handleUploadFiles(req) {
     total += file.size;
     if (total > MAX_UPLOAD_TOTAL_BYTES)
       return text("upload too large", 413);
-    const target = join19(realDir, safeName);
+    const target = join20(realDir, safeName);
     if (relative7(realDir, dirname5(target)) !== "")
       return text("invalid filename", 400);
     if (existsSync8(target))
@@ -25485,9 +26338,9 @@ function triggerUpdate(changedPaths) {
   sendSse("update", data);
 }
 function moveMacPathIntoTrash(path) {
-  const trashDir = join19(homedir3(), ".Trash");
+  const trashDir = join20(homedir3(), ".Trash");
   const base = basename3(path) || "code-viewer-trash-item";
-  const target = join19(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
+  const target = join20(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
   try {
     mkdirSync4(trashDir, { recursive: true });
     renameSync(path, target);
@@ -25529,7 +26382,7 @@ async function restoreTrashPath(originalPath, trashPath) {
     if (!existsSync8(trashPath))
       return { ok: false, error: "trash item not found" };
     try {
-      const trashRoot = join19(homedir3(), ".Trash");
+      const trashRoot = join20(homedir3(), ".Trash");
       const trashRelative = relative7(trashRoot, trashPath);
       if (trashRelative === "" || trashRelative.startsWith("..") || trashRelative.startsWith("/") || trashRelative.startsWith("\\"))
         return { ok: false, error: "invalid trash handle" };
@@ -25679,7 +26532,7 @@ async function handleCreateDirectory(req) {
   const targetPath = dir ? `${dir}/${name}` : name;
   if (!safeRepoPath(targetPath) || isGitInternalPath(targetPath))
     return text("invalid target", 400);
-  const target = join19(parent, name);
+  const target = join20(parent, name);
   if (existsSync8(target))
     return text("already exists", 409);
   try {
@@ -26277,8 +27130,8 @@ var init_preview = __esm(async () => {
   init_server_registry();
   init_state_store();
   init_worktree_watcher();
-  WEB_ROOT = join19(ROOT, "web");
-  VERSION = JSON.parse(readFileSync9(join19(ROOT, "package.json"), "utf8")).version;
+  WEB_ROOT = join20(ROOT, "web");
+  VERSION = JSON.parse(readFileSync9(join20(ROOT, "package.json"), "utf8")).version;
   DEFAULT_ARGS = ["HEAD"];
   WATCHED_ASSET_FILES = ["index.html", "style.css", "app.js"];
   LINE_INDEX_MAX_FILE_BYTES = 256 * 1024 * 1024;