zen-gitsync 2.17.47 → 2.17.49

package/README.md

@@ -444,7 +444,7 @@ A dedicated view (robot icon in the activity bar) for chatting with the built-in
 | Task plan | Multi-step work gets a visible plan: the agent calls the built-in `update_plan` tool to split the task into 3-8 verifiable steps before touching anything, then updates each step's status as it goes. Steps render as a checklist with completed / in-progress / pending states and a `2/5` progress header — in the terminal as a `✓ / ▶ / ○` list, in the Web panel as a card that **stays visible even when the tool group is collapsed** (collapsing hides other tool calls, never the current plan) |
 | Recent-projects awareness | Ask "which of my projects need a pull?" and the agent calls its built-in `list_projects` tool instead of scanning the disk: it returns exactly the list behind the GUI's **Recent projects** panel (recent directories plus any directory a task was created in, with branch / ahead / behind / uncommitted counts and task progress), so the agent's answer and the UI agree. Ahead/behind reads local refs, so the agent can pass `refresh=true` to run a `git fetch` pass first when the question is about pulling |
 | Session persistence | All conversations are saved to `~/.zen-gitsync/agent-sessions/` as JSON files; the CLI agent (`g ai`) writes to the same directory so Web and CLI sessions are unified |
-| Skill / MCP plaza | The **Skill plaza** and **MCP plaza** tabs list skills and MCP servers from several sources, each with its description, weekly downloads / usage count and install state. Install one into the **current project** (`<project>/.zen-gitsync/ai/skills/<id>/SKILL.md` and `<project>/.zen-gitsync/ai/mcp.json`) or into the **`g ai` agent** (`~/.zen-gitsync/ai/`, applying to every project) — zen-gitsync's own directories, not another tool's. Entries already installed can be opened in the system file manager or uninstalled from the same row, and ones that still need environment variables are flagged. The installed list shows both the skill's own `name` and the on-disk id, since a repository often ships a skill whose `SKILL.md` calls itself something else. From a terminal, `g ai` lists what is installed with `/skills` (`/mcp` is an alias) |
+| Skill / MCP plaza | The **Skill plaza** and **MCP plaza** tabs list skills and MCP servers from several sources, each with its description, weekly downloads / usage count and install state. Install one into the **current project** (`<project>/.zen-gitsync/ai/skills/<id>/SKILL.md` and `<project>/.zen-gitsync/ai/mcp.json`) or into the **`g ai` agent** (`~/.zen-gitsync/ai/`, applying to every project) — zen-gitsync's own directories, not another tool's. Entries already installed can be opened in the system file manager or uninstalled from the same row, and ones that still need environment variables are flagged. The installed list shows both the skill's own `name` and the on-disk id, since a repository often ships a skill whose `SKILL.md` calls itself something else. From a terminal, `g ai` lists what is installed with `/skills` (`/mcp` is an alias). Entries land in one of two shapes: an npm package (`command: npx …`, i.e. stdio) or a remote endpoint (`type: http` + `url` + optional `headers`, which the agent's Streamable HTTP client talks to directly — no `mcp-remote` bridge in between) |
 | SSH-first cloning | When you ask it to clone a repo (or add a remote) it uses the SSH form — `git@github.com:owner/repo.git` / `git@gitee.com:owner/repo.git` — converting an `https://` URL first, so the clone never stalls on a Git Credential Manager username/password prompt; it falls back to https only when SSH genuinely fails (`Permission denied (publickey)` / host-key verification) and says which one it used. The same preference is injected into every workbench task, whose executor is an external CLI with a system prompt this app does not own |
 | Per-turn tool limit | A single message may trigger up to N tool calls in a row (default **200**, range 1–2000). Configurable in **Settings → AI models → Agent Runtime**; hitting the limit ends the turn and asks you to send another message. The same setting drives the CLI agent |
 | Preset questions | Quick-start buttons on the welcome screen for common tasks (view project structure, analyze code quality, write tests, check git status, start the project) |
@@ -541,6 +541,14 @@ where they came from. Installation itself happens in the GUI's **Skill / MCP pla
 view): pick the current project or the `g ai` agent as the target, and the entry becomes usable
 from that side.
 
