dsh-db-tool 1.8.4 → 1.8.8

package/dist/adapters/mysql/index.js

@@ -9,23 +9,9 @@ import mysql from 'mysql2/promise';
 import { assertIdent, clampLimit, clampOffset, humanize, normalizeCell, quoteIdent, validPort } from '../sql-shared/common.js';
 /** ro 模式下 query 允许的读语句首词白名单 */
 const RO_READ_PREFIX = /^(select|show|desc|describe|explain|use|help|table)\b/i;
-/**
- * 吞掉 'connection' 回调里会话级 SET 的失败（ro / time_zone 仅是增强，失败不应拖垮连接与进程）。
- * mysql2 promise 池的 'connection' 事件由核心池 emit、经 lib/promise/inherit_events.js
- * 原样转发参数，回调收到的是 callback 版 PoolConnection：其 query() 返回 Query 命令
- * 对象（EventEmitter，无 onResult 时错误走 emit('error')，lib/commands/command.js），
- * 无监听会抛 uncaughtException 崩溃进程——.catch 防御对它恒不生效，必须挂 error 监听。
- * 若驱动版本改为返回 Promise，则走 .catch 吞 rejection（双分支防御）。
- */
-function swallowSetError(r) {
-    if (r && typeof r.catch === 'function') {
-        void r.catch(() => { });
-        return;
-    }
-    if (r && typeof r.on === 'function') {
-        r.on('error', () => { });
-    }
-}
+// 【历史教训，勿回退】'connection' 钩子里 SET 的失败处理只能走回调参数吞掉，
+// 不得给返回的 Query 命令挂 error 监听防 uncaughtException——
+// 该监听会打断池接管前的命令处理序列并使连接永久卡死（1.7.4 真机复现，见 ro 钩子处注释）。
 function connOptions(conn) {
     const base = {
         waitForConnections: true,
@@ -97,13 +83,17 @@ export async function createMysqlAdapter(conn, opts) {
             throw new Error('mysql 连接已关闭：请重新连接后重试');
     };
     /** ro 模式：每个新底层连接自动设为只读会话（应用层另有 query 白名单双保险）。
-     *  回调收到的是 callback 版 PoolConnection，query() 返回 Query 命令对象（EventEmitter）：
-     *  吞掉 SET 失败防 uncaughtException（见 swallowSetError）。主池与跨库池共用同一注册。 */
+     *  mysql2 promise 池 'connection' 回调拿到的是 callback 版连接；SET 必须回调式执行，
+     *  且绝不能对返回的 Query 命令对象挂 error 监听——swallowSetError 的 .on('error') 会
+     *  打断池接管前的命令处理序列，连接状态机卡死，该连接后续一切查询永挂
+     *  （真机复现：ro 模式列库/列表/预览全部永久 pending，即「表显示不出来」直接根因；
+     *  非回调式与「回调式+error 监听」两种形态均挂，唯「回调式+空回调」正常）。
+     *  主池与跨库池共用同一注册。 */
     const attachReadOnly = (p) => {
         if (!readOnly)
             return;
         p.on('connection', (c) => {
-            swallowSetError(c.query('SET SESSION TRANSACTION READ ONLY'));
+            c.query('SET SESSION TRANSACTION READ ONLY', () => { });
         });
     };
     attachReadOnly(pool);
@@ -237,6 +227,28 @@ export async function createMysqlAdapter(conn, opts) {
                 };
             });
         }),
