dsh-api-runner 0.2.1 → 0.3.1

package/src/main.js

@@ -19,30 +19,55 @@ import { ApiRunnerService, asObject, toText } from './ops.js';
 import { ProjectStore } from './project-store.js';
 import { JavaRunner } from './java-runner.js';
 import { SettingsStore } from './settings.js';
+import { normalizeProjectKey } from './util.js';
 
 export const inject = ['webServer', 'sessions', 'tools', 'connection', 'systemPrompt'];
 
-const TOOL_DESCRIPTION = `开发联调工具（dsh-api-runner）：按配置调用后端 HTTP 接口、启停本地服务、增量读取日志。
+/**
+ * 会话 cwd → 项目 key。数据库授权按这个 key 归档。
+ * 没有 cwd 时回落 'default'，和 ProjectStore 的约定一致。
+ */
+function projectKeyOf(cwd) {
+    return normalizeProjectKey(String(cwd || '')) || 'default';
+}
+
+const TOOL_DESCRIPTION = `开发联调工具（dsh-api-runner）：按配置调用后端 HTTP 接口、启停本地服务、增量读取日志、直接查数据库。
 
 典型用法（改完后端代码后自测）：
-1. action=describe —— 先看有哪些接口/服务/日志可用（含每个接口需要的参数名）。
+1. action=describe —— 先看有哪些接口/服务/日志/数据库可用（含每个接口需要的参数名）。
 2. action=service + service_action=restart —— 重启本地服务（managed 模式由插件托管进程；
    observe 模式下插件不托管，需你到 IDEA 里重启，然后用 service_action=wait 等就绪）。
 3. action=log + pattern —— 增量读日志；或 action=wait_log 等启动完成/报错特征出现。
 4. action=call —— 调用接口，params 里的键会替换 URL 里的 {name} 并拼进 query/body。
 5. action=verify —— 一条命令串起「重启 → 读日志 → 调接口」，适合改完后端后自检。
+6. action=db —— 直接查数据库：db_action=list_connections 看有哪些库；
+   list_tables / describe_table 看结构；query 执行 SQL。
+
+安全约束（务必遵守）：
+- 只有**已被当前项目授权**的连接才会出现在 describe 里；未授权的连接查不到也调不动。
+- 模型侧**永远只读**：只允许 SELECT / SHOW / DESCRIBE / EXPLAIN 等查询。
+  传 db_readonly=false 也不会放开写操作——写数据只能由人在面板里做。
+- DROP / TRUNCATE / 无 WHERE 的 DELETE 等毁灭性操作一律拒绝。
+
+什么时候该用 db：
+- 需要确认数据是否真的写进去了（接口返回成功但不确认落库）。
+- 排查数据问题：某条记录状态不对、关联数据缺失、字段值与预期不符。
+- 需要先了解表结构才能写对查询时，先 describe_table 再 query。
+遇到「数据对不对」这类问题就主动查，不用等用户提醒。
 
 注意：
 - 日志游标按 logId 持久化，第一次读只取文件末尾一段；要全量请传 reset=true。
 - 服务重启会 kill 整个进程树后重新拉起（managed）；失败时返回 exit code 与健康检查明细。
