@nsyan/db 1.2.1 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nsyan/db",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "AI 数据库接入扩展 for pi —— 达梦(DM)/PostgreSQL/MySQL/Oracle/Redis/Elasticsearch/MongoDB/Neo4j/Hive/Spark 十种数据库，六大家族方言，提供查询/表结构/扫描建连/连接清单 LLM 工具 | Database access extension for the pi coding agent: query, schema browsing, connection scanning and audit tools for PostgreSQL, MySQL, Oracle, DM (Dameng 达梦), Redis, Elasticsearch, MongoDB, Neo4j, Hive and Spark",
   "keywords": [
     "pi-extension",
@@ -60,14 +60,17 @@
     "mysql2": "^3.23.1",
     "neo4j-driver": "^5.28.3",
     "oracledb": "^7.0.1",
-    "neo4j-driver": "^5.28.3",
     "pg": "^8.22.0"
   },
   "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@types/node": "^22.20.2",
     "@types/pg": "^8.20.0",
-    "tsx": "^4.23.13"
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2"
   },
   "scripts": {
-    "test": "tsx --test \"test/**/*.test.ts\""
+    "test": "tsx --test \"test/**/*.test.ts\"",
+    "typecheck": "tsc -p tsconfig.typecheck.json"
   }
 }

package/src/config.ts

@@ -274,11 +274,26 @@ export function toRuntimeConfig(c: ConnConfig, defaultPort: number): ConnConfig
   };
 }
 
-// 供 UI 层展示类型短标签（原 index.ts 内 5 处重复映射的收敛点之一）
+// 供 UI 层展示类型标签（原 index.ts 内 5 处重复映射的收敛点之一）
+// 单一数据源：短标签与全称同表维护。键类型用 Record<DbTypeId, ...> 而非 Record<string, ...>，
+// 新增方言而漏补标签时会在类型检查阶段报错，不再静默 fallback 成原始 id。
+const TYPE_LABELS: Record<DbTypeId, { short: string; full: string }> = {
+  postgresql: { short: "PG", full: "PostgreSQL" },
+  mysql: { short: "MySQL", full: "MySQL" },
+  oracle: { short: "Oracle", full: "Oracle" },
+  dm: { short: "DM", full: "达梦" },
+  redis: { short: "Redis", full: "Redis" },
+  elasticsearch: { short: "ES", full: "Elasticsearch" },
+  mongodb: { short: "MongoDB", full: "MongoDB" },
+  neo4j: { short: "Neo4j", full: "Neo4j" },
+  hive: { short: "Hive", full: "Hive" },
+  spark: { short: "Spark", full: "Spark" },
+};
+
 export function shortTypeLabel(type: DbTypeId): string {
-  return ({ postgresql: "PG", mysql: "MySQL", oracle: "Oracle", mongodb: "MongoDB", neo4j: "Neo4j" } as Record<string, string>)[type] ?? type;
+  return TYPE_LABELS[type]?.short ?? type;
 }
 
 export function fullTypeLabel(type: DbTypeId): string {
-  return ({ postgresql: "PostgreSQL", mysql: "MySQL", oracle: "Oracle", mongodb: "MongoDB", neo4j: "Neo4j" } as Record<string, string>)[type] ?? type;
+  return TYPE_LABELS[type]?.full ?? type;
 }

package/src/core/index.ts

@@ -1,6 +1,6 @@
 // core/index.ts —— core 聚合 re-export（package.json exports "./core" 的入口）
 export type { DbTypeId, DbFamily, ConnConfig, ParsedTarget, DbConnection, ExecOpts,
-  CandidateStatus, Candidate, TableInfo, ColumnInfo, QueryResult, ListTablesResult,
+  CandidateStatus, Candidate, CandidateInput, TableInfo, ColumnInfo, QueryResult, ListTablesResult,
   DescribeTableResult, TestConnectionResult } from "./types.js";
 export { stripComments, splitStatements, isWriteStatement, isDropStatement } from "./sql-text.js";
 export { decide } from "./policy.js";

package/src/core/scan/tree.ts