+        searchTables: (keyword, database, limit) => humanize('mysql 搜索表', async () => {
+            // 以 | 为 LIKE 转义符（避开反斜杠在 SQL 字面量/NO_BACKSLASH_ESCAPES 模式下的歧义）：
+            // % _ | \ 四字符全部转义后子串匹配，命中值经参数绑定传输、无注入面
+            const esc = keyword.replace(/[\\%_|]/g, (m) => `|${m}`);
+            const cap = Math.max(1, Math.min(200, Math.floor(Number(limit) || 100)));
+            const [rows] = await pool.query(`SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE, TABLE_COMMENT
+           FROM information_schema.TABLES
+           WHERE TABLE_NAME LIKE CONCAT('%', ?, '%') ESCAPE '|'
+             ${database ? 'AND TABLE_SCHEMA = ?' : "AND TABLE_SCHEMA NOT IN ('information_schema','mysql','performance_schema','sys')"}
+           ORDER BY TABLE_SCHEMA, TABLE_NAME
+           LIMIT ${cap}`, database ? [esc, database] : [esc]);
+            return rows.map((r) => {
+                const rawType = String(r.TABLE_TYPE);
+                const comment = r.TABLE_COMMENT;
+                return {
+                    database: String(r.TABLE_SCHEMA),
+                    name: String(r.TABLE_NAME),
+                    type: rawType === 'BASE TABLE' ? 'TABLE' : rawType,
+                    comment: comment != null && comment !== '' ? String(comment) : undefined,
+                };
+            });
+        }),
         describeTable: (table, database) => humanize('mysql 查看表结构', async () => {
             const db = database ? assertIdent(database, '库名') : defaultDb();
             const tbl = assertIdent(table, '表名');
@@ -280,8 +292,10 @@ export const factory = (conn) => createMysqlAdapter(conn);
 export async function openMysqlRaw(conn) {
     const opts = connOptions(conn);
     const pool = mysql.createPool({ ...opts, dateStrings: true });
-    // 回调式 query（带 err 回调吞错）。必须用回调式：非回调式返回的 Query 命令对象与
-    // promise 池连接状态机冲突 → 该连接所有后续 query 永挂（真机实证 mysql2 3.24.4）
+    // 回调式 query（带 err 回调吞错）。两点缺一不可（1.7.4 真机复现）：
+    // 1) 必须回调式——非回调式命令无 onResult，与 promise 池连接建立序列冲突；
+    // 2) 绝不能对返回的 Query 命令挂 error 监听——会打断池接管前的命令处理，
+    //    连接状态机卡死 → 该连接所有后续 query 永挂（mysql2 3.24.4）
     pool.on('connection', (c) => {
         // 运行时 c 是 callback 版连接（promise 池类型标注不反映），按回调式调用
         c.query("SET time_zone = '+00:00'", () => { });

package/dist/adapters/redis/index.js

@@ -344,7 +344,9 @@ export async function createRedisAdapter(conn, opts) {
                         const countIdx = rest.findIndex((a, i) => i > 0 && a.toUpperCase() === 'COUNT');
                         const entries = await client.xRange(key, rest[1] ?? '-', rest[2] ?? '+', countIdx > 0 ? { COUNT: Number(rest[countIdx + 1] ?? 20) } : undefined);
                         const rows = [];
-                        for (const entry of entries) {
+                        // xRange 返回 NullReply | StreamMessageReply[]：键不存在时服务端回空数组、
+                        // 客户端类型却含 null（XRANGE.d.ts transformReply），直接迭代会 TypeError。
+                        for (const entry of entries ?? []) {
                             const fields = Object.entries(entry.message ?? {});
                             if (fields.length === 0)
                                 rows.push([cell(entry.id), null, null]);
@@ -460,7 +462,8 @@ export async function createRedisAdapter(conn, opts) {
                     case 'stream': {
                         const entries = await client.xRange(key, '-', '+', { COUNT: n });
                         const rows = [];
-                        for (const entry of entries) {
+                        // 同上：xRange 类型含 null，空键时必须按空结果处理而非迭代崩溃
+                        for (const entry of entries ?? []) {
                             const fields = Object.entries(entry.message ?? {});
                             if (fields.length === 0)
                                 rows.push([cell(entry.id), null, null]);

package/dist/adapters/sql-shared/pg-like.js

@@ -249,6 +249,31 @@ export async function createPgLikeAdapter(kind, Driver, conn, opts) {
         const f = conn.fields;
         return f && typeof f.schema === 'string' && f.schema ? f.schema : 'public';
     };
+    /** 集群内可连接库名（listDatabases 与跨库 searchTables 共用） */
+    const listDbNames = async () => {
+        const res = await pool.query('SELECT datname FROM pg_database WHERE datistemplate = false AND datallowconn = true ORDER BY datname');
+        return res.rows.map((r) => String(r.datname));
+    };
+    /** 单库内搜表：schema 给定精确限定，否则该库全部用户 schema（排除 information_schema 与 pg_* 系） */
+    const searchOneDb = async (p, dbName, pattern, cap, schema) => {
+        const params = schema ? [pattern, schema] : [pattern];
+        const res = await p.query(`SELECT table_schema, table_name, table_type
+       FROM information_schema.tables
+       WHERE table_name ILIKE $1 ESCAPE '~'
+         AND table_schema <> 'information_schema' AND table_schema NOT LIKE 'pg\\_%'
+         ${schema ? 'AND table_schema = $2' : ''}
+       ORDER BY table_schema, table_name
+       LIMIT ${cap}`, params);
+        return res.rows.map((r) => {
+            const rawType = String(r.table_type);
+            return {
+                database: dbName,
+                schema: String(r.table_schema),
+                name: String(r.table_name),
+                type: rawType === 'BASE TABLE' ? 'TABLE' : rawType,
+            };
+        });
+    };
     /** 浏览目标解析："db.schema"（跨库）| "schema"（当前库）| 空（当前库默认 schema）。
      *  PG 标识符不允许裸点，按第一个点切分安全；多余点由 assertIdent 拒绝。 */
     const parseBrowseTarget = (ref, what) => {
@@ -332,10 +357,7 @@ export async function createPgLikeAdapter(kind, Driver, conn, opts) {
                 message: typeof n === 'number' ? `执行成功，受影响 ${n} 行` : '执行成功',
             };
         }),
-        listDatabases: () => humanize(`${kind} 列出数据库`, async () => {
-            const res = await pool.query('SELECT datname FROM pg_database WHERE datistemplate = false AND datallowconn = true ORDER BY datname');
-            return res.rows.map((r) => String(r.datname));
-        }),
+        listDatabases: () => humanize(`${kind} 列出数据库`, async () => listDbNames()),
         // 库内 schema 清单（Navicat 官方层级：数据库 → 模式 → 表）。
         // database 参数 = 库名（UI 树第一层）；pg_* 前缀覆盖 pg_catalog/pg_toast/pg_temp 系。
         listSchemas: (database) => humanize(`${kind} 列出模式`, async () => {
@@ -359,6 +381,33 @@ export async function createPgLikeAdapter(kind, Driver, conn, opts) {
                 };
             });
         }),
+        // 跨库搜表。database 语义（与 UI 库下拉一致）：'db'（该库全部用户 schema）|
+        // 'db.schema'（精确单 schema）| 'schema'（当前库）| 空（集群全部库逐池并发）。
+        // ILIKE 大小写不敏感；转义符 '~' 避开反斜杠歧义，% _ \ ~ 全转义，参数绑定无注入面。
+        searchTables: (keyword, database, limit) => humanize(`${kind} 搜索表`, async () => {
+            const cap = Math.max(1, Math.min(200, Math.floor(Number(limit) || 100)));
+            const pattern = '%' + keyword.replace(/[~%_\\]/g, (m) => `~${m}`) + '%';
+            if (database) {
+                const dot = database.indexOf('.');
+                const dbName = assertIdent(dot >= 0 ? database.slice(0, dot) : database, '数据库');
+                const schema = dot >= 0 ? assertIdent(database.slice(dot + 1), 'schema') : null;
+                return searchOneDb(poolFor(dbName), dbName, pattern, cap, schema);
+            }
+            const dbNames = await listDbNames();
+            const hits = [];
+            for (let i = 0; i < dbNames.length && hits.length < cap; i += 8) {
+                const batch = await Promise.all(dbNames.slice(i, i + 8).map(async (dbName) => {
+                    try {
+                        return await searchOneDb(poolFor(dbName), dbName, pattern, cap, null);
+                    }
+                    catch {
+                        return []; // 个别库不可连接（权限/模板库）不拖垮整体搜索
+                    }
+                }));
+                hits.push(...batch.flat());
+            }
+            return hits.slice(0, cap);
+        }),
         describeTable: (table, database) => humanize(`${kind} 查看表结构`, async () => {
             const { db, schema } = parseBrowseTarget(database, 'schema');
             const tbl = assertIdent(table, '表名');

package/dist/adapters/sqlserver/index.js

@@ -52,6 +52,14 @@ function vendor() {
 /* ============================ 配置解析 ============================ */
 /** tedious 支持的 TDS 协议版本（默认 7_4） */
 const TDS_VERSIONS = new Set(['7_4', '7_3_A', '7_3_B', '7_2', '7_1']);
+/**
+ * 可显式下探的最低 TLS 版本（默认不设置，沿用 Node 默认下限 TLSv1.2）。
+ *
+ * 刻意不含 TLSv1.3：tedious message-io.js 在调用方未给 maxVersion 时硬性补成 'TLSv1.2'，
+ * 于是 minVersion=TLSv1.3 会变成 min>max，握手直接抛 ERR_SSL_NO_PROTOCOLS_AVAILABLE
+ * （已实测）——那是个 100% 失败的配置，放进白名单只会把用户引到另一条死路。
+ */
+const TLS_MIN_VERSIONS = ['TLSv1', 'TLSv1.1', 'TLSv1.2'];
 /** URLSearchParams 取值（参数名大小写不敏感，URL 里常见 camelCase 与全小写混写） */
 function queryParam(sp, name) {
     const lower = name.toLowerCase();
@@ -73,6 +81,52 @@ function boolParam(sp, name, dflt) {
         return false;
     throw new Error(`sqlserver 连接 URL 的 ${name} 取值非法：${JSON.stringify(v)}（只接受 true/false）`);
 }
+/** fields 分支的布尔取值：分字段表单以字符串提交，故与 URL 同口径归一；非法值同样 fail-closed */
+function boolField(v, name, dflt) {
+    if (v === undefined || v === null || v === '')
+        return dflt;
+    if (typeof v === 'boolean')
+        return v;
+    const s = String(v).trim().toLowerCase();
+    if (s === 'true' || s === '1' || s === 'yes')
+        return true;
+    if (s === 'false' || s === '0' || s === 'no')
+        return false;
+    throw new Error(`sqlserver 连接配置的 ${name} 取值非法：${JSON.stringify(v)}（只接受 true/false）`);
+}
+/** TDS 版本白名单（URL 与 fields 共用，避免两套文案漂移） */
+function applyTdsVersion(options, raw, source) {
+    if (raw === undefined || raw === null || String(raw) === '')
+        return;
+    const v = String(raw);
+    if (!TDS_VERSIONS.has(v)) {
+        throw new Error(`sqlserver 连接${source}的 tdsVersion 取值非法：${JSON.stringify(raw)}（可选 ${[...TDS_VERSIONS].join('/')}，默认 7_4）`);
+    }
+    options.tdsVersion = v;
+}
+/**
+ * 最低 TLS 版本（URL ?tlsMinVersion= 与 fields.tlsMinVersion 同口径）。
+ *
+ * 只写 cryptoCredentialsDetails.minVersion，刻意不提供 ciphers / maxVersion 开关：
+ *  - Electron 内置 Node 是 BoringSSL，OpenSSL 专有的 cipher 串（如 DEFAULT@SECLEVEL=0）会直接抛
+ *    INVALID_COMMAND；而「连 2008/2008R2 只有 TLS 1.0」这个场景只需把下限从默认的 TLSv1.2 放开即可。
+ *  - tedious message-io 自己会把 maxVersion 补成 TLSv1.2（未指定时），故上限天然封顶在 1.2；
+ *    这里再写 maxVersion 反而会削弱安全性，保持只设下限。
+ *
+ * 取值区分大小写、不做归一化（与 Node tls 官方 API 语义一致：'tlsv1' / 'TLSv1_0' 均会被底层拒绝）。
+ * 非法值 fail-closed：静默回退到 Node 默认下限会让用户以为已下探，实际握手仍按 TLS 1.2 起步，
+ * 白白多一轮失败排查。
+ */
+function applyTlsMinVersion(options, raw, source) {
+    if (raw === undefined || raw === null || String(raw) === '')
+        return;
+    const v = String(raw);
+    const hit = TLS_MIN_VERSIONS.find((x) => x === v);
+    if (hit === undefined) {
+        throw new Error(`sqlserver 连接${source}的 tlsMinVersion 取值非法：${JSON.stringify(raw)}（可选 ${TLS_MIN_VERSIONS.join('/')}，默认不设置=沿用 Node 默认 TLSv1.2；TLSv1.3 不可选：底层 tedious 把 TLS 上限封顶在 1.2，设 1.3 会导致最小版本大于最大版本而握手失败）`);
+    }
+    options.cryptoCredentialsDetails = { minVersion: hit };
+}
 function decodeCred(raw) {
     try {
         return decodeURIComponent(raw);
@@ -142,13 +196,8 @@ function poolConfig(conn) {
         options.encrypt = boolParam(u.searchParams, 'encrypt', true);
         options.trustServerCertificate = boolParam(u.searchParams, 'trustServerCertificate', false);
         options.useUTC = boolParam(u.searchParams, 'useUTC', true);
-        const tds = queryParam(u.searchParams, 'tdsVersion');
-        if (tds !== undefined && tds !== '') {
-            if (!TDS_VERSIONS.has(tds)) {
-                throw new Error(`sqlserver 连接 URL 的 tdsVersion 取值非法：${JSON.stringify(tds)}（可选 ${[...TDS_VERSIONS].join('/')}，默认 7_4）`);
-            }
-            options.tdsVersion = tds;
-        }
+        applyTdsVersion(options, queryParam(u.searchParams, 'tdsVersion'), ' URL ');
+        applyTlsMinVersion(options, queryParam(u.searchParams, 'tlsMinVersion'), ' URL ');
         const instance = queryParam(u.searchParams, 'instanceName');
         // instanceName 与 port 互斥：mssql 层在建连前会 delete 掉 port（tedious 对两者共存直接抛
         // 互斥 Error），端口改由 SQL Server Browser（UDP 1434）按实例名解析
@@ -174,6 +223,14 @@ function poolConfig(conn) {
             cfg.database = String(f.database);
         if (f.instanceName != null && String(f.instanceName) !== '')
             options.instanceName = String(f.instanceName);
+        // 分字段表单此前完全读不到这几个键：用户在表单里关掉加密/信任证书、选 TDS 版本或下探
+        // TLS 下限都不生效（连接仍按 URL 默认值走），排障时会误以为参数没被实现。此处与 URL 分支
+        // 同口径补齐，默认值仍取自 options 初始值（encrypt=true / trustServerCertificate=false /
+        // tdsVersion=7_4 / useUTC=true）。
+        options.encrypt = boolField(f.encrypt, 'encrypt', options.encrypt);
+        options.trustServerCertificate = boolField(f.trustServerCertificate, 'trustServerCertificate', options.trustServerCertificate);
+        applyTdsVersion(options, f.tdsVersion, '配置');
+        applyTlsMinVersion(options, f.tlsMinVersion, '配置');
     }
     else {
         throw new Error('sqlserver 连接缺少 url 或 fields 配置');
@@ -378,19 +435,29 @@ function mssqlReason(e) {
     const num = typeof err.number === 'number' ? err.number : undefined;
     const sev = typeof err.severity === 'number' ? err.severity : undefined;
     const line = typeof err.lineNumber === 'number' ? err.lineNumber : undefined;
-    // TLS/证书类失败（自签证书、链不可验证、协议版本不符）在 SQL Server 2008/2008 R2 上很常见。
-    // 默认 encrypt=true + trustServerCertificate=false 与 mssql 官方一致（不改默认值），但必须：
-    //  1) 不把「TCP 已连通、TLS 校验失败」误报成网络不可达（会把用户引向错误排查方向）；
-    //  2) 把「怎么连上」写清楚（URL 加 ?trustServerCertificate=true / ?encrypt=false）。
+    // TLS 失败在 SQL Server 2008/2008 R2 上很常见，但根因分两族、解法正交，必须分开给：
+    //  - 证书族（自签/链不可验证）：证书校验阶段失败 → trustServerCertificate=true / encrypt=false；
+    //  - 协议族（无共同 TLS 版本）：版本协商阶段就失败，证书校验根本没执行 → 只能升服务端 TLS 1.2
+    //    或让客户端下探 ?tlsMinVersion=。给它 trustServerCertificate 是开错药方（用户会白跑一轮）。
+    // 默认 encrypt=true + trustServerCertificate=false 与 mssql 官方一致（不改默认值），且无论哪族
+    // 都不能把「TCP 已连通、TLS 失败」误报成网络不可达（会把用户引向错误排查方向）。
     // tedious 建连期把底层 socket/TLS 错误用 ES cause 选项挂在 err.cause（originalError 是 mssql 事务
     // abort 专用，建连场景恒 undefined），message 已聚合底层原文但读 cause 更稳，一并纳入特征文本。
     const causeText = errText(err.cause);
     const tlsText = `${detail} ${errText(err.originalError)} ${causeText}`;
-    // 特征族来源：OpenSSL/BoringSSL 原生错误串（SSL routines/OPENSSL_internal/UNSUPPORTED_PROTOCOL、
-    // handshake_*.c）、Node ERR_SSL_NO_PROTOCOLS_AVAILABLE 的 message、服务器 alert 拒绝握手/版本。
-    // 刻意不加 ECONNRESET/socket hang up/ENOTFOUND——与真实网络故障不可区分，误加会让 ECONNREFUSED
-    // 场景被套上 TLS 指引。
-    const tlsish = /self[ -]?signed|certificate|unable to verify|wrong version number|ERR_SSL|EPROTO|CERT_|UNSUPPORTED_PROTOCOL|SSL[ -_]?routines|OPENSSL_internal|handshake[ _-]?(failure|client|server)|TLSV1_ALERT|SSLV3_ALERT|alert protocol version|alert handshake failure|no protocols available/i.test(tlsText);
+    // 协议族：BoringSSL/OpenSSL 的「没有共同协议版本」家族。UNSUPPORTED_PROTOCOL = SSL_R_UNSUPPORTED_PROTOCOL，
+    // 在 ClientHello/ServerHello 版本协商阶段就返回，握手从未走到证书校验；`no protocols available` 是 Node
+    // 侧同一语义的表述（ERR_SSL_NO_PROTOCOLS_AVAILABLE 亦含此串）。SSL routines 单独出现不足以判族
+    // （证书错误也带该前缀），故要求同时含 UNSUPPORTED。
+    const tlsProtoish = /UNSUPPORTED_PROTOCOL|no protocols available|alert protocol version|(?:SSL[ -_]?routines|OPENSSL_internal)[\s\S]{0,80}?UNSUPPORTED/i.test(tlsText);
+    // 证书族：证书本身不可信（自签、链断、主机名不符、已过期）
+    const tlsCertish = /self[ -]?signed|certificate|unable to verify|CERT_/i.test(tlsText);
+    // 兜底「确实是 TLS 层失败」的通用前缀：只用于把 base 从「网络不可达」纠正为「TCP 已连通」，
+    // 不据此给任何具体药方（族未定就不该猜）。刻意不加 ECONNRESET/socket hang up/ENOTFOUND——
+    // 与真实网络故障不可区分，误加会让 ECONNREFUSED 场景被套上 TLS 指引。
+    const tlsish = tlsProtoish ||
+        tlsCertish ||
+        /ERR_SSL|EPROTO|SSL[ -_]?routines|OPENSSL_internal|handshake[ _-]?(failure|client|server)|TLSV1_ALERT|SSLV3_ALERT|alert handshake failure/i.test(tlsText);
     let base;
     switch (code) {
         case 'ELOGIN':
@@ -403,10 +470,13 @@ function mssqlReason(e) {
                     : `请求超时：语句执行超过 requestTimeout，请拆小查询或调大超时（${detail}）`;
             break;
         case 'ESOCKET':
-            // 保留「网络不可达」字样（既有断言与用户检索习惯依赖），但 TLS 特征时先说明 TCP 已连通
-            base = tlsish
-                ? `TCP 已连通但 TLS 握手/证书校验失败（不是网络不可达：网络不可达指主机/端口不可达或连接被拒，此处 TCP 已建立）（${detail}）`
-                : `网络不可达：无法与服务器建立 TCP 连接，请检查主机名、端口与网络；端口确认可达仍反复出现时，也可能是服务器在 TLS 握手阶段主动断开（如老实例仅支持 TLS 1.0）（${detail}）`;
+            // 保留「网络不可达」字样（既有断言与用户检索习惯依赖），但 TLS 特征时先说明 TCP 已连通。
+            // 协议族与证书族分开表述：前者是版本协商失败，与证书无关。
+            base = tlsProtoish
+                ? `TCP 已连通但 TLS 协议版本协商失败：客户端与服务端没有共同的 TLS 协议版本（UNSUPPORTED_PROTOCOL 出现在版本协商阶段，此时证书校验尚未执行，故与证书是否受信无关）（${detail}）`
+                : tlsish
+                    ? `TCP 已连通但 TLS 握手/证书校验失败（不是网络不可达：网络不可达指主机/端口不可达或连接被拒，此处 TCP 已建立）（${detail}）`
+                    : `网络不可达：无法与服务器建立 TCP 连接，请检查主机名、端口与网络；端口确认可达仍反复出现时，也可能是服务器在 TLS 握手阶段主动断开（如老实例仅支持 TLS 1.0）（${detail}）`;
             break;
         // 服务器强制加密（SQL Server 2022 / Azure SQL 默认）而客户端 encrypt=false：tedious 抛英文原文，
         // 不映射则中文界面里只剩英文，故单列一条给出可直接照做的改法。
@@ -430,7 +500,15 @@ function mssqlReason(e) {
             base = detail;
     }
     const trail = [];
-    if (tlsish) {
+    if (tlsProtoish) {
+        // 顺序即优先级：服务端升级是正解（一次性、对所有客户端生效），客户端下探是权宜（仍受限于
+        // 服务端实际支持的版本）。第③条显式点名「跳过证书校验」是先发制人——用户看到 TLS 报错的第一
+        // 反应通常就是去信任证书，明说无效比沉默更省一轮排查；措辞必须是否定式，不得写成可尝试项。
+        trail.push('修复优先级：① 首选在服务端启用 TLS 1.2（SQL Server 2008 R2 SP3 装 KB4057113、SQL Server 2008 SP4 装 KB4057114，之后重启实例）——这是根治，且对所有客户端生效');
+        trail.push('② 若暂时无法动服务端，可在连接 URL 追加 ?tlsMinVersion=TLSv1 让客户端把最低 TLS 版本下探到 1.0（本插件已支持；上限仍由 tedious 封顶在 TLS 1.2）');
+        trail.push('③ 注意：跳过证书校验（信任任意证书）对这类错误无效——它只影响证书校验阶段，而此处是协议版本协商失败，证书校验根本没执行');
+    }
+    else if (tlsCertish) {
         trail.push('若目标是 SQL Server 2008/2008 R2 或使用自签名证书的实例，可在连接 URL 追加 ?trustServerCertificate=true（或 ?encrypt=false，前提是服务器未强制加密）');
     }
     if (err.originalError !== undefined)

package/dist/http/index.js

@@ -5,7 +5,9 @@
  * 调用 handleDbToolRequest——前端同源相对路径 fetch 即可达。
  *
  * trust 校验（等价移植 dsh-ssh-tunnel lib/shared/http-trust.js，自包含）：
- *  - Host 必须是 loopback（或 ctx.webRuntime.trustedHosts 中的条目）；
+ *  - Host 必须是 loopback（或受信条目）：0.2.1-rc.3 起来自 ctx.webStartup.trustedHosts
+ *    加监听 bind 地址（Connection 的 isBindAddressAuthority 语义），旧宿主来自已删除的
+ *    ctx.webRuntime.trustedHosts；
  *  - 带 Origin/Referer 时其 host 必须是 loopback（且同端口）或受信条目。
  *  - 0.0.0.0 不是 loopback。违者 403 FORBIDDEN。
  *
@@ -240,6 +242,10 @@ async function route(req, res, service, path, q, opts) {
     if (path === '/api/tables' && req.method === 'GET') {
         return sendOk(res, await service.tables(projectOf(q), required(q, 'connId'), q.get('database') ?? undefined));
     }
+    if (path === '/api/search-tables' && req.method === 'GET') {
+        const limit = q.get('limit') !== null ? Number(q.get('limit')) : undefined;
+        return sendOk(res, await service.searchTables(projectOf(q), required(q, 'connId'), required(q, 'keyword'), q.get('database') ?? undefined, limit));
+    }
     if (path === '/api/schemas' && req.method === 'GET') {
         return sendOk(res, await service.schemas(projectOf(q), required(q, 'connId'), q.get('database') ?? undefined));
     }

package/dist/index.js

@@ -10,6 +10,7 @@
  *    http-trust 本地校验（Host loopback / trustedHosts + Origin 同源校验）。
  *  - ctx.effect 收尾：注销 HTTP 路由、关适配器、停 challenge 清理。
  */
+import { isIP } from 'node:net';
 import { DbToolStore, normalizeProjectKey } from './store/index.js';
 import { DbToolService, handleToolAction } from './manager.js';
 import { handleDbToolRequest } from './http/index.js';
@@ -19,7 +20,9 @@ import { handleDbToolRequest } from './http/index.js';
  * 注意：不要把 webRuntime 写进来。宿主 @deepseek-ai/dsh-web-app 提供的是
  * webApp，从不注册 webRuntime；cordis 的 inject 是硬依赖，缺失服务会让 fiber
  * 永久 pending、apply() 不执行，HTTP 路由也就不会注册（前端表现为 HTTP 404）。
- * trustedHosts 改用 ctx.get('webRuntime', true) 可选读取。
+ * trustedHosts 改用 ctx.get('webStartup' | 'webRuntime', true) 可选读取：
+ * 0.2.1-rc.3 删除了 webRuntime 服务、信任权威改为 webStartup.trustedHosts，
+ * 旧宿主仍用 webRuntime，故按新优先、旧回退读取。
  */
 export const inject = ['webServer', 'sessions', 'tools', 'connection'];
 const TOOL_DESCRIPTION = `数据库管理工具（dsh-db-tool）：在已配置的数据库连接上执行查询/写操作/脚本。
@@ -47,11 +50,37 @@ export function apply(ctx) {
     const store = new DbToolStore();
     const service = new DbToolService(store);
     // HTTP API：挂在 DSH webServer 的 /dsh-db-tool/api 前缀下（同源访问）
+    /**
+     * rc.3 的 Connection 在 trustedHosts 之外还单独接受监听 bind 地址
+     * （isBindAddressAuthority）。本地兜底对齐该语义，但只补具体单播字面量：
+     * wildcard（0.0.0.0/::/*）与 loopback 一律跳过，不放宽 DNS rebinding 攻击面。
+     */
+    const bindAuthorities = () => {
+        const host = ctx.webServer?.host;
+        if (typeof host !== 'string')
+            return [];
+        const h = host.trim();
+        if (h === '' || h === '*' || h === '0.0.0.0' || h === '::')
+            return [];
+        if (isIP(h) === 0)
+            return [];
+        if (h === '::1' || h === '::ffff:127.0.0.1' || /^127\./.test(h))
+            return [];
+        const port = ctx.webServer?.port;
+        if (typeof port !== 'number' || !(port > 0))
+            return [h];
+        return [h, `${h.includes(':') ? `[${h}]` : h}:${port}`];
+    };
     const trustedHosts = () => {
         try {
-            // webRuntime 不在 inject 内：缺失服务会让插件永不激活，故可选读取
-            const runtime = ctx.get?.('webRuntime', true);
-            return runtime?.trustedHosts ?? [];
+            // webRuntime 不在 inject 内：缺失服务会让插件永不激活，故可选读取。
+            // 0.2.1-rc.3 删除了 webRuntime，改由 webStartup.trustedHosts 提供信任权威。
+            const startup = ctx.get?.('webStartup', true);
+            const declared = startup?.trustedHosts ??
+                ctx.get?.('webRuntime', true)?.trustedHosts ??
+                [];
+            // 仅 rc.3（webStartup 存在）补 bind 地址；旧宿主的 webRuntime 已含 bind 派生的 LAN 地址。
+            return startup === undefined ? declared : [...bindAuthorities(), ...declared];
         }
         catch {
             return [];

package/dist/manager.js

@@ -27,6 +27,9 @@ function assertNonEmpty(v, label) {
         throw new DbToolError('INVALID_ARGUMENT', `缺少必填参数: ${label}`);
     return s;
 }
+/** searchTables 回退白名单：listTables(database) 语义为「库名」的 kind（pg/gaussdb 有原生实现；
+ *  redis/oracle/dmdb 语义不兼容，回退会错标来源或重复返回，见 manager.searchTables 注释） */
+const SEARCH_FALLBACK_KINDS = new Set(['mysql', 'mongodb', 'sqlite']);
 /** 单连接并发控制台事务会话上限（每会话独占驱动池 + checkout 连接，防连接耗尽） */
 const MAX_CONSOLE_SESSIONS_PER_CONN = 4;
 /** 全局并发传输任务上限（每任务独立 reader/writer 连接，防连接耗尽） */
@@ -259,6 +262,56 @@ export class DbToolService {
             throw this.toDriverError(e);
         }
     }
+    /**
+     * 跨库表名模糊搜索（ro 即可）。优先用适配器原生实现（mysql 走 information_schema
+     * 一条 LIKE）；未实现时回退「逐库 listTables + 内存过滤」（小并发防打满连接池），
+     * 单库语义（sqlite/redis）只搜默认库。limit 钳制 1..200，默认 100。
+     */
+    async searchTables(projectPath, connId, keyword, database, limit) {
+        const kw = assertNonEmpty(keyword, 'keyword').trim();
+        const cap = Math.max(1, Math.min(200, Math.floor(Number(limit) || 100)));
+        const { key, adapter } = await this.authorize(projectPath, connId, false);
+        const auditStmt = `search "${kw.length > 100 ? kw.slice(0, 100) + '…' : kw}"${database ? ` @ ${database}` : ''}`;
+        try {
+            let hits;
+            if (adapter.searchTables) {
+                hits = await adapter.searchTables(kw, database, cap);
+            }
+            else if (SEARCH_FALLBACK_KINDS.has(adapter.kind)) {
+                // 回退仅对「listTables(database) 语义 = 库名」的 kind 安全：
+                // pg/gaussdb 走原生 searchTables；redis listTables 忽略库名（逐库循环会重复返回同一批键）、
+                // oracle/dmdb database 语义为 owner，跨库回退会错标来源——这些 kind 不支持回退，返回空。
+                if (database) {
+                    const list = await adapter.listTables(database);
+                    hits = filterTables(list, kw, database);
+                }
+                else {
+                    const dbs = await adapter.listDatabases();
+                    hits = [];
+                    for (let i = 0; i < dbs.length && hits.length < cap; i += 8) {
+                        const batch = await Promise.all(dbs.slice(i, i + 8).map(async (db) => {
+                            try {
+                                return filterTables(await adapter.listTables(db), kw, db);
+                            }
+                            catch {
+                                return []; // 个别库不可读（权限/系统库）不拖垮整体搜索
+                            }
+                        }));
+                        hits = hits.concat(...batch);
+                    }
+                }
+            }
+            else {
+                hits = [];
+            }
+            this.audit(key, connId, 'search_tables', auditStmt, 'none', false, true, undefined, hits.length);
+            return hits.slice(0, cap);
+        }
+        catch (e) {
+            this.audit(key, connId, 'search_tables', auditStmt, 'none', false, false, this.errText(e));
+            throw this.toDriverError(e);
+        }
+    }
     /** 库内 schema 清单（仅 PG/GaussDB 等三层语义适配器实现；ro 即可）。 */
     async schemas(projectPath, connId, database) {
         const { key, adapter } = await this.authorize(projectPath, connId, false);
@@ -538,12 +591,12 @@ export class DbToolService {
         if (this.disposed)
             throw new DbToolError('INVALID_ARGUMENT', '服务已关闭');
         if (!projectPath || projectPath.trim() === '') {
-            throw new DbToolError('UNAUTHORIZED_PROJECT', '业务操作需要 projectPath（匿名项目仅可管理连接）');
+            throw new DbToolError('UNAUTHORIZED_PROJECT', '项目路径为空：请先在面板顶部填写当前项目路径（或重新打开侧边栏让插件自动解析），再进行数据浏览/查询');
         }
         const key = normalizeProjectKey(projectPath);
         const mode = this.store.grants.check(key, connId);
         if (!mode)
-            throw new DbToolError('UNAUTHORIZED_PROJECT', `项目未授权该连接: ${connId}`);
+            throw new DbToolError('UNAUTHORIZED_PROJECT', `项目未授权该连接: ${connId}（请切到「项目授权」面板，为当前项目勾选该连接的 ro/rw 授权后重试）`);
         if (needWrite && mode === 'ro') {
             throw new DbToolError('READ_ONLY', '该连接对本项目为只读授权（ro），拒绝写操作');
         }
@@ -971,6 +1024,14 @@ export class DbToolService {
         return new DbToolError('DRIVER_ERROR', this.errText(e));
     }
 }
+/** 表名/注释子串匹配（大小写不敏感，回退路径用；命中转 TableSearchHit） */
+function filterTables(list, keyword, database) {
+    const kw = keyword.toLowerCase();
+    return list
+        .filter((t) => t.name.toLowerCase().includes(kw) ||
+        (t.comment !== undefined && t.comment.toLowerCase().includes(kw)))
+        .map((t) => ({ database, name: t.name, type: t.type, comment: t.comment }));
+}
 function pick(args, snake) {
     return args[snake] ?? (snake === 'conn_id' ? args.connId : args.challengeId);
 }

package/dist/store/connections.js

@@ -163,7 +163,7 @@ function toMeta(rec, hasPassword = false) {
     if (hasPassword)
         meta.hasPassword = true;
     if (rec.fields) {
-        const { host, port, user, database } = rec.fields;
+        const { host, port, user, database, tlsMinVersion } = rec.fields;
         if (typeof host === 'string')
             meta.host = host;
         if (typeof port === 'number')
@@ -172,6 +172,8 @@ function toMeta(rec, hasPassword = false) {
             meta.user = user;
         if (typeof database === 'string')
             meta.database = database;
+        if (typeof tlsMinVersion === 'string')
+            meta.tlsMinVersion = tlsMinVersion;
     }
     return meta;
 }