mcp-multi-bridge 0.0.0-stage → 2.1.0

package/bin.js

@@ -0,0 +1,683 @@
+#!/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_MULTI_HOME 改到别处（旧名 MCP_BRIDGE_HOME 仍兼容）。
+放在客户端配置的 env 里，可以一个客户端同时接多套系统。默认 ~/.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 } : {})
+    };
+}
+
+/**
+ * 生成「需要登录」的引导文案
+ *
+ * 这段文字是给模型看的指令：告诉它当前登录态不可用，以及该执行什么命令。
+ * 之所以写这么具体，是因为模型拿不到本文件的上下文，
+ * 只说「请登录」它不知道登录入口在哪、也不知道要等待人机验证。
+ *
+ * 命令里必须带 --home：同一个客户端可能同时接多套系统，各自一个配置目录。
+ * 只说 `mes-login` 会让模型登到另一套系统去，那边看起来成功了、
+ * 这边的 token 却没变，表现是「登录了但还是未登录」，非常难查。
+ *
+ * @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;
+    // --home 用本实例实际读的目录，保证与登录写入的是同一个。
+    // 反斜杠统一转正斜杠：Windows 下 CMD / PowerShell / Git Bash 都能正确解析，
+    // 反斜杠在部分 shell 里会被当转义字符。
+    const homeForCmd = String(CONFIG_DIR).replace(/\\/g, '/');
+    const homeArg = ` --home "${homeForCmd}"`;
+    const orgArg = org && org.key ? ` --org ${org.key}` : '';
+    const orgLine = org
+        ? `\n相关${L.tenantLabel}：${org.name}（已通过 --org ${org.key} 预设选中）\n`
+        : '';
+
+    return `## ${status}
+
+请调用 Bash 工具执行以下命令，启动 ${L.systemName}${L.nameGap}登录页：
+
+\`\`\`bash
+${L.loginCommand}${homeArg}${orgArg}
+\`\`\`
+
+执行说明：
+1. 该命令会启动一个临时登录页并在浏览器中打开
+2. 需要在页面上输入用户名密码，并完成图形点选验证码（由人操作，AI 无法代替）
+3. 登录成功后 token 会自动写入本地文件，本服务**下一次调用即可生效，无需重启**
+4. 命令会一直运行到登录完成才退出，**请以后台方式运行**（run_in_background），避免阻塞
+5. \`--home\` 不能省：本服务读的是 \`${CONFIG_DIR}\`，命令指向别的目录会写错位置
+${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);
+});