+`g ai` speaks both MCP transports: an entry with a `command` runs over **stdio** (a child
+process), one with only a `url` over **Streamable HTTP** (`"type": "http"`, plus `headers` for
+things like `Authorization`; `Mcp-Session-Id` is echoed back and the session is closed with
+`DELETE` on exit). HTTPS endpoints are verified against Node's bundled root CAs rather than the
+OS store, so a server that ships only its leaf certificate fails with
+`UNABLE_TO_VERIFY_LEAF_SIGNATURE` while browsers are perfectly happy — start the agent with
+`NODE_EXTRA_CA_CERTS=<ca file>`, or on Node ≥ 22.15 with `NODE_OPTIONS=--use-system-ca`.
+
 In-session commands: `/help`, `/model`, `/addmodel`, `/cd <path>`, `/image [path]`, `/think`, `/tools`, `/stats`, `/new`, `/resume`, `/skills` (`/mcp` is an alias), `/clear`, `/exit` (or `/quit`).
 
 Reasoning, tool calls and answers have separate visual sections. Reasoning returned by the model is shown in full by default;
@@ -1165,7 +1173,7 @@ Activity Bar 中的机器人图标视图，可直接在浏览器中与内置 AI
 | 任务计划 | 多步任务有一份看得见的计划：智能体在动手之前先调内置的 `update_plan` 工具，把任务拆成 3-8 个可核对的步骤，随后逐步更新状态。步骤以清单渲染，区分完成 / 进行中 / 待办三态，标题右侧带 `2/5` 进度 —— 终端里是 `✓ / ▶ / ○` 列表，Web 面板里是一张卡片，且**工具组折叠时仍然常驻**（折叠只藏别的工具调用，绝不藏当前计划） |
 | 最近项目感知 | 问「我哪些项目需要 pull」时，智能体调用内置的 `list_projects` 工具，而不是自己去扫盘：返回的就是 GUI「最近项目」面板那份清单（最近目录 + 建过任务的目录，带分支 / 领先 / 落后 / 未提交数与任务进度），回答与界面对得上。领先/落后读的是本地引用，因此问到"要不要拉"时它可以带 `refresh=true` 先联网 fetch 一轮再答 |
 | 会话持久化 | 所有对话保存为 JSON 文件到 `~/.zen-gitsync/agent-sessions/`；CLI 智能体（`g ai`）写入同一目录，Web 端与 CLI 端会话统一管理 |
