mcp-multi-bridge 0.0.0-stage → 2.0.0

package/README.md

@@ -1,3 +1,307 @@
-# Temporary Holding Version
+# mcp-multi-bridge
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+多后端 MCP 桥接（stdio 代理）。
+
+把一个网关后面「多个后端 × 多个租户」的工具集，合并成一个 MCP 服务暴露给客户端；
+调用时按 `orgKey` 选中租户，自动注入凭据后转发。
+
+**只做转发，不做登录。** 没有 HTTP 服务、不监听端口、不弹浏览器。
+
+最初为 MES 系统而写，现已与具体业务系统解耦：系统名、租户称谓、凭据字段名、
+登录失效错误码、登录命令全部可配置（见[自定义](#自定义系统差异)）。不配置时沿用 MES 的默认值。
+
+## 安装
+
+```bash
+npm i -g mcp-multi-bridge mes-login-cli
+```
+
+两个包配合使用：
+
+- `mes-login-cli` 负责登录，把 token 写入本地文件
+- `mcp-multi-bridge` 负责读取 token 并转发请求
+
+> **从 `mes-mcp-bridge` 升级是破坏性的，按下面三步走**
+>
+> 1. 卸载旧包、装新包：
+>
+>    ```bash
+>    npm rm -g mes-mcp-bridge
+>    npm i -g mcp-multi-bridge
+>    ```
+>
+> 2. **改 `mcp.json` 里的 command**（这一步不能省——本包只提供 `mcp-multi-bridge`
+>    一个命令名，旧的 `mes-mcp-bridge` 不再存在）：
+>
+>    ```diff
+>    - "command": "mes-mcp-bridge"
+>    + "command": "mcp-multi-bridge"
+>    ```
+>
+> 3. 重启 MCP 客户端。
+>
+> 配置目录与 `config.json` 结构不变，无需重新登录。
+
+## 多后端与工具列表
+
+`config.json` 里的每个组织都带一个 `path`，指向它在 Higress 上的 MCP 路由。
+**多个组织可能共享同一个 path**（比如测试环境的太仓和具身智能），
+它们只是登录身份不同，后台是同一个 MCP Server。
+
+bridge 拉取工具列表的规则：
+
+1. 按 `path` 去重，同一 path 只查一次（不是按组织逐个查）
+2. 多个 path 并行查询
+3. 按**工具名**合并：同名工具只出现一次，`orgKey` 的可选值是提供该工具的所有组织
+4. 单个 path 失败不阻断整体，能拿到多少给多少，失败的写进 `login` 工具的告警里
+
+### `orgKey` 只能选同后端的组织
+
+这是为了避免一种必然失败的情况：工具来自 A 后端，`orgKey` 却指向 B 后端的组织，
+请求发过去那边不认识这个工具。bridge 会在调用前校验，跨后端直接拒绝并列出可用选项。
+
+### 工具数量上限
+
+默认上限 40 个。超过后会在 `login` 工具的描述里告警——工具过多会挤占模型上下文，
+也会降低工具选择的准确率。真到这一步，说明该拆 server 了。
+
+### 拆成多个客户端条目
+
+不想把所有后端压在一个 bridge 里，可以用环境变量限定本实例负责的 path：
+
+```json
+{
+  "mcpServers": {
+    "mes-test": {
+      "command": "mcp-multi-bridge",
+      "args": [],
+      "env": { "MES_MCP_PATHS": "mes-mcp-server" }
+    },
+    "mes-prod": {
+      "command": "mcp-multi-bridge",
+      "args": [],
+      "env": { "MES_MCP_PATHS": "tc-mes-mcp-server" }
+    }
+  }
+}
+```
+
+`MES_MCP_PATHS` 用逗号分隔，可以写完整 path（`/mcp-servers/xxx`），
+也可以只写末段（`xxx`），两种都识别。
+
+这样客户端列表里会出现两个独立条目，各自的工具集和 `orgKey` 范围互不干扰。
+
+## 检查安装的版本
+
+```bash
+mcp-multi-bridge --version     # 只输出版本号，如 1.4.0
+mcp-multi-bridge --status      # 版本 + 安装位置 + 网关地址 + 后端分组 + 各组织登录状态
+mcp-multi-bridge --help        # 帮助
+```
+
+`--version` 只输出纯版本号，方便脚本取值：
+
+```bash
+mcp-multi-bridge --version | xargs echo "当前版本:"
+```
+
+如果怀疑跑的不是自己想跑的那份（比如同时存在 `npm link` 的软链和全局安装），
+用 `--status` 看「安装位置」即可确认。
+
+`mes-login` 同样支持 `--version`。
+
+## 配置 MCP 客户端
+
+任选其一。
+
+### 方式一：npx（免安装）
+
+```json
+{
+  "mcpServers": {
+    "mes": {
+      "command": "npx",
+      "args": ["-y", "mcp-multi-bridge"]
+    }
+  }
+}
+```
+
+### 方式二：全局安装（推荐）
+
+```bash
+npm i -g mcp-multi-bridge
+```
+
+```json
+{
+  "mcpServers": {
+    "mes": {
+      "command": "mcp-multi-bridge",
+      "args": []
+    }
+  }
+}
+```
+
+全局安装的好处是升级可控：`npx` 只跳过安装确认，**不会因为发布了新版本就刷新本地缓存**。
+
+### 方式三：绝对路径（最稳）
+
+如果客户端启动子进程时找不到命令（`ENOENT`），直接用 node 加绝对路径：
+
+```json
+{
+  "mcpServers": {
+    "mes": {
+      "command": "node",
+      "args": ["C:/Users/你的用户名/AppData/Roaming/npm/node_modules/mcp-multi-bridge/bin.js"]
+    }
+  }
+}
+```
+
+实际路径用这条命令查：
+
+```bash
+npm root -g
+```
+
+## 使用流程
+
+1. 首次使用，或 token 过期时，执行登录：
+
+   ```bash
+   mes-login
+   ```
+
+2. 在打开的登录页里完成账号密码和图形验证码
+
+3. 回到 MCP 客户端，直接调用工具即可
+
+**登录后无需重启客户端。** bridge 每次调用都重新读取 token 文件，所以登录结果立即生效。
+
+## 未登录时的表现
+
+工具调用会返回明确的引导文案，说明该执行 `mes-login` 以及要等人工完成验证码。模型拿到这段文字后可以自行发起登录。
+
+## 多组织
+
+登录页支持切换组织，每个组织单独保存 token，互不覆盖。
+
+调用工具时可以指定组织：
+
+```json
+{ "orgKey": "tc" }
+```
+
+`orgKey` 的取值就是 `config.json` 里各组织的 `key`，不传则用最后一次登录的组织。
+
+## 自定义系统差异
+
+合并、路由、凭据注入这套逻辑与具体业务系统无关，真正随系统变化的是六件事。
+全部在 `config.json` 里配置，**都不写则沿用 MES 的默认值，升级后行为不变**。
+
+```json
+{
+  "systemName": "ERP 中台",
+  "tenantLabel": "租户",
+  "credentialField": "authToken",
+  "tenantIdField": "tenantId",
+  "hiddenArgs": ["authToken", "tenantId"],
+  "invalidCodes": [401, 403],
+  "invalidCodeReasons": { "401": "未授权，请重新登录" },
+  "loginCommand": "erp-login"
+}
+```
+
+| 字段 | 默认值 | 作用 |
+|---|---|---|
+| `systemName` | `MES` | 系统名，出现在登录引导与状态标题里 |
+| `tenantLabel` | `组织` | 租户称谓，出现在 `orgKey` 参数说明、状态清单与各类提示里 |
+| `credentialField` | `access_token` | 注入到工具参数里的凭据字段名，**必须与网关 requestTemplate 取值的字段一致** |
+| `tenantIdField` | `orgId` | 注入租户 ID 时用的参数名，取值来自配置的 `orgs[].orgId` |
+| `hiddenArgs` | 跟随上面两个字段 | 对模型隐藏的参数。凭据与租户 ID 由本层填，露给模型只会引发「我该填什么」 |
+| `invalidCodes` | `[613,614,615,616]` | 视为「登录失效」的业务错误码，命中后返回重新登录引导 |
+| `invalidCodeReasons` | MES 的四个码 | 错误码说明，与默认值**合并**，只写要覆盖的项 |
+| `loginCommand` | `mes-login` | 登录引导里让模型执行的命令名 |
+
+> **租户 ID 由本层注入，不让模型填。** 网关的工具模板通常是
+> `{{if .args.orgId}}{{.args.orgId}}{{else}}1{{end}}` —— 不传就一律按 1 查，
+> 同一个后端下的其他租户会静默查到错误组织的数据。所以本层总是把
+> `orgs[].orgId` 注入进去，客户端传的同名字段会被覆盖。
+
+### 显示效果对比
+
+| | 默认 | 上面那份配置 |
+|---|---|---|
+| 工具描述 | 查询 MES 的组织与登录状态 | 查询 ERP 中台的租户与登录状态 |
+| 参数说明 | 要操作的组织标识 | 要操作的租户标识 |
+| 状态标题 | ## MES 组织状态 | ## ERP 中台租户状态 |
+| 更新提示 | 该组织尚未登录 | 该租户尚未登录 |
+| 引导命令 | `mes-login --org tc` | `erp-login --org tc` |
+
+`orgKey` 这个参数名不会变——它是路由用的标识，改文案不影响调用方代码。
+
+### 容错
+
+所有字段都做了类型校验，配错（`null`、空串、非数组、非数字）时**静默回落默认值**，
+不会让服务起不来。`systemName` 以汉字结尾时不加空格（「查询 ERP 中台的租户」），
+以拉丁字母结尾时加（「查询 MES 的组织」）。
+
+## 配置目录
+
+**有默认目录：`~/.mes-mcp-login`**，不设环境变量就用它。
+
+目录名仍带 `mes` 是**故意不改**的——`mes-login-cli` 把 `config.json` 和 `token.json`
+写在这个路径下（写死，不支持环境变量）。桥接层的默认值必须与它一致，否则登录完
+照样找不到文件。要改名得两个包一起改。
+
+所以 `MCP_BRIDGE_HOME` 的用途是**跑第二套系统时隔离**，不是改默认位置：
+
+```bash
+# 第二套系统（非 MES）单独一份配置与登录态
+export MCP_BRIDGE_HOME=~/.erp-bridge
+```
+
+目录里同样放 `config.json` 和 `token.json`，两套互不干扰，各自登录各自的 token。
+
+| 环境变量 | 作用 | 默认 |
+|---|---|---|
+| `MCP_BRIDGE_HOME` | 配置目录 | `~/.mes-mcp-login` |
+| `MCP_BRIDGE_PATHS` | 限定本实例负责的 path，逗号分隔 | 不限制（全部加载） |
+
+> 旧名 `MES_MCP_PATHS` 仍兼容，`MCP_BRIDGE_PATHS` 优先。
+
+## 文件依赖
+
+读取配置目录下的两个文件：
+
+| 文件 | 由谁创建 |
+|---|---|
+| `config.json` | 登录侧 CLI（如 `mes-login-cli`），也可手写 |
+| `token.json` | 登录侧 CLI（登录时写入） |
+
+本包**只读不写**，不会创建、修改或删除这两个文件。
+
+所以使用前必须先安装并运行一次登录 CLI（MES 用 `mes-login-cli`）。
+
+## 提供的工具
+
+工具列表由网关返回，本包原样透传。`login` 会被本包替换成本地状态查询工具。
+
+工具本身（有哪些、叫什么、什么参数）完全取决于网关侧配置，本包不做增删。
+当前 MES 网关提供的是：
+
+- `login` 登录态查询（本包接管）
+- `captchaGet` 获取验证码
+- `captchaCheck` 校验验证码
+- `searchRidReport` RID 明细报表
+
+## 平台支持
+
+Windows / macOS / Linux。需要 Node.js >= 18。
+
+## License
+
+MIT

package/bin.js

@@ -0,0 +1,672 @@
+#!/usr/bin/env node
+/**
+ * mcp-multi-bridge —— 多后端 MCP 桥接（stdio 代理）
+ *
+ * 把一个网关上「多个后端 × 多个租户」的工具集合并成一个 MCP 服务暴露给客户端。
+ * 纯代理，不做登录：登录由独立的 CLI 完成，两者只通过 token 文件耦合。
+ *
+ * 与本项目最初服务的 MES 系统解耦——系统名、租户称谓、凭据字段名、
+ * 登录失效错误码、登录命令都在 config.json 里配置，见 lib/settings.js。
+ * 不配置时沿用 MES 的默认值，老用户升级后行为不变。
+ *
+ * 设计要点：
+ *   1. 工具列表按 path 去重后并行拉取，再按工具名合并。
+ *      多个租户可能共享同一个 path（如测试/正式各有两个租户），
+ *      共享 path 的工具集完全相同，去重后不会重复计入口。
+ *   2. 每个工具记住「哪些 path 提供它」，orgKey 的枚举只填指向这些 path 的租户。
+ *      这样不会出现「工具来自 A 后台、orgKey 指向 B 后台」的错位——
+ *      那种情况下请求必然打到一个不认识该工具的服务上。
+ *   3. 工具描述与参数说明由网关侧维护，本层不改写文字，只补 orgKey、隐藏凭据参数。
+ *   4. 结果标注来源：每次返回都带上数据来自哪个租户，模型才能判断结果是否符合预期。
+ *   5. login 工具改造为状态查询：列出已配置租户的登录情况，模型一次调用就知道全貌。
+ *      远端的用户名密码登录工具对客户端无用——验证码必须人工完成，由登录 CLI 承担。
+ *   6. 工具数量超过 MAX_TOOLS 时给出告警，提示拆分 server，
+ *      而不是让客户端悄悄被几十上百个工具挤占上下文。
+ *
+ * 拆分（多 server 并存）：
+ *   默认加载 config.json 里所有 path。若只想让本实例负责部分 path，
+ *   设环境变量 MCP_BRIDGE_PATHS=/mcp-servers/xxx,/mcp-servers/yyy，
+ *   即可在 mcp.json 里配多个 bridge 条目，各自负责一组后端。
+ *
+ * 约束：
+ *   - 只读 token.json / config.json，永不写入或删除
+ *   - 不监听任何端口，不弹浏览器
+ *   - 凭据每次调用重新读文件（所以登录后立即生效，无需重启）
+ *   - 工具列表短暂缓存（TOOLS_TTL_MS），避免一次会话内反复打网关
+ */
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { loadConfig, findOrg, defaultOrg, allowedPaths, CONFIG_FILE, CONFIG_DIR } from './lib/config.js';
+import { getOrgAuth, getCurrentOrgKey, listLoggedInOrgs } from './lib/token.js';
+import { rpc, extractPayload } from './lib/higress.js';
+import { settings, DEFAULT_SETTINGS } from './lib/settings.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const PKG = require('./package.json');
+
+// 由 bridge 自己提供、不从 Higress 透传的工具
+const LOCAL_TOOL = 'login';
+
+// 工具数量上限：超过则告警，建议拆分 server 或缩小合并范围
+const MAX_TOOLS = 40;
+
+// 工具列表缓存时长：客户端本来只在启动时拉一次，这里仅避免同一会话内重复打网关
+const TOOLS_TTL_MS = 5000;
+
+/**
+ * 按 path 归组组织
+ *
+ * 同一 path 下的组织共用一套工具集——它们只是登录身份不同，
+ * 后台是同一个 MCP Server。
+ *
+ * @returns {{path:string, orgs:object[], rep:object}[]}
+ */
+export function groupByPath(cfg) {
+    const map = new Map();
+    for (const o of cfg.orgs) {
+        const p = String(o.path || '');
+        if (!map.has(p)) map.set(p, { path: p, orgs: [] });
+        map.get(p).orgs.push(o);
+    }
+    // rep 用于拼 url：同一 path 下任取一个组织即可（url 只由 baseUrl + path 决定）
+    return [...map.values()].map((g) => ({ ...g, rep: g.orgs[0] }));
+}
+
+/**
+ * 该 path 是否被环境变量限定排除
+ *
+ * 匹配规则（依次尝试，命中即算允许）：
+ *   1. 完整 path 一致：/mcp-servers/mes-mcp-server
+ *   2. 只写末段：mes-mcp-server —— 少打字，也不容易写错
+ *   3. 末段相同即算匹配：允许用户写 tc-mes-mcp-server 而不用管前缀
+ *
+ * 为什么要容错：MCP_BRIDGE_PATHS 常在 shell 里临时设置，
+ * 而 Git Bash 之类的环境会把 /xxx 当路径转成 D:/... ，
+ * 严格全等匹配会让人以为配置没生效。
+ */
+function pathAllowed(p, allow) {
+    if (!allow) return true;
+    const norm = (s) => String(s).trim().replace(/^\/+|\/+$/g, '');
+    const target = norm(p);
+    const tail = target.split('/').filter(Boolean).pop() || '';
+
+    return allow.some((a) => {
+        const n = norm(a);
+        if (!n) return false;
+        if (n === target) return true; // 完整一致
+        if (!n.includes('/')) return n === tail; // 只给了末段
+        return n.endsWith('/' + tail) || target.endsWith('/' + n); // 前缀/后缀包含
+    });
+}
+
+/**
+ * 处理 --version / --help / --status
+ *
+ * 本程序正常运行时是被 MCP 客户端以 stdio 拉起的长驻进程，
+ * stdin 收到 JSON-RPC 才开始工作。所以只有在显式传入参数时才走这里，
+ * 不带参数启动时保持原行为（进入 stdio 服务）。
+ */
+async function handleCli(argv) {
+    const has = (f) => argv.includes(f);
+
+    if (has('--version') || has('-v')) {
+        // 只输出纯版本号，便于脚本取值：mcp-multi-bridge --version | xargs ...
+        // 需要安装路径与后端清单时用 --status
+        console.log(PKG.version);
+        return true;
+    }
+
+    if (has('--help') || has('-h')) {
+        // 帮助里出现的系统名与命令名取配置，未配置则用默认值
+        const L = settings(loadConfig());
+        const BIN = PKG.name;
+        console.log(`${BIN} —— ${L.systemName} MCP 桥接（stdio 代理）
+
+通常由 MCP 客户端自动启动，不需要手动运行。
+
+用法:
+  ${BIN} --version   显示版本号
+  ${BIN} --status    显示配置、后端分组与登录状态
+  ${BIN} --help      显示本帮助
+
+无参数启动时进入 stdio 服务模式，等待客户端发送 JSON-RPC。
+
+多后端合并:
+  默认合并 config.json 中所有 path 的工具集（按 path 去重）。
+  如需拆成多个客户端条目，用环境变量限定本实例负责的 path：
+    MCP_BRIDGE_PATHS=/mcp-servers/mes-mcp-server
+    MCP_BRIDGE_PATHS=/mcp-servers/tc-mes-mcp-server
+  然后在 mcp.json 里配多个带不同 env 的条目。
+
+配置文件: ${CONFIG_FILE}
+登录文件: ${CONFIG_DIR}/token.json（由 ${L.loginCommand} 写入）
+
+配置目录可用环境变量 MCP_BRIDGE_HOME 改到别处（默认 ~/.mes-mcp-login）。
+
+本程序只读上述文件，不会修改或删除。`);
+        return true;
+    }
+
+    if (has('--status')) {
+        const cfg = loadConfig();
+        if (!cfg) {
+            const L = settings(null);
+            console.log(`未找到配置 ${CONFIG_FILE}`);
+            console.log(`请先运行：${L.loginCommand}`);
+            return true;
+        }
+
+        const allow = allowedPaths();
+        const groups = groupByPath(cfg);
+        const active = groups.filter((g) => pathAllowed(g.path, allow));
+        const skipped = groups.filter((g) => !pathAllowed(g.path, allow));
+        const L = settings(cfg);
+
+        console.log(`${PKG.name} ${PKG.version}`);
+        console.log(`安装位置: ${__dirname}`);
+        console.log(`网关地址: ${cfg.baseUrl}`);
+        console.log(`工具上限: ${MAX_TOOLS}`);
+        if (allow) console.log(`限定 path: ${allow.join(', ')}`);
+        console.log();
+
+        const current = getCurrentOrgKey();
+        const logged = new Set(listLoggedInOrgs());
+
+        console.log(`后端分组（${active.length} 个参与合并${skipped.length ? `，${skipped.length} 个被 MCP_BRIDGE_PATHS 排除` : ''}）:`);
+        for (const g of active) {
+            console.log(`  ${g.path}`);
+            for (const o of g.orgs) {
+                const isLogged = logged.has(o.key);
+                const marks = [];
+                if (o.key === current) marks.push('当前生效');
+                if (!isLogged) marks.push('未登录');
+                const auth = isLogged ? getOrgAuth(o.key) : null;
+                const who = auth && auth.username ? `，账号 ${auth.username}` : '';
+                const suffix = marks.length ? `（${marks.join('，')}）` : '';
+                console.log(`      ${o.key.padEnd(28)} ${o.name}${suffix}${who}`);
+            }
+        }
+        for (const g of skipped) {
+            console.log(`  ${g.path}  （已排除）`);
+        }
+
+        if (!logged.size) {
+            console.log(`\n当前没有任何${L.tenantLabel}处于登录状态，请运行：${L.loginCommand}`);
+        }
+        return true;
+    }
+
+    return false;
+}
+
+if (await handleCli(process.argv.slice(2))) {
+    process.exit(0);
+}
+
+function textResult(text, isError = false) {
+    return {
+        content: [{ type: 'text', text }],
+        ...(isError ? { isError: true } : {})
+    };
+}
+
+/**
+ * 生成「需要登录」的引导文案
+ *
+ * 这段文字是给模型看的指令：告诉它当前登录态不可用，以及该执行什么命令。
+ * 之所以写这么具体，是因为模型拿不到本文件的上下文，
+ * 只说「请登录」它不知道登录入口在哪、也不知道要等待人机验证。
+ *
+ * @param {string} status 状态描述，如「未登录」/「登录已失效（code=613：token 已过期）」
+ * @param {{key:string, name:string}} [org] 相关组织，用于预设登录页选中的组织
+ * @param {object|null} [cfg] 配置，用于取系统名与租户称谓；不传则用默认值
+ */
+function loginGuide(status, org, cfg) {
+    const L = cfg ? settings(cfg) : DEFAULT_SETTINGS;
+    const orgArg = org && org.key ? ` --org ${org.key}` : '';
+    const orgLine = org
+        ? `\n相关${L.tenantLabel}：${org.name}（已通过 --org ${orgArg.trim()} 预设选中）\n`
+        : '';
+
+    return `## ${status}
+
+请调用 Bash 工具执行以下命令，启动 ${L.systemName}${L.nameGap}登录页：
+
+\`\`\`bash
+${L.loginCommand}${orgArg}
+\`\`\`
+
+执行说明：
+1. 该命令会启动一个临时登录页并在浏览器中打开
+2. 需要在页面上输入用户名密码，并完成图形点选验证码（由人操作，AI 无法代替）
+3. 登录成功后 token 会自动写入本地文件，本服务**下一次调用即可生效，无需重启**
+4. 命令会一直运行到登录完成才退出，**请以后台方式运行**（run_in_background），避免阻塞
+${orgLine}
+登录完成后，请重新调用刚才的工具。
+`;
+}
+
+/**
+ * 组织清单（给模型看的全貌）
+ *
+ * 模型不应该通过读 config.json 了解有哪些组织，
+ * 这里把「配置里有什么 / 哪些已登录 / 当前用哪个 / 分几组后端」一次说清。
+ */
+function orgOverview(cfg) {
+    const L = settings(cfg);
+    const current = getCurrentOrgKey();
+    const logged = new Set(listLoggedInOrgs());
+    const allow = allowedPaths();
+    const groups = groupByPath(cfg).filter((g) => pathAllowed(g.path, allow));
+
+    const sections = groups.map((g) => {
+        const rows = g.orgs.map((o) => {
+            const isLogged = logged.has(o.key);
+            const marks = [];
+            if (o.key === current) marks.push('当前生效');
+            if (!isLogged) marks.push('未登录');
+            const suffix = marks.length ? `（${marks.join('，')}）` : '';
+            const auth = isLogged ? getOrgAuth(o.key) : null;
+            const who = auth && auth.username ? `，账号 ${auth.username}` : '';
+            return `  - \`${o.key}\` — ${o.name}${suffix}${who}`;
+        });
+        return `后端 \`${g.path}\`\n${rows.join('\n')}`;
+    });
+
+    const head = logged.size
+        ? `当前生效${L.tenantLabel}：\`${current}\``
+        : `当前没有任何${L.tenantLabel}处于登录状态`;
+
+    // 示例里的 key 取自配置，避免写死后与实际 key 不一致（旧版写死过 taicang）
+    const sampleKey = defaultOrg(cfg)?.key || 'xxx';
+
+    return `## ${L.systemName}${L.nameGap}${L.tenantLabel}状态
+
+${head}
+
+${sections.join('\n\n')}
+
+调用业务工具时可用 \`orgKey\` 参数指定目标${L.tenantLabel}（如 \`{"orgKey": "${sampleKey}"}\`），
+不传则使用当前生效${L.tenantLabel}。注意：\`orgKey\` 只能在**提供该工具的后端**对应的${L.tenantLabel}中选择，
+跨后端会被拒绝。
+
+需要登录或切换账号时，请在终端执行（或让 AI 通过 Bash 执行）：\`${L.loginCommand}\``;
+}
+
+/**
+ * 选中要操作的组织
+ *
+ * 优先级：显式传入的 orgKey > 最后一次登录的组织 > 配置里的默认组织
+ *
+ * @param {string[]} [allowedOrgKeys] 该工具允许的组织；不传表示不限制
+ */
+function selectOrg(cfg, requestedKey, allowedOrgKeys) {
+    const L = settings(cfg);
+    const candidates = (key) => !allowedOrgKeys || allowedOrgKeys.includes(key);
+
+    let key = requestedKey;
+    if (!key) {
+        // 未指定：优先当前生效组织，但必须落在允许范围内
+        const cur = getCurrentOrgKey();
+        if (cur && candidates(cur)) key = cur;
+        else if (allowedOrgKeys && allowedOrgKeys.length) key = allowedOrgKeys[0];
+        else {
+            const d = defaultOrg(cfg);
+            key = d ? d.key : null;
+        }
+    }
+
+    if (!key) {
+        return { org: null, auth: null, reason: loginGuide(`尚未配置任何${L.tenantLabel}`, null, cfg) };
+    }
+
+    const org = findOrg(cfg, key);
+    if (!org) {
+        const avail = cfg.orgs.map((o) => `\`${o.key}\`（${o.name}）`).join('、');
+        return {
+            org: null,
+            auth: null,
+            reason: `配置中不存在${L.tenantLabel} \`${key}\`。\n\n当前可用的 orgKey：${avail}\n\n如需用默认${L.tenantLabel}，请不传 orgKey。`
+        };
+    }
+
+    // 关键校验：该工具不在这台后端上，硬发过去只会得到「未知工具」
+    if (!candidates(key)) {
+        const avail = allowedOrgKeys.map((k) => {
+            const o = findOrg(cfg, k);
+            return `\`${k}\`（${o ? o.name : k}）`;
+        }).join('、');
+        return {
+            org: null,
+            auth: null,
+            reason: `该工具不在此${L.tenantLabel}对应的后端上。\n\n本工具可用的 orgKey：${avail}\n\n请改用上述${L.tenantLabel}，或不传 orgKey 使用默认。`
+        };
+    }
+
+    const auth = getOrgAuth(key);
+    if (!auth) {
+        return { org, auth: null, reason: loginGuide(`该${L.tenantLabel}尚未登录`, org, cfg) };
+    }
+
+    return { org, auth, reason: null };
+}
+
+/**
+ * 把 orgKey 列表渲染成「`key`（中文名）」的形式
+ *
+ * 模型看不到 config.json，只靠这段文字把用户口语里的「海宁」「汽车技术」
+ * 对应到 key。少了中文名，hn / qc 这类与字面毫无关联的 key 基本靠猜。
+ *
+ * @param {object|null} cfg 配置；为 null 时退化为纯 key 列表
+ * @param {string[]} orgKeys 组织标识
+ */
+function orgKeyList(cfg, orgKeys) {
+    return orgKeys
+        .map((k) => {
+            const o = cfg && findOrg(cfg, k);
+            return o && o.name ? `\`${k}\`（${o.name}）` : `\`${k}\``;
+        })
+        .join('、');
+}
+
+/**
+ * 给工具补上组织选择参数
+ *
+ * 描述文案由 Higress 侧维护（已规范化），本层不再改写文字，
+ * 只做一件网关做不到的事：把「提供该工具的组织」以 enum 形式暴露给模型。
+ * 同时把凭据类参数从 schema 里隐藏——本层会自动注入，
+ * 让模型看见这些参数只会引发「我该填什么」的困惑。
+ *
+ * 注意：参数只是对模型隐藏，请求发往网关时仍会带上，
+ * 因为网关的 requestTemplate 依赖 {{.args.<credentialField>}} 取值。
+ */
+function augmentTool(tool, orgKeys, cfg) {
+    const L = settings(cfg);
+    const schema = tool.inputSchema || { type: 'object', properties: {} };
+    const props = { ...(schema.properties || {}) };
+
+    // 对模型隐藏：凭据由本层注入，租户 ID 由组织配置决定
+    for (const name of L.hiddenArgs) delete props[name];
+
+    // 不传 orgKey 时会回落到「最后登录的组织」——跨组织操作时容易查错环境，
+    // 把当前值写进描述里，让模型有机会提醒用户
+    const cur = getCurrentOrgKey();
+    const curOrg = cur && cfg ? findOrg(cfg, cur) : null;
+    const tail = curOrg
+        ? `不传则使用当前登录的${L.tenantLabel}（当前为 \`${cur}\`，${curOrg.name}）。如果不确定用户要哪个环境，请先调用 \`${LOCAL_TOOL}\` 工具确认。`
+        : `不传则使用当前登录的${L.tenantLabel}。`;
+
+    // 补上组织选择参数
+    props.orgKey = {
+        type: 'string',
+        description: `要操作的${L.tenantLabel}标识。可选值：${orgKeyList(cfg, orgKeys)}。${tail}`,
+        ...(orgKeys.length ? { enum: orgKeys } : {})
+    };
+
+    return {
+        ...tool,
+        inputSchema: {
+            ...schema,
+            type: 'object',
+            properties: props,
+            required: (schema.required || []).filter((k) => k in props)
+        }
+    };
+}
+
+/**
+ * 本服务自己提供的 login 工具（实际是状态查询）
+ *
+ * 覆盖 Higress 那个「用户名密码登录」的 login：
+ * 登录由 mes-login-cli 在终端完成，bridge 只负责报告状态。
+ */
+function localLoginTool(cfg, orgKeys, warning) {
+    const L = settings(cfg);
+    const warn = warning ? `\n\n⚠ ${warning}\n` : '';
+    return {
+        name: LOCAL_TOOL,
+        description: `查询 ${L.systemName}${L.nameGap}的${L.tenantLabel}与登录状态。不需要任何参数。${warn}
+
+返回内容包含：当前生效的${L.tenantLabel}、所有已配置的${L.tenantLabel}、哪些已登录及对应账号，以及后端分组。
+想切换${L.tenantLabel}或重新登录时，需要执行 CLI 命令 \`${L.loginCommand}\`（会打开浏览器让人输入密码和验证码）。`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orgKey: {
+                    type: 'string',
+                    description: `可选，只看某个${L.tenantLabel}的状态。可选值：${orgKeyList(cfg, orgKeys)}`,
+                    ...(orgKeys.length ? { enum: orgKeys } : {})
+                }
+            }
+        }
+    };
+}
+
+/**
+ * 按 path 去重拉取工具清单，并按工具名合并
+ *
+ * 并行的目的是：后端多时不要串行等 N 次网络往返。
+ * 单个后端失败不阻断整体——能拿到多少给多少，失败的记在 errors 里。
+ *
+ * @returns {{tools:object[], index:Map<string,{orgKeys:string[],paths:string[]}>, errors:string[], warnings:string[]}}
+ */
+async function collectTools(cfg) {
+    const allow = allowedPaths();
+    const groups = groupByPath(cfg).filter((g) => pathAllowed(g.path, allow));
+
+    const settled = await Promise.allSettled(
+        groups.map(async (g) => {
+            const r = await rpc(cfg, g.rep, 'tools/list', {});
+            return { group: g, tools: (r.result || r).tools || [] };
+        })
+    );
+
+    const errors = [];
+    const warnings = [];
+    const merged = new Map(); // name -> { tool, orgKeys:Set, paths:Set }
+
+    settled.forEach((s, i) => {
+        const g = groups[i];
+        if (s.status === 'rejected') {
+            errors.push(`${g.path}: ${s.reason?.message || s.reason}`);
+            return;
+        }
+        for (const t of s.value.tools) {
+            if (t.name === LOCAL_TOOL) continue; // 用本地状态工具替换远端登录
+            let e = merged.get(t.name);
+            if (!e) {
+                e = { tool: t, orgKeys: new Set(), paths: new Set() };
+                merged.set(t.name, e);
+            }
+            for (const o of g.orgs) e.orgKeys.add(o.key);
+            e.paths.add(g.path);
+        }
+    });
+
+    // 同名工具出现在多个后端时提示一次——语义可能不同，但通常是一致的
+    for (const [name, e] of merged) {
+        if (e.paths.size > 1) {
+            warnings.push(
+                `工具 ${name} 同时存在于 ${e.paths.size} 个后端，已合并（orgKey 为各后端${settings(cfg).tenantLabel}的并集）`
+            );
+        }
+    }
+
+    const tools = [];
+    const index = new Map();
+    for (const [name, e] of merged) {
+        const orgKeys = [...e.orgKeys];
+        tools.push(augmentTool(e.tool, orgKeys, cfg));
+        index.set(name, { orgKeys, paths: [...e.paths] });
+    }
+
+    return { tools, index, errors, warnings, groupCount: groups.length };
+}
+
+async function main() {
+    const server = new Server(
+        { name: PKG.name, version: PKG.version },
+        { capabilities: { tools: {} } }
+    );
+
+    // 工具索引缓存：tools/call 需要知道「这个工具能在哪些组织上用」
+    let cache = { at: 0, index: new Map(), tools: [], errors: [], warnings: [], groupCount: 0 };
+
+    async function getTools(force = false) {
+        if (!force && Date.now() - cache.at < TOOLS_TTL_MS && cache.index.size) return cache;
+        const cfg = loadConfig();
+        if (!cfg) {
+            cache = { at: Date.now(), index: new Map(), tools: [], errors: ['未找到配置'], warnings: [], groupCount: 0 };
+            return cache;
+        }
+        const r = await collectTools(cfg);
+        cache = { at: Date.now(), ...r };
+        return cache;
+    }
+
+    // tools/list：按 path 去重拉取后合并，改写后交给客户端
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const cfg = loadConfig();
+        if (!cfg) {
+            console.error(`[bridge] 未找到配置 ${CONFIG_FILE}，请先运行：${settings(null).loginCommand}`);
+            return { tools: [localLoginTool(null, [])] };
+        }
+
+        const allKeys = cfg.orgs.map((o) => o.key);
+        const r = await getTools(true);
+
+        for (const e of r.errors) console.error(`[bridge] 后端拉取失败 ${e}`);
+        for (const w of r.warnings) console.error(`[bridge] ${w}`);
+
+        let warning;
+        if (r.tools.length + 1 > MAX_TOOLS) {
+            warning = `当前合并了 ${r.tools.length + 1} 个工具，超过建议上限 ${MAX_TOOLS}。` +
+                `工具过多会挤占模型上下文并降低选择准确率，建议用 MCP_BRIDGE_PATHS 拆分到多个 server 条目。`;
+            console.error(`[bridge] ${warning}`);
+        } else if (r.errors.length) {
+            warning = `${r.errors.length} 个后端拉取失败，工具列表可能不完整：${r.errors.join('；')}`;
+        }
+
+        return { tools: [localLoginTool(cfg, allKeys, warning), ...r.tools] };
+    });
+
+    // tools/call：按 orgKey 选中组织，注入该组织的 token 后转发
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args = {} } = request.params;
+
+        try {
+            const cfg = loadConfig();
+
+            // login 已改造成状态查询，不走网关
+            if (name === LOCAL_TOOL) {
+                if (!cfg) return textResult(loginGuide('尚未初始化配置'), true);
+                const L = settings(cfg);
+                const { orgKey } = args;
+                if (orgKey) {
+                    const org = findOrg(cfg, orgKey);
+                    if (!org) {
+                        const avail = cfg.orgs.map((o) => `\`${o.key}\`（${o.name}）`).join('、');
+                        return textResult(`配置中不存在${L.tenantLabel} \`${orgKey}\`。\n\n可用：${avail}`, true);
+                    }
+                    const auth = getOrgAuth(orgKey);
+                    if (!auth) {
+                        return textResult(loginGuide(`${L.tenantLabel}「${org.name}」尚未登录`, org, cfg), true);
+                    }
+                    return textResult(
+                        `${L.tenantLabel} \`${orgKey}\`（${org.name}）已登录，账号：${auth.username || '未知'}。\n\n${orgOverview(cfg)}`
+                    );
+                }
+                return textResult(orgOverview(cfg));
+            }
+
+            if (!cfg) return textResult(loginGuide('尚未初始化配置'), true);
+
+            const S = settings(cfg);
+
+            // orgKey 是路由参数；凭据一律以本服务注入的为准，客户端传来的同名字段作废
+            const rawArgs = { ...args };
+            const orgKey = rawArgs.orgKey;
+            delete rawArgs.orgKey;
+            for (const hidden of S.hiddenArgs) delete rawArgs[hidden];
+            const bizArgs = rawArgs;
+
+            // 查该工具允许的组织范围
+            const r = await getTools(false);
+            const meta = r.index.get(name);
+
+            // 索引里没有这个工具：可能后端刚增减，强制刷新一次再判断
+            let info = meta;
+            if (!info) {
+                const fresh = await getTools(true);
+                info = fresh.index.get(name);
+            }
+            if (!info) {
+                const known = [...r.index.keys()].sort();
+                return textResult(
+                    `未知工具 \`${name}\`。\n\n当前可用的工具：${known.join('、') || '（无）'}\n\n` +
+                        (r.errors.length ? `另有后端拉取失败：${r.errors.join('；')}` : ''),
+                    true
+                );
+            }
+
+            const { org, auth, reason } = selectOrg(cfg, orgKey, info.orgKeys);
+            if (!org || !auth) return textResult(reason || loginGuide('未登录'), true);
+
+            const result = await rpc(cfg, org, 'tools/call', {
+                name,
+                arguments: {
+                    ...bizArgs,
+                    [S.credentialField]: auth.token,
+                    // 租户 ID 必须由本层注入：网关模板通常是
+                    // {{if .args.orgId}}{{.args.orgId}}{{else}}1{{end}}，
+                    // 不传就一律按 1 查，同后端下的其他租户会查错组织。
+                    // 取值固定来自配置的 orgs[].orgId，tenantIdField 只决定发给网关的参数名。
+                    ...(org.orgId != null ? { [S.tenantIdField]: String(org.orgId) } : {})
+                }
+            });
+
+            const payload = extractPayload(result);
+            if (payload && S.invalidCodes.includes(payload.code)) {
+                const why = S.invalidReasons[payload.code] || payload.message || '凭据不可用';
+                console.error(`[bridge] ${S.tenantLabel} ${org.key} 的凭据不可用（code=${payload.code}）`);
+                return textResult(
+                    loginGuide(`${S.systemName}${S.nameGap}登录已失效（code=${payload.code}：${why}）`, org, cfg),
+                    true
+                );
+            }
+
+            // 正常结果：附一条组织说明，让模型知道这份数据属于哪个组织
+            const L = S;
+            const inner = result.result || result;
+            if (inner && Array.isArray(inner.content)) {
+                return {
+                    ...inner,
+                    content: [
+                        ...inner.content,
+                        {
+                            type: 'text',
+                            text: `\n—— 以上数据来自${L.tenantLabel}：${org.name}（orgKey: \`${org.key}\`）`
+                        }
+                    ]
+                };
+            }
+            return inner;
+        } catch (e) {
+            return textResult(`调用失败: ${e.message}`, true);
+        }
+    });
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[bridge] 已就绪');
+}
+
+main().catch((err) => {
+    console.error('[bridge] 启动失败:', err.message || err);
+    process.exit(1);
+});

