reasonix 0.51.0 → 0.52.0

package/dist/cli/{chunk-FEZK652I.js → chunk-MVLPXZAA.js}

@@ -1,5 +1,39 @@
 #!/usr/bin/env node
 import { createRequire as __cr } from 'node:module'; if (typeof globalThis.require === 'undefined') { globalThis.require = __cr(import.meta.url); }
+import {
+  formatMcpLifecycleEvent,
+  formatMcpSlowToast
+} from "./chunk-CFJY64UA.js";
+import {
+  buildTransportFromSpec,
+  preflightStdioSpec
+} from "./chunk-XUZHBQSM.js";
+import {
+  bridgeMcpTools
+} from "./chunk-HNZ4727T.js";
+import {
+  McpClient,
+  inspectMcpServer
+} from "./chunk-RCC73DWQ.js";
+import {
+  loadDotenv
+} from "./chunk-2UQP6H6T.js";
+import {
+  t
+} from "./chunk-CLHMV6OL.js";
+import {
+  decideQQAccess,
+  describeQQAccess,
+  loadQQConfig,
+  normalizeMcpConfig,
+  normalizeQQAllowlist,
+  normalizeQQOpenId,
+  overlayMatchedSpec,
+  parseMcpSpec,
+  readConfig,
+  redactQQOpenId,
+  specToRaw
+} from "./chunk-AOYUW3HR.js";
 import {
   __commonJS,
   __require,
@@ -2209,14 +2243,14 @@ var require_extension = __commonJS({
 var require_websocket = __commonJS({
   "node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
-    var EventEmitter = __require("events");
+    var EventEmitter2 = __require("events");
     var https = __require("https");
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
     var { randomBytes, createHash } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
-    var { URL } = __require("url");
+    var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
     var Receiver2 = require_receiver();
     var Sender2 = require_sender();
@@ -2241,7 +2275,7 @@ var require_websocket = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket2 = class _WebSocket extends EventEmitter {
+    var WebSocket2 = class _WebSocket extends EventEmitter2 {
       /**
        * Create a new `WebSocket`.
        *
@@ -2709,11 +2743,11 @@ var require_websocket = __commonJS({
         );
       }
       let parsedUrl;
-      if (address instanceof URL) {
+      if (address instanceof URL2) {
         parsedUrl = address;
       } else {
         try {
-          parsedUrl = new URL(address);
+          parsedUrl = new URL2(address);
         } catch {
           throw new SyntaxError(`Invalid URL: ${address}`);
         }
@@ -2850,7 +2884,7 @@ var require_websocket = __commonJS({
           req.abort();
           let addr;
           try {
-            addr = new URL(location, address);
+            addr = new URL2(location, address);
           } catch (e) {
             const err = new SyntaxError(`Invalid URL: ${location}`);
             emitErrorAndClose(websocket, err);
@@ -3238,7 +3272,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
-    var EventEmitter = __require("events");
+    var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
     var { createHash } = __require("crypto");
@@ -3251,7 +3285,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer2 = class extends EventEmitter {
+    var WebSocketServer2 = class extends EventEmitter2 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -3627,6 +3661,14 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// src/qq/channel.ts
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/qq/bot.ts
+import { EventEmitter } from "events";
+
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
 var import_extension = __toESM(require_extension(), 1);
@@ -3638,7 +3680,789 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
+// src/qq/bot.ts
+var TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
+var BASE_URL = "https://api.sgroup.qq.com";
+var SANDBOX_URL = "https://sandbox.api.sgroup.qq.com";
+var INTENT_C2C_GROUP = 1 << 25;
+var MIN_HEARTBEAT_INTERVAL_MS = 5e3;
+var MAX_HEARTBEAT_INTERVAL_MS = 6e4;
+var ALLOWED_GATEWAY_HOSTS = ["api.sgroup.qq.com", "sandbox.api.sgroup.qq.com", "qq.com"];
+var QQBot = class extends EventEmitter {
+  config;
+  token = "";
+  tokenExpiresAt = 0;
+  ws = null;
+  heartbeatTimer = null;
+  seq = 0;
+  sessionId = "";
+  closed = false;
+  readyReceived = false;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  get baseUrl() {
+    return this.config.sandbox ? SANDBOX_URL : BASE_URL;
+  }
+  sanitizeHeartbeatInterval(interval) {
+    if (typeof interval !== "number" || !Number.isFinite(interval)) {
+      return null;
+    }
+    if (interval < MIN_HEARTBEAT_INTERVAL_MS) {
+      return MIN_HEARTBEAT_INTERVAL_MS;
+    }
+    if (interval > MAX_HEARTBEAT_INTERVAL_MS) {
+      return MAX_HEARTBEAT_INTERVAL_MS;
+    }
+    return Math.trunc(interval);
+  }
+  validateGatewayUrl(rawUrl) {
+    const url = new URL(rawUrl);
+    const trustedHost = ALLOWED_GATEWAY_HOSTS.some(
+      (host) => url.hostname === host || url.hostname.endsWith(`.${host}`)
+    );
+    if (url.protocol !== "wss:" || !trustedHost || url.username || url.password || url.search || url.hash) {
+      throw new Error(`Unexpected QQ gateway URL: ${rawUrl}`);
+    }
+    return url.toString();
+  }
+  async ensureToken() {
+    if (this.token && Date.now() < this.tokenExpiresAt - 6e4) {
+      return this.token;
+    }
+    const res = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        appId: this.config.appid,
+        clientSecret: this.config.secret
+      })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Failed to get access token (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    this.token = data.access_token;
+    this.tokenExpiresAt = Date.now() + data.expires_in * 1e3;
+    return this.token;
+  }
+  async getGateway() {
+    const token = await this.ensureToken();
+    const res = await fetch(`${this.baseUrl}/gateway`, {
+      headers: { Authorization: `QQBot ${token}` }
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Failed to get gateway (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    return this.validateGatewayUrl(data.url);
+  }
+  sendOp(op, data) {
+    if (!this.ws) return;
+    this.ws.send(JSON.stringify({ op, d: data ?? {} }));
+  }
+  async handlePayload(payload) {
+    switch (payload.op) {
+      case 10: {
+        const d = payload.d;
+        this.sendOp(2, {
+          token: `QQBot ${await this.ensureToken()}`,
+          intents: INTENT_C2C_GROUP,
+          shard: [0, 1]
+        });
+        const heartbeatInterval = this.sanitizeHeartbeatInterval(d?.heartbeat_interval);
+        if (heartbeatInterval) {
+          this.heartbeatTimer = setInterval(() => {
+            this.sendOp(1, this.seq || null);
+          }, heartbeatInterval);
+        }
+        break;
+      }
+      case 0: {
+        if (payload.s) this.seq = payload.s;
+        if (payload.t === "READY") {
+          const d = payload.d;
+          this.sessionId = d.session_id;
+          this.readyReceived = true;
+          this.emit("online");
+        } else if (payload.t === "C2C_MESSAGE_CREATE") {
+          this.emit("message.private", payload.d);
+        } else if (payload.t === "GROUP_AT_MESSAGE_CREATE") {
+          this.emit("message.group", payload.d);
+        }
+        break;
+      }
+      case 7: {
+        this.reconnect();
+        break;
+      }
+      case 9: {
+        this.sessionId = "";
+        this.sendOp(2, {
+          token: `QQBot ${await this.ensureToken()}`,
+          intents: INTENT_C2C_GROUP,
+          shard: [0, 1]
+        });
+        break;
+      }
+    }
+  }
+  async reconnect() {
+    this.cleanup();
+    await this.connect();
+  }
+  cleanup() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  async connect() {
+    const gatewayUrl = await this.getGateway();
+    const token = await this.ensureToken();
+    this.ws = new wrapper_default(gatewayUrl, {
+      headers: {
+        Authorization: `QQBot ${token}`,
+        "X-Union-Appid": this.config.appid
+      }
+    });
+    this.ws.on("open", () => {
+      if (this.sessionId) {
+        this.sendOp(6, {
+          token: `QQBot ${this.token}`,
+          session_id: this.sessionId,
+          seq: this.seq
+        });
+      }
+    });
+    this.ws.on("message", (raw) => {
+      try {
+        const payload = JSON.parse(raw.toString());
+        this.handlePayload(payload).catch(() => {
+        });
+      } catch {
+      }
+    });
+    this.ws.on("close", () => {
+      if (!this.closed) {
+        if (this.readyReceived) {
+          console.error("QQ WebSocket reconnecting...");
+          this.cleanup();
+          setTimeout(() => this.reconnect(), 3e3);
+        } else {
+          const msg = "QQ WebSocket closed before authentication completed \u2014 check your appId and appSecret";
+          this.emit("bot_error", msg);
+          this.closed = true;
+        }
+      }
+    });
+    this.ws.on("error", (err) => {
+      const msg = `QQ WebSocket error: ${err.message}`;
+      console.error(msg);
+      this.emit("bot_error", msg);
+    });
+  }
+  async start() {
+    this.closed = false;
+    this.readyReceived = false;
+    await this.connect();
+  }
+  async stop() {
+    this.closed = true;
+    this.cleanup();
+  }
+  async sendPrivateMessage(openid, content, msgId, msgSeq) {
+    const token = await this.ensureToken();
+    const body = {
+      content,
+      msg_type: 0
+    };
+    if (msgId) body.msg_id = msgId;
+    if (typeof msgSeq === "number" && Number.isFinite(msgSeq)) body.msg_seq = Math.trunc(msgSeq);
+    const res = await fetch(`${this.baseUrl}/v2/users/${encodeURIComponent(openid)}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `QQBot ${token}`,
+        "Content-Type": "application/json",
+        "X-Union-Appid": this.config.appid
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      const msg = `QQ sendPrivateMessage failed (${res.status}): ${text}`;
+      throw new Error(msg);
+    }
+  }
+};
+
+// src/qq/strings.ts
+function formatQQModeLabel(codeMode) {
+  return t(codeMode ? "handlers.qq.modeCode" : "handlers.qq.modeChat");
+}
+function formatQQAccessSummary(config) {
+  const ownerOpenId = normalizeQQOpenId(config.ownerOpenId);
+  const allowlist = normalizeQQAllowlist(config.allowlist) ?? [];
+  const runtimeBoundOpenId = normalizeQQOpenId(config.runtimeBoundOpenId);
+  if (ownerOpenId) {
+    if (allowlist.length > 0) {
+      return t("handlers.qq.accessOwnerWithAllowlist", {
+        owner: redactQQOpenId(ownerOpenId),
+        count: allowlist.length
+      });
+    }
+    return t("handlers.qq.accessOwner", {
+      owner: redactQQOpenId(ownerOpenId)
+    });
+  }
+  if (allowlist.length > 0) {
+    return t("handlers.qq.accessAllowlist", { count: allowlist.length });
+  }
+  if (runtimeBoundOpenId) {
+    return t("handlers.qq.accessRuntime", {
+      owner: redactQQOpenId(runtimeBoundOpenId)
+    });
+  }
+  return t("handlers.qq.accessOpen");
+}
+function formatQQSetupPrompt(step) {
+  return t(step === "appId" ? "handlers.qq.promptAppId" : "handlers.qq.promptAppSecret");
+}
+function formatQQSetupWaiting(step) {
+  return t(
+    step === "appId" ? "handlers.qq.setupWaitingAppId" : "handlers.qq.setupWaitingAppSecret"
+  );
+}
+
+// src/qq/channel.ts
+var QQ_LOCK_FILE = join(homedir(), ".reasonix", "qq-channel.pid");
+var QQ_MAX_CHUNK_BYTES = 1500;
+var NATURAL_SPLIT_MIN_FRACTION = 0.6;
+function fitUtf8Slice(text, maxBytes) {
+  let end = 0;
+  let bytes = 0;
+  for (const char of text) {
+    const nextBytes = Buffer.byteLength(char, "utf8");
+    if (bytes > 0 && bytes + nextBytes > maxBytes) break;
+    end += char.length;
+    bytes += nextBytes;
+  }
+  return end > 0 ? text.slice(0, end) : text.slice(0, 1);
+}
+function pickNaturalSplit(candidate) {
+  const minSplit = Math.floor(candidate.length * NATURAL_SPLIT_MIN_FRACTION);
+  const splitters = ["\n\n", "\n", " "];
+  for (const splitter of splitters) {
+    const at = candidate.lastIndexOf(splitter);
+    if (at >= minSplit) return at + splitter.length;
+  }
+  return candidate.length;
+}
+function splitQQMessage(text, maxBytes = QQ_MAX_CHUNK_BYTES) {
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (Buffer.byteLength(remaining, "utf8") <= maxBytes) {
+      chunks.push(remaining);
+      break;
+    }
+    const candidate = fitUtf8Slice(remaining, maxBytes);
+    const splitAt = pickNaturalSplit(candidate);
+    chunks.push(candidate.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}
+var QQChannel = class {
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  callbacks;
+  bot = null;
+  qqUserId = null;
+  qqMessageId = null;
+  ownerOpenId;
+  allowlist;
+  runtimeBoundOpenId = null;
+  processedMsgIds = /* @__PURE__ */ new Set();
+  processedMsgIdQueue = [];
+  lockAcquired = false;
+  nextOutboundMsgSeq = 1;
+  rememberMessage(id) {
+    if (this.processedMsgIds.has(id)) return false;
+    this.processedMsgIds.add(id);
+    this.processedMsgIdQueue.push(id);
+    if (this.processedMsgIdQueue.length > 200) {
+      const oldest = this.processedMsgIdQueue.shift();
+      if (oldest) this.processedMsgIds.delete(oldest);
+    }
+    return true;
+  }
+  acquireLock() {
+    try {
+      const existing = Number(readFileSync(QQ_LOCK_FILE, "utf8").trim());
+      if (Number.isInteger(existing) && existing > 0 && existing !== process.pid) {
+        try {
+          process.kill(existing, 0);
+          throw new Error(t("handlers.qq.lockAlreadyRunning", { pid: existing }));
+        } catch (err) {
+          const e = err;
+          if (e.code !== "ESRCH") throw err;
+        }
+      }
+    } catch (err) {
+      const e = err;
+      if (e.code !== "ENOENT") throw err;
+    }
+    mkdirSync(dirname(QQ_LOCK_FILE), { recursive: true });
+    writeFileSync(QQ_LOCK_FILE, String(process.pid), "utf8");
+    this.lockAcquired = true;
+  }
+  releaseLock() {
+    if (!this.lockAcquired) return;
+    try {
+      const existing = Number(readFileSync(QQ_LOCK_FILE, "utf8").trim());
+      if (existing === process.pid) unlinkSync(QQ_LOCK_FILE);
+    } catch {
+    }
+    this.lockAcquired = false;
+  }
+  applyAccessConfig(config) {
+    this.ownerOpenId = config.ownerOpenId;
+    this.allowlist = config.allowlist;
+    if (this.ownerOpenId || (this.allowlist?.length ?? 0) > 0) {
+      this.runtimeBoundOpenId = null;
+    }
+  }
+  handlePrivateMessage(msg) {
+    const text = msg.content?.trim();
+    if (!text) return;
+    if (!this.rememberMessage(msg.id)) return;
+    const openid = msg.author.user_openid;
+    const verdict = decideQQAccess(
+      {
+        ownerOpenId: this.ownerOpenId,
+        allowlist: this.allowlist,
+        runtimeBoundOpenId: this.runtimeBoundOpenId
+      },
+      openid
+    );
+    if (!verdict.accept) {
+      this.callbacks.onError?.(
+        t("handlers.qq.unauthorizedMessage", {
+          openid: redactQQOpenId(openid),
+          access: formatQQAccessSummary({
+            ownerOpenId: this.ownerOpenId,
+            allowlist: this.allowlist,
+            runtimeBoundOpenId: this.runtimeBoundOpenId
+          })
+        })
+      );
+      return;
+    }
+    if (verdict.bindRuntime) {
+      this.runtimeBoundOpenId = openid;
+      this.callbacks.onError?.(
+        t("handlers.qq.runtimeBound", {
+          openid: redactQQOpenId(openid)
+        })
+      );
+    }
+    this.qqUserId = openid;
+    this.qqMessageId = msg.id;
+    this.callbacks.onSubmitMessage(`[QQ] ${text}`);
+  }
+  refreshAccessConfig() {
+    this.applyAccessConfig(loadQQConfig());
+  }
+  describeAccess() {
+    return describeQQAccess({
+      ownerOpenId: this.ownerOpenId,
+      allowlist: this.allowlist,
+      runtimeBoundOpenId: this.runtimeBoundOpenId
+    });
+  }
+  getRuntimeBoundOpenId() {
+    return this.runtimeBoundOpenId;
+  }
+  async start() {
+    loadDotenv();
+    this.acquireLock();
+    const config = loadQQConfig();
+    if (!config.appId) {
+      this.releaseLock();
+      throw new Error(t("handlers.qq.missingAppId"));
+    }
+    if (!config.appSecret) {
+      this.releaseLock();
+      throw new Error(t("handlers.qq.missingAppSecret"));
+    }
+    this.applyAccessConfig(config);
+    const bot = new QQBot({
+      appid: config.appId,
+      secret: config.appSecret,
+      sandbox: config.sandbox ?? false
+    });
+    bot.on("online", () => {
+      process.stderr.write("QQ bot is online!\n");
+    });
+    bot.on("bot_error", (msg) => {
+      this.callbacks.onError?.(msg);
+    });
+    bot.on("message.private", (msg) => {
+      this.handlePrivateMessage(msg);
+    });
+    this.bot = bot;
+    try {
+      await bot.start();
+      const readyOrError = await Promise.race([
+        new Promise((resolve) => bot.once("online", () => resolve("ready"))),
+        new Promise((resolve) => bot.once("bot_error", () => resolve("error"))),
+        new Promise((resolve) => setTimeout(() => resolve("timeout"), 15e3))
+      ]);
+      if (readyOrError === "error") {
+        throw new Error(t("handlers.qq.authFailed"));
+      }
+      if (readyOrError === "timeout") {
+        throw new Error(t("handlers.qq.readyTimeout"));
+      }
+    } catch (err) {
+      this.releaseLock();
+      throw err;
+    }
+  }
+  async sendResponse(text) {
+    if (!this.bot || !this.qqUserId) return;
+    const chunks = splitQQMessage(text);
+    for (let index = 0; index < chunks.length; index++) {
+      const chunk = chunks[index];
+      if (!chunk) continue;
+      try {
+        await this.bot.sendPrivateMessage(
+          this.qqUserId,
+          chunk,
+          this.qqMessageId ?? void 0,
+          this.nextOutboundMsgSeq++
+        );
+      } catch (err) {
+        const msg = `QQ sendResponse chunk ${index + 1}/${chunks.length} failed: ${err.message}`;
+        this.callbacks.onError?.(msg);
+        break;
+      }
+    }
+  }
+  async stop() {
+    await this.bot?.stop();
+    this.releaseLock();
+  }
+};
+
+// src/mcp/summary.ts
+function buildMcpServerSummary(opts) {
+  return {
+    label: opts.label,
+    spec: opts.spec,
+    toolCount: opts.toolCount,
+    report: opts.report,
+    host: opts.host,
+    bridgeEnv: opts.bridgeEnv,
+    readResource(uri) {
+      return opts.host.client.readResource(uri);
+    },
+    getPrompt(name, args) {
+      return args !== void 0 ? opts.host.client.getPrompt(name, args) : opts.host.client.getPrompt(name);
+    }
+  };
+}
+
+// src/cli/commands/mcp-runtime.ts
+var stderrLifecycleSink = (n) => {
+  if (n.kind === "slow") {
+    process.stderr.write(
+      `${formatMcpSlowToast({ name: n.serverName, p95Ms: n.p95Ms, sampleSize: n.sampleSize })}
+`
+    );
+    return;
+  }
+  if (n.kind === "failed") {
+    process.stderr.write(
+      `${formatMcpLifecycleEvent({ state: "failed", name: n.name, reason: n.reason })}
+  \u2192 ${t("mcpLifecycle.failedSetupHint")}
+`
+    );
+    return;
+  }
+  if (n.kind === "connected") {
+    process.stderr.write(
+      `${formatMcpLifecycleEvent({
+        state: "connected",
+        name: n.name,
+        tools: n.tools,
+        resources: n.resources,
+        prompts: n.prompts,
+        ms: n.ms
+      })}
+`
+    );
+    return;
+  }
+  if (n.kind === "tools-ready") {
+    process.stderr.write(
+      `${formatMcpLifecycleEvent({ state: "tools-ready", name: n.name, tools: n.tools, ms: n.ms })}
+`
+    );
+    return;
+  }
+  if (n.kind === "warn") {
+    process.stderr.write(
+      `${formatMcpLifecycleEvent({ state: "warn", name: n.name, reason: n.reason })}
+`
+    );
+    return;
+  }
+  process.stderr.write(
+    `${formatMcpLifecycleEvent({ state: n.kind, name: n.name })}
+`
+  );
+};
+function createMcpRuntime(ctx) {
+  const records = /* @__PURE__ */ new Map();
+  const insertionOrder = [];
+  const failureMap = /* @__PURE__ */ new Map();
+  let sink = stderrLifecycleSink;
+  async function addSpec(raw, loop, signal) {
+    if (records.has(raw)) {
+      return { ok: true, summary: records.get(raw).summary };
+    }
+    failureMap.delete(raw);
+    const tools = ctx.getTools();
+    if (!tools) return { ok: false, reason: "no tool registry available" };
+    const cfg = readConfig();
+    const normalized = normalizeMcpConfig(cfg);
+    let label = "anon";
+    let mcp;
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    ready.catch(() => void 0);
+    try {
+      const parsed = parseMcpSpec(raw);
+      label = parsed.name ?? "anon";
+      const matched = parsed.name ? normalized.find((s) => s.name === parsed.name) : void 0;
+      const spec = overlayMatchedSpec(parsed, matched);
+      if (spec.disabled) {
+        sink({ kind: "disabled", name: label });
+        rejectReady(new Error(`MCP server "${label}" is disabled`));
+        failureMap.set(raw, { spec: raw, name: label, reason: "disabled by user", at: Date.now() });
+        return { ok: false, reason: "disabled by user" };
+      }
+      sink({ kind: "handshake", name: label });
+      const t0 = Date.now();
+      const namePrefix = spec.name ? `${spec.name}_` : ctx.getRequestedCount() === 1 && ctx.getMcpPrefix() ? ctx.getMcpPrefix() : "";
+      if (spec.transport === "stdio") preflightStdioSpec(spec);
+      const workspaceDir = ctx.getWorkspaceDir?.();
+      const transport = buildTransportFromSpec(spec, { cwd: workspaceDir });
+      mcp = new McpClient({ transport, workspaceDir });
+      await mcp.initialize({ signal });
+      const host = { client: mcp };
+      const bridge = await bridgeMcpTools(mcp, {
+        registry: tools,
+        namePrefix,
+        serverName: label,
+        host,
+        ready,
+        onProgress: (info) => ctx.progressSink.current?.(info),
+        onSlow: (info) => sink({
+          kind: "slow",
+          serverName: info.serverName,
+          p95Ms: info.p95Ms,
+          sampleSize: info.sampleSize
+        })
+      });
+      const ms = Date.now() - t0;
+      const allSpecs = tools.specs();
+      const registeredSpecs = allSpecs.filter(
+        (s) => bridge.registeredNames.includes(s.function.name)
+      );
+      records.set(raw, {
+        spec: raw,
+        client: mcp,
+        summary: buildMcpServerSummary({
+          label,
+          spec: raw,
+          toolCount: bridge.registeredNames.length,
+          report: {
+            protocolVersion: mcp.protocolVersion,
+            serverInfo: mcp.serverInfo,
+            capabilities: mcp.serverCapabilities ?? {},
+            tools: { supported: true, items: [] },
+            resources: { supported: false, reason: "still inspecting" },
+            prompts: { supported: false, reason: "still inspecting" },
+            elapsedMs: ms
+          },
+          host,
+          bridgeEnv: bridge.env
+        }),
+        registeredNames: bridge.registeredNames,
+        registeredSpecs
+      });
+      insertionOrder.push(raw);
+      resolveReady();
+      sink({
+        kind: "tools-ready",
+        name: label,
+        tools: bridge.registeredNames.length,
+        ms
+      });
+      let report;
+      try {
+        report = await inspectMcpServer(mcp);
+      } catch {
+        report = {
+          protocolVersion: mcp.protocolVersion,
+          serverInfo: mcp.serverInfo,
+          capabilities: mcp.serverCapabilities ?? {},
+          tools: { supported: true, items: [] },
+          resources: { supported: false, reason: "inspect failed" },
+          prompts: { supported: false, reason: "inspect failed" },
+          elapsedMs: 0
+        };
+      }
+      const resourceCount = report.resources.supported ? report.resources.items.length : 0;
+      const promptCount = report.prompts.supported ? report.prompts.items.length : 0;
+      sink({
+        kind: "connected",
+        name: label,
+        tools: bridge.registeredNames.length,
+        resources: resourceCount,
+        prompts: promptCount,
+        ms
+      });
+      const summary = buildMcpServerSummary({
+        label,
+        spec: raw,
+        toolCount: bridge.registeredNames.length,
+        report,
+        host,
+        bridgeEnv: bridge.env
+      });
+      records.set(raw, {
+        spec: raw,
+        client: mcp,
+        summary,
+        registeredNames: bridge.registeredNames,
+        registeredSpecs
+      });
+      if (loop)
+        for (const s of registeredSpecs)
+          try {
+            loop.prefix.addTool(s);
+          } catch (err) {
+            sink({
+              kind: "warn",
+              name: label,
+              reason: `addTool failed for ${s.function.name}: ${err.message}`
+            });
+          }
+      return { ok: true, summary };
+    } catch (err) {
+      const reason = err.message;
+      if (!records.has(raw)) {
+        await mcp?.close().catch(() => void 0);
+        rejectReady(new Error(`MCP server "${label}" failed to start: ${reason}`));
+        sink({ kind: "failed", name: label, reason });
+        failureMap.set(raw, { spec: raw, name: label, reason, at: Date.now() });
+        return { ok: false, reason };
+      }
+      sink({ kind: "warn", name: label, reason });
+      return { ok: true, summary: records.get(raw).summary };
+    }
+  }
+  async function removeSpec(raw, loop) {
+    failureMap.delete(raw);
+    const record = records.get(raw);
+    if (!record) return false;
+    await record.client.close().catch(() => void 0);
+    const tools = ctx.getTools();
+    for (const name of record.registeredNames) {
+      tools?.unregister(name);
+      loop?.prefix.removeTool(name);
+    }
+    records.delete(raw);
+    const idx = insertionOrder.indexOf(raw);
+    if (idx >= 0) insertionOrder.splice(idx, 1);
+    return true;
+  }
+  async function reloadFromConfig(loop) {
+    const normalized = normalizeMcpConfig(readConfig());
+    const desired = normalized.map(specToRaw);
+    const desiredSet = new Set(desired);
+    const currentSet = new Set(records.keys());
+    const added = [];
+    const removed = [];
+    const failed = [];
+    for (const spec of [...currentSet]) {
+      if (!desiredSet.has(spec)) {
+        await removeSpec(spec, loop);
+        removed.push(spec);
+      }
+    }
+    for (const spec of desired) {
+      if (currentSet.has(spec)) continue;
+      const result = await addSpec(spec, loop);
+      if (result.ok) added.push(spec);
+      else failed.push({ spec, reason: result.reason });
+    }
+    return { added, removed, failed, summaries: summaries() };
+  }
+  function specs() {
+    return [...insertionOrder];
+  }
+  function summaries() {
+    return insertionOrder.map((s) => records.get(s)?.summary).filter((s) => Boolean(s));
+  }
+  async function closeAll() {
+    for (const r of records.values()) await r.client.close().catch(() => void 0);
+    records.clear();
+    insertionOrder.length = 0;
+    failureMap.clear();
+  }
+  function failures() {
+    return [...failureMap.values()];
+  }
+  function setLifecycleSink(s) {
+    sink = s;
+  }
+  return {
+    size: () => records.size,
+    specs,
+    summaries,
+    failures,
+    addSpec,
+    removeSpec,
+    reloadFromConfig,
+    closeAll,
+    setLifecycleSink
+  };
+}
+
 export {
-  wrapper_default
+  formatQQModeLabel,
+  formatQQAccessSummary,
+  formatQQSetupPrompt,
+  formatQQSetupWaiting,
+  QQChannel,
+  createMcpRuntime
 };
-//# sourceMappingURL=chunk-FEZK652I.js.map
+//# sourceMappingURL=chunk-MVLPXZAA.js.map