-| Skill / MCP 广场 | **Skill 广场** 与 **MCP 广场** 两个 tab 列出多个来源的 Skill 与 MCP 服务，每项带说明、周下载 / 使用次数与安装状态。可安装到**当前项目**（`<项目>/.zen-gitsync/ai/skills/<id>/SKILL.md` 与 `<项目>/.zen-gitsync/ai/mcp.json`）或 **`g ai` 智能体**（`~/.zen-gitsync/ai/`，对所有项目生效）—— 两处都是 zen-gitsync 自己的目录，不借别家工具的。已安装的可在同一行「打开文件夹」定位到落盘位置，或直接卸载，还缺环境变量的会标出「还缺环境变量」。已安装清单同时显示 skill 自报的 `name` 和实际落盘的目录 id —— 仓库名和 `SKILL.md` 里自称的名字经常不是一个。终端侧 `g ai` 用 `/skills`（`/mcp` 为别名）查看已装清单 |
+| Skill / MCP 广场 | **Skill 广场** 与 **MCP 广场** 两个 tab 列出多个来源的 Skill 与 MCP 服务，每项带说明、周下载 / 使用次数与安装状态。可安装到**当前项目**（`<项目>/.zen-gitsync/ai/skills/<id>/SKILL.md` 与 `<项目>/.zen-gitsync/ai/mcp.json`）或 **`g ai` 智能体**（`~/.zen-gitsync/ai/`，对所有项目生效）—— 两处都是 zen-gitsync 自己的目录，不借别家工具的。已安装的可在同一行「打开文件夹」定位到落盘位置，或直接卸载，还缺环境变量的会标出「还缺环境变量」。已安装清单同时显示 skill 自报的 `name` 和实际落盘的目录 id —— 仓库名和 `SKILL.md` 里自称的名字经常不是一个。终端侧 `g ai` 用 `/skills`（`/mcp` 为别名）查看已装清单。装下来的条目就两类形状：npm 包（落成 `command: npx …`，走 stdio）与远程端点（落成 `type: http` + `url` + 可选 `headers`，由 g ai 的 Streamable HTTP 客户端直连，中间不再经 `mcp-remote` 桥接） |
 | 克隆优先 SSH | 让它克隆仓库（或加远端）时走 SSH 形式 —— `git@github.com:owner/repo.git` / `git@gitee.com:owner/repo.git`；拿到 `https://` 地址先换算，克隆不会停在 Git Credential Manager 的账号密码弹窗上。只有 SSH 真的不可用（`Permission denied (publickey)` / 主机密钥校验失败）才退回 https，并说明这次走的是哪条。同一条偏好也会注入到每个工作台任务的 prompt —— 那里执行器是外部 CLI，系统提示词不归本应用管，环境上下文块是唯一的注入口 |
 | 单轮工具调用上限 | 一条消息内智能体最多连续调用多少次工具（默认 **200**，可调范围 1–2000）。在 **设置 → AI 模型配置 → 智能体运行时** 中修改；达到上限本轮会被强制结束并提示再发一条消息继续。CLI 智能体共用同一项设置 |
 | 预设问题 | 开场界面提供快捷按钮（查看项目结构、分析代码质量、写测试、Git 状态检查、帮我启动项目）|
@@ -1252,6 +1260,12 @@ $ g ai --model=2                # 使用第 2 个已配置的模型（序号或
 `/skills`（`/mcp` 为别名）列出智能体当前已安装的 Skill 与 MCP 服务及来源。安装本身在 GUI 的
 **Skill / MCP 广场**（智能体视图）里完成：选择安装到当前项目或 `g ai` 智能体，装好后对应一侧即可使用。
 
+`g ai` 两种 MCP 传输都支持：有 `command` 的走 **stdio**（起子进程），只有 `url` 的走
+**Streamable HTTP**（配置写 `"type": "http"`，鉴权放 `headers`，例如 `Authorization`；
+响应里的 `Mcp-Session-Id` 会回传，退出时 `DELETE` 结束会话）。HTTPS 端点按 **Node 内置根证书**
+校验、不读系统证书库 —— 站点只发叶证书时会报 `UNABLE_TO_VERIFY_LEAF_SIGNATURE`（浏览器却一切正常），
+启动前设 `NODE_EXTRA_CA_CERTS=<CA 文件>`，或 Node ≥ 22.15 时用 `NODE_OPTIONS=--use-system-ca` 即可。
+
 会话内命令：`/help`、`/model`、`/addmodel`、`/cd <路径>`、`/image [路径]`、`/think`、`/tools`、`/stats`、`/new`、`/resume`、`/skills`（`/mcp` 为别名）、`/clear`、`/exit`（或 `/quit`）。
 
 思考、工具调用和回答分区展示。默认完整显示模型返回的思考，`/think full` 恢复完整显示，

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zen-gitsync",
-  "version": "2.17.47",
+  "version": "2.17.49",
   "description": "Auto commit, scheduled sync, and visual GUI for Git. Run `g` in any repo for one-key commit & push, AI commit messages, scheduled background sync, and a drag-and-drop workflow builder.",
   "main": "index.js",
   "type": "module",
@@ -77,6 +77,7 @@
     "verify:wb-responsive": "node scripts/verify-wb-responsive.cjs",
     "verify:wb-editor-persist": "node scripts/verify-workbench-editor-persist.cjs",
     "verify:wb-open-scroll-bottom": "node scripts/verify-workbench-open-scroll-bottom.cjs",