package/lib/config.js

@@ -0,0 +1,91 @@
+/**
+ * config.js —— 只读配置
+ *
+ * 本模块不创建、不写入 config.json，也不内置默认值。
+ * 配置结构由登录侧 CLI（如 mes-login-cli）定义，两边各自维护默认值必然漂移，
+ * 所以桥接层只认文件；文件缺失时明确报错，引导用户去跑登录命令。
+ *
+ * 目录可换：默认沿用 ~/.mes-mcp-login（历史约定），
+ * 用 MCP_BRIDGE_HOME 指向别的目录即可支持第二套系统并存，
+ * 两套互不干扰，各自登录各自的 token。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+/** 历史默认目录，保持兼容 */
+const LEGACY_DIR_NAME = '.mes-mcp-login';
+
+/**
+ * 解析配置目录
+ *
+ * 优先级：MCP_BRIDGE_HOME > ~/.mes-mcp-login
+ * 用环境变量而不是 config.json 里的字段——要读配置就得先知道目录，写进配置里是循环依赖。
+ */
+function resolveDir() {
+    const custom = process.env.MCP_BRIDGE_HOME;
+    if (typeof custom === 'string' && custom.trim()) {
+        // 支持 ~ 开头，避免用户写了相对路径找不到
+        const raw = custom.trim();
+        if (raw === '~') return os.homedir();
+        if (raw.startsWith('~/') || raw.startsWith('~\\')) {
+            return path.join(os.homedir(), raw.slice(2));
+        }
+        return path.resolve(raw);
+    }
+    return path.join(os.homedir(), LEGACY_DIR_NAME);
+}
+
+export const CONFIG_DIR = resolveDir();
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json');
+
+/**
+ * 读取配置
+ * @returns {object|null} 配置对象；文件缺失或损坏返回 null
+ */
+export function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE)) return null;
+        const cfg = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        if (!cfg || !Array.isArray(cfg.orgs) || !cfg.orgs.length) return null;
+        cfg.baseUrl = String(cfg.baseUrl || '').replace(/\/+$/, '');
+        return cfg;
+    } catch (e) {
+        return null;
+    }
+}
+
+export function findOrg(cfg, key) {
+    if (!cfg) return null;
+    return cfg.orgs.find((o) => o.key === key) || null;
+}
+
+export function defaultOrg(cfg) {
+    if (!cfg) return null;
+    return cfg.orgs.find((o) => o.default) || cfg.orgs[0] || null;
+}
+
+// 拼出某个组织的完整 MCP 地址
+export function orgUrl(cfg, org) {
+    const p = String(org.path || '').startsWith('/') ? org.path : '/' + org.path;
+    return cfg.baseUrl + p;
+}
+
+/**
+ * 限定本实例负责的 path（多 server 拆分用）
+ *
+ * 环境变量优先级：MCP_BRIDGE_PATHS > MES_MCP_PATHS（旧名，保留兼容）
+ * 这里只做切分；容错匹配（允许只写末段）由调用方的 pathAllowed 处理。
+ *
+ * @returns {string[]|null} null 表示不限制
+ */
+export function allowedPaths() {
+    const pick = (v) => (typeof v === 'string' && v.trim() ? v.trim() : '');
+    const raw = pick(process.env.MCP_BRIDGE_PATHS) || pick(process.env.MES_MCP_PATHS);
+    if (!raw) return null;
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}

