@carllee1983/dbcli 1.1.0 → 1.2.0

package/dist/cli.mjs

@@ -6105,7 +6105,9 @@ var exports_validation = {};
 __export(exports_validation, {
   validateFormat: () => validateFormat,
   PermissionSchema: () => PermissionSchema,
+  NamedConnectionSchema: () => NamedConnectionSchema,
   MetadataSchema: () => MetadataSchema,
+  DbcliConfigV2Schema: () => DbcliConfigV2Schema,
   DbcliConfigSchema: () => DbcliConfigSchema,
   ConnectionConfigSchema: () => ConnectionConfigSchema,
   BlacklistConfigSchema: () => BlacklistConfigSchema
@@ -6116,7 +6118,7 @@ function validateFormat(value, allowedFormats, commandName) {
     throw new Error(`Invalid format "${value}" for ${commandName}. Allowed: ${allowed}`);
   }
 }
-var EnvRefSchema, StringOrEnvRef, NumberOrEnvRef, ConnectionConfigSchema, PermissionSchema, MetadataSchema, BlacklistConfigSchema, DbcliConfigSchema;
+var EnvRefSchema, StringOrEnvRef, NumberOrEnvRef, ConnectionConfigSchema, PermissionSchema, MetadataSchema, BlacklistConfigSchema, DbcliConfigSchema, NamedConnectionSchema, DbcliConfigV2Schema;
 var init_validation = __esm(() => {
   init_zod();
   EnvRefSchema = exports_external.object({
@@ -6154,6 +6156,18 @@ var init_validation = __esm(() => {
     metadata: MetadataSchema,
     blacklist: BlacklistConfigSchema
   });
+  NamedConnectionSchema = ConnectionConfigSchema.extend({
+    permission: PermissionSchema,
+    envFile: exports_external.string().optional()
+  });
+  DbcliConfigV2Schema = exports_external.object({
+    version: exports_external.literal(2),
+    default: exports_external.string().min(1),
+    connections: exports_external.record(NamedConnectionSchema).refine((conns) => Object.keys(conns).length > 0, { message: "At least one connection is required" }),
+    schema: exports_external.record(exports_external.any()).optional().default({}),
+    metadata: MetadataSchema,
+    blacklist: BlacklistConfigSchema
+  }).refine((config) => (config.default in config.connections), { message: "Default connection must exist in connections", path: ["default"] });
 });
 
 // node_modules/@inquirer/core/dist/esm/lib/key.mjs
@@ -42998,7 +43012,7 @@ var require_named_placeholders = __commonJS((exports, module) => {
       }
       return s;
     }
-    function join2(tree) {
+    function join3(tree) {
       if (tree.length === 1) {
         return tree;
       }
@@ -43024,7 +43038,7 @@ var require_named_placeholders = __commonJS((exports, module) => {
       if (cache && (tree = cache.get(query))) {
         return toArrayParams(tree, paramsObj);
       }
-      tree = join2(parse(query));
+      tree = join3(parse(query));
       if (cache) {
         cache.set(query, tree);
       }
@@ -46850,7 +46864,7 @@ var {
 // package.json
 var package_default = {
   name: "@carllee1983/dbcli",
-  version: "1.1.0",
+  version: "1.2.0",
   description: "Database CLI for AI agents",
   type: "module",
   publishConfig: {
@@ -46952,7 +46966,27 @@ var messages_default = {
     skip_test_env_ref: "Skipping connection test in env-ref mode",
     skip_test: "Skipping connection test (--skip-test)",
     connection_hints: "Hints:",
-    config_exists_use_force: ".dbcli exists. Use --force option to overwrite."
+    config_exists_use_force: ".dbcli exists. Use --force option to overwrite.",
+    connection_added: "Connection '{{name}}' added",
+    connection_removed: "Connection '{{name}}' removed",
+    connection_removed_switched: "Connection '{{name}}' removed. Default connection switched to '{{newDefault}}'",
+    connection_renamed: "Connection '{{oldName}}' renamed to '{{newName}}'",
+    v1_migration_prompt: "Detected old config format. Create new format and import existing connection as 'default'?",
+    config_saved_v2: "V2 configuration saved to .dbcli",
+    config_not_found: "Configuration file not found",
+    requires_v2_remove: "Removing a connection requires V2 config format",
+    requires_v2_rename: "Renaming a connection requires V2 config format",
+    connection_not_found: "Connection '{{name}}' does not exist",
+    cannot_remove_last: "Cannot remove the last connection",
+    connection_already_exists: "Connection '{{name}}' already exists",
+    rename_invalid_format: "Usage: --rename <old-name>:<new-name>"
+  },
+  use: {
+    description: "Switch or display the default database connection",
+    switched: "Switched default connection to {{name}}",
+    current: "Current default connection: {{name}}",
+    requires_v2: "This feature requires v2 config format. Use 'dbcli init --conn-name <name>' to create one",
+    available: "Available connections"
   },
   schema: {
     description: "Retrieve table structure or list all tables",
@@ -47104,7 +47138,27 @@ var messages_default2 = {
     skip_test_env_ref: "\u8DF3\u904E\u9023\u7DDA\u6E2C\u8A66\uFF08\u74B0\u5883\u8B8A\u6578\u53C3\u7167\u6A21\u5F0F\uFF09",
     skip_test: "\u8DF3\u904E\u9023\u7DDA\u6E2C\u8A66\uFF08--skip-test\uFF09",
     connection_hints: "\u63D0\u793A\uFF1A",
-    config_exists_use_force: ".dbcli \u5DF2\u5B58\u5728\u3002\u4F7F\u7528 --force \u9078\u9805\u8986\u84CB\u3002"
+    config_exists_use_force: ".dbcli \u5DF2\u5B58\u5728\u3002\u4F7F\u7528 --force \u9078\u9805\u8986\u84CB\u3002",
+    connection_added: "\u5DF2\u65B0\u589E\u9023\u7DDA '{{name}}'",
+    connection_removed: "\u5DF2\u79FB\u9664\u9023\u7DDA '{{name}}'",
+    connection_removed_switched: "\u5DF2\u79FB\u9664\u9023\u7DDA '{{name}}'\uFF0C\u9810\u8A2D\u9023\u7DDA\u5DF2\u5207\u63DB\u70BA '{{newDefault}}'",
+    connection_renamed: "\u5DF2\u5C07\u9023\u7DDA '{{oldName}}' \u91CD\u65B0\u547D\u540D\u70BA '{{newName}}'",
+    v1_migration_prompt: "\u5075\u6E2C\u5230\u820A\u683C\u5F0F\u8A2D\u5B9A\uFF0C\u5C07\u5EFA\u7ACB\u65B0\u683C\u5F0F\u4E26\u5C07\u73FE\u6709\u9023\u7DDA\u532F\u5165\u70BA 'default'\uFF0C\u662F\u5426\u7E7C\u7E8C\uFF1F",
+    config_saved_v2: "V2 \u8A2D\u5B9A\u5DF2\u5132\u5B58\u81F3 .dbcli",
+    config_not_found: "\u627E\u4E0D\u5230\u8A2D\u5B9A\u6A94",
+    requires_v2_remove: "\u79FB\u9664\u9023\u7DDA\u9700\u8981 V2 \u683C\u5F0F\u8A2D\u5B9A",
+    requires_v2_rename: "\u91CD\u65B0\u547D\u540D\u9023\u7DDA\u9700\u8981 V2 \u683C\u5F0F\u8A2D\u5B9A",
+    connection_not_found: "\u9023\u7DDA '{{name}}' \u4E0D\u5B58\u5728",
+    cannot_remove_last: "\u7121\u6CD5\u79FB\u9664\u6700\u5F8C\u4E00\u500B\u9023\u7DDA",
+    connection_already_exists: "\u9023\u7DDA '{{name}}' \u5DF2\u5B58\u5728",
+    rename_invalid_format: "\u7528\u6CD5\uFF1A--rename <\u820A\u540D\u7A31>:<\u65B0\u540D\u7A31>"
+  },
+  use: {
+    description: "\u5207\u63DB\u6216\u986F\u793A\u9810\u8A2D\u8CC7\u6599\u5EAB\u9023\u7DDA",
+    switched: "\u5DF2\u5207\u63DB\u9810\u8A2D\u9023\u7DDA\u70BA {{name}}",
+    current: "\u76EE\u524D\u9810\u8A2D\u9023\u7DDA\uFF1A{{name}}",
+    requires_v2: "\u6B64\u529F\u80FD\u9700\u8981\u65B0\u683C\u5F0F\u8A2D\u5B9A\u3002\u8ACB\u4F7F\u7528 dbcli init --conn-name <\u540D\u7A31> \u5EFA\u7ACB\u591A\u9023\u7DDA\u8A2D\u5B9A",
+    available: "\u53EF\u7528\u9023\u7DDA"
   },
   schema: {
     description: "\u6AA2\u7D22\u8868\u683C\u7D50\u69CB\u6216\u5217\u51FA\u6240\u6709\u8868\u683C",
@@ -47389,6 +47443,9 @@ function getLogger() {
   return globalLogger;
 }
 
+// src/commands/init.ts
+import { join as join3 } from "path";
+
 // src/utils/errors.ts
 class EnvParseError extends Error {
   constructor(message) {
@@ -47490,7 +47547,97 @@ function parseEnvDatabase(env) {
 
 // src/core/config.ts
 init_validation();
+
+// src/core/config-v2.ts
+init_validation();
+
+// src/core/env-loader.ts
+function parseEnvContent(content) {
+  const entries = [];
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1)
+      continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1);
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    entries.push([key, value]);
+  }
+  return entries;
+}
+async function loadEnvFile(filePath) {
+  const file = Bun.file(filePath);
+  const exists = await file.exists();
+  if (!exists) {
+    throw new ConfigError(`\u627E\u4E0D\u5230 env \u6A94\u6848\uFF1A${filePath}`);
+  }
+  const content = await file.text();
+  const entries = parseEnvContent(content);
+  for (const [key, value] of entries) {
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+}
+
+// src/core/config-v2.ts
 import { join } from "path";
+function detectConfigVersion(raw) {
+  if (typeof raw === "object" && raw !== null && "version" in raw && raw.version === 2 && "connections" in raw) {
+    return 2;
+  }
+  return 1;
+}
+function resolveConnection(config, name) {
+  const connectionName = name ?? config.default;
+  const conn = config.connections[connectionName];
+  if (!conn) {
+    const available = Object.keys(config.connections).join(", ");
+    throw new ConfigError(`\u9023\u7DDA '${connectionName}' \u4E0D\u5B58\u5728\u3002\u53EF\u7528\u9023\u7DDA\uFF1A${available}`);
+  }
+  const { permission, envFile, ...connectionFields } = conn;
+  return {
+    name: connectionName,
+    connection: connectionFields,
+    permission,
+    envFile
+  };
+}
+async function loadConnectionEnv(resolved, basePath) {
+  if (resolved.envFile) {
+    const envPath = join(basePath, "..", resolved.envFile);
+    await loadEnvFile(envPath);
+  }
+}
+async function readV2Config(path) {
+  const configPath = join(path, "config.json");
+  const file = Bun.file(configPath);
+  if (!await file.exists()) {
+    throw new ConfigError(`\u627E\u4E0D\u5230 V2 \u8A2D\u5B9A\u6A94\uFF1A${configPath}`);
+  }
+  const content = await file.text();
+  const raw = JSON.parse(content);
+  return DbcliConfigV2Schema.parse(raw);
+}
+async function writeV2Config(path, config) {
+  DbcliConfigV2Schema.parse(config);
+  const configPath = join(path, "config.json");
+  const json = JSON.stringify(config, null, 2);
+  await Bun.write(configPath, json);
+}
+
+// src/core/config.ts
+import { join as join2 } from "path";
+var _globalConnectionName;
+function setGlobalConnectionName(name) {
+  _globalConnectionName = name;
+}
 var DEFAULT_CONFIG = {
   connection: {
     system: "postgresql",
@@ -47547,7 +47694,8 @@ function parseEnvPassword(content) {
   return match ? match[1].trim() : null;
 }
 var configModule = {
-  async read(path) {
+  async read(path, connectionName) {
+    const effectiveConnectionName = connectionName ?? _globalConnectionName;
     try {
       let isDirectory = false;
       try {
@@ -47557,14 +47705,40 @@ var configModule = {
         isDirectory = false;
       }
       if (isDirectory) {
-        const configPath = join(path, "config.json");
+        const configPath = join2(path, "config.json");
         const configFile = Bun.file(configPath);
         const configExists = await configFile.exists();
         if (configExists) {
           const content = await configFile.text();
           const config = JSON.parse(content);
+          if (detectConfigVersion(config) === 2) {
+            const v2Config = DbcliConfigV2Schema.parse(config);
+            const resolved = resolveConnection(v2Config, effectiveConnectionName);
+            await loadConnectionEnv(resolved, configPath);
+            const envLocalPath = join2(path, ".env.local");
+            const envLocalFile = Bun.file(envLocalPath);
+            let legacyPassword = null;
+            if (await envLocalFile.exists()) {
+              const envContent = await envLocalFile.text();
+              legacyPassword = parseEnvPassword(envContent);
+              if (legacyPassword && !process.env.DBCLI_PASSWORD) {
+                process.env.DBCLI_PASSWORD = legacyPassword;
+              }
+            }
+            const resolvedConnection = resolveEnvReferences(resolved.connection, process.env, undefined, false);
+            if (!resolvedConnection.password && legacyPassword) {
+              resolvedConnection.password = legacyPassword;
+            }
+            return DbcliConfigSchema.parse({
+              connection: resolvedConnection,
+              permission: resolved.permission,
+              schema: v2Config.schema,
+              metadata: v2Config.metadata,
+              blacklist: v2Config.blacklist
+            });
+          }
           const resolvedConfig = resolveEnvReferences(config, process.env, undefined, false);
-          const envPath = join(path, ".env.local");
+          const envPath = join2(path, ".env.local");
           const envFile = Bun.file(envPath);
           if (await envFile.exists()) {
             const envContent = await envFile.text();
@@ -47586,6 +47760,8 @@ var configModule = {
       }
       return { ...DEFAULT_CONFIG };
     } catch (error) {
+      if (error instanceof ConfigError)
+        throw error;
       if (error instanceof Error && error.message.includes("JSON")) {
         throw new ConfigError(`Failed to parse .dbcli file: ${error.message}`);
       }
@@ -47629,7 +47805,7 @@ var configModule = {
       if (isDirectory || path.endsWith(".dbcli")) {
         const hasEnvReferences = isEnvReference(config.connection.password);
         if (hasEnvReferences) {
-          const configPath = join(path, "config.json");
+          const configPath = join2(path, "config.json");
           const configJson = JSON.stringify(config, null, 2);
           await Bun.file(configPath).write(configJson);
         } else {
@@ -47642,11 +47818,11 @@ var configModule = {
             }
           };
           delete configWithoutPassword.connection.password;
-          const configPath = join(path, "config.json");
+          const configPath = join2(path, "config.json");
           const configJson = JSON.stringify(configWithoutPassword, null, 2);
           await Bun.file(configPath).write(configJson);
           if (password) {
-            const envPath = join(path, ".env.local");
+            const envPath = join2(path, ".env.local");
             const envContent = `# Database Credentials - DO NOT commit to git
 
 DBCLI_PASSWORD=${password}
@@ -48440,10 +48616,10 @@ class AdapterFactory {
 }
 // src/commands/init.ts
 var VALID_PERMISSIONS = ["query-only", "read-write", "data-admin", "admin"];
-async function checkOverwrite(shouldPrompt, force) {
-  const configFile = Bun.file(".dbcli");
-  const fileExists = await configFile.exists();
-  if (!fileExists || force)
+async function checkOverwrite(configPath, shouldPrompt, force) {
+  const fileExists = await Bun.file(configPath).exists();
+  const dirConfigExists = await Bun.file(join3(configPath, "config.json")).exists();
+  if (!fileExists && !dirConfigExists || force)
     return true;
   if (shouldPrompt) {
     const overwrite = await promptUser.confirm(t("init.config_exists_overwrite"));
@@ -48455,7 +48631,140 @@ async function checkOverwrite(shouldPrompt, force) {
   }
   throw new Error(t("init.config_exists_use_force"));
 }
-var initCommand = new Command("init").description("Initialize dbcli configuration with .env parsing and interactive prompts").option("--host <host>", "Database host").option("--port <port>", "Database port").option("--user <user>", "Database user").option("--password <password>", "Database password").option("--name <name>", "Database name").option("--system <system>", "Database system (postgresql, mysql, mariadb)").option("--permission <permission>", "Permission level (query-only, read-write, data-admin, admin)", "query-only").option("--use-env-refs", "Store env var references in config instead of actual values (for CI/CD or multi-env)", false).option("--env-host <var>", "Env var name for host (with --use-env-refs)").option("--env-port <var>", "Env var name for port (with --use-env-refs)").option("--env-user <var>", "Env var name for user (with --use-env-refs)").option("--env-password <var>", "Env var name for password (with --use-env-refs)").option("--env-database <var>", "Env var name for database (with --use-env-refs)").option("--skip-test", "Skip database connection test").option("--no-interactive", "Non-interactive mode (requires all values via flags)").option("--force", "Skip overwrite confirmation if .dbcli exists").action(async (options) => {
+async function handleRemove(configPath, name) {
+  const configFile = Bun.file(join3(configPath, "config.json"));
+  if (!await configFile.exists()) {
+    throw new Error(t("init.config_not_found"));
+  }
+  const raw = JSON.parse(await configFile.text());
+  if (detectConfigVersion(raw) !== 2) {
+    throw new Error(t("init.requires_v2_remove"));
+  }
+  const config = await readV2Config(configPath);
+  if (!config.connections[name]) {
+    throw new Error(t_vars("init.connection_not_found", { name }));
+  }
+  const connectionCount = Object.keys(config.connections).length;
+  if (connectionCount <= 1) {
+    throw new Error(t("init.cannot_remove_last"));
+  }
+  const { [name]: _removed, ...remaining } = config.connections;
+  const newDefault = config.default === name ? Object.keys(remaining)[0] : config.default;
+  const updated = {
+    ...config,
+    default: newDefault,
+    connections: remaining
+  };
+  await writeV2Config(configPath, updated);
+  if (config.default === name) {
+    console.log(t_vars("init.connection_removed_switched", { name, newDefault }));
+  } else {
+    console.log(t_vars("init.connection_removed", { name }));
+  }
+}
+async function handleRename(configPath, renameArg) {
+  const [oldName, newName] = renameArg.split(":");
+  if (!oldName || !newName) {
+    throw new Error(t("init.rename_invalid_format"));
+  }
+  const configFile = Bun.file(join3(configPath, "config.json"));
+  if (!await configFile.exists()) {
+    throw new Error(t("init.config_not_found"));
+  }
+  const raw = JSON.parse(await configFile.text());
+  if (detectConfigVersion(raw) !== 2) {
+    throw new Error(t("init.requires_v2_rename"));
+  }
+  const config = await readV2Config(configPath);
+  if (!config.connections[oldName]) {
+    throw new Error(t_vars("init.connection_not_found", { name: oldName }));
+  }
+  if (config.connections[newName]) {
+    throw new Error(t_vars("init.connection_already_exists", { name: newName }));
+  }
+  const entries = Object.entries(config.connections).map(([key2, value]) => [key2 === oldName ? newName : key2, value]);
+  const updated = {
+    ...config,
+    default: config.default === oldName ? newName : config.default,
+    connections: Object.fromEntries(entries)
+  };
+  await writeV2Config(configPath, updated);
+  console.log(t_vars("init.connection_renamed", { oldName, newName }));
+}
+async function writeV2InitConfig(configPath, connectionName, connection, permission, envFile) {
+  const configJsonPath = join3(configPath, "config.json");
+  const configFile = Bun.file(configJsonPath);
+  let existingV2 = null;
+  if (await configFile.exists()) {
+    const raw = JSON.parse(await configFile.text());
+    if (detectConfigVersion(raw) === 2) {
+      existingV2 = await readV2Config(configPath);
+    } else {
+      const v1Config = await configModule.read(configPath);
+      existingV2 = {
+        version: 2,
+        default: "default",
+        connections: {
+          default: {
+            ...v1Config.connection,
+            permission: v1Config.permission
+          }
+        },
+        schema: v1Config.schema || {},
+        metadata: v1Config.metadata || { version: "1.0" },
+        blacklist: v1Config.blacklist || { tables: [], columns: {} }
+      };
+    }
+  } else {
+    const legacyFile = Bun.file(configPath);
+    if (await legacyFile.exists()) {
+      const raw = JSON.parse(await legacyFile.text());
+      if (detectConfigVersion(raw) !== 2) {
+        const v1Config = await configModule.read(configPath);
+        existingV2 = {
+          version: 2,
+          default: "default",
+          connections: {
+            default: {
+              ...v1Config.connection,
+              permission: v1Config.permission
+            }
+          },
+          schema: v1Config.schema || {},
+          metadata: v1Config.metadata || { version: "1.0" },
+          blacklist: v1Config.blacklist || { tables: [], columns: {} }
+        };
+      }
+    }
+  }
+  const connEntry = {
+    ...connection,
+    permission
+  };
+  if (envFile) {
+    connEntry.envFile = envFile;
+  }
+  const v2Config = existingV2 ? {
+    ...existingV2,
+    connections: {
+      ...existingV2.connections,
+      [connectionName]: connEntry
+    }
+  } : {
+    version: 2,
+    default: connectionName,
+    connections: {
+      [connectionName]: connEntry
+    },
+    schema: {},
+    metadata: { version: "1.0", createdAt: new Date().toISOString() },
+    blacklist: { tables: [], columns: {} }
+  };
+  await Bun.$`mkdir -p ${configPath}`;
+  await writeV2Config(configPath, v2Config);
+  console.log(t("init.config_saved"));
+}
+var initCommand = new Command("init").description("Initialize dbcli configuration with .env parsing and interactive prompts").option("--host <host>", "Database host").option("--port <port>", "Database port").option("--user <user>", "Database user").option("--password <password>", "Database password").option("--name <name>", "Database name").option("--system <system>", "Database system (postgresql, mysql, mariadb)").option("--permission <permission>", "Permission level (query-only, read-write, data-admin, admin)", "query-only").option("--use-env-refs", "Store env var references in config instead of actual values (for CI/CD or multi-env)", false).option("--env-host <var>", "Env var name for host (with --use-env-refs)").option("--env-port <var>", "Env var name for port (with --use-env-refs)").option("--env-user <var>", "Env var name for user (with --use-env-refs)").option("--env-password <var>", "Env var name for password (with --use-env-refs)").option("--env-database <var>", "Env var name for database (with --use-env-refs)").option("--skip-test", "Skip database connection test").option("--no-interactive", "Non-interactive mode (requires all values via flags)").option("--force", "Skip overwrite confirmation if .dbcli exists").option("--conn-name <name>", "Connection name (creates v2 multi-connection config)").option("--env-file <path>", "Path to env file for this connection").option("--remove <name>", "Remove a named connection").option("--rename <names>", "Rename a connection (format: old:new)").action(async (options) => {
   try {
     await initCommandHandler(options);
   } catch (error) {
@@ -48468,7 +48777,18 @@ var initCommand = new Command("init").description("Initialize dbcli configuratio
   }
 });
 async function initCommandHandler(options) {
-  const existingConfig = await configModule.read(".dbcli");
+  const configPath = initCommand.parent?.opts().config ?? ".dbcli";
+  if (options.remove) {
+    await handleRemove(configPath, options.remove);
+    return;
+  }
+  if (options.rename) {
+    await handleRename(configPath, options.rename);
+    return;
+  }
+  const isV2Init = !!(options.connName || options.envFile);
+  const connectionName = options.connName || "default";
+  const existingConfig = await configModule.read(configPath);
   const isUsingEnvRefs = options.useEnvRefs;
   const hasAllEnvOptions = isUsingEnvRefs && options.envHost && options.envPort && options.envUser && options.envPassword && options.envDatabase;
   const shouldPrompt = !options.noInteractive && !hasAllEnvOptions;
@@ -48526,11 +48846,15 @@ async function initCommandHandler(options) {
       connection: configForWrite,
       permission: permission2
     });
-    const canProceed2 = await checkOverwrite(shouldPrompt, !!options.force);
+    const canProceed2 = await checkOverwrite(configPath, shouldPrompt, !!options.force);
     if (!canProceed2)
       return;
     console.log(`\u23ED\uFE0F  ${t("init.skip_test_env_ref")}`);
-    await configModule.write(".dbcli", newConfig2);
+    if (isV2Init) {
+      await writeV2InitConfig(configPath, connectionName, configForWrite, permission2, options.envFile);
+      return;
+    }
+    await configModule.write(configPath, newConfig2);
     console.log(t("init.config_saved"));
     return;
   }
@@ -48585,7 +48909,7 @@ async function initCommandHandler(options) {
     connection: configForWrite,
     permission
   });
-  const canProceed = await checkOverwrite(shouldPrompt, !!options.force);
+  const canProceed = await checkOverwrite(configPath, shouldPrompt, !!options.force);
   if (!canProceed)
     return;
   if (!options.skipTest && !options.useEnvRefs) {
@@ -48631,7 +48955,11 @@ async function initCommandHandler(options) {
     const msgKey = options.useEnvRefs ? "init.skip_test_env_ref" : "init.skip_test";
     console.log(`\u23ED\uFE0F  ${t(msgKey)}`);
   }
-  await configModule.write(".dbcli", newConfig);
+  if (isV2Init) {
+    await writeV2InitConfig(configPath, connectionName, configForWrite, permission, options.envFile);
+    return;
+  }
+  await configModule.write(configPath, newConfig);
   console.log(t("init.config_saved"));
 }
 
@@ -51287,7 +51615,7 @@ var statusCommand = new Command("status").description("Show current configuratio
 
 // src/commands/doctor.ts
 init_validation();
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 var ALLOWED_FORMATS7 = ["text", "json"];
 var SENSITIVE_PATTERNS = [
   "password",
@@ -51349,7 +51677,7 @@ var runDoctorChecks = {
     }
   },
   async checkConfigExists(configPath, existsFn) {
-    const exists = existsFn ? await existsFn(configPath) : await Bun.file(configPath).exists() || await Bun.file(join3(configPath, "config.json")).exists();
+    const exists = existsFn ? await existsFn(configPath) : await Bun.file(configPath).exists() || await Bun.file(join5(configPath, "config.json")).exists();
     return {
       group: "Configuration",
       label: "Config exists",
@@ -51441,6 +51769,60 @@ var runDoctorChecks = {
       message: `Large tables: ${list}`
     };
   },
+  async checkV2Config(configPath) {
+    const results = [];
+    const configFile = Bun.file(join5(configPath, "config.json"));
+    if (!await configFile.exists())
+      return results;
+    let raw;
+    try {
+      raw = JSON.parse(await configFile.text());
+    } catch {
+      return results;
+    }
+    if (detectConfigVersion(raw) !== 2)
+      return results;
+    let config;
+    try {
+      config = DbcliConfigV2Schema.parse(raw);
+    } catch {
+      results.push({
+        group: "Configuration",
+        label: "V2 config validation",
+        status: "error",
+        message: "V2 \u8A2D\u5B9A\u6A94\u683C\u5F0F\u7121\u6548"
+      });
+      return results;
+    }
+    if (!config.connections[config.default]) {
+      results.push({
+        group: "Configuration",
+        label: "Default connection",
+        status: "error",
+        message: `\u9810\u8A2D\u9023\u7DDA '${config.default}' \u4E0D\u5B58\u5728\u65BC connections \u4E2D`
+      });
+    } else {
+      results.push({
+        group: "Configuration",
+        label: "Default connection",
+        status: "pass",
+        message: `\u9810\u8A2D\u9023\u7DDA '${config.default}' \u6709\u6548`
+      });
+    }
+    for (const [name, conn] of Object.entries(config.connections)) {
+      if (conn.envFile) {
+        const envPath = join5(configPath, "..", conn.envFile);
+        const exists = await Bun.file(envPath).exists();
+        results.push({
+          group: "Configuration",
+          label: `Env file (${name})`,
+          status: exists ? "pass" : "error",
+          message: exists ? `${conn.envFile} \u5B58\u5728` : `\u9023\u7DDA '${name}' \u7684 env \u6A94\u6848 ${conn.envFile} \u4E0D\u5B58\u5728`
+        });
+      }
+    }
+    return results;
+  },
   formatTextOutput(results, version) {
     const lines2 = [`dbcli doctor v${version}`, ""];
     const groups = ["Environment", "Configuration", "Connection & Data"];
@@ -51489,6 +51871,8 @@ var doctorCommand = new Command("doctor").description("Run diagnostic checks on
         status: "pass",
         message: `Permission: ${config.permission}`
       });
+      const v2Results = await runDoctorChecks.checkV2Config(configPath);
+      results.push(...v2Results);
       const blacklistedColumns = new Map;
       if (config.blacklist?.columns) {
         for (const [table, cols] of Object.entries(config.blacklist.columns)) {
@@ -51523,7 +51907,7 @@ var doctorCommand = new Command("doctor").description("Run diagnostic checks on
           logger.debug("Could not list tables for blacklist/large table check");
         }
         try {
-          const indexPath = join3(configPath, "schemas", "index.json");
+          const indexPath = join5(configPath, "schemas", "index.json");
           const indexFile = Bun.file(indexPath);
           if (await indexFile.exists()) {
             const indexContent = await indexFile.text();
@@ -51565,7 +51949,7 @@ var doctorCommand = new Command("doctor").description("Run diagnostic checks on
 });
 
 // src/commands/completion.ts
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 import { homedir as homedir2 } from "os";
 function extractCommands(program2) {
   return program2.commands.map((cmd) => ({
@@ -51670,11 +52054,11 @@ function getInstallPath2(shell) {
   const home = homedir2();
   switch (shell) {
     case "bash":
-      return join4(home, ".bashrc");
+      return join6(home, ".bashrc");
     case "zsh":
-      return join4(home, ".zshrc");
+      return join6(home, ".zshrc");
     case "fish":
-      return join4(home, ".config", "fish", "completions", "dbcli.fish");
+      return join6(home, ".config", "fish", "completions", "dbcli.fish");
     default:
       throw new Error(`Unsupported shell: ${shell}. Supported: bash, zsh, fish`);
   }
@@ -51694,7 +52078,7 @@ var MARKER_END = "# <<< dbcli completion <<<";
 async function installCompletion(shell, script) {
   const targetPath = getInstallPath2(shell);
   if (shell === "fish") {
-    const dir = join4(homedir2(), ".config", "fish", "completions");
+    const dir = join6(homedir2(), ".config", "fish", "completions");
     await Bun.$`mkdir -p ${dir}`.quiet();
     await Bun.file(targetPath).write(script);
     console.log(colors.success(`\u2713 Fish completion installed to ${targetPath}`));
@@ -51897,7 +52281,7 @@ var upgradeCommand = new Command("upgrade").description("Check for updates and u
 
 // src/commands/shell.ts
 import { createInterface as createInterface2 } from "readline";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/core/repl/types.ts
@@ -52585,7 +52969,7 @@ function matchWithSuffix(candidates, prefix) {
 
 // src/commands/shell.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
-var HISTORY_PATH = join5(homedir3(), ".dbcli_history");
+var HISTORY_PATH = join7(homedir3(), ".dbcli_history");
 var shellCommand = new Command("shell").description("Interactive database shell with auto-completion and syntax highlighting").option("--sql", "SQL-only mode (skip dbcli command parsing)").action(async (options) => {
   const globalOpts = shellCommand.optsWithGlobals?.() ?? {};
   const configPath = globalOpts.config ?? ".dbcli";
@@ -53483,12 +53867,73 @@ addExecOpts(migrateCommand.command("drop-enum <name>").description(t("migrate.dr
   }
 });
 
+// src/commands/use.ts
+import { join as join8 } from "path";
+async function switchDefault(configPath, name, config) {
+  if (!config.connections[name]) {
+    const available = Object.keys(config.connections).join(", ");
+    throw new ConfigError(`${t_vars("init.connection_not_found", { name })}. ${t("use.available")}: ${available}`);
+  }
+  const updated = {
+    ...config,
+    default: name
+  };
+  await writeV2Config(configPath, updated);
+}
+function listConnectionsForDisplay(config) {
+  return Object.entries(config.connections).map(([name, conn]) => {
+    const marker = name === config.default ? "*" : " ";
+    const host = typeof conn.host === "object" ? `\${${conn.host.$env}}` : conn.host;
+    const port = typeof conn.port === "object" ? `\${${conn.port.$env}}` : conn.port;
+    const db = typeof conn.database === "object" ? `\${${conn.database.$env}}` : conn.database;
+    return `${marker} ${name.padEnd(12)} ${conn.system.padEnd(12)} ${host}:${port}/${db}`;
+  });
+}
+async function ensureV2Config(configPath) {
+  const configFile = Bun.file(join8(configPath, "config.json"));
+  if (!await configFile.exists()) {
+    throw new ConfigError(t("init.config_not_found"));
+  }
+  const raw = JSON.parse(await configFile.text());
+  if (!raw.version || raw.version !== 2 || !raw.connections) {
+    throw new ConfigError(t("use.requires_v2"));
+  }
+  return readV2Config(configPath);
+}
+var useCommand = new Command("use").description("Switch or display the default database connection (v2 config)").argument("[name]", "Connection name to switch to").option("--list", "List all connections").action(async (name, options) => {
+  try {
+    const configPath = useCommand.parent?.opts().config ?? ".dbcli";
+    const config = await ensureV2Config(configPath);
+    if (options.list || !name) {
+      if (!name) {
+        console.log(t_vars("use.current", { name: config.default }));
+      }
+      console.log("");
+      for (const line of listConnectionsForDisplay(config)) {
+        console.log(line);
+      }
+      return;
+    }
+    await switchDefault(configPath, name, config);
+    console.log(t_vars("use.switched", { name }));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error(String(error));
+    }
+    process.exit(1);
+  }
+});
+
 // src/cli.ts
-import { join as join6 } from "path";
+import { join as join9 } from "path";
 var _bgVersionCheckResult;
-var program2 = new Command().name("dbcli").description("Database CLI for AI agents").version(package_default.version).option("--no-color", "Disable colored output").option("-v, --verbose", "Increase verbosity (-v verbose, -vv debug)", (_, prev) => prev + 1, 0).option("-q, --quiet", "Suppress non-essential output").option("--config <path>", "Path to .dbcli config file", ".dbcli");
+var program2 = new Command().name("dbcli").description("Database CLI for AI agents").version(package_default.version).option("--no-color", "Disable colored output").option("-v, --verbose", "Increase verbosity (-v verbose, -vv debug)", (_, prev) => prev + 1, 0).option("-q, --quiet", "Suppress non-essential output").option("--config <path>", "Path to .dbcli config file", ".dbcli").option("--use <connection>", "Use a specific named connection (v2 config)");
 program2.hook("preAction", (thisCommand, actionCommand) => {
   const opts = thisCommand.opts();
+  const useConnection = opts.use;
+  setGlobalConnectionName(useConnection);
   if (opts.color === false) {
     process.env.NO_COLOR = "1";
   }
@@ -53508,7 +53953,7 @@ program2.hook("preAction", (thisCommand, actionCommand) => {
       try {
         let cache = null;
         try {
-          const cacheFile = Bun.file(join6(configPath, "version-check.json"));
+          const cacheFile = Bun.file(join9(configPath, "version-check.json"));
           if (await cacheFile.exists()) {
             cache = await cacheFile.json();
           }
@@ -53589,6 +54034,7 @@ program2.addCommand(completionCommand);
 program2.addCommand(upgradeCommand);
 program2.addCommand(shellCommand);
 program2.addCommand(migrateCommand);
+program2.addCommand(useCommand);
 if (!process.argv.slice(2).length) {
   program2.outputHelp();
 }