@zz1996/dbhub-dameng 0.1.7 → 1.2.5-dameng.620

package/README.md

@@ -1,183 +1,75 @@
-> [!NOTE]  
-> Brought to you by [Bytebase](https://www.bytebase.com/), open-source database DevSecOps platform.
-
-> [!NOTE]
-> This package is a local Dameng/DM8 connector fork of Bytebase DBHub. Use
-> `npx -y @zz1996/dbhub-dameng --transport stdio --config ./dbhub.dameng.toml`
-> for Dameng MCP usage.
->
-> Dameng DSN format: `dameng://user:password@host:5236/schema`. Prefer a
-> least-privilege read-only Dameng account for production or shared databases,
-> even when the `execute_sql` tool is configured with `readonly = true`.
-
-<p align="center">
-<a href="https://dbhub.ai/" target="_blank">
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/logo/full-dark.svg" width="75%">
-  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/logo/full-light.svg" width="75%">
-  <img src="https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/logo/full-light.svg" width="75%" alt="DBHub Logo">
-</picture>
-</a>
-</p>
-
-```bash
-            +------------------+    +--------------+    +------------------+
-            |                  |    |              |    |                  |
-            |                  |    |              |    |                  |
-            |  Claude Desktop  +--->+              +--->+    PostgreSQL    |
-            |                  |    |              |    |                  |
-            |  Claude Code     +--->+              +--->+    SQL Server    |
-            |                  |    |              |    |                  |
-            |  Cursor          +--->+    DBHub     +--->+    SQLite        |
-            |                  |    |              |    |                  |
-            |  VS Code         +--->+              +--->+    MySQL         |
-            |                  |    |              |    |                  |
-            |  Copilot CLI     +--->+              +--->+    MariaDB       |
-            |                  |    |              |    |                  |
-            |                  +--->+              +--->+    Dameng / DM8  |
-            |                  |    |              |    |                  |
-            +------------------+    +--------------+    +------------------+
-                 MCP Clients           MCP Server             Databases
-```
-
-DBHub is a zero-dependency, token efficient MCP server implementing the Model Context Protocol (MCP) server interface. This lightweight gateway allows MCP-compatible clients to connect to and explore different databases:
-
-- **Local Development First**: Zero dependency, token efficient with just two MCP tools to maximize context window
-- **Multi-Database**: PostgreSQL, MySQL, MariaDB, SQL Server, SQLite, and Dameng/DM8 through a single interface
-- **Multi-Connection**: Connect to multiple databases simultaneously with TOML configuration
-- **Guardrails**: Read-only mode, row limiting, and query timeout to prevent runaway operations
-- **Secure Access**: SSH tunneling and SSL/TLS encryption
-
-## Supported Databases
-
-PostgreSQL, MySQL, SQL Server, MariaDB, SQLite, and Dameng/DM8.
-
-## MCP Tools
-
-DBHub implements MCP tools for database operations:
-
-- **[execute_sql](https://dbhub.ai/tools/execute-sql)**: Execute SQL queries with transaction support and safety controls
-- **[search_objects](https://dbhub.ai/tools/search-objects)**: Search and explore database schemas, tables, columns, indexes, and procedures with progressive disclosure
-- **[Custom Tools](https://dbhub.ai/tools/custom-tools)**: Define reusable, parameterized SQL operations in your `dbhub.toml` configuration file
+# DBHub：最小达梦适配
 
-## Workbench
+基于 [Bytebase DBHub](https://github.com/bytebase/dbhub) 的薄层 fork。
+默认仍只有 `search_objects` 和 `execute_sql`，保留上游搜索流程和结果格式。
 
-DBHub includes a [built-in web interface](https://dbhub.ai/workbench/overview) for interacting with your database tools. It provides a visual way to execute queries, run custom tools, and view request traces without requiring an MCP client.
+## 使用
 
-![workbench](https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/workbench/workbench.webp)
+Node.js >= 22.5。将 `dbhub.dameng.toml.example` 复制为本地 `dbhub.toml`，
+通过环境变量 `DAMENG_DSN` 提供连接串：
 
-## Installation
-
-See the full [Installation Guide](https://dbhub.ai/installation) for detailed instructions.
-
-### Quick Start
-
-**Docker:**
-
-```bash
-docker run --rm --init \
-   --name dbhub \
-   --publish 8080:8080 \
-   bytebase/dbhub \
-   --transport http \
-   --port 8080 \
-   --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
+```text
+dameng://user:password@host:5236/APP
 ```
 
-**NPM:** (requires Node.js >= 22.5.0)
+账号、密码中的特殊字符需要 URL 编码。路径是 schema，名称与数据库保持一致，
+包括大小写。使用最小权限只读账号连接共享或生产库。
 
-```bash
-npx @bytebase/dbhub@latest --transport http --port 8080 --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
+```sh
+npx @zz1996/dbhub-dameng@latest --transport stdio --config ./dbhub.toml
 ```
 
-**Dameng / DM8 fork:**
-
-```bash
-npx -y @zz1996/dbhub-dameng --transport stdio --config ./dbhub.dameng.toml
-```
-
-Minimal Dameng TOML configuration:
-
-```toml
-[[sources]]
-id = "dm8_readonly"
-description = "Dameng DM8 database for schema discovery and read-only SQL queries"
-dsn = "dameng://${DM8_USER}:${DM8_PASSWORD}@${DM8_HOST}:5236/${DM8_SCHEMA}"
-query_timeout = 30
-lazy = true
-
-[[tools]]
-name = "search_objects"
-source = "dm8_readonly"
-
-[[tools]]
-name = "execute_sql"
-source = "dm8_readonly"
-readonly = true
-max_rows = 100
+- 驱动为固定版本 `dmdb`，采用原生连接池、参数绑定和行数限制。
+- 不增加连接重试、超时重建、后台恢复或元数据搜索加速。
+- `connection_timeout`、`query_timeout` 分别传给驱动的 `connectTimeout`、`sessionTimeout`。
+- SQL 结果按语句返回，超过 `max_rows` 时附带 `truncated`。
+- 自定义工具使用 `?` 占位符；参数仅支持单语句。
+- 只读判断复用上游策略，不能代替数据库账号权限；函数副作用不由连接器保证隔离。
+- 本实验覆盖普通 SQL 查询和元数据浏览；不提供达梦 `explain_sql`、`health_check`，
+  不支持包含内部分号的匿名 PL/SQL 块。初始化脚本按上游惯例在启动时执行，
+  不应依赖它设置连接池每条连接的会话状态，schema 应在 DSN 中指定。
+
+## 验证
+
+```sh
+pnpm install --frozen-lockfile
+pnpm test:unit
+pnpm build
+pnpm test:build
+# 可选：明确指定本机配置，只读验证真实 DM8（不会执行 init_script）
+node scripts/verify-dameng.mjs /absolute/path/to/dbhub.toml [source-id]
 ```
 
-To verify the local Dameng connector against a real DM8 instance without
-committing credentials, set `DAMENG_DSN` or point to a local TOML file:
+GitHub 检查无需真实库凭据；真实 DM8 验证在本机显式运行。
 
-```bash
-DAMENG_DSN="dameng://user:password@host:5236/schema" pnpm verify:dameng
-pnpm verify:dameng -- --config ./dbhub.dameng.toml --source dm8_readonly
-```
+## 自动同步和发布
 
-**Demo Mode:**
+`.github/workflows/dameng-sync-publish.yml` 每天北京时间 10:23 执行，
+也会在 `main` 更新时执行，支持手动运行。
 
-```bash
-npx @bytebase/dbhub@latest --transport http --port 8080 --demo
-```
-
-**Restrict to loopback (recommended for production):**
-
-```bash
-npx @bytebase/dbhub@latest --transport http --host 127.0.0.1 --port 8080 --demo
-```
-
-> The HTTP transport defaults to `--host 0.0.0.0`, exposing DBHub on every network interface. For production, bind to `127.0.0.1` and front DBHub with a reverse proxy (nginx/Caddy) or firewall — DBHub does not authenticate HTTP clients.
->
-> The HTTP transport also has built-in DNS-rebinding protection: it only accepts requests whose `Host` is loopback, this machine's own hostname/IPs, or a name you allow via [`--allowed-hosts`](https://dbhub.ai/config/command-line#allowed-hosts). If a client behind a reverse proxy or custom DNS name gets a `403`, add that hostname with `--allowed-hosts`.
-
-See [Command-Line Options](https://dbhub.ai/config/command-line) for all available parameters.
-
-### Multi-Database Setup
-
-Connect to multiple databases simultaneously using TOML configuration files. Perfect for managing production, staging, and development databases from a single DBHub instance.
-
-See [Multi-Database Configuration](https://dbhub.ai/config/toml) for complete setup instructions.
-
-## Development
-
-Requires Node.js >= 22.5.0 (DBHub uses the built-in `node:sqlite` module).
-
-```bash
-# Install dependencies
-pnpm install
-
-# Run in development mode
-pnpm dev
-
-# Build and run for production
-pnpm build && pnpm start --transport stdio --dsn "postgres://user:password@localhost:5432/dbname"
-```
+1. 将最新 `bytebase/dbhub:main` 合并到临时工作区。
+2. 安装锁定依赖，运行单测、完整构建与打包导入检查。
+3. 全部通过后才将合并提交推送到本仓库 `main`，不强推。
+4. 准备发布目录，使用 npm OIDC 发布 `@zz1996/dbhub-dameng`。
 
-See [Testing](.claude/skills/testing/SKILL.md) and [Debug](https://dbhub.ai/config/debug).
+冲突、测试或构建失败时停止，不更新远端 `main`，通过 GitHub Actions 失败通知处理。
+发布失败时保留已验证的合并结果，可重新运行；已发布版本会跳过。
+机器人推送不会触发新的 workflow；产生合并提交后显式再次触发本工作流，
+由新提交对应的运行发布，确保 npm provenance 指向实际构建的提交。
+这是检查后直接合并的最小流程，不创建自动审批 PR，也不需要长期 PAT。
 
-## Contributors
+源码的 `package.json` 版本号、包名、上游 README 和上游发布工作流保持原样。
+仅打包时设置 fork 身份，版本为 `<上游版本>-dameng.<提交总数>`，发布到 `latest` 标签。
+例如 `1.2.5-dameng.620`；它是独立 fork 版本，不是 Bytebase 官方发行版。
+每次代码合并都会得到新版本，同一提交重跑使用同一个版本号。
 
-<a href="https://github.com/bytebase/dbhub/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=bytebase/dbhub" />
-</a>
+首次配置：
 
-## Star History
+- 在本仓库 Actions 设置中禁用继承的 `npm-publish.yml`、`docker-publish.yml`、
+  `mcpb-release.yml`，避免执行 Bytebase 的发布流程；保持文件原样以降低同步冲突。
+- 在 npm 包设置中添加 GitHub Actions Trusted Publisher：用户 `zuozh11`，
+  仓库 `dbhub-dameng`，工作流 `dameng-sync-publish.yml`，环境名留空，允许 `npm publish`。
+- workflow 显式申请 `contents: write`、`actions: write` 和 `id-token: write`；无需 npm token。
+- 手动运行时可取消 `publish`，只验证同步和打包。
 
-<a href="https://www.star-history.com/?repos=bytebase%2Fdbhub&type=date&legend=top-left">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=bytebase/dbhub&type=date&theme=dark&legend=top-left" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=bytebase/dbhub&type=date&legend=top-left" />
-   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=bytebase/dbhub&type=date&legend=top-left" />
- </picture>
-</a>
+旧实现保留在 `dameng-connector` 分支中；新实现不继承其恢复机制。

package/dbhub.dameng.toml.example

@@ -1,20 +1,13 @@
-# Example DBHub configuration for the local Dameng/DM8 fork.
-# Do not commit real credentials. Prefer environment variables.
-
 [[sources]]
-id = "dm8_dev"
-description = "Dameng DM8 development database. Read-only access for agent schema discovery and SQL queries."
-dsn = "dameng://${DM8_USER}:${DM8_PASSWORD}@${DM8_HOST}:5236/${DM8_SCHEMA}"
-connection_timeout = 5
-query_timeout = 30
-lazy = true
+id = "default"
+dsn = "${DAMENG_DSN}"
 
 [[tools]]
 name = "execute_sql"
-source = "dm8_dev"
+source = "default"
 readonly = true
 max_rows = 100
 
 [[tools]]
 name = "search_objects"
-source = "dm8_dev"
+source = "default"

package/dist/{chunk-SQA2ISDE.js → chunk-2JL4KCP5.js}

@@ -91,7 +91,9 @@ var SafeURL = class {
           }
         });
       }
-      const atIndex = urlString.indexOf("@");
+      const pathStart = urlString.indexOf("/");
+      const authorityEnd = pathStart === -1 ? urlString.length : pathStart;
+      const atIndex = urlString.lastIndexOf("@", authorityEnd - 1);
       if (atIndex !== -1) {
         const auth = urlString.substring(0, atIndex);
         urlString = urlString.substring(atIndex + 1);
@@ -143,118 +145,6 @@ var SafeURL = class {
   }
 };
 
-// src/utils/dsn-obfuscate.ts
-function parseConnectionInfoFromDSN(dsn) {
-  if (!dsn) {
-    return null;
-  }
-  try {
-    const type = getDatabaseTypeFromDSN(dsn);
-    if (typeof type === "undefined") {
-      return null;
-    }
-    if (type === "sqlite") {
-      const prefix = "sqlite:///";
-      if (dsn.length > prefix.length) {
-        const rawPath = dsn.substring(prefix.length);
-        const firstChar = rawPath[0];
-        const isWindowsDrive = rawPath.length > 1 && rawPath[1] === ":";
-        const isSpecialPath = firstChar === ":" || firstChar === "." || firstChar === "~" || isWindowsDrive;
-        return {
-          type,
-          database: isSpecialPath ? rawPath : "/" + rawPath
-        };
-      }
-      return { type };
-    }
-    const url = new SafeURL(dsn);
-    const info = { type };
-    if (url.hostname) {
-      info.host = url.hostname;
-    }
-    if (url.port) {
-      info.port = parseInt(url.port, 10);
-    }
-    if (url.pathname && url.pathname.length > 1) {
-      info.database = url.pathname.substring(1);
-    }
-    if (url.username) {
-      info.user = url.username;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function obfuscateDSNPassword(dsn) {
-  if (!dsn) {
-    return dsn;
-  }
-  try {
-    const type = getDatabaseTypeFromDSN(dsn);
-    if (type === "sqlite") {
-      return dsn;
-    }
-    const url = new SafeURL(dsn);
-    if (!url.password) {
-      return dsn;
-    }
-    const obfuscatedPassword = "*".repeat(Math.min(url.password.length, 8));
-    const protocol = dsn.split(":")[0];
-    let result;
-    if (url.username) {
-      result = `${protocol}://${url.username}:${obfuscatedPassword}@${url.hostname}`;
-    } else {
-      result = `${protocol}://${obfuscatedPassword}@${url.hostname}`;
-    }
-    if (url.port) {
-      result += `:${url.port}`;
-    }
-    result += url.pathname;
-    if (url.searchParams.size > 0) {
-      const params = [];
-      url.forEachSearchParam((value, key) => {
-        params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-      });
-      result += `?${params.join("&")}`;
-    }
-    return result;
-  } catch {
-    return dsn;
-  }
-}
-function getDatabaseTypeFromDSN(dsn) {
-  if (!dsn) {
-    return void 0;
-  }
-  const protocol = dsn.split(":")[0];
-  return protocolToConnectorType(protocol);
-}
-function protocolToConnectorType(protocol) {
-  const mapping = {
-    "postgres": "postgres",
-    "postgresql": "postgres",
-    "mysql": "mysql",
-    "mariadb": "mariadb",
-    "sqlserver": "sqlserver",
-    "sqlite": "sqlite",
-    "dameng": "dameng",
-    "dm": "dameng"
-  };
-  return mapping[protocol];
-}
-function getDefaultPortForType(type) {
-  const ports = {
-    "postgres": 5432,
-    "mysql": 3306,
-    "mariadb": 3306,
-    "sqlserver": 1433,
-    "sqlite": void 0,
-    "dameng": 5236
-  };
-  return ports[type];
-}
-
 // src/utils/sql-parser.ts
 var TokenType = { Plain: 0, Comment: 1, QuotedBlock: 2 };
 function plainToken(i) {
@@ -431,12 +321,12 @@ function scanTokenSQLServer(sql, i) {
   return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBracketQuotedIdentifier(sql, i) ?? plainToken(i);
 }
 var dialectScanners = {
+  dameng: scanTokenAnsi,
   postgres: scanTokenPostgres,
   mysql: scanTokenMySQL,
   mariadb: scanTokenMySQL,
   sqlite: scanTokenSQLite,
-  sqlserver: scanTokenSQLServer,
-  dameng: scanTokenAnsi
+  sqlserver: scanTokenSQLServer
 };
 function getScanner(dialect) {
   return dialect ? dialectScanners[dialect] ?? scanTokenAnsi : scanTokenAnsi;
@@ -466,6 +356,21 @@ function stripCommentsAndStrings(sql, dialect) {
   }
   return parts.join("");
 }
+function blankCommentsAndStrings(sql, dialect) {
+  const scanToken = getScanner(dialect);
+  let result = "";
+  let i = 0;
+  while (i < sql.length) {
+    const token = scanToken(sql, i);
+    if (token.type === TokenType.Plain) {
+      result += sql[i];
+    } else {
+      result += " ".repeat(token.end - i);
+    }
+    i = token.end;
+  }
+  return result;
+}
 function splitSQLStatements(sql, dialect) {
   const scanToken = getScanner(dialect);
   const statements = [];
@@ -494,10 +399,7 @@ function splitSQLStatements(sql, dialect) {
 export {
   ConnectorRegistry,
   SafeURL,
-  parseConnectionInfoFromDSN,
-  obfuscateDSNPassword,
-  getDatabaseTypeFromDSN,
-  getDefaultPortForType,
   stripCommentsAndStrings,
+  blankCommentsAndStrings,
   splitSQLStatements
 };

package/dist/chunk-3RJRH3CN.js

@@ -0,0 +1,121 @@
+import {
+  SafeURL
+} from "./chunk-2JL4KCP5.js";
+
+// src/utils/dsn-obfuscate.ts
+function parseConnectionInfoFromDSN(dsn) {
+  if (!dsn) {
+    return null;
+  }
+  try {
+    const type = getDatabaseTypeFromDSN(dsn);
+    if (typeof type === "undefined") {
+      return null;
+    }
+    if (type === "sqlite") {
+      const prefix = "sqlite:///";
+      if (dsn.length > prefix.length) {
+        const rawPath = dsn.substring(prefix.length);
+        const firstChar = rawPath[0];
+        const isWindowsDrive = rawPath.length > 1 && rawPath[1] === ":";
+        const isSpecialPath = firstChar === ":" || firstChar === "." || firstChar === "~" || isWindowsDrive;
+        return {
+          type,
+          database: isSpecialPath ? rawPath : "/" + rawPath
+        };
+      }
+      return { type };
+    }
+    const url = new SafeURL(dsn);
+    const info = { type };
+    if (url.hostname) {
+      info.host = url.hostname;
+    }
+    if (url.port) {
+      info.port = parseInt(url.port, 10);
+    }
+    if (url.pathname && url.pathname.length > 1) {
+      info.database = url.pathname.substring(1);
+    }
+    if (url.username) {
+      info.user = url.username;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+function obfuscateDSNPassword(dsn) {
+  if (!dsn) {
+    return dsn;
+  }
+  try {
+    const type = getDatabaseTypeFromDSN(dsn);
+    if (type === "sqlite") {
+      return dsn;
+    }
+    const url = new SafeURL(dsn);
+    if (!url.password) {
+      return dsn;
+    }
+    const obfuscatedPassword = "*".repeat(Math.min(url.password.length, 8));
+    const protocol = dsn.split(":")[0];
+    let result;
+    if (url.username) {
+      result = `${protocol}://${url.username}:${obfuscatedPassword}@${url.hostname}`;
+    } else {
+      result = `${protocol}://${obfuscatedPassword}@${url.hostname}`;
+    }
+    if (url.port) {
+      result += `:${url.port}`;
+    }
+    result += url.pathname;
+    if (url.searchParams.size > 0) {
+      const params = [];
+      url.forEachSearchParam((value, key) => {
+        params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      });
+      result += `?${params.join("&")}`;
+    }
+    return result;
+  } catch {
+    return dsn;
+  }
+}
+function getDatabaseTypeFromDSN(dsn) {
+  if (!dsn) {
+    return void 0;
+  }
+  const protocol = dsn.split(":")[0];
+  return protocolToConnectorType(protocol);
+}
+function protocolToConnectorType(protocol) {
+  const mapping = {
+    "dameng": "dameng",
+    "postgres": "postgres",
+    "postgresql": "postgres",
+    "mysql": "mysql",
+    "mariadb": "mariadb",
+    "sqlserver": "sqlserver",
+    "sqlite": "sqlite"
+  };
+  return mapping[protocol];
+}
+function getDefaultPortForType(type) {
+  const ports = {
+    "dameng": 5236,
+    "postgres": 5432,
+    "mysql": 3306,
+    "mariadb": 3306,
+    "sqlserver": 1433,
+    "sqlite": void 0
+  };
+  return ports[type];
+}
+
+export {
+  parseConnectionInfoFromDSN,
+  obfuscateDSNPassword,
+  getDatabaseTypeFromDSN,
+  getDefaultPortForType
+};