+    "verify:chat-rail": "node scripts/verify-chat-message-rail.cjs",
     "verify:editor-preview-scroll": "node scripts/verify-editor-preview-scroll.cjs",
     "verify:editor-sidebar-width": "node scripts/verify-editor-sidebar-width.cjs",
     "verify:editor-disk-sync": "node scripts/verify-editor-disk-sync.cjs",

package/src/cli/ai/mcp.js

@@ -12,19 +12,32 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// g ai 的 MCP(Model Context Protocol)客户端 — stdio 传输实现。
+// g ai 的 MCP(Model Context Protocol)客户端 — 支持 stdio 与 Streamable HTTP 两种传输。
 //
 // 为什么自己实现而不是装 SDK:
-//   本包 dependencies 一直保持精简,而 stdio 这一层的协议面很小
-//   (newline-delimited JSON-RPC + initialize / tools/list / tools/call 三个方法),
-//   自己写≈200 行,换取零依赖 + 完全可控的超时与降级行为。
+//   本包 dependencies 一直保持精简,而这两种传输的协议面都很小
+//   (JSON-RPC + initialize / tools/list / tools/call 三个方法),自己写换取
+//   零依赖 + 完全可控的超时与降级行为。
 //
 // 配置来源(两级,项目级覆盖全局同名 server):
 //   1) ~/.zen-gitsync/ai/mcp.json                    「g ai 智能体」全局安装(对所有项目生效)
 //   2) <cwd>/.zen-gitsync/ai/mcp.json                项目级安装
 //   形状沿用生态通行的 mcpServers。项目级路径常量与广场安装端共用 src/paths.js 那一份;
 //   项目级**不再读** <cwd>/.mcp.json(那是 Claude Code 一系的约定路径,2026-09-30 迁出)。
-//   { "mcpServers": { "github": { "command": "npx", "args": ["-y", "@..."], "env": {} } } }
+//
+// 两种条目形状,按有没有 command 自动区分(同一条目同时有两者时以 command 为准):
+//   { "github": { "command": "npx", "args": ["-y", "@..."], "env": {} } }
+//   { "todo":   { "type": "http", "url": "https://.../api/mcp", "headers": { "Authorization": "Bearer ..." } } }
+//
+// HTTP 侧只说 Streamable HTTP(2025-03-26 起规范里的那套):
+//   POST JSON-RPC → 200 application/json 或 text/event-stream(取 id 匹配的那一帧);
+//   响应头里的 Mcp-Session-Id 会被记住并在后续请求回传;关闭时尽力 DELETE 结束会话。
+//   老式 "HTTP+SSE"(2024-11-05 的 GET /sse + POST endpoint)不在此列 —— 那种服务端
+//   自己也在陆续迁走,真需要时用 mcp-remote 桥成 stdio 更省事。
+//
+// ⚠️ HTTPS 的证书链:fetch 走 Node 内置根证书,不读 Windows/macOS 证书库。
+//   站点只发叶证书、中间证书没带全时,Node 会报 unable to verify the first certificate,
+//   而浏览器/curl 都正常。这里**不擅自关校验**(那是安全红线),只在报错里把可操作的做法写清楚。
 //
 // ⚠️ Windows 上 spawn 的两个坑(已实测,不要"优化"掉):
 //   1) 带空格的参数在 shell:true 下会被 cmd 拆碎 ——
@@ -46,6 +59,11 @@ const IS_WIN = process.platform === 'win32';
 // 工具名前缀。OpenAI function calling 允许 [A-Za-z0-9_-],用双下划线分段。
 export const MCP_TOOL_PREFIX = 'mcp__';
 
+// 握手时声明的协议版本。stdio 沿用旧值不动(现有 server 都是照这个档位对接的);
+// HTTP 侧必须报 Streamable HTTP 那一版,否则部分服务端会按老式 HTTP+SSE 处理。
+const STDIO_PROTOCOL_VERSION = '2024-11-05';
+const HTTP_PROTOCOL_VERSION = '2025-03-26';
+
 // 初始化握手超时。
 // ⚠️ 别按"握手只需要几百毫秒"来定这个值:command 是 npx -y 时,**首次**会现场下载
 // 整个 server 包及其依赖。国内直连 registry(无代理)实测这一步能轻松吃掉 30s+,
