dsh-db-tool 1.5.91 → 1.6.0

package/client/client.js

@@ -72,6 +72,16 @@ window.__ModuleLoader__.load({
 			auditDetail: "详情",
 			auditDenied: "拒绝",
 			auditConfirmed: "已确认",
+			// 连接导出/导入（口令加密备份）
+			exportConns: "导出",
+			importConns: "导入",
+			passphrase: "口令",
+			passphraseHint: "8 位以上，仅本次导出/导入使用",
+			exportDone: "已导出 {n} 条连接",
+			importResult: "已导入 {i} 条，跳过 {s} 条",
+			importPartialFail: "部分失败：成功 {i} 条，跳过 {s} 条，失败 {f} 条",
+			importDecryptFail: "口令错误或文件已损坏",
+			pickFile: "选择文件",
 			// 授权
 			grantsHint: "为当前项目授权连接。只读=仅查询/浏览，读写=允许执行语句与脚本。未授权的连接在业务操作中一律拒绝。",
 			grantsEmptyHint: "当前项目尚未授权任何连接，在下方每行选择「只读」或「读写」即可完成授权。",
@@ -213,6 +223,15 @@ window.__ModuleLoader__.load({
 			auditDetail: "Detail",
 			auditDenied: "denied",
 			auditConfirmed: "confirmed",
+			exportConns: "Export",
+			importConns: "Import",
+			passphrase: "Passphrase",
+			passphraseHint: "8+ characters, used only for this export/import",
+			exportDone: "Exported {n} connection(s)",
+			importResult: "Imported {i}, skipped {s}",
+			importPartialFail: "Partial failure: {i} imported, {s} skipped, {f} failed",
+			importDecryptFail: "Wrong passphrase or corrupted file",
+			pickFile: "Pick file",
 			grantsHint: "Grant connections to the current project. ro = read-only (query/browse), rw = read-write (execute/script allowed). Unauthorized connections are always rejected.",
 			grantsEmptyHint: "No connections granted to this project yet. Pick read-only or read-write on a row below to grant.",
 			grantsSummary: "{granted}/{total} connections granted",
@@ -596,6 +615,74 @@ window.__ModuleLoader__.load({
 		/* ---------------- 连接管理 ---------------- */
 		const EMPTY_FORM = { id: "", kind: "mysql", name: "", mode: "url", url: "", urlUser: "", urlPassword: "", host: "", port: "", user: "", password: "", database: "", ssl: false };
 
+		// 口令弹窗（ManageView 局部复用，导出/导入共用）：键盘契约对齐 DangerDialog
+		// （Escape=取消、Tab 在对话框内循环锁定）；差异：初始焦点在口令输入框，确认按钮主色。
+		// ponytail: 仅两处使用，故为 ManageView 内部局部组件，不抽通用模块。
+		function PassphraseDialog(props) {
+			const [value, setValue] = React.useState("");
+			const [err, setErr] = React.useState(""); // 就地错误（如口令过短）；读屏经 role=alert 播报
+			const inputRef = React.useRef(null);
+			const dialogRef = React.useRef(null);
+			const titleId = "dbt-pass-title";
+			function done(v) { props.onClose(v); }
+			function submit() {
+				const v = value.trim();
+				if (v.length < 8) { setErr(t("passphraseHint")); return; } // 与服务端 PASSPHRASE_MIN=8 对齐（服务端为权威边界）
+				done(v);
+			}
+			function onKeyDown(e) {
+				if (e.key === "Escape") { e.preventDefault(); done(null); return; }
+				if (e.key === "Enter" && e.target === inputRef.current) { e.preventDefault(); submit(); return; }
+				if (e.key !== "Tab") return;
+				const dialog = dialogRef.current;
+				if (!dialog) return;
+				const els = dialog.querySelectorAll("input,button");
+				if (els.length === 0) return;
+				const first = els[0];
+				const last = els[els.length - 1];
+				const doc = dialog.ownerDocument || document;
+				if (!dialog.contains(doc.activeElement)) { e.preventDefault(); (e.shiftKey ? last : first).focus(); return; }
+				if (!e.shiftKey && doc.activeElement === last) { e.preventDefault(); first.focus(); }
+				else if (e.shiftKey && doc.activeElement === first) { e.preventDefault(); last.focus(); }
+			}
+			// 挂载后焦点落口令输入框（与 DangerDialog 落「取消」不同：本弹窗无危险语义，输入即主路径）
+			React.useEffect(() => {
+				if (inputRef.current && typeof inputRef.current.focus === "function") inputRef.current.focus();
+			}, []);
+			return React.createElement(
+				"div",
+				{ className: "dbt-overlay", onClick: () => done(null), onKeyDown },
+				React.createElement(
+					"div",
+					{
+						className: "dbt-dialog",
+						onClick: (e) => e.stopPropagation(),
+						role: "dialog",
+						"aria-modal": "true",
+						"aria-labelledby": titleId,
+						ref: dialogRef,
+					},
+					React.createElement("strong", { id: titleId }, props.title),
+					React.createElement("input", {
+						type: "password",
+						"aria-label": t("passphrase"),
+						placeholder: t("passphrase"),
+						autoComplete: "off",
+						value,
+						ref: inputRef,
+						onChange: (e) => { setValue(e.target.value); if (err) setErr(""); },
+					}),
+					React.createElement("div", { className: "dbt-muted" }, t("passphraseHint")),
+					err ? React.createElement("div", { className: "dbt-err", role: "alert" }, err) : null,
+					React.createElement(
+						"div",
+						{ className: "dbt-row" },
+						React.createElement("button", { className: "dbt-btn primary", onClick: submit }, props.confirmLabel),
+						React.createElement("button", { className: "dbt-btn", onClick: () => done(null) }, t("cancel")),
+					),
+				),
+			);
+		}
 		// 通用表格渲染：columns + rows（审计列表与查询结果共用）；wrapClass 可选（浏览弹窗用自适应高度容器）
 		function resultTable(columns, rows, cellTitles, wrapClass) {
 			return React.createElement(
@@ -1107,6 +1194,11 @@ window.__ModuleLoader__.load({
 			const [auditOpen, setAuditOpen] = React.useState(false);
 			const [audit, setAudit] = React.useState(null);
 			const [testInfo, setTestInfo] = React.useState({}); // connId -> "ok" | "fail: msg"
+			// 导出/导入流程态：passReq 非空即弹口令窗（"export" | "import"）；fileRef 承载隐藏文件选择器
+			const [passReq, setPassReq] = React.useState(null);
+			const [pendingJson, setPendingJson] = React.useState(null); // 待导入的密文文本（选文件后暂存，口令确认后发送）
+			const [ioInfo, setIoInfo] = React.useState(null); // null | {kind: "ok"|"err", text}
+			const fileRef = React.useRef(null);
 			// 键盘焦点态：统一走模块级 focusRingProps()（描边同 DESIGN.md focus 规范，accent 2px 内缩）
 
 			async function saveConn(body, reset) {
@@ -1156,6 +1248,64 @@ window.__ModuleLoader__.load({
 				}
 			}
 
+			// 口令弹窗确认回调：按 passReq 分流导出/导入；value 为 null 即取消
+			async function onPassphrase(value) {
+				const mode = passReq;
+				setPassReq(null);
+				if (value === null || value === undefined) { setPendingJson(null); return; } // 取消即清密文
+				if (mode === "export") await doExport(value);
+				else if (mode === "import") await doImport(value);
+				setPendingJson(null); // 完成即清密文，避免敏感数据滞留组件状态
+			}
+			// 导出：POST /connections/export 拿密文 json → Blob + a[download] 落盘（文件名带日期戳）
+			async function doExport(passphrase) {
+				await props.run("export", async () => {
+					const data = await api("connections/export", { method: "POST", body: { passphrase } });
+					const json = data && data.json;
+					const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, ""); // YYYYMMDD
+					const blob = new Blob([typeof json === "string" ? json : JSON.stringify(json, null, 2)], { type: "application/json" });
+					const url = URL.createObjectURL(blob);
+					const a = document.createElement("a");
+					a.href = url;
+					a.download = "dsh-db-connections-" + stamp + ".enc.json";
+					document.body.appendChild(a);
+					a.click();
+					a.remove();
+					// 延迟回收：部分浏览器在 click 后才异步 fetch blob，同步 revoke 可能中断下载（与结果导出 download 同模式）
+					window.setTimeout(() => URL.revokeObjectURL(url), 1000);
+					// 服务端回传权威条数 count；缺失时回退本地列表（不声称精确数字）
+					const n = (data && typeof data.count === "number") ? data.count : conns.length;
+					setIoInfo({ kind: "ok", text: t("exportDone", { n }) });
+				});
+			}
+			// 导入：密文已在 pendingJson；口令错（INVALID_ARGUMENT + 解密失败文案）给专用提示，其余透传后端 message
+			async function doImport(passphrase) {
+				const json = pendingJson;
+				await props.run("import", async () => {
+					const data = await api("connections/import", { method: "POST", body: { json, passphrase } });
+					await reload();
+					const failed = (data && data.errors ? data.errors.length : 0);
+					const i = (data && data.imported) || 0;
+					const s = (data && data.skipped ? data.skipped.length : 0);
+					setIoInfo(failed > 0
+						? { kind: "err", text: t("importPartialFail", { i, s, f: failed }) }
+						: { kind: "ok", text: t("importResult", { i, s }) });
+				});
+			}
+			// 隐藏文件选择器回调：FileReader 读文本后暂存，再弹口令窗；读失败走通用错误通道
+			function onPickFile(e) {
+				const file = e.target.files && e.target.files[0];
+				e.target.value = ""; // 允许重复选同一文件
+				if (!file) return;
+				const reader = new FileReader();
+				reader.onload = () => {
+					setPendingJson(String(reader.result || ""));
+					setPassReq("import");
+				};
+				reader.onerror = () => props.onError(reader.error || new Error(t("loadFailed")));
+				reader.readAsText(file);
+			}
+
 			if (editing) {
 				return React.createElement(ConnForm, {
 					initial: editing === "new" ? null : buildEditForm(editing),
@@ -1167,13 +1317,23 @@ window.__ModuleLoader__.load({
 			return React.createElement(
 				"div",
 				{ style: { display: "flex", flexDirection: "column", gap: 8 } },
-				// 顶部操作行：审计在左，「新建连接」主按钮置右侧
+				// 顶部操作行：审计 + 导出/导入在左，「新建连接」主按钮置右侧
 				React.createElement(
 					"div",
 					{ className: "dbt-row", style: { justifyContent: "space-between" } },
-					React.createElement("button", { className: "dbt-btn", "aria-expanded": auditOpen, ...focusRingProps(), onClick: loadAudit }, t("auditShort")),
+					React.createElement(
+						"div",
+						{ className: "dbt-row" },
+						React.createElement("button", { className: "dbt-btn", "aria-expanded": auditOpen, ...focusRingProps(), onClick: loadAudit }, t("auditShort")),
+						React.createElement("button", { className: "dbt-btn", disabled: busy === "export", ...focusRingProps(), onClick: () => setPassReq("export") }, t("exportConns")),
+						React.createElement("button", { className: "dbt-btn", disabled: busy === "import", ...focusRingProps(), onClick: () => { if (fileRef.current) fileRef.current.click(); } }, t("importConns")),
+					),
 					React.createElement("button", { className: "dbt-btn primary", ...focusRingProps(), onClick: () => setEditing("new") }, t("newConn")),
 				),
+				// 隐藏文件选择器：仅导入用，accept 限定 .json
+				React.createElement("input", { type: "file", accept: ".json", "aria-label": t("pickFile"), style: { display: "none" }, ref: fileRef, onChange: onPickFile }),
+				// 导出/导入就地反馈（与测试反馈同语言：dbt-msg 绿 / dbt-err 红）
+				ioInfo ? React.createElement("div", { role: ioInfo.kind === "ok" ? "status" : "alert", className: ioInfo.kind === "ok" ? "dbt-msg" : "dbt-err" }, ioInfo.text) : null,
 				conns.length === 0
 					? // 空状态引导：一句引导 + 主按钮直达新增表单（state 切换在 ManageView 内）
 						React.createElement(
@@ -1231,6 +1391,12 @@ window.__ModuleLoader__.load({
 								auditTable(audit),
 					)
 					: null,
+				// 口令弹窗：导出/导入共用；取消（null）不动作
+				passReq ? React.createElement(PassphraseDialog, {
+					title: passReq === "export" ? t("exportConns") : t("importConns"),
+					confirmLabel: passReq === "export" ? t("exportConns") : t("importConns"),
+					onClose: onPassphrase,
+				}) : null,
 			);
 		}
 

package/dist/http/index.js

@@ -148,6 +148,27 @@ async function route(req, res, service, path, q, opts) {
             }));
         }
     }
+    // 连接导出/导入（口令加密包）。必须置于 connMatch 之前：
+    // /api/connections/export 与 /api/connections/import 都是单层路径，
+    // 若落到 connMatch 会被当作连接 id 匹配（DELETE 无分支静默 404、PUT 误更新）。
+    if (path === '/api/connections/export' && req.method === 'POST') {
+        const b = await readBody(req);
+        const passphrase = str(b['passphrase']);
+        if (!passphrase)
+            return send(res, 400, { ok: false, error: '缺少 passphrase', code: 'INVALID_ARGUMENT' });
+        const count = service.listConnections().length; // 权威条数，前端不再用可能过期的本地列表
+        return sendOk(res, { json: service.exportConnections(passphrase), count });
+    }
+    if (path === '/api/connections/import' && req.method === 'POST') {
+        const b = await readBody(req);
+        const json = str(b['json']);
+        const passphrase = str(b['passphrase']);
+        if (!json)
+            return send(res, 400, { ok: false, error: '缺少 json', code: 'INVALID_ARGUMENT' });
+        if (!passphrase)
+            return send(res, 400, { ok: false, error: '缺少 passphrase', code: 'INVALID_ARGUMENT' });
+        return sendOk(res, service.importConnections(json, passphrase));
+    }
     // 测试未保存的连接草稿（保存前测试；不落库）
     if (path === '/api/test-draft' && req.method === 'POST') {
         const b = await readBody(req);

package/dist/manager.js

@@ -1,8 +1,9 @@
 import { randomBytes } from 'node:crypto';
 import { getAdapter } from './adapters/index.js';
 import { ChallengeStore, classifyStatement, sqlHead, SQL_READ_HEADS, } from './guard/index.js';
-import { mergeUrlCredentials, normalizeProjectKey, } from './store/index.js';
+import { mergeUrlCredentials, normalizeProjectKey, DECRYPT_FAIL_MESSAGE, } from './store/index.js';
 import { runScriptInChild } from './script/runner.js';
+import { decryptPayload, encryptPayload } from './store/export-crypto.js';
 /* ---------------- 错误与结果类型 ---------------- */
 /** 携带机器可读 code 的业务错误（HTTP 层直接映射 {ok:false,error,code}） */
 export class DbToolError extends Error {
@@ -144,6 +145,60 @@ export class DbToolService {
             throw this.toDriverError(e);
         }
     }
+    /* -- 连接导出/导入（口令加密，无需授权；口令不落审计） -- */
+    /** 口令下限：导出包含全部连接机密（明文密码/完整 URL），安全边界在服务端而非 UI */
+    static PASSPHRASE_MIN = 8;
+    /**
+     * 导出全部连接（含机密）为口令加密的 JSON 密文。
+     * 审计只记连接条数，绝不落口令与密文内容。
+     */
+    exportConnections(passphrase) {
+        const pp = assertNonEmpty(passphrase, 'passphrase');
+        if (pp.length < DbToolService.PASSPHRASE_MIN) {
+            throw new DbToolError('INVALID_ARGUMENT', `口令长度至少 ${DbToolService.PASSPHRASE_MIN} 位`);
+        }
+        const bundle = this.store.connections.exportBundle();
+        const json = encryptPayload(bundle, pp);
+        this.audit('', '', 'export_connections', `导出 ${bundle.connections.length} 个连接`, 'none', false, true);
+        return json;
+    }
+    /**
+     * 从口令加密的 JSON 密文导入连接。口令错误或密文损坏统一报
+     * INVALID_ARGUMENT(DECRYPT_FAIL_MESSAGE)（不区分原因，防口令探测）。
+     */
+    importConnections(encryptedJson, passphrase) {
+        const enc = assertNonEmpty(encryptedJson, 'json');
+        const pp = assertNonEmpty(passphrase, 'passphrase');
+        if (pp.length < DbToolService.PASSPHRASE_MIN) {
+            throw new DbToolError('INVALID_ARGUMENT', `口令长度至少 ${DbToolService.PASSPHRASE_MIN} 位`);
+        }
+        let bundle;
+        try {
+            bundle = decryptPayload(enc, pp);
+        }
+        catch {
+            // 口令错误/密文损坏/非合法 JSON 统一归一（decryptPayload 已统一文案，这里兜底）
+            throw new DbToolError('INVALID_ARGUMENT', DECRYPT_FAIL_MESSAGE);
+        }
+        // 结构校验：必须是含 connections 数组的对象，且每个元素为带非空 string id/kind 的对象。
+        // 畸形元素会让 importBundle 在 try 之外抛 TypeError（绕开统一文案），
+        // 或以 undefined id 静默落库成 UI 删不掉的幽灵记录
+        const conns = bundle?.connections;
+        if (!bundle ||
+            typeof bundle !== 'object' ||
+            !Array.isArray(conns) ||
+            conns.some((c) => c === null ||
+                typeof c !== 'object' ||
+                typeof c.id !== 'string' ||
+                c.id === '' ||
+                typeof c.kind !== 'string' ||
+                c.kind === '')) {
+            throw new DbToolError('INVALID_ARGUMENT', DECRYPT_FAIL_MESSAGE);
+        }
+        const summary = this.store.connections.importBundle(bundle);
+        this.audit('', '', 'import_connections', `导入 ${summary.imported} 个连接，跳过 ${summary.skipped.length} 个，失败 ${summary.errors.length} 个`, 'none', false, true);
+        return summary;
+    }
     /* -- 授权管理 -- */
     /** 项目路径归一化（/api/project-context 无会话解析器时的回退路径） */
     projectKey(projectPath) {

package/dist/store/connections.js

@@ -10,6 +10,16 @@ import * as path from 'node:path';
 import { readJson, writeJsonAtomic } from './io.js';
 /** fields 中被视为机密的键，落盘前拆出到 secrets.json */
 const PASSWORD_KEY = 'password';
+/** id 冲突哨兵错误：importBundle 以此 instanceof 识别跳过项，
+ *  替代对 create() 中文错误文案的字符串匹配（文案改动不破坏幂等契约） */
+export class DuplicateConnectionError extends Error {
+    connId;
+    constructor(connId) {
+        super(`连接已存在: ${connId}`);
+        this.connId = connId;
+        this.name = 'DuplicateConnectionError';
+    }
+}
 /** authority 段定位：scheme:// 到首个 /?#（兼容可选 jdbc: 前缀，如 jdbc:gaussdb://），
  *  捕获组 1 为 scheme:// 部分、组 2 为 authority（多主机逗号串整体落在该段内）。
  *  redactUrl 与 mergeUrlCredentials 的字符串回退注入共用。 */
@@ -178,11 +188,11 @@ export class ConnectionStore {
         const rec = this.findRec(this.load(), id);
         return rec ? toMeta(rec, this.hasPassword(id)) : undefined;
     }
-    /** 新建连接；id 已存在时抛错 */
+    /** 新建连接；id 已存在时抛 DuplicateConnectionError */
     create(input) {
         const data = this.load();
         if (this.findRec(data, input.id)) {
-            throw new Error(`连接已存在: ${input.id}`);
+            throw new DuplicateConnectionError(input.id);
         }
         const rec = { id: input.id, kind: input.kind };
         if (input.name !== undefined)
@@ -296,4 +306,77 @@ export class ConnectionStore {
             rc.ssl = rec.ssl;
         return rc;
     }
+    /** 导出连接迁移包：全部连接记录 + 对应机密（含明文密码）。
+     *  调用方必须将整个返回值经 export-crypto 加密后方可落盘/传输，
+     *  本方法本身不加密（加密口令属于 HTTP 层入参，不应侵入存储层）。 */
+    exportBundle() {
+        const connections = this.load().connections;
+        const secrets = {};
+        for (const rec of connections) {
+            const sec = this.secrets.get(rec.id);
+            if (sec !== undefined)
+                secrets[rec.id] = sec;
+        }
+        return { connections, secrets };
+    }
+    /** 导入连接迁移包：逐条走既有 create()（机密拆分/脱敏逻辑全复用）。
+     *  - id 冲突（「连接已存在」）→ 记入 skipped，不覆盖已有数据；
+     *  - 其他异常 → 记入 errors 并继续处理后续条目；
+     *  - 幂等可重入：重复导入同一 bundle，已存在的全部落入 skipped。 */
+    importBundle(bundle) {
+        const result = { imported: 0, skipped: [], errors: [] };
+        for (const rec of bundle.connections) {
+            // per-record 校验：解密成功的包也可能内容畸形（schema 漂移/手工构造），
+            // 缺 id/kind 的记录不落库，计入 errors
+            if (rec === null ||
+                typeof rec !== 'object' ||
+                typeof rec.id !== 'string' ||
+                rec.id === '' ||
+                typeof rec.kind !== 'string' ||
+                rec.kind === '') {
+                result.errors.push({ id: String(rec?.id ?? ''), message: '记录结构非法（缺少 id/kind）' });
+                continue;
+            }
+            const sec = bundle.secrets?.[rec.id];
+            try {
+                // 重建 create 入参：脱敏 URL 回换完整 URL（机密在 sec.url 中）；
+                // fields 模式密码经 fields.password 传入由 create 自动拆分到 secrets
+                this.create({
+                    id: rec.id,
+                    kind: rec.kind,
+                    name: rec.name,
+                    url: sec?.url,
+                    fields: sec?.password !== undefined ? { ...(rec.fields ?? {}), password: sec.password } : rec.fields,
+                    ssl: rec.ssl,
+                });
+                // 覆盖式写回：create 成功后该 id 必无冲突，先清掉既有/孤儿机密
+                // （create 崩溃窗口可能残留旧条目），再整体重写，确保导入后机密与包一致。
+                // 合并写会残留旧键（如旧 url），适配器优先用 rc.url，会被静默错连旧主机。
+                this.secrets.delete(rec.id);
+                try {
+                    if (sec !== undefined)
+                        this.secrets.set(rec.id, sec);
+                }
+                catch (secErr) {
+                    // 写回机密失败：连接行已落盘，回滚避免「errors 里却已存在」的半导入门状态
+                    try {
+                        this.remove(rec.id);
+                    }
+                    catch { /* 尽力而为 */ }
+                    throw secErr;
+                }
+                result.imported += 1;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (err instanceof DuplicateConnectionError) {
+                    result.skipped.push(rec.id);
+                }
+                else {
+                    result.errors.push({ id: rec.id, message });
+                }
+            }
+        }
+        return result;
+    }
 }

package/dist/store/export-crypto.js

@@ -0,0 +1,78 @@
+/**
+ * 连接导出/导入的口令加解密（纯函数，仅用 Node stdlib crypto）。
+ *
+ * 方案：
+ *  - KDF：scryptSync(passphrase, salt, 32) 派生 AES-256 密钥；
+ *  - 算法：AES-256-GCM（机密性 + 完整性一体，tag 防篡改）；
+ *  - iv：12 字节随机（GCM 推荐长度）；salt：16 字节随机；
+ *  - 输出为 JSON 字符串：{ v: 1, kdf: 'scrypt', salt, iv, tag, data }，二进制段全部 base64。
+ *
+ * 失败统一抛 Error('口令错误或文件已损坏')，不向外泄漏是口令错还是文件坏，
+ * 避免给攻击者侧信道。口令本身为空/非字符串时单独抛 Error（参数错误，非解密失败）。
+ */
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+/** 解密失败/文件损坏的统一错误信息 */
+export const DECRYPT_FAIL_MESSAGE = '口令错误或文件已损坏';
+/** 口令断言：必须为非空字符串 */
+function assertPassphrase(passphrase) {
+    if (typeof passphrase !== 'string' || passphrase.length === 0) {
+        throw new Error('口令必须为非空字符串');
+    }
+}
+/** 加密任意可 JSON 序列化的 payload，返回信封 JSON 字符串 */
+export function encryptPayload(plain, passphrase) {
+    assertPassphrase(passphrase);
+    const salt = randomBytes(16);
+    // 显式固定 scrypt 成本参数（与 Node 当前默认一致），加解密两侧同步使用，
+    // 避免导出包跨运行时/跨 Node 版本时因默认值漂移而无法解密
+    const key = scryptSync(passphrase, salt, 32, { N: 16384, r: 8, p: 1 });
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const data = Buffer.concat([cipher.update(JSON.stringify(plain), 'utf8'), cipher.final()]);
+    const box = {
+        v: 1,
+        kdf: 'scrypt',
+        salt: salt.toString('base64'),
+        iv: iv.toString('base64'),
+        tag: cipher.getAuthTag().toString('base64'),
+        data: data.toString('base64'),
+    };
+    return JSON.stringify(box);
+}
+/** 结构校验：缺字段/类型不符即视为文件损坏 */
+function isEncryptedBox(x) {
+    if (x === null || typeof x !== 'object')
+        return false;
+    const b = x;
+    return (b.v === 1 &&
+        b.kdf === 'scrypt' &&
+        typeof b.salt === 'string' &&
+        typeof b.iv === 'string' &&
+        typeof b.tag === 'string' &&
+        typeof b.data === 'string');
+}
+/** 解密信封 JSON，返回原始 payload；口令错误或任一环节损坏统一抛 DECRYPT_FAIL_MESSAGE */
+export function decryptPayload(encryptedJson, passphrase) {
+    assertPassphrase(passphrase);
+    try {
+        const box = JSON.parse(encryptedJson);
+        if (!isEncryptedBox(box))
+            throw new Error('结构非法');
+        const salt = Buffer.from(box.salt, 'base64');
+        const iv = Buffer.from(box.iv, 'base64');
+        const tag = Buffer.from(box.tag, 'base64');
+        const data = Buffer.from(box.data, 'base64');
+        // base64 解码静默容错，需显式校验解码后长度（iv 12B / tag 16B / salt 非空）
+        if (iv.length !== 12 || tag.length !== 16 || salt.length === 0)
+            throw new Error('长度非法');
+        const key = scryptSync(passphrase, salt, 32, { N: 16384, r: 8, p: 1 });
+        const decipher = createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        const plain = Buffer.concat([decipher.update(data), decipher.final()]);
+        return JSON.parse(plain.toString('utf8'));
+    }
+    catch (err) {
+        // 对外统一文案（防侧信道），原始错误挂 cause 供服务端日志区分失败模式
+        throw new Error(DECRYPT_FAIL_MESSAGE, { cause: err });
+    }
+}

package/dist/store/index.js

@@ -18,7 +18,8 @@ import { GrantStore } from './grants.js';
 import { chmodBestEffort } from './io.js';
 import { SecretsBox } from './secrets.js';
 export { normalizeProjectKey } from './normalize.js';
-export { mergeUrlCredentials, redactUrl } from './connections.js';
+export { mergeUrlCredentials, redactUrl, DuplicateConnectionError } from './connections.js';
+export { encryptPayload, decryptPayload, DECRYPT_FAIL_MESSAGE } from './export-crypto.js';
 export { AuditLog, ConnectionStore, GrantStore, SecretsBox };
 export class DbToolStore {
     /** 数据目录：$DSH_HOME/db-tool */

package/docs/connection-export-import.md

@@ -0,0 +1,172 @@
+# 连接管理「导出 / 导入」方案
+
+> 状态：已实现并验收（全仓 `tsc --noEmit` 0 报错；全量 `npm test` 564/564 通过；`npm run build` 成功）
+> 版本：dsh-db-tool ≥ 1.5.91
+> 范围：仅侧边栏「连接管理」面板；模型工具（LLM）不暴露。
+> 技术依据：Node.js crypto 官方文档 + MDN Web Docs（经 context7 检索），逐条对照见 §3、§4.4。
+
+## 1. 背景与目标
+
+dsh-db-tool 把连接配置拆两处持久化：
+
+- `connections.json` — 连接元数据（绝不含密码；密码段在 URL 中被替换为 `***`）
+- `secrets.json` — 连接级机密（完整 URL / 明文密码，权限 0600）
+
+用户需要跨机器迁移连接：一键导出为**单个加密文件**，在另一台机器（或另一个 DSH 实例）用口令解密导入。
+
+### 成功标准（验收已满足）
+
+- 导出文件用任意文本编辑器打开**无明文密码**（整个 payload 加密）。
+- 导出 → 删除全部连接 → 导入，round-trip 后 `testTarget` 可拼回真实 URL/密码，连接可 test 连通。
+- 重复导入幂等：已存在 id 全部计入 `skipped`，不覆盖。
+- 零新增 npm 依赖（全部走 Node stdlib + 各库官方驱动）。
+
+### 明确不做（YAGNI）
+
+- 不含 `grants.json` / `audit.jsonl`：授权是「项目路径 ↔ 连接」的机器绑定关系，跨机迁移无意义；审计不可移植。
+- 不做选择性导出（勾选部分连接）：需要时后续给 export API 加 `ids?: string[]` 即可，不预留抽象。
+- 不在 `handleToolAction`（模型工具）暴露导出：机密不应进入 LLM 上下文，仅 HTTP 面板可用。
+
+## 2. 关键设计决策
+
+| 决策点 | 结论 | 依据 |
+|---|---|---|
+| 导出内容 | 含密码 | 目标是跨机器迁移，无密码无法做到导入即可用 |
+| 加密算法 | 用户口令 + scrypt 派生密钥 + AES-256-GCM | Node stdlib `crypto` 足够，不引第三方加密库（ponytail 阶梯：stdlib 优先） |
+| 冲突策略 | **skip**（不覆盖） | 用户明确选择；幂等可重入，重复导入安全 |
+| 错误反馈 | 口令错 / 密文篡改 / 格式坏**统一**报「口令错误或文件已损坏」 | 不向外泄露失败原因，防侧信道探测 |
+| AAD | 不使用 | 见 §3「AAD 裁决」 |
+
+## 3. 加密格式（按 Node 官方文档校准）
+
+信封结构（JSON，二进制段全 base64）：
+
+```json
+{
+  "v": 1,
+  "kdf": "scrypt",
+  "salt": "<base64, 16 字节>",
+  "iv":   "<base64, 12 字节>",
+  "tag":  "<base64, 16 字节>",
+  "data": "<base64 密文>"
+}
+```
+
+### 官方文档逐条对照
+
+| 参数 | 取值 | 官方依据（context7 → nodejs/node） |
+|---|---|---|
+| KDF | `scryptSync(passphrase, salt, 32)` | `crypto.scryptSync` 官方定位为 password-based KDF，"designed to be expensive computationally and memory-wise in order to make brute-force attacks unrewarding" |
+| scrypt cost/blockSize/parallelization | **默认值**（N=16384, r=8, p=1），maxmem 默认 32MB | 官方默认值即推荐值，不显式覆盖 |
+| salt | 随机 **16 字节**（`randomBytes(16)`） | 官方："It is recommended that a salt is random and at least 16 bytes long"（NIST SP 800-132） |
+| 算法 | `aes-256-gcm` | GCM 同时提供机密性与完整性（auth tag 防篡改） |
+| IV | 随机 **12 字节**（`randomBytes(12)`） | OpenSSL 官方变更说明："The IV length is by default 12 bytes (96 bits)"，GCM 推荐 96-bit |
+| auth tag | **默认 16 字节**，不显式传 `authTagLength` | Node DEP0182 已废止短 tag（<16B）以对齐 NIST SP 800-38D；`createCipheriv` 文档明确 GCM 默认 16 字节 |
+| 解密顺序 | `setAuthTag(tag)` 必须在 `final()` 前 | 官方示例代码（`test-crypto-authenticated.js`）：`decrypt.setAuthTag(...)` → `update` → `final` |
+
+### AAD 裁决（不使用，理由记录）
+
+官方示例用 `setAAD` 把密文绑定到外部上下文（用户 id、文件名等），防信封被整体搬到别的上下文冒充。本方案不加，理由：
+
+1. 信封自含 `v/kdf/salt/iv/tag`，且**口令本身就是解密前提**——信封整体替换后在任何机器上都需要同一口令才能解，AAD 不增加实际安全边界。
+2. 引入 AAD 需要持久化一个额外的上下文字段并保持两端同步，是真实复杂度（ponytail 阶梯：两个同级方案取边界更简单的）。
+3. 文件本身就是交付物，不存在「信封被混进别的数据流」的攻击面。
+
+解密任一环节失败（JSON 解析、结构校验、base64 长度校验、GCM tag 验证、明文 JSON 解析）统一抛 `Error('口令错误或文件已损坏')`（常量 `DECRYPT_FAIL_MESSAGE`）。
+
+明文 payload 结构：
+
+```json
+{
+  "connections": [{ "id", "kind", "name?", "urlSafe?", "fields?", "ssl?" }],
+  "secrets": { "<connId>": { "url?", "password?", "...其他机密键" } }
+}
+```
+
+`secrets` 保留 `SecretEntry` 的扩展键（如 MongoDB 的额外凭证），不只挑 `url/password`。
+
+## 4. 实现分层
+
+### 4.1 存储层 — `lib/store/`
+
+**`export-crypto.ts`（新建，纯函数）**
+
+- `encryptPayload(plain: unknown, passphrase: string): string` — 非空口令断言 → scryptSync(pass, salt, 32) → AES-256-GCM → 信封 JSON。
+- `decryptPayload(encryptedJson: string, passphrase: string): unknown` — 结构校验 + iv/tag/salt 长度校验 + tag 验证 → 原始 payload；任一失败统一抛 `DECRYPT_FAIL_MESSAGE`。
+- `DECRYPT_FAIL_MESSAGE` 导出供 service 层复用。
+
+**`connections.ts`（修改）**
+
+- `exportBundle(): { connections: ConnRecord[]; secrets: Record<string, SecretEntry> }`
+  从 `load()` 取全部连接记录，逐条 `this.secrets.get(id)` 合并；无机密的连接不出现在 `secrets` 中。
+- `importBundle(bundle): { imported: number; skipped: string[]; errors: {id, message}[] }`
+  逐条走**既有** `this.create()`（机密拆分 / URL 脱敏逻辑全复用，不新造写入路径）：`sec.url` 作完整 URL 传入、`sec.password` 经 `fields.password` 自动拆分。冲突（`连接已存在`）→ `skipped`；其他异常 → `errors` 续跑。create 后 `this.secrets.set(rec.id, sec)` 幂等合并写回，保留扩展机密键。
+
+**`index.ts`（修改）**：补导出 `encryptPayload / decryptPayload / DECRYPT_FAIL_MESSAGE` 及 `ConnRecord` 类型。
+
+### 4.2 服务层 — `lib/manager.ts`（DbToolService）
+
+- `exportConnections(passphrase: string): string`
+  非空校验 → `store.exportBundle()` → `encryptPayload` → 审计 `export_connections`（statement 仅记「导出 N 个连接」，不落口令/密文）。
+- `importConnections(encryptedJson: string, passphrase: string)`
+  解密失败 + 结构校验失败（缺 `connections` 数组）统一转 `DbToolError('INVALID_ARGUMENT', DECRYPT_FAIL_MESSAGE)` → `store.importBundle` → 审计 `import_connections`（记 imported/skipped 数）。
+
+### 4.3 HTTP 层 — `lib/http/index.ts`
+
+两条新路由，**插在 `connMatch` 之前**（`/api/connections/export` 与 `/api/connections/import` 都是单层路径，放后面会被正则 `^/api/connections/([^/]+)` 当作连接 id 静默吞掉）：
+
+| 路由 | Body | 成功 | 失败 |
+|---|---|---|---|
+| `POST /api/connections/export` | `{passphrase}` | `{ok:true, data:{json}}` | 缺/空 passphrase → 400 INVALID_ARGUMENT |
+| `POST /api/connections/import` | `{json, passphrase}` | `{ok:true, data:{imported, skipped[], errors[]}}` | 缺参 400；口令错走 `sendError` → 200 + `{ok:false, code:'INVALID_ARGUMENT'}`（与既有契约一致） |
+
+trust 校验（Host/Origin loopback）、2MB body 上限、`{ok,error,code}` 响应契约全部复用既有链路。
+
+### 4.4 客户端 — `client/client.js`（ManageView）
+
+**i18n**：zh/en 各加 8 键（exportConns / importConns / passphrase / passphraseHint / exportDone / importResult / importDecryptFail / pickFile）。
+
+**`PassphraseDialog`**（局部组件，紧邻 `EMPTY_FORM`）：复用 `dbt-overlay/dbt-dialog` 样式；键盘契约对齐 `DangerDialog`（Escape=取消、Tab 循环锁定），差异——初始焦点在口令输入框、确认按钮主色、Enter 提交、前端预校验 ≥6 位。ponytail：仅两处使用，未抽通用模块。
+
+**导出 / 导入文件 IO（按 MDN 官方文档校准）**：
+
+| 操作 | MDN 最佳实践 | 实现 |
+|---|---|---|
+| 下载 | `Blob` → `URL.createObjectURL` → `a.download` → click | `dsh-db-connections-YYYYMMDD.enc.json` |
+| 释放 object URL | 必须 `revokeObjectURL`，但**不能过早**（官方明示：立即 revoke 会让用户无法保存/打开） | `a.click()` 后 `setTimeout(revoke, 1000)`，与仓库内结果导出下载同一模式 |
+| 读取本地文件 | `FileReader.readAsText` + `onload/onerror` 双通道，先校验文件存在 | 读失败走通用错误通道 |
+
+**流程**：
+- 导出：点导出 → 口令窗 → `POST connections/export` → Blob 下载 → `dbt-msg` 显示 `exportDone`。
+- 导入：点导入 → 隐藏 `input[type=file accept=".json"]` 选文件 → FileReader 读文本 → 口令窗 → `POST connections/import` → `reload()` → `dbt-msg` 显示 `importResult`；`err.code === 'INVALID_ARGUMENT'` 时 `dbt-err` 显示 `importDecryptFail`。
+
+## 5. 边界与失败模式
+
+| 场景 | 行为 |
+|---|---|
+| 口令为空 / 非字符串 | store 层抛 `Error('口令必须为非空字符串')`；HTTP 层 400 |
+| 密文被篡改 | GCM tag 校验失败 → 统一「口令错误或文件已损坏」（不泄露是哪一环） |
+| 导入文件非信封结构 / 明文缺 `connections` 数组 | 同上统一错误 |
+| 单条导入失败（kind 非法、secrets 写入 I/O 故障等） | 记入 `errors` 续跑，不整批回滚（与 skip 语义一致，幂等可重入） |
+| 连接无密码 | 不出现在 `secrets` 段；导入后无 `hasPassword` 指示 |
+
+## 6. 测试
+
+- `tests/store/export-crypto.spec.ts`（5 例）：round-trip（密文不含明文）、随机 salt/iv 同文异密、错口令统一错误、篡改 data/tag/结构统一错误、空/非字符串口令拒绝。
+- `tests/store/connections.spec.ts`（追加 4 例）：exportBundle 含密码、importBundle skip 冲突不覆盖 + 重复导入幂等、单条异常入 errors 续跑、round-trip 后 testTarget 密码/URL 一致且 connections.json 无明文。
+- `tests/tool/manager.spec.ts`（追加 4 例）：round-trip（导出→删除→导入恢复）、错口令 INVALID_ARGUMENT、空参数 INVALID_ARGUMENT、导出/导入审计断言（记条数、不落口令）。
+- `tests/http/api.spec.ts`（追加 3 例）：happy path（HTTP 建连接→导出→全删→导入恢复，断言密文不含明文连接串）、缺/空 passphrase 400、坏密文导入 INVALID_ARGUMENT。
+
+验收命令：`npm run typecheck && npm test && npm run build`，全部通过。
+
+## 7. 实施过程（Agent Teams 并行）
+
+任务拆为 3 个 teammate 并行，写范围互斥：
+
+| Teammate | 写范围 | 产出 |
+|---|---|---|
+| store-crypto | `lib/store/connections.ts`、`lib/store/export-crypto.ts` + 配套测试 | 存储层 + 加解密，21 测试绿 |
+| service-http | `lib/manager.ts`、`lib/http/index.ts` + 配套测试 | service + HTTP 路由，46 测试绿 |
+| client-ui | `client/client.js` | UI + i18n，98 client 测试无回归 |
+
+契约先行冻结（store 方法签名、HTTP 端点、错误 code），三路按契约并行开发；store-crypto 完成后 service-http 的真实 store 联跑自然转绿。Lead 负责收尾 integrator（`lib/store/index.ts` 导出面）+ 全仓验收。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-db-tool",
-  "version": "1.5.91",
+  "version": "1.6.0",
   "description": "DSH community plugin: chat-operated multi-database admin tool with sidebar management, project-scoped grants, ro/rw modes and dangerous-operation confirmation",
   "type": "module",
   "license": "MIT",