@@ -0,0 +1,34 @@
+// scan/tree.ts —— 项目文件树收集（AI 扫描时代的"发现层"）
+// 设计（v1.3.0 共识）：文件发现与内容提取全部交给会话模型——本模块只做确定性的事情：
+//   走完整棵目录树、排除无关目录、产出相对路径清单。语言无关（Java/Py/TS/Go/Rust...）。
+// 注：不再做任何"这是不是配置文件"的猜测（原文件名模式匹配已废弃）——
+//     模型看到完整树后自行判断哪些文件值得读（用其自带 read 工具），长尾格式天然覆盖。
+
+import { resolveRoot, walk } from "./walker.js";
+
+export interface TreeResult {
+  root: string;            // 绝对路径
+  total: number;           // 收集到的文件总数
+  truncated: boolean;      // 是否超出 MAX_TREE_LINES 被截断
+  lines: string[];         // 相对路径清单（已排序：浅层优先）
+}
+
+const MAX_TREE_LINES = 3000;
+
+/** 收集项目文件树（相对路径排序清单）；越界由 resolveRoot 拒绝 */
+export function collectTree(rootInput: string): TreeResult {
+  const root = resolveRoot(rootInput);
+  const files = walk(root);
+  const rels = files
+    .map((f) => f.slice(root.length + 1).split("\\").join("/"))
+    .sort((a, b) => {
+      const da = a.split("/").length, db = b.split("/").length;
+      return da !== db ? da - db : a.localeCompare(b);
+    });
+  return {
+    root,
+    total: rels.length,
+    truncated: rels.length > MAX_TREE_LINES,
+    lines: rels.slice(0, MAX_TREE_LINES),
+  };
+}

package/src/core/scan/validate.ts