package/lib/higress.js

@@ -0,0 +1,49 @@
+/**
+ * higress.js —— 转发到网关的 MCP 端点
+ *
+ * 只做两件事：把 tools/list 直接转发；把 tools/call 补上凭据后转发。
+ * 网关侧的路由凭据（appId / appKey / 租户 ID 等）由网关在转发时注入，本进程不持有。
+ *
+ * 这里不判断「哪个错误码代表登录失效」——那是业务系统的知识，
+ * 由 settings.js 从配置里读（invalidCodes / invalidCodeReasons）。
+ */
+import { orgUrl } from './config.js';
+
+// 自增 id，避免同毫秒并发撞号
+let rpcSeq = 0;
+
+/**
+ * 发一个 JSON-RPC 请求到网关
+ */
+export async function rpc(cfg, org, method, params) {
+    const res = await fetch(orgUrl(cfg, org), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: ++rpcSeq, method, params })
+    });
+    const text = await res.text();
+    try {
+        return JSON.parse(text);
+    } catch (e) {
+        throw new Error(`网关响应异常（HTTP ${res.status}）: ${text.slice(0, 120)}`);
+    }
+}
+
+/**
+ * 从 MCP 工具返回里取出业务 JSON
+ * 网关可能在正文前拼一段说明文字，需从第一个 { 截取
+ */
+export function extractPayload(rpcResult) {
+    const content = rpcResult?.result?.content;
+    if (!Array.isArray(content) || !content.length) {
+        return rpcResult?.result?.isError ? { code: -1, message: '调用失败' } : null;
+    }
+    const text = content[0].text || '';
+    const start = text.indexOf('{');
+    if (start === -1) return { code: -1, message: text.trim() || '响应无 JSON 内容' };
+    try {
+        return JSON.parse(text.slice(start));
+    } catch (e) {
+        return { code: -1, message: text.slice(0, 200) };
+    }
+}