-- 接口响应体默认截断到 32KB，可用 max_bytes 调整；请求头在返回里已脱敏。`;
+- 接口响应体默认截断到 32KB，可用 max_bytes 调整；请求头在返回里已脱敏。
+- SQL 只允许单条语句；用 db_params 传参，不要拼接字符串（防注入）。
+- 数据库连接是跨项目的全局配置，但**访问权按项目隔离**。`;
 
 const PARAMETERS = {
     type: 'object',
     properties: {
         action: {
             type: 'string',
-            enum: ['describe', 'call', 'login', 'service', 'log', 'wait_log', 'reset_log', 'verify', 'java'],
+            enum: ['describe', 'call', 'login', 'service', 'log', 'wait_log', 'reset_log', 'verify', 'java', 'db'],
             description: '要执行的操作',
         },
         api_id: { type: 'string', description: '接口 id 或 name（call、login、verify 用）' },
@@ -69,6 +94,34 @@ const PARAMETERS = {
             items: { type: 'string' },
             description: 'java_action=start_all 时只启动这些服务（省略则启动全部已保存的）',
         },
+        db_action: {
+            type: 'string',
+            enum: ['list_connections', 'test', 'save', 'delete', 'query', 'list_databases', 'list_tables', 'describe_table'],
+            description: '数据库动作（action=db 用）：list_connections 列出连接；test 试连；save 保存连接；delete 删除连接；query 执行 SQL（只读模式默认开）；list_databases/list_tables/describe_table 看元数据',
+        },
+        connection_id: { type: 'string', description: '数据库连接 id（db_action=query/list_tables/describe_table/test/delete 用）' },
+        sql: { type: 'string', description: '要执行的 SQL（db_action=query 用，只允许单条语句）' },
+        params: {
+            type: 'object',
+            additionalProperties: true,
+            description: '接口参数（action=call/login）：键会替换 URL/body 里的 {key} 占位。db_action=query 时请改用 db_params。',
+        },
+        db_params: {
+            type: 'array',
+            items: {},
+            description: 'SQL 参数化占位值（db_action=query 用），按 ?/$1/:1 顺序绑定，不要拼字符串',
+        },
+        db_readonly: {
+            type: 'boolean',
+            description: '（已废弃，保留仅为兼容）模型侧永远只读，传 false 也不会放开写操作。写数据只能由人在面板里操作。',
+        },
+        connection: {
+            type: 'object',
+            additionalProperties: true,
+            description: '连接配置（db_action=save/test 用）：{ id?, name, type(sqlite|mysql|postgres|oracle|dm), host, port, database, username, password, connectString?, extra }。connectString 是 URL 模式（如 dm://user:pass@host:5236），填了就不用 host/port',
+        },
+        table: { type: 'string', description: '表名（db_action=describe_table 用）' },
+        database: { type: 'string', description: '库名/模式名（db_action=list_tables 用；MySQL 必填）' },
         pid: { type: 'number', description: '要接管的 Java 进程 pid（java_action=start 用）' },
         java_id: { type: 'string', description: '插件托管的服务名或 pid（java_action=stop/restart/log/save/unsave/start_saved 用）' },
         port: { type: 'number', description: '服务端口（java_action=start 用；省略则从进程参数推断）' },
@@ -210,6 +263,74 @@ async function runTool(service, args, projectPath) {
             }
             return { ok: false, code: 'BAD_ACTION', message: `不支持的 java_action: ${javaAction}` };
         }
+        case 'db': {
+            const dbAction = String(args.db_action || 'list_connections');
+            /**
+             * 项目（工作空间）key：授权是按项目走的，所有 db 动作都要带上它。
+             * runTool 的 projectPath 就是会话 cwd，用它派生 key。
+             */
+            const projectKey = projectKeyOf(projectPath);
+            if (dbAction === 'list_connections') return service.dbConnections();
+            if (dbAction === 'list_databases') {
+                if (!args.connection_id) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=list_databases 需要 connection_id' };
+                return service.dbDatabases(String(args.connection_id), { projectKey });
+            }
+            if (dbAction === 'test') {
+                const target = args.connection || args.connection_id;
+                if (!target) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=test 需要 connection_id 或 connection 配置' };
+                return service.dbTest(args.connection ? asObject(args.connection) : String(args.connection_id));
+            }
+            if (dbAction === 'save') {
+                /**
+                 * connection 可能是对象，也可能被上游序列化成 JSON 字符串
+                 * （工具参数走 JSON 时常见）。两种都接住，不要只认对象。
+                 */
+                const raw = args.connection;
+                let config;
+                if (typeof raw === 'string' && raw.trim() !== '') {
+                    try {
+                        config = JSON.parse(raw);
+                    } catch {
+                        return { ok: false, code: 'BAD_ARGUMENT', message: 'connection 不是合法 JSON' };
+                    }
+                } else if (raw && typeof raw === 'object') {
+                    config = raw;
+                }
+                if (!config || typeof config !== 'object') {
+                    return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=save 需要 connection 配置（对象或 JSON 字符串）' };
+                }
+                return service.dbSave(asObject(config));
+            }
+            if (dbAction === 'delete') {
+                if (!args.connection_id) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=delete 需要 connection_id' };
+                return service.dbDelete(String(args.connection_id));
+            }
+            if (dbAction === 'query') {
+                if (!args.connection_id) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=query 需要 connection_id' };
+                if (!args.sql) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=query 需要 sql' };
+                return service.dbQuery(String(args.connection_id), String(args.sql), Array.isArray(args.db_params) ? args.db_params : [], {
+                    /**
+                     * 模型侧**永远只读**：不接受 args 里传的 db_readonly=false。
+                     * 写操作只能由人在面板里做（面板走的是另一条带 UI 确认的路径）。
+                     * 这样即使模型被诱导，也删不掉任何数据。
+                     */
+                    readonly: true,
+                    projectKey,
+                    maxRows: args.max_lines ? Number(args.max_lines) : undefined,
+                    timeoutMs,
+                });
+            }
+            if (dbAction === 'list_tables') {
+                if (!args.connection_id) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=list_tables 需要 connection_id' };
+                return service.dbTables(String(args.connection_id), args.database ? String(args.database) : '', { projectKey });
+            }
+            if (dbAction === 'describe_table') {
+                if (!args.connection_id) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=describe_table 需要 connection_id' };
+                if (!args.table) return { ok: false, code: 'MISSING_ARGUMENT', message: 'db_action=describe_table 需要 table' };
+                return service.dbDescribeTable(String(args.connection_id), String(args.table), { projectKey });
+            }
+            return { ok: false, code: 'BAD_ACTION', message: `不支持的 db_action: ${dbAction}` };
+        }
         case 'service': {
             const serviceAction = String(args.service_action || 'status');
             if (!args.service_id && serviceAction !== 'status') {
@@ -328,13 +449,15 @@ export function apply(ctx) {
                         const apis = info.apis.map((api) => `- ${api.id}（${api.method} ${api.url}）${api.params.length ? ` 参数: ${api.params.join(', ')}` : ''}`).join('\n');
                         const services = info.services.map((item) => `- ${item.id}（${item.mode}）${item.name}`).join('\n');
                         const logs = info.logs.map((item) => `- ${item.id} → ${item.path}`).join('\n');
-                        if (!apis && !services && !logs) return '';
+                        const databases = (info.databases || []).map((item) => `- ${item.id}（${item.type}）${item.name} → ${item.target}`).join('\n');
+                        if (!apis && !services && !logs && !databases) return '';
                         return [
                             '# 本地开发联调（dsh-api-runner）',
                             '可用工具 ApiRunner 已配置以下资源；改完后端代码后可用它重启服务、读日志、直接调接口验证。',
                             apis ? `\n接口：\n${apis}` : '',
                             services ? `\n服务：\n${services}` : '',
                             logs ? `\n日志：\n${logs}` : '',
+                            databases ? `\n数据库（可用 action=db 直接查询，默认只读）：\n${databases}\n需要看表结构时用 db_action=list_tables / describe_table；查数据用 db_action=query + sql（用 db_params 传参，别拼字符串）。` : '',
                         ].join('\n');
                     } catch {
                         return '';
@@ -576,6 +699,83 @@ async function handleHttp(req, res, service, projectOf) {
     if (route === 'java/start-all/status' && req.method === 'GET') {
         return send(200, service.startBatchStatus(url.searchParams.get('batch') || ''));
     }
+
+    // ---- 数据库：连接管理与 SQL 执行（连接是跨项目的，不按 cwd 归档） ----
+    if (route === 'db' && req.method === 'GET') {
+        return send(200, service.dbConnections());
+    }
+    if (route === 'db/test' && req.method === 'POST') {
+        const body = await readBody();
+        const target = body.connection ? asObject(body.connection) : String(body.connection_id || body.id || '');
+        if (!target || (typeof target === 'string' && target === '')) {
+            return send(400, { ok: false, code: 'MISSING_ARGUMENT', message: '需要 connection_id 或 connection 配置' });
+        }
+        // timeout_ms 让前端能把等待压到可接受范围（默认 15s，见 DbManager.probeTimeoutMs）
+        return send(200, await service.dbTest(target, {
+            timeoutMs: body.timeout_ms ? Number(body.timeout_ms) : undefined,
+        }));
+    }
+    if (route === 'db/save' && req.method === 'POST') {
+        const body = await readBody();
+        return send(200, service.dbSave(asObject(body.connection || body)));
+    }
+    if (route === 'db/delete' && req.method === 'POST') {
+        const body = await readBody();
+        return send(200, service.dbDelete(String(body.connection_id || body.id || '')));
+    }
+    if (route === 'db/query' && req.method === 'POST') {
+        const body = await readBody();
+        return send(200, await service.dbQuery(
+            String(body.connection_id || ''),
+            String(body.sql || ''),
+            Array.isArray(body.params) ? body.params : [],
+            {
+                /**
+                 * 面板里的写操作需要「项目授权 = readwrite」才放行，
+                 * 且 DROP/TRUNCATE/无 WHERE 的 DELETE 仍会被 DESTRUCTIVE_BLOCKED 拦住。
+                 * readonly 由前端传，但真正的闸门是项目授权等级。
+                 */
+                readonly: body.readonly !== false,
+                projectKey: projectKeyOf(cwd),
+                maxRows: body.max_rows ? Number(body.max_rows) : undefined,
+                timeoutMs: body.timeout_ms ? Number(body.timeout_ms) : undefined,
+            },
+        ));
+    }
+    if (route === 'db/databases' && req.method === 'GET') {
+        return send(200, await service.dbDatabases(
+            String(url.searchParams.get('connection_id') || ''),
+            { projectKey: projectKeyOf(cwd) },
+        ));
+    }
+    if (route === 'db/tables' && req.method === 'GET') {
+        return send(200, await service.dbTables(
+            String(url.searchParams.get('connection_id') || ''),
+            String(url.searchParams.get('database') || ''),
+            { projectKey: projectKeyOf(cwd) },
+        ));
+    }
+    if (route === 'db/table' && req.method === 'GET') {
+        return send(200, await service.dbDescribeTable(
+            String(url.searchParams.get('connection_id') || ''),
+            String(url.searchParams.get('name') || url.searchParams.get('table') || ''),
+            { projectKey: projectKeyOf(cwd) },
+        ));
+    }
+
+    // ---- 数据库项目授权（默认拒绝，必须显式授权） ----
+    if (route === 'db/access' && req.method === 'GET') {
+        return send(200, service.dbAccess(projectKeyOf(cwd)));
+    }
+    if (route === 'db/access' && req.method === 'POST') {
+        const body = await readBody();
+        return send(200, service.dbSetAccess(
+            projectKeyOf(body.project_key ? String(body.project_key) : cwd),
+            String(body.connection_id || ''),
+            String(body.level || 'none'),
+        ));
+    }
+
     if (route === 'settings' && req.method === 'GET') {
         return send(200, service.settings());
     }

package/src/ops.js

@@ -6,6 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { ConfigStore } from './config.js';
 import { callApi, pickPath } from './api.js';
+import { DbManager } from './db.js';
 import { JavaRunner } from './java-runner.js';
 import { discoverLogs, listJavaProcesses, readFileChunk, readFileTail } from './java.js';
 import { LogReader } from './log.js';
@@ -39,6 +40,12 @@ export class ApiRunnerService {
          */
         this.startBatches = new Map();
         this._batchSeq = 0;
+        /**
+         * 数据库连接管理。数据库能力从原 dsh-db-tool 合并进来，
+         * 但**不依赖任何 DSH 服务**（原插件把 betterSidebar 当硬依赖，
+         * 服务没就绪就一直 pending，拖垮整个 web 启动）。
+         */
+        this.dbManager = options.dbManager || new DbManager({ homeDir: this.homeDir, settingsStore: this.settingsStore });
     }
 
     /** 面板配置转成 YAML 同构的覆盖层；没有面板存储时返回 undefined */
@@ -98,6 +105,33 @@ export class ApiRunnerService {
                 exists: fileExists(log.path),
                 size: fileSize(log.path),
             })),
+            /**
+             * 数据库连接也放进 describe：模型据此知道「有哪些库可查」。
+             *
+             * **只列当前项目已授权的连接**——未授权的连接模型不该看见，
+             * 否则它会反复尝试然后被拒，浪费轮次还误导用户。
+             * 只给 id / 名称 / 类型 / 目标 / 权限等级，不给账号密码。
+             */
+            databases: this.dbManager
+                ? (() => {
+                    const access = this.dbManager.accessOf('default');
+                    return this.dbManager.listConnections()
+                        .map((item) => {
+                            const level = access[item.id] || 'none';
+                            return {
+                                id: item.id,
+                                name: item.name,
+                                type: item.type,
+                                target: item.urlMode
+                                    ? item.connectString
+                                    : (item.type === 'sqlite' ? (item.file || ':memory:') : `${item.host}:${item.port}/${item.database}`),
+                                username: item.username || '',
+                                level,
+                            };
+                        })
+                        .filter((item) => item.level !== 'none');
+                })()
+                : [],
         };
     }
 
@@ -1161,9 +1195,72 @@ export class ApiRunnerService {
         return { ok: true, message: `已取消关联 pid ${pid}` };
     }
 
+    // ---- 数据库（从 dsh-db-tool 合并进来的能力） ----
+    /**
+     * 数据库连接是**跨项目**的：同一套库通常被多个项目共用，
+     * 按项目归档反而每次换项目都要重配。所以这里不接 cwd 参数。
+     */
+    dbConnections() {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        try {
+            const connections = this.dbManager.listConnections();
+            return { ok: true, connections, total: connections.length };
+        } catch (error) {
+            return { ok: false, code: 'DB_ERROR', message: String(error?.message || error) };
+        }
+    }
+
+    async dbTest(target, options = {}) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.testConnection(target, options);
+    }
+
+    dbSave(patch) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.saveConnection(patch);
+    }
+
+    dbDelete(id) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.deleteConnection(id);
+    }
+
+    async dbQuery(id, sql, params = [], options = {}) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.query(id, sql, params, options);
+    }
+
+    async dbDatabases(id, options = {}) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.listDatabases(id, options);
+    }
+
+    async dbTables(id, database = '', options = {}) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.listTables(id, database, options);
+    }
+
+    async dbDescribeTable(id, table, options = {}) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.describeTable(id, table, options);
+    }
+
+    // ---- 数据库项目授权（默认拒绝，必须显式授权） ----
+    dbAccess(projectKey) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.accessView(projectKey);
+    }
+
+    dbSetAccess(projectKey, connectionId, level) {
+        if (!this.dbManager) return { ok: false, code: 'NO_DB', message: '数据库模块不可用' };
+        return this.dbManager.setAccess(projectKey, connectionId, level);
+    }
+
     dispose() {
         this.logReader.dispose();
         this.serviceManager.dispose();
+        // 数据库连接池也要关，否则插件卸载后连接泄漏
+        if (this.dbManager) this.dbManager.dispose();
     }
 }
 

package/test/client.mjs

@@ -43,8 +43,10 @@ const windowStub = {
     confirm: () => true,
     document: {
         getElementById: () => null,
-        createElement: () => ({ set textContent(v) {}, id: '' }),
+        querySelectorAll: () => [],
+        createElement: () => ({ set textContent(v) {}, id: '', remove() {} }),
         head: { appendChild: () => {} },
+        documentElement: { appendChild: () => {} },
     },
 };
 // bundle 里会读 document / window，通过函数参数作用域注入
@@ -148,6 +150,144 @@ const rightPanel = byName('sidebar.right.pane.tab')[0].render({ sessionId: 'sess
 assert.ok(rightPanel, '右侧栏页签正文应返回元素');
 assert.equal(typeof rightPanel.type, 'function');
 
+// 数据库子页：结构断言（直接扫源码，避免为渲染造一堆桩）
+assert.ok(/id: 'db', label: '数据库'/.test(source), "面板 tabs 应包含「数据库」子页");
+assert.ok(/tab === 'db' \? dbPane : null/.test(source), '应渲染 dbPane 分支');
+assert.ok(/function EditDbForm/.test(source), '应有数据库连接编辑表单');
+assert.ok(/function DbResultCard/.test(source), '应有 SQL 结果卡片');
+assert.ok(/function TableDetail/.test(source), '应有表结构视图');
+assert.ok(/type: 'password'/.test(source), '密码框必须是 password 类型，不能明文显示');
+assert.ok(/只读模式（拒绝写操作）/.test(source), '应有只读模式开关');
+assert.ok(/db\/query/.test(source), 'SQL 执行应走 db/query 路由');
+
+// UI 层级：顶部页签用 ar-tabs，一级标题用独立胶囊 ar-segmented（参照宿主插件详情页）
+assert.ok(/className: 'ar-tabs'/.test(source), '顶部应有页签容器 ar-tabs');
+assert.ok(/className: 'ar-segmented'/.test(source), '一级标题应是小胶囊容器 ar-segmented');
+assert.ok(/'ar-seg on' : 'ar-seg'/.test(source), '胶囊选中态应有独立样式');
+assert.ok(/label: '连接管理'/.test(source) && /label: '项目授权'/.test(source)
+    && /label: 'SQL'/.test(source) && /label: '表结构'/.test(source),
+    '数据库子页应有「连接管理 / 项目授权 / SQL / 表结构」四个一级标题');
+assert.ok(/const \[dbSection, setDbSection\]/.test(source), '数据库子页需要 dbSection 状态');
+assert.ok(/\.ar-segmented \{/.test(source), '缺少 .ar-segmented 样式');
+assert.ok(/--ar-elevated:/.test(source), '选中态需要 --ar-elevated 变量（深/浅色主题各一份）');
+
+/**
+ * 布局回归：一级标题胶囊必须横向一排。
+ * 曾用 flex-wrap: wrap，结果在窄面板（右侧栏 ~300px）里被挤成竖排，
+ * 用户看到的就是「连接 / SQL / 表结构」三个上下堆叠的方块。
+ */
+assert.ok(/\.ar-segmented \{[^}]*flex-wrap:\s*nowrap/s.test(source), 'ar-segmented 必须禁止换行');
+assert.ok(/\.ar-segmented \{[^}]*overflow-x:\s*auto/s.test(source), 'ar-segmented 超出时应横向滚动');
+assert.ok(/\.ar-seg \{[^}]*flex:\s*0 0 auto/s.test(source), '胶囊不应被压缩');
+assert.ok(/\.ar-seg \{[^}]*white-space:\s*nowrap/s.test(source), '胶囊文字不应换行');
+assert.ok(!/\.ar-segmented \{[^}]*flex-wrap:\s*wrap/s.test(source), 'ar-segmented 不能用 flex-wrap: wrap（会竖排）');
+assert.ok(/\.ar-tabs \{[^}]*overflow-x:\s*auto/s.test(source), '顶部页签超出时应横向滚动');
+assert.ok(/scrollIntoView/.test(source), '选中的胶囊应自动滚入视野');
+
+/**
+ * 样式热更新回归：installStyles 不能因为「元素已存在」就跳过，
+ * 否则插件升级后页面里还是旧 CSS（胶囊退化成原生 button、竖排），刷新也无效。
+ */
+assert.ok(/style\[id\^="dsh-api-runner-style"\]/.test(source), '应清理历史版本的 style 元素');
+assert.ok(/el\.textContent !== CSS/.test(source), '样式内容变化时应替换，而不是跳过');
+assert.ok(!/if \(document\.getElementById\(STYLE_ID\)\) return;/.test(source), '不能因 id 已存在就提前返回');
+assert.ok(/const STYLE_ID = '[^']*-v\d+'/.test(source), 'style id 应带版本后缀，避免被按 id 去重');
+
+/**
+ * 数据库表单的三处修复（用户报的缺陷）：
+ *   1. 端口输入框被写死 90px，和 host 挤一行时变形
+ *   2. 新增时填完没法试连
+ *   3. 支持 URL 直连
+ */
+assert.ok(!/flex: '0 0 90px'/.test(source), '端口输入框不能固定像素宽（窄面板会变形）');
+assert.ok(/测试中…' : '测试'/.test(source), '表单应有「测试」按钮，新增时也能试连');
+assert.ok(/label: 'URL'/.test(source), '表单应支持 URL 录入方式');
+assert.ok(/connectString/.test(source), '应支持 connectString（URL 模式）');
+assert.ok(/item\.urlMode \? h\('span'/.test(source), '列表应标出 URL 模式的连接');
+assert.ok(/replace\(\/\[\^\\d\]\/g, ''\)/.test(source), '端口输入框应只接受数字');
+
+// 项目授权 UI：三档切换 + 安全说明
+assert.ok(/setDbAccessLevel/.test(source), '应有设置授权的处理函数');
+assert.ok(/label: '未授权'/.test(source) && /label: '只读'/.test(source) && /label: '读写'/.test(source),
+    '授权应有「未授权 / 只读 / 读写」三档');
+assert.ok(/毁灭性操作/.test(source), '授权页应说明毁灭性操作会被拒绝');
+assert.ok(/refreshDbAccess/.test(source), '应能刷新授权状态');
+
+// UI 重设计：命名空间分离 + 设计 token
+assert.ok(/className: 'ar-switch'/.test(source), '响应切换条应使用 ar-switch（不与 ar-seg 胶囊冲突）');
+assert.ok(!/className: 'ar-seg'/.test(source), 'ar-seg 只能当胶囊按钮，不能再被当容器');
+assert.ok(/--ar-surface-1/.test(source) && /--ar-surface-2/.test(source) && /--ar-surface-3/.test(source),
+    '应有三级中性面 token，用于分层');
+assert.ok(/--ar-r-lg/.test(source), '应有大圆角 token');
+assert.ok(/dsh-api-runner-style-v5/.test(source), '样式版本应为 v5');
+
+/**
+ * 试连不能锁死整个面板：
+ * 达梦连不上要等十几秒，若共用全局 busy，期间保存/取消/编辑全被 disabled，
+ * 用户会以为界面卡死。试连必须用独立的 testing 状态。
+ */
+assert.ok(/const \[dbTesting, setDbTesting\]/.test(source), '试连应有独立状态 dbTesting');
+assert.ok(/disabled: testing \|\| busy === 'save'/.test(source), '测试按钮只锁自己，不锁其它');
+assert.ok(/busy === 'save' \? '保存中…' : '保存'/.test(source), '保存按钮只受保存中影响');
+assert.ok(!/busy === 'test'/.test(source), '不应再用全局 busy 表示测试中');
+
+/**
+ * 回归：useEffect 的依赖数组里引用了「在它之后才 const 声明」的变量，
+ * 会因暂时性死区抛 `Cannot access 'x' before initialization`，
+ * 整个 Panel 崩溃 -> 面板白屏。这个 bug 真实发生过（refreshDb）。
+ *
+ * 做法：把 Panel 函数体抽出来，逐行累积「已声明的标识符」，
+ * 遇到 `}, [...])` 形式的依赖数组就检查里面的名字是否都已声明。
+ */
+const panelStart = source.indexOf('function Panel(props) {');
+assert.ok(panelStart > 0, '应能定位 Panel 函数');
+let depth = 0;
+let panelEnd = -1;
+for (let i = source.indexOf('{', panelStart); i < source.length; i++) {
+    if (source[i] === '{') depth += 1;
+    else if (source[i] === '}') { depth -= 1; if (depth === 0) { panelEnd = i + 1; break; } }
+}
+const panelBody = source.slice(panelStart, panelEnd);
+const panelLines = panelBody.split('\n');
+const declaredBefore = new Set();
+const tdzIssues = [];
+/** 全局可用的名字，不需要在 Panel 内声明 */
+const GLOBALS = new Set(['visible', 'props', 'React', 'h', 'window', 'document', 'setInterval', 'clearInterval', 'setTimeout', 'console', 'undefined', 'null', 'true', 'false']);
+
+for (let i = 0; i < panelLines.length; i += 1) {
+    const line = panelLines[i];
+    // 依赖数组行：`}, [a, b, c]);` 或 `}, [a, b]);`
+    const depMatch = line.match(/\},\s*\[([^\]]*)\]\s*\)/);
+    if (depMatch) {
+        for (const raw of depMatch[1].split(',')) {
+            const name = raw.trim();
+            if (!/^[A-Za-z_$][\w$]*$/.test(name)) continue;
+            if (GLOBALS.has(name)) continue;
+            if (!declaredBefore.has(name)) {
+                tdzIssues.push(`Panel 第 ${i + 1} 行：依赖 "${name}" 在该行之前未声明（TDZ 会导致面板白屏）`);
+            }
+        }
+    }
+    // 记录本行声明：const/let/var 单变量
+    for (const m of line.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/g)) declaredBefore.add(m[1]);
+    // 记录解构声明：const [a, b] = ... / const { a, b } = ...
+    for (const m of line.matchAll(/\b(?:const|let|var)\s*\[([^\]]+)\]\s*=/g)) {
+        for (const part of m[1].split(',')) {
+            const name = part.trim().split(':').pop().trim();
+            if (/^[A-Za-z_$][\w$]*$/.test(name)) declaredBefore.add(name);
+        }
+    }
+    for (const m of line.matchAll(/\b(?:const|let|var)\s*\{([^}]+)\}\s*=/g)) {
+        for (const part of m[1].split(',')) {
+            const name = part.trim().split(':').pop().trim();
+            if (/^[A-Za-z_$][\w$]*$/.test(name)) declaredBefore.add(name);
+        }
+    }
+    // 记录函数声明
+    for (const m of line.matchAll(/\bfunction\s+([A-Za-z_$][\w$]*)\s*\(/g)) declaredBefore.add(m[1]);
+}
+assert.deepEqual(tdzIssues, [], `useEffect 依赖里出现了「声明在之后」的变量（会导致面板白屏）：\n${tdzIssues.join('\n')}`);
+
 // 宿主没提供 slots 时 apply 要安全退出，不能抛
 recorded.exports.apply({ effect: () => {} });