@@ -0,0 +1,119 @@
+// scan/validate.ts —— AI 提交候选的校验层（防幻觉 + 归一化，纯函数可单测）
+// 设计（v1.3.0 共识）：候选由会话模型从配置文件提取后经 db_scan_save 提交。
+//   模型可能编造 host/类型，这里用确定性规则过滤：
+//   ① dialectId 必须在 registry ② 带 url 时方言 parseUrl 必须能解析（claim 与 url 矛盾即拒）
+//   ③ 无 url 时 host 必填、port 范围校验 ④ REQUIRED 表判定缺字段 ⑤ 同名查重
+
+import { basename } from "node:path";
+import { registry } from "../../dialects/index.js";
+import type { Candidate, CandidateInput, CandidateStatus, ConnConfig, DbTypeId } from "../types.js";
+
+/** 各类型建连必需字段（空串同样视为缺失）——家族语义，非正则，保留 */
+const REQUIRED: Record<DbTypeId, string[]> = {
+  postgresql: ["host", "port", "database", "username", "password"],
+  mysql: ["host", "port", "database", "username", "password"],
+  oracle: ["host", "port", "database", "username", "password"],
+  dm: ["host", "port", "database", "username", "password"],
+  hive: ["host", "port", "database", "username"],
+  spark: ["host", "port", "database", "username"],
+  redis: ["host", "port", "password"],
+  elasticsearch: ["host", "port"],
+  neo4j: ["host", "port", "username", "password"], // 工作库可选（缺省 neo4j；社区版默认开认证）
+  mongodb: ["host", "port"], // 账号/工作库可选（本地无认证常见）
+};
+
+function nonEmpty(v: unknown): v is string | number {
+  return v !== undefined && v !== null && String(v).trim() !== "";
+}
+
+export interface ValidateResult {
+  candidates: Candidate[];
+  rejected: string[];   // 被拒候选及原因（回传给模型可自查重提）
+}
+
+/** 校验 + 归一化一批模型提交的候选 */
+export function validateCandidates(raw: unknown, existingNames: Set<string>): ValidateResult {
+  const list = Array.isArray(raw) ? raw : [raw];
+  const candidates: Candidate[] = [];
+  const rejected: string[] = [];
+  const seenNames = new Set(existingNames);
+
+  for (const [i, item] of list.entries()) {
+    if (item === null || typeof item !== "object") {
+      rejected.push(`#${i + 1}: 非对象，已丢弃`);
+      continue;
+    }
+    const c = item as Record<string, unknown> & Partial<CandidateInput>;
+
+    // ① 类型必须被注册表认领
+    const dialect = registry.get(c.dialectId as DbTypeId);
+    if (!dialect) {
+      rejected.push(`#${i + 1}: 未知数据库类型 ${JSON.stringify(c.dialectId)}，支持: ${[...registry.keys()].join("/")}`);
+      continue;
+    }
+
+    // ② 带 url 时：方言 parseUrl 必须能解析（防幻觉——claim 与 url 矛盾整条拒）
+    //    解析成功时以解析结果为准（host/port/database/username/password 由 URL 补全）
+    // 归一化后 port/dbIndex 恒为 number（下行 parseInt 收敛）。此处用 Partial<ConnConfig> 而非
+    // Partial<CandidateInput>——后者的 port 是 number|string，会让下方端口范围校验退化为字符串比较。
+    let bag: Partial<ConnConfig> = {
+      host: typeof c.host === "string" ? c.host.trim() : undefined,
+      port: typeof c.port === "number" ? c.port : parseInt(String(c.port ?? ""), 10) || undefined,
+      username: nonEmpty(c.username) ? String(c.username) : undefined,
+      password: nonEmpty(c.password) ? String(c.password) : undefined,
+      database: nonEmpty(c.database) ? String(c.database) : undefined,
+      dbIndex: typeof c.dbIndex === "number" ? c.dbIndex : parseInt(String(c.dbIndex ?? ""), 10) || undefined,
+    };
+    if (nonEmpty(c.url)) {
+      const parsed = dialect.parseUrl(String(c.url).trim());
+      if (!parsed) {
+        rejected.push(`#${i + 1}: url 无法被 ${dialect.id} 方言解析（疑似编造），已拒绝: ${String(c.url).slice(0, 80)}`);
+        continue;
+      }
+      bag = {
+        ...bag,
+        host: parsed.host,
+        port: parsed.port,
+        username: bag.username ?? parsed.username,
+        password: bag.password ?? parsed.password,
+        database: bag.database ?? parsed.database,
+        dbIndex: bag.dbIndex ?? parsed.dbIndex,
+      };
+    }
+
+    // ③ 无 url 时 host 必填；port 范围校验
+    if (!nonEmpty(bag.host)) {
+      rejected.push(`#${i + 1}: ${dialect.id} 候选缺 host（无 url 时 host 必填）`);
+      continue;
+    }
+    if (bag.port !== undefined && (!Number.isInteger(bag.port) || bag.port < 1 || bag.port > 65535)) {
+      rejected.push(`#${i + 1}: ${dialect.id} 候选 port 非法: ${bag.port}`);
+      continue;
+    }
+
+    // ④ 缺字段判定
+    const missing = (REQUIRED[dialect.id] ?? []).filter((f) => !nonEmpty(bag[f as keyof ConnConfig]));
+
+    // ⑤ 命名：显式 name > 默认；同名（含与本批前序候选撞名）→ exists 状态
+    let name = nonEmpty(c.name) ? String(c.name).trim()
+      : `${dialect.id}-${bag.host}${bag.database ? "-" + bag.database : ""}`;
+    let status: CandidateStatus = missing.length > 0 ? "incomplete" : "ready";
+    if (seenNames.has(name)) status = "exists";
+    seenNames.add(name);
+
+    candidates.push({
+      status,
+      dialectId: dialect.id,
+      partial: { name, ...bag } as Partial<import("../types.js").ConnConfig>,
+      missing,
+      source: nonEmpty(c.source) ? String(c.source) : "AI 提取",
+      warnings: Array.isArray(c.warnings) ? c.warnings.map(String).slice(0, 3) : undefined,
+    });
+  }
+  return { candidates, rejected };
+}
+
+/** 供展示层使用的默认项目名（db_scan_save 的 name 兜底） */
+export function defaultProjectName(root: string): string {
+  return basename(root);
+}

package/src/core/types.ts

@@ -37,14 +37,28 @@ export interface ParsedTarget {
 export interface DbConnection { type: DbTypeId; client: unknown; close(): Promise<void>; }
 export interface ExecOpts { readonly: boolean; maxRows: number; timeoutSec: number; }
 
-// scan/candidates.ts
-export type CandidateStatus = "ready" | "incomplete" | "encrypted" | "exists";
+// scan（v1.3.0：文件发现与提取交给会话模型，本层只做校验归一化）
+export type CandidateStatus = "ready" | "incomplete" | "exists";
+/** 模型经 db_scan_save 提交的原始候选形状 */
+export interface CandidateInput {
+  dialectId: DbTypeId;
+  host?: string; port?: number | string;
+  username?: string; password?: string;
+  database?: string; dbIndex?: number | string;
+  /** 完整连接串（可选；提供时必须能被方言 parseUrl 解析，否则整条拒绝——防幻觉） */
+  url?: string;
+  name?: string;
+  /** 来源描述（如配置文件相对路径），展示用 */
+  source?: string;
+  warnings?: string[];
+}
 export interface Candidate {
   status: CandidateStatus;
-  dialectId: DbTypeId;              // 由方言 fingerprints 匹配得出
-  partial: Partial<ConnConfig>;     // 已抽到的字段
+  dialectId: DbTypeId;
+  partial: Partial<ConnConfig>;     // 归一化后的字段（含默认 name）
   missing: string[];                // 待补字段名（incomplete 时）
-  source: { file: string; profile?: string; confidence: number };
+  source: string;                   // 来源描述
+  warnings?: string[];
 }
 
 // ── 以下从 src/db.ts 原样搬入（字段不变） ──────────

package/src/dialects/dm.ts

@@ -80,10 +80,12 @@ class DmDialect extends RelationalDialect {
   protected async doExecute(client: unknown, stmt: string, opts: ExecOpts): Promise<{ columns: string[]; rows: unknown[][]; rowCount: number }> {
     const dmConn = client as dmdb.Connection;
     const maxRows = opts.maxRows;
+    // 上游 dmdb 的 ExecuteOptions 未声明 maxRows/fetchArraySize（运行时可接受或被忽略）；
+    // 结果另有下方 .slice(0, maxRows) 兜底，故此处仅放宽类型断言，不改运行时行为。
     const res = await dmConn.execute(stmt, [], {
       maxRows,
       fetchArraySize: maxRows,
-    });
+    } as dmdb.ExecuteOptions);
     if (res.metaData && res.metaData.length > 0) {
       const columns = res.metaData.map((m: any) => m.name);
       const rows = (res.rows ?? []).slice(0, maxRows).map((r: any) => [...r]);
@@ -95,7 +97,8 @@ class DmDialect extends RelationalDialect {
   async versionQuery(conn: DbConnection): Promise<string> {
     const dmConn = conn.client as dmdb.Connection;
     const res = await dmConn.execute("SELECT * FROM V$VERSION");
-    return (res.rows ?? [])[0]?.[0] as string ?? "unknown";
+    const rows = (res.rows as unknown[][] | undefined) ?? [];
+    return (rows[0]?.[0] as string | undefined) ?? "unknown";
   }
 
   async listTables(config: ConnConfig, pattern?: string): Promise<ListTablesResult> {

package/src/dialects/elasticsearch.ts

@@ -7,19 +7,27 @@ import type { ConnConfig, DbConnection, ExecOpts, ParsedTarget,
 import { SearchDialect, type DslKind } from "./search-dialect.js";
 import { register, filterTables, type Fingerprints } from "./dialect.js";
 
-// ── URL 解析：http(s)://host:port（认证走账号/密码字段，API Key 二期）───
-const ES_RE = /^(https?):\/\/([^:/?#@]+)(?::(\d+))?(\/.*)?$/;
+// ── URL 解析：http(s)://[user:pass@]host:port（认证解出后归一化到 username/password，API Key 二期）───
+const ES_RE = /^(https?):\/\/(?:([^:/?#@]*)(?::([^@]*))?@)?([^:/?#@]+)(?::(\d+))?(\/.*)?$/;
 
 function parseEsUrl(url: string): ParsedTarget | null {
   const clean = url.split("?")[0].replace(/\/+$/, "");
   const m = clean.match(ES_RE);
   if (!m) return null;
-  const host = m[2];
+  const host = m[4];
   const defaultPort = m[1] === "https" ? 443 : 9200;
-  const port = m[3] ? parseInt(m[3], 10) : defaultPort;
+  const port = m[5] ? parseInt(m[5], 10) : defaultPort;
   const ssl = m[1] === "https";
   if (!host) return null;
-  return { host, port, ssl };
+  const out: ParsedTarget = { host, port, ssl };
+  // userinfo 段（可能含 URL 编码密码）解出归一化，供扫描建连/测连直接用
+  if (m[2] !== undefined) {
+    try { out.username = decodeURIComponent(m[2]); } catch { out.username = m[2]; }
+  }
+  if (m[3] !== undefined) {
+    try { out.password = decodeURIComponent(m[3]); } catch { out.password = m[3]; }
+  }
+  return out;
 }
 
 /** 从 `version.number`（如 "7.17.0"）取大版本号 */
@@ -155,7 +163,9 @@ class ElasticsearchDialect extends SearchDialect {
         return { columns: ["count"], rows: [[count]], rowCount: count };
       }
       if (kind.endpoint === "_mget") {
-        const res = await es.mget({ index, body: { docs: [] } });
+        // 注：_mget 需兼容 v7 客户端的 body 形态（本文件为 v7/v8/v9 三客户端分发），
+        // 而 v8/v9 的类型已把请求体改为顶层 docs，故按运行时通用形态传参并放宽参数类型。
+        const res = await es.mget({ index, body: { docs: [] } } as unknown as Parameters<ClientV8["mget"]>[0]);
         return docsToRows(unwrap(res));
       }
       // _search：DSL 整体即 body

package/src/dialects/hive.ts

@@ -61,7 +61,9 @@ class HiveDialect extends BigDataDialect {
   }
 
   protected async doConnect(config: ConnConfig, timeoutMs: number): Promise<DbConnection> {
-    const client = new hive.HiveClient(TCLIService, TCLIService_types);
+    // 上游 hive-driver 的 TCLIServiceTypes 声明不完整（缺 25 个请求类型），与其运行时实际
+    // 使用的 thrift 定义不一致；仅放宽类型断言，运行时对象未做任何改动。
+    const client = new hive.HiveClient(TCLIService, TCLIService_types as any);
     await client.connect(
       { host: config.host ?? "localhost", port: config.port ?? DEFAULT_PORT },
       new hive.connections.TcpConnection(),

package/src/dialects/mysql.ts

@@ -109,9 +109,11 @@ class MysqlDialect extends RelationalDialect {
     try {
       const tables = await this.withConnection(config, async (conn) => {
         const mysqlConn = conn.client as mysql.Connection;
+        // config.database 为可选（ConnConfig），而 mysql2 的 ExecuteValues 不接受 undefined 元素；
+        // 此处仅放宽类型断言，运行时参数与既有行为完全一致。
         const [rows] = await mysqlConn.execute(
           "SELECT TABLE_NAME, TABLE_TYPE, TABLE_COMMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME",
-          [config.database],
+          [config.database] as any[],
         );
         const all = (rows as any[]).map((r: any) => ({
           schema: "",
@@ -149,7 +151,7 @@ class MysqlDialect extends RelationalDialect {
         try {
           const [commentRows] = await mysqlConn.execute(
             "SELECT COLUMN_NAME, COLUMN_COMMENT FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?",
-            [config.database, table],
+            [config.database, table] as any[],
           );
           const commentMap = new Map((commentRows as any[]).map((r: any) => [r.COLUMN_NAME, r.COLUMN_COMMENT]));
           for (const col of cols) {

package/src/dialects/neo4j.ts

@@ -270,7 +270,7 @@ class Neo4jDialect extends GraphDialect {
             const f = r._fields ?? [];
             const types = f[3] as string[] | null;
             if (!Array.isArray(types) || !types.includes(graphName)) continue;
-            indexLines.push(`${f[0]}(${f[1]}, ${f[5] ?? "online"}) ON ${isRel ? "rel" : "node"}(${types.join(":")}).(${(f[4] ?? []).join(",")})`);
+            indexLines.push(`${f[0]}(${f[1]}, ${f[5] ?? "online"}) ON ${isRel ? "rel" : "node"}(${types.join(":")}).(${((f[4] ?? []) as string[]).join(",")})`);
           }
         } catch { /* SHOW 失败降级 */ }
         try {
@@ -281,7 +281,7 @@ class Neo4jDialect extends GraphDialect {
             const types = f[3] as string[] | null;
             if (!Array.isArray(types) || !types.includes(graphName)) continue;
             for (const p of (f[4] ?? []) as string[]) if (String(f[1]).toUpperCase().includes("UNIQUE")) uniqueProps.add(p);
-            indexLines.push(`${f[0]}(${f[1]}) ON ${types.join(":")}.(${(f[4] ?? []).join(",")})`);
+            indexLines.push(`${f[0]}(${f[1]}) ON ${types.join(":")}.(${((f[4] ?? []) as string[]).join(",")})`);
           }
         } catch { /* 降级 */ }
 

package/src/dialects/oracle.ts

@@ -1,7 +1,7 @@
 // src/dialects/oracle.ts
 import oracledb from "oracledb";
 import type { ConnConfig, DbConnection, ExecOpts, ParsedTarget,
-  ListTablesResult, DescribeTableResult, ColumnInfo, TestConnectionResult } from "../core/types.js";
+  ListTablesResult, DescribeTableResult, TableInfo, ColumnInfo, TestConnectionResult } from "../core/types.js";
 import { RelationalDialect } from "./relational-dialect.js";
 import { register, filterTables, type Fingerprints } from "./dialect.js";
 
@@ -107,7 +107,9 @@ class OracleDialect extends RelationalDialect {
            WHERE T.OWNER NOT IN ('SYS', 'SYSTEM', 'DBSNMP', 'XDB')
            ORDER BY T.OWNER, T.TABLE_NAME`,
         );
-        const all = (res.rows ?? []).map((r: any) => ({
+        // 显式标注 TableInfo[]：oracledb 无类型声明，res.rows 退化为 any，若不标注则
+        // filterTables 的泛型会回退到约束 { name; schema? }，丢失 type/description 两个字段。
+        const all: TableInfo[] = (res.rows ?? []).map((r: any) => ({
           schema: r[1],
           name: r[0],
           type: "TABLE",

package/src/dialects/redis.ts

@@ -93,9 +93,13 @@ class RedisDialect extends KvDialect {
         let sampled = 0;
         let cursor = "0";
         // LIKE（%/_）→ SCAN 通配（*/?），全局替换（String.replace 单次替换是 bug）
-        const matchArgs = pattern ? ["MATCH", pattern.split("").map((ch) => ch === "%" ? "*" : ch === "_" ? "?" : ch).join("")] : [];
+        const scanPattern = pattern ? pattern.split("").map((ch) => ch === "%" ? "*" : ch === "_" ? "?" : ch).join("") : null;
         do {
-          const [next, keys] = await redis.scan(cursor, "COUNT", 100, ...matchArgs);
+          // ioredis 的 scan 重载要求 MATCH/COUNT 固定次序，不能靠 spread 拼参；
+          // Redis 的 SCAN 命令本身不区分参数顺序，故两个分支与原来的命令语义完全一致。
+          const [next, keys] = scanPattern
+            ? await redis.scan(cursor, "MATCH", scanPattern, "COUNT", 100)
+            : await redis.scan(cursor, "COUNT", 100);
           cursor = next;
           for (const key of keys) {
             if (sampled >= 200) break;
@@ -166,7 +170,8 @@ class RedisDialect extends KvDialect {
           } else if (type === "set") {
             preview = JSON.stringify(await redis.smembers(key)).slice(0, 200);
           } else if (type === "zset") {
-            preview = JSON.stringify(await redis.zrange(key, 0, 9, "WITHSCORES")).slice(0, 200);
+            // ioredis 6 的 zrange 重载把 stop 声明为 string|Buffer（漏了 number）；索引 "9" 与数字 9 等价。
+            preview = JSON.stringify(await redis.zrange(key, 0, "9", "WITHSCORES")).slice(0, 200);
           }
         } catch { /* ignore */ }
         return [

package/src/dialects/spark.ts

@@ -58,7 +58,8 @@ class SparkDialect extends BigDataDialect {
   }
 
   protected async doConnect(config: ConnConfig, timeoutMs: number): Promise<DbConnection> {
-    const client = new hive.HiveClient(TCLIService, TCLIService_types);
+    // 同 hive.ts：上游 hive-driver 的 TCLIServiceTypes 声明不完整，仅放宽类型断言，不动运行时。
+    const client = new hive.HiveClient(TCLIService, TCLIService_types as any);
     await client.connect(
       { host: config.host ?? "localhost", port: config.port ?? DEFAULT_PORT },
       new hive.connections.TcpConnection(),