package/lib/settings.js

@@ -0,0 +1,125 @@
+/**
+ * settings.js —— 可配置的系统差异点
+ *
+ * 这套桥接的核心逻辑（按 path 去重合并、租户隔离、凭据注入、状态查询工具）
+ * 与具体业务系统无关。真正随系统变化的是五件事，全部收在这里：
+ *
+ *   systemName        系统名，出现在标题与描述里                 默认 MES
+ *   tenantLabel       租户概念，出现在参数说明与提示里           默认 组织
+ *   credentialField   注入到工具参数里的凭据字段名               默认 access_token
+ *   hiddenArgs        对模型隐藏的参数（凭据与租户 ID 由本层填） 默认 access_token / orgId
+ *   invalidCodes      表示登录态失效的业务错误码                 默认 613/614/615/616
+ *   loginCommand      登录引导里让模型执行的命令                 默认 mes-login
+ *
+ * 全部有默认值，不配置时行为与改造前完全一致。
+ * 每一项都做了类型校验，配错（null、空串、非数组）时回落默认而不是让服务崩掉。
+ */
+
+/** 系统名默认值 */
+export const DEFAULT_SYSTEM_NAME = 'MES';
+/** 租户称谓默认值 */
+export const DEFAULT_TENANT_LABEL = '组织';
+/** 凭据字段默认名 */
+export const DEFAULT_CREDENTIAL_FIELD = 'access_token';
+/** 租户 ID 字段默认名 */
+export const DEFAULT_TENANT_ID_FIELD = 'orgId';
+/** 默认隐藏的参数：凭据字段 + 租户 ID，实际取自配置 */
+export const DEFAULT_HIDDEN_ARGS = [DEFAULT_CREDENTIAL_FIELD, DEFAULT_TENANT_ID_FIELD];
+/** 默认的登录失效错误码 */
+export const DEFAULT_INVALID_CODES = [613, 614, 615, 616];
+/** 默认登录命令 */
+export const DEFAULT_LOGIN_COMMAND = 'mes-login';
+
+/**
+ * 默认失效码的中文说明
+ *
+ * MES 的语义：613 过期 / 614 解析失败 / 615 被顶下线 / 616 无效。
+ * 别的系统换一套码时，用 invalidCodeReasons 覆盖或补充。
+ */
+export const DEFAULT_INVALID_REASONS = {
+    613: 'token 已过期',
+    614: 'token 解析失败',
+    615: '账号已在别处登录，当前 token 被顶下线',
+    616: 'token 无效'
+};
+
+const isNonEmptyString = (v) => typeof v === 'string' && v.trim().length > 0;
+
+/**
+ * 规范化字符串数组：去掉空项与非字符串，非法输入回落默认
+ */
+function stringList(v, fallback) {
+    if (!Array.isArray(v)) return [...fallback];
+    const list = v.filter(isNonEmptyString).map((s) => s.trim());
+    return list.length ? list : [...fallback];
+}
+
+/**
+ * 规范化错误码数组：只接受有限数字，非法输入回落默认
+ */
+function codeList(v, fallback) {
+    if (!Array.isArray(v)) return [...fallback];
+    const list = [...new Set(v.map((n) => Number(n)).filter((n) => Number.isFinite(n)))];
+    return list.length ? list : [...fallback];
+}
+
+/**
+ * 规范化错误码说明表，与默认值合并（用户只需写要覆盖的项）
+ */
+function reasonMap(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v)) return { ...DEFAULT_INVALID_REASONS };
+    const out = { ...DEFAULT_INVALID_REASONS };
+    for (const [k, val] of Object.entries(v)) {
+        const code = Number(k);
+        if (Number.isFinite(code) && isNonEmptyString(val)) out[code] = val.trim();
+    }
+    return out;
+}
+
+/**
+ * 取出全部可配置项
+ *
+ * `nameGap` 不是配置项，是排版修正：中文习惯在拉丁字母与汉字之间留空格
+ * （「查询 MES 的组织」），但系统名本身以汉字结尾时再加空格会变成
+ * 「查询 ERP 中台 的租户」，很难看。按末位字符自动决定。
+ *
+ * @param {object|null} cfg 配置对象；为 null 时返回全部默认值
+ * @returns {{
+ *   systemName:string, tenantLabel:string, nameGap:string,
+ *   credentialField:string, hiddenArgs:string[],
+ *   invalidCodes:number[], invalidReasons:Record<number,string>,
+ *   loginCommand:string
+ * }}
+ */
+export function settings(cfg) {
+    const systemName = isNonEmptyString(cfg?.systemName) ? cfg.systemName.trim() : DEFAULT_SYSTEM_NAME;
+    const credentialField = isNonEmptyString(cfg?.credentialField)
+        ? cfg.credentialField.trim()
+        : DEFAULT_CREDENTIAL_FIELD;
+    // 租户 ID 字段：与 orgs[].orgId 的键名对应，本层会把选中租户的值注入进去
+    const tenantIdField = isNonEmptyString(cfg?.tenantIdField)
+        ? cfg.tenantIdField.trim()
+        : DEFAULT_TENANT_ID_FIELD;
+
+    // 默认隐藏「凭据字段 + 租户 ID」：凭据由本层注入，租户 ID 由配置决定，
+    // 露给模型只会引发「我该填什么」的困惑（填了也会被覆盖）。
+    const hiddenArgs = stringList(cfg?.hiddenArgs, [credentialField, tenantIdField]);
+    if (!hiddenArgs.includes(credentialField)) hiddenArgs.push(credentialField);
+
+    return {
+        systemName,
+        tenantLabel: isNonEmptyString(cfg?.tenantLabel) ? cfg.tenantLabel.trim() : DEFAULT_TENANT_LABEL,
+        nameGap: /[A-Za-z0-9]$/.test(systemName) ? ' ' : '',
+        credentialField,
+        tenantIdField,
+        hiddenArgs,
+        invalidCodes: codeList(cfg?.invalidCodes, DEFAULT_INVALID_CODES),
+        invalidReasons: reasonMap(cfg?.invalidCodeReasons),
+        loginCommand: isNonEmptyString(cfg?.loginCommand) ? cfg.loginCommand.trim() : DEFAULT_LOGIN_COMMAND
+    };
+}
+
+/**
+ * 默认值全集，供拿不到配置的场景（CLI 帮助、配置缺失提示）使用
+ */
+export const DEFAULT_SETTINGS = settings(null);

package/lib/token.js

@@ -0,0 +1,61 @@
+/**
+ * token.js —— 只读契约文件（多组织）
+ *
+ * 契约结构见 mes-login-cli/lib/token.js 头部注释。
+ *
+ * 本模块永不写入、永不删除 token.json：
+ * 登录态归 mes-login-cli 管理。桥接层若在 token 失效时删文件，
+ * 会把其他组织刚登录的 token 一起干掉。
+ *
+ * 不本地判断过期：是否失效完全由 MES 的返回码（614/615/616）决定。
+ */
+import fs from 'node:fs';
+import { TOKEN_FILE } from './config.js';
+
+/**
+ * 读取整个契约文件
+ * @returns {{current:string|null, orgs:Object}}
+ */
+export function readStore() {
+    try {
+        if (!fs.existsSync(TOKEN_FILE)) return { current: null, orgs: {} };
+        const data = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
+        if (!data || typeof data !== 'object') return { current: null, orgs: {} };
+        return {
+            current: data.current || null,
+            orgs: data.orgs && typeof data.orgs === 'object' ? data.orgs : {}
+        };
+    } catch (e) {
+        // 文件损坏或正在被替换，按未登录处理，下次调用会重新读
+        return { current: null, orgs: {} };
+    }
+}
+
+/**
+ * 取某个组织的登录态
+ * @param {string} orgKey
+ * @returns {{token:string, username:string, orgName:string, path:string}|null}
+ */
+export function getOrgAuth(orgKey) {
+    if (!orgKey) return null;
+    const store = readStore();
+    const auth = store.orgs[orgKey];
+    return auth && auth.token ? auth : null;
+}
+
+/**
+ * 当前生效组织的 key（最后一次登录的组织）
+ */
+export function getCurrentOrgKey() {
+    const store = readStore();
+    if (store.current && store.orgs[store.current]) return store.current;
+    const keys = Object.keys(store.orgs);
+    return keys.length ? keys[0] : null;
+}
+
+/**
+ * 列出所有已登录的组织 key
+ */
+export function listLoggedInOrgs() {
+    return Object.keys(readStore().orgs);
+}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "mcp-multi-bridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "多后端 MCP 桥接：把网关后多个后端、多个租户的工具集合并成一个 MCP 服务，凭据由登录 CLI 提供",
+  "type": "module",
+  "bin": {
+    "mcp-multi-bridge": "bin.js"
+  },
+  "files": [
+    "bin.js",
+    "lib/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node bin.js",
+    "pack:check": "npm pack --dry-run"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "bridge",
+    "multi-tenant",
+    "multi-backend",
+    "mes"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.20.2"
+  }
+}