@@ -144,6 +162,9 @@ export function buildSpawnSpec(command, args, env) {
 /**
  * 读取一个 mcp.json 形状的配置文件,返回 mcpServers 对象。
  * 文件不存在 / 坏了都只当"没有配置",不抛错 —— 一个坏文件不该让 g ai 起不来。
+ *
+ * 保留条件:有 command(stdio)或有 http(s) 的 url(Streamable HTTP)。
+ * 两者都没有的条目直接丢掉 —— 免得后面按 undefined 去 spawn 炸得莫名其妙。
  */
 async function readServersFile(file) {
   const raw = await fs.readFile(file, 'utf8').catch(() => '');
@@ -155,7 +176,9 @@ async function readServersFile(file) {
     const out = {};
     for (const [id, cfg] of Object.entries(servers)) {
       if (!cfg || typeof cfg !== 'object') continue;
-      if (!cfg.command || typeof cfg.command !== 'string') continue;
+      const hasCommand = typeof cfg.command === 'string' && cfg.command.trim() !== '';
+      const hasUrl = typeof cfg.url === 'string' && /^https?:\/\//i.test(cfg.url.trim());
+      if (!hasCommand && !hasUrl) continue;
       out[id] = cfg;
     }
     return out;
@@ -187,11 +210,55 @@ export async function loadMcpServers({ cwd, globalFile = AI_MCP_FILE, projectFil
 // 单个 server 的连接
 // ──────────────────────────────────────────────
 
+/**
+ * 这个条目该走哪种传输:有 command 就是 stdio(优先级高于 url),
+ * 否则 url 是 http(s) 时走 Streamable HTTP。
+ *
+ * @param {object} config
+ * @returns {'stdio'|'http'|null} null = 两边都不像,调用方应跳过
+ */
+export function serverTransport(config) {
+  if (!config || typeof config !== 'object') return null;
+  if (typeof config.command === 'string' && config.command.trim() !== '') return 'stdio';
+  if (typeof config.url === 'string' && /^https?:\/\//i.test(config.url.trim())) return 'http';
+  return null;
+}
+
 // 工具名会被拼进 OpenAI 的 function name,必须收敛到安全字符集
 function sanitizeToolName(name) {
   return String(name || '').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 48);
 }
 
+/**
+ * 两种传输共用的握手:initialize → notifications/initialized → tools/list。
+ * 请求/通知都通过参数注入,stdio 与 HTTP 各交各的实现。
+ *
+ * @param {{ id: string, protocolVersion: string,
+ *           request: (method: string, params: object, timeoutMs: number) => Promise<any>,
+ *           notify: (method: string, params: object) => any }} io
+ * @returns {Promise<Array<object>>} 归一化后的工具定义
+ */
+async function handshake({ id, protocolVersion, request, notify }) {
+  await request('initialize', {
+    protocolVersion,
+    capabilities: {},
+    clientInfo: { name: 'zen-gitsync-g-ai', version: '1.0.0' },
+  }, INIT_TIMEOUT_MS);
+  await notify('notifications/initialized', {});
+
+  const listed = await request('tools/list', {}, INIT_TIMEOUT_MS);
+  return (Array.isArray(listed?.tools) ? listed.tools : [])
+    .filter(tool => tool && typeof tool.name === 'string')
+    .map(tool => ({
+      serverId: id,
+      name: tool.name,
+      description: tool.description || '',
+      inputSchema: tool.inputSchema && typeof tool.inputSchema === 'object'
+        ? tool.inputSchema
+        : { type: 'object', properties: {} },
+    }));
+}
+
 class McpConnection {
   /**
    * @param {string} id - server 标识(配置里的键名)
@@ -216,6 +283,11 @@ class McpConnection {
     return sanitizeToolName(this.id);
   }
 
+  /** 传输类型。诊断(/mcp)与 UI 展示用,连接本身不依赖它。 */
+  get transport() {
+    return 'stdio';
+  }
+
   /**
    * 启动子进程并完成 initialize + tools/list 握手。
    * 任何失败都写进 this.error 并返回 false,由调用方决定是否提示用户。
@@ -246,24 +318,12 @@ class McpConnection {
       this.spawnFailed = spawnFailed;
       spawnFailed.catch(() => {});
 
-      await this.#request('initialize', {
-        protocolVersion: '2024-11-05',
-        capabilities: {},
-        clientInfo: { name: 'zen-gitsync-g-ai', version: '1.0.0' },
-      }, INIT_TIMEOUT_MS);
-      this.#notify('notifications/initialized', {});
-
-      const listed = await this.#request('tools/list', {}, INIT_TIMEOUT_MS);
-      this.tools = (Array.isArray(listed?.tools) ? listed.tools : [])
-        .filter(tool => tool && typeof tool.name === 'string')
-        .map(tool => ({
-          serverId: this.id,
-          name: tool.name,
-          description: tool.description || '',
-          inputSchema: tool.inputSchema && typeof tool.inputSchema === 'object'
-            ? tool.inputSchema
-            : { type: 'object', properties: {} },
-        }));
+      this.tools = await handshake({
+        id: this.id,
+        protocolVersion: STDIO_PROTOCOL_VERSION,
+        request: (method, params, timeoutMs) => this.#request(method, params, timeoutMs),
+        notify: (method, params) => this.#notify(method, params),
+      });
       return true;
     } catch (err) {
       this.error = err.message;
@@ -360,6 +420,237 @@ class McpConnection {
   }
 }
 
+// ──────────────────────────────────────────────
+// Streamable HTTP 传输
+// ──────────────────────────────────────────────
+
+// Node 内置根证书不认站点证书链时的错误码 —— 单独识别出来,好把"该怎么修"写进提示
+const TLS_ERROR_CODES = new Set([
+  'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+  'SELF_SIGNED_CERT_IN_CHAIN',
+  'UNABLE_TO_GET_ISSUER_CERT_LOCALLY',
+  'DEPTH_ZERO_SELF_SIGNED_CERT',
+  'CERT_HAS_EXPIRED',
+  'ERR_TLS_CERT_ALTNAME_INVALID',
+]);
+
+function shortText(text, max) {
+  const clean = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+}
+
+/**
+ * 把 fetch 的失败翻译成用户能照着做的中文。
+ * 证书链那条是本项目实测踩过的坑:服务端只发叶证书时,浏览器和 curl 都正常,
+ * 唯独 Node 报 unable to verify the first certificate —— 只说 "fetch failed" 等于没说。
+ */
+function describeHttpError(err, id) {
+  const message = err?.message || String(err);
+  // 已经翻译过的(#send 里翻过一次)不要二次加工成"连接 x 失败: 连接 x 失败: ..."
+  if (message.startsWith(`连接 "${id}"`)) return message;
+
+  const cause = err?.cause;
+  const code = cause?.code || '';
+  if (TLS_ERROR_CODES.has(code)) {
+    return `连接 "${id}" 失败:服务器证书链不被 Node 内置根证书信任(${code})。`
+      + '可任选一种办法:① 启动 g ai 前设 NODE_EXTRA_CA_CERTS=<站点 CA 文件路径>;'
+      + '② Node ≥ 22.15 时用 NODE_OPTIONS=--use-system-ca 改走系统证书库;'
+      + '③ 让服务端补齐中间证书。';
+  }
+  if (message === 'fetch failed' && (code || cause?.message)) {
+    // 优先用错误码:undici 的 cause.message 往往还是那句 "fetch failed",没有信息量
+    const detail = code || cause.message;
+    return `连接 "${id}" 失败: ${message} (${detail})`;
+  }
+  return `连接 "${id}" 失败: ${message}`;
+}
+
+/** SSE 帧 → JSON-RPC 消息。只认 data: 行,event: / id: / 注释行一律忽略。 */
+function parseSseFrame(frame) {
+  const data = frame.split(/\r?\n/)
+    .filter(line => line.startsWith('data:'))
+    .map(line => line.slice(5).trimStart())
+    .join('\n');
+  if (!data.trim()) return null;
+  try { return JSON.parse(data) } catch { return null }
+}
+
+/**
+ * 一个远程 MCP 服务(Streamable HTTP)的连接。
+ * 对外接口与 stdio 版完全一致(start / tools / callTool / close / error),
+ * 上层 McpManager 不需要知道下面是怎么连的。
+ */
+export class HttpConnection {
+  /**
+   * @param {string} id - server 标识(配置里的键名)
+   * @param {object} config - { url, headers?, disabled? }
+   * @param {string} cwd - 只是保持与 stdio 版的构造签名一致(HTTP 没有子进程)
+   */
+  constructor(id, config, cwd) {
+    this.id = id;
+    this.config = config;
+    this.cwd = cwd || process.cwd();
+    this.tools = [];
+    this.error = null;
+    // 与 stdio 版同形状:那边把子进程 stderr 留在这里,HTTP 没有对应物
+    this.stderr = '';
+    this.closed = false;
+    this.sessionId = '';
+    this.nextId = 1;
+  }
+
+  get safeId() { return sanitizeToolName(this.id) }
+
+  get transport() { return 'http' }
+
+  get endpoint() { return String(this.config.url || '').trim() }
+
+  /**
+   * 握手(initialize → notifications/initialized → tools/list)。
+   * 失败写进 this.error 并返回 false,由 McpManager 汇总,不影响其他 server。
+   */
+  async start() {
+    try {
+      if (!/^https?:\/\//i.test(this.endpoint)) {
+        throw new Error(`url 不合法: ${this.endpoint || '(空)'}`);
+      }
+      this.tools = await handshake({
+        id: this.id,
+        protocolVersion: HTTP_PROTOCOL_VERSION,
+        request: (method, params, timeoutMs) => this.#request(method, params, timeoutMs),
+        // 通知失败不拖垮握手(与 stdio 版一个态度),只在后台记账
+        notify: (method, params) => { this.#notify(method, params).catch(() => {}) },
+      });
+      return true;
+    } catch (err) {
+      this.error = describeHttpError(err, this.id);
+      this.closed = true;
+      return false;
+    }
+  }
+
+  #headers() {
+    const headers = {
+      'Content-Type': 'application/json',
+      // 少写 text/event-stream 会被规范型实现判 406,这是 Streamable HTTP 的硬要求
+      'Accept': 'application/json, text/event-stream',
+    };
+    for (const [key, value] of Object.entries(this.config.headers || {})) {
+      if (!key || value === undefined || value === null) continue;
+      headers[key] = String(value);
+    }
+    if (this.sessionId) headers['Mcp-Session-Id'] = this.sessionId;
+    return headers;
+  }
+
+  /** 发一条 JSON-RPC,返回 result(通知类无响应体时是 null);失败抛已翻译过的 Error。 */
+  async #send(payload, timeoutMs) {
+    if (this.closed) throw new Error('MCP 连接已关闭');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      let response;
+      try {
+        response = await fetch(this.endpoint, {
+          method: 'POST',
+          headers: this.#headers(),
+          body: JSON.stringify(payload),
+          signal: controller.signal,
+        });
+      } catch (err) {
+        const failure = err?.name === 'AbortError'
+          ? new Error(`请求超时(${Math.round(timeoutMs / 1000)}s)`)
+          : err;
+        throw new Error(describeHttpError(failure, this.id));
+      }
+
+      const sessionId = response.headers.get('mcp-session-id');
+      if (sessionId) this.sessionId = sessionId;
+
+      if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`HTTP ${response.status}${body ? `: ${shortText(body, 300)}` : ''}`);
+      }
+
+      const contentType = String(response.headers.get('content-type') || '');
+      if (contentType.includes('text/event-stream')) {
+        return await this.#readSseResult(response, payload.id);
+      }
+
+      const text = await response.text();
+      if (!text.trim()) return null; // 202 Accepted:通知类请求没有响应体
+      let message;
+      try { message = JSON.parse(text) } catch {
+        throw new Error(`响应不是合法 JSON: ${shortText(text, 200)}`);
+      }
+      if (message?.error) throw new Error(message.error.message || `MCP error ${message.error.code}`);
+      return message?.result ?? null;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /**
+   * 读 SSE 响应,取 id 匹配的那一帧。
+   *
+   * 用流式 reader 而不是 await response.text():服务端完全可以在返回响应后继续推通知、
+   * 把流一直挂着,等整条流读完就会一路挂到超时。拿到目标帧立刻 cancel。
+   */
+  async #readSseResult(response, wantedId) {
+    const reader = response.body?.getReader?.();
+    if (!reader) return null;
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let found = null;
+    try {
+      while (!found) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let index;
+        while ((index = buffer.search(/\r?\n\r?\n/)) >= 0) {
+          const frame = buffer.slice(0, index);
+          buffer = buffer.slice(index).replace(/^\r?\n\r?\n/, '');
+          const message = parseSseFrame(frame);
+          if (!message) continue;
+          // 服务器主动推的通知(没有 id)直接忽略
+          if (wantedId === undefined || message.id === wantedId) { found = message; break }
+        }
+      }
+    } finally {
+      reader.cancel().catch(() => {});
+    }
+    if (!found) return null;
+    if (found.error) throw new Error(found.error.message || `MCP error ${found.error.code}`);
+    return found.result ?? null;
+  }
+
+  #request(method, params, timeoutMs) {
+    const id = this.nextId++;
+    return this.#send({ jsonrpc: '2.0', id, method, params }, timeoutMs);
+  }
+
+  #notify(method, params) {
+    return this.#send({ jsonrpc: '2.0', method, params }, INIT_TIMEOUT_MS);
+  }
+
+  /** 调用一个工具。口径与 stdio 版一致:content 数组拍平成字符串回喂给模型。 */
+  async callTool(name, args) {
+    const result = await this.#request('tools/call', { name, arguments: args || {} }, CALL_TIMEOUT_MS);
+    return flattenToolResult(result);
+  }
+
+  async close() {
+    this.closed = true;
+    const url = this.endpoint;
+    if (!url || !this.sessionId) return;
+    // 规范里结束会话是 DELETE(带 session 头),不是所有服务端都实现 —— 尽力而为
+    try {
+      await fetch(url, { method: 'DELETE', headers: this.#headers(), signal: AbortSignal.timeout(5000) });
+    } catch { /* noop */ }
+  }
+}
+
 // MCP tools/call 返回 { content: [{type:'text',text} | {type:'image',...} | {type:'resource',...}], isError? }
 function flattenToolResult(result) {
   const parts = Array.isArray(result?.content) ? result.content : [];
@@ -420,7 +711,10 @@ export class McpManager {
     const enabled = Object.entries(resolved).filter(([, cfg]) => !cfg.disabled);
 
     const settled = await Promise.all(enabled.map(async ([id, cfg]) => {
-      const connection = new McpConnection(id, cfg, cwd || process.cwd());
+      // 有 command → 本地子进程;只有 url → 远程 Streamable HTTP(serverTransport 已判过一遍)
+      const connection = serverTransport(cfg) === 'http'
+        ? new HttpConnection(id, cfg, cwd || process.cwd())
+        : new McpConnection(id, cfg, cwd || process.cwd());
       const ok = await connection.start();
       if (!ok && onWarn) onWarn(`MCP "${id}" 连接失败: ${connection.error}`);
       return connection;
@@ -471,7 +765,9 @@ export class McpManager {
   status() {
     return this.connections.map(connection => ({
       id: connection.id,
-      command: connection.config.command,
+      transport: connection.transport,
+      // http 型没有 command,退回显示 url —— 渲染端只认这一个字段
+      command: connection.config.command || connection.config.url || '',
       tools: connection.tools.length,
       error: connection.error,
     }));
@@ -496,4 +792,4 @@ export class McpManager {
   }
 }
 
-export default { McpManager, loadMcpServers, buildSpawnSpec, MCP_TOOL_PREFIX };
+export default { McpManager, HttpConnection, loadMcpServers, buildSpawnSpec, serverTransport, MCP_TOOL_PREFIX };