@fieldwangai/agentflow 0.1.34 → 0.1.36

package/bin/lib/ui-server.mjs

@@ -1,6 +1,6 @@
 /**
  * 本地 HTTP：静态 UI + /api/flows（GET/POST/HEAD）、/api/flows/import（POST multipart 导入 .yaml/.zip）、/api/flow/archive（POST）、/api/flow/delete（POST 永久删除）、/api/model-lists、/api/ui-context、/api/pipeline-recent-runs、/api/run-node-statuses（GET 某次 run 各节点磁盘状态）、/api/workspace-tree（GET 工作区目录树）、/api/nodes、/api/flow（GET/POST）、
- * /api/flow-editor-sync（POST 通知画布刷新）、/api/flow-editor-sync-events（GET SSE）、/api/flow/run（POST NDJSON 流式执行 agentflow apply --machine-readable）、/api/flow/run/stop（POST 终止运行）、
+ * /api/flow-editor-sync（POST 通知画布刷新）、/api/flow-editor-sync-events（GET SSE）、/api/flow/run（POST NDJSON 流式执行 agentflow apply --machine-readable）、/api/flow/run/stop（POST 终止运行）、/api/workspace/run/stop（POST 终止 Workspace 临时运行）、
  * /api/composer-agent（POST NDJSON；有 flow 时结束后 validate-flow，失败则自动 agent 修复至多 5 次）、
  * /api/agentflow-config（GET/POST 读写 ~/agentflow/config.json 的 opencodeProvider；POST 后执行 update-model-lists）、/api/update-model-lists（POST 可选 JSON body.opencodeProvider 覆盖本次拉取用的 Provider，未保存 config 也可用）；
  * listen 后后台 updateModelLists
@@ -89,8 +89,10 @@ import {
   buildClearSessionCookie,
   buildSessionCookie,
   getAuthUserFromRequest,
+  isAuthUserAllowed,
   loginOrCreateUser,
   logoutRequest,
+  readUserAllowlist,
 } from "./auth.mjs";
 import { readUserEnvObject, readUserEnvRows, writeUserEnvRows } from "./user-env.mjs";
 
@@ -297,6 +299,45 @@ function writeSkillCollectionConfig(userCtx = {}, payload = {}, availableSkills
   return config;
 }
 
+function upsertSkillhubCollectionGroup(userCtx = {}, collectionId = "", beforeSkills = [], afterSkills = [], collectionName = "") {
+  const rawCollectionId = String(collectionId || "").trim();
+  if (!rawCollectionId) return null;
+  const beforeKeys = new Set((Array.isArray(beforeSkills) ? beforeSkills : []).map((skill) => String(skill?.key || "")).filter(Boolean));
+  const addedKeys = (Array.isArray(afterSkills) ? afterSkills : [])
+    .map((skill) => String(skill?.key || "").trim())
+    .filter((key) => key && !beforeKeys.has(key));
+  const config = readSkillCollectionConfig(userCtx, afterSkills);
+  const groupId = slugifySkillCollectionId(`skillhub-collection-${rawCollectionId}`, "skillhub-collection");
+  const now = Date.now();
+  const existing = config.collections.find((collection) => collection.id === groupId);
+  const existingKeys = Array.isArray(existing?.skillKeys) ? existing.skillKeys : [];
+  const mergedKeys = Array.from(new Set([...existingKeys, ...addedKeys]));
+  const nextCollections = config.collections.filter((collection) => collection.id !== groupId);
+  nextCollections.push({
+    id: groupId,
+    name: String(collectionName || "").trim() || `SkillHub Collection ${rawCollectionId}`,
+    skillKeys: mergedKeys,
+    builtin: false,
+    createdAt: Number.isFinite(existing?.createdAt) ? existing.createdAt : now,
+    updatedAt: now,
+  });
+  return writeSkillCollectionConfig(userCtx, { version: 1, collections: nextCollections }, afterSkills);
+}
+
+function removeSkillhubCollectionGroup(userCtx = {}, collectionId = "", root = process.cwd()) {
+  const rawCollectionId = String(collectionId || "").trim();
+  if (!rawCollectionId) return null;
+  const availableSkills = listComposerSkills(PACKAGE_ROOT, root);
+  const config = readSkillCollectionConfig(userCtx, availableSkills);
+  const groupId = slugifySkillCollectionId(`skillhub-collection-${rawCollectionId}`, "skillhub-collection");
+  if (!config.collections.some((collection) => collection.id === groupId)) return config;
+  return writeSkillCollectionConfig(
+    userCtx,
+    { version: 1, collections: config.collections.filter((collection) => collection.id !== groupId) },
+    availableSkills,
+  );
+}
+
 function runtimeEnvForUser(userCtx = {}, extra = {}) {
   return {
     ...process.env,
@@ -317,6 +358,448 @@ function readAgentflowUserConfigObject() {
   }
 }
 
+function cursorMcpConfigPath() {
+  return path.join(os.homedir(), ".cursor", "mcp.json");
+}
+
+function readCursorMcpConfig() {
+  const p = cursorMcpConfigPath();
+  try {
+    if (!fs.existsSync(p)) return { mcpServers: {} };
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    return data && typeof data === "object" && !Array.isArray(data) ? data : { mcpServers: {} };
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+
+function userMcpPrivatePath(userCtx = {}) {
+  return path.join(getAgentflowUserDataRoot(userCtx.userId), "mcp-private.json");
+}
+
+function readUserMcpPrivate(userCtx = {}) {
+  const p = userMcpPrivatePath(userCtx);
+  try {
+    if (!fs.existsSync(p)) return { version: 1, servers: {} };
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    const servers = data?.servers && typeof data.servers === "object" && !Array.isArray(data.servers) ? data.servers : {};
+    return { version: 1, servers };
+  } catch {
+    return { version: 1, servers: {} };
+  }
+}
+
+function writeUserMcpPrivate(userCtx = {}, data = {}) {
+  const p = userMcpPrivatePath(userCtx);
+  const servers = data?.servers && typeof data.servers === "object" && !Array.isArray(data.servers) ? data.servers : {};
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify({ version: 1, servers }, null, 2) + "\n", "utf-8");
+  return { version: 1, servers };
+}
+
+function normalizeMcpPrivateKeys(keys) {
+  return new Set((Array.isArray(keys) ? keys : []).map((key) => String(key || "").trim()).filter(Boolean));
+}
+
+function pickObjectKeys(obj, keys) {
+  const out = {};
+  for (const key of keys) {
+    if (obj && Object.prototype.hasOwnProperty.call(obj, key)) out[key] = String(obj[key] ?? "");
+  }
+  return out;
+}
+
+function omitObjectKeys(obj, keys) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj && typeof obj === "object" ? obj : {})) {
+    if (!keys.has(key)) out[key] = value;
+  }
+  return out;
+}
+
+function privateKeyMetadataFromConfig(configValue = {}) {
+  const meta = configValue?.__agentflowPrivateKeys;
+  const env = Array.isArray(meta?.env) ? meta.env.map((key) => String(key || "").trim()).filter(Boolean) : [];
+  const headers = Array.isArray(meta?.headers) ? meta.headers.map((key) => String(key || "").trim()).filter(Boolean) : [];
+  return { env: Array.from(new Set(env)), headers: Array.from(new Set(headers)) };
+}
+
+function withPrivatePlaceholders(obj, keys) {
+  const out = { ...(obj && typeof obj === "object" && !Array.isArray(obj) ? obj : {}) };
+  for (const key of keys) {
+    if (key && !Object.prototype.hasOwnProperty.call(out, key)) out[key] = "";
+  }
+  return out;
+}
+
+function normalizeMcpServerConfig(value) {
+  const raw = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const next = {};
+  const url = typeof raw.url === "string" ? raw.url.trim() : "";
+  const command = typeof raw.command === "string" ? raw.command.trim() : "";
+  const description = typeof raw.description === "string" ? raw.description.trim() : "";
+  if (url) next.url = url;
+  if (command) next.command = command;
+  if (Array.isArray(raw.args)) next.args = raw.args.map((x) => String(x)).filter((x) => x.length > 0);
+  if (raw.env && typeof raw.env === "object" && !Array.isArray(raw.env)) {
+    const env = {};
+    for (const [k, v] of Object.entries(raw.env)) {
+      const key = String(k || "").trim();
+      if (key) env[key] = String(v ?? "");
+    }
+    if (Object.keys(env).length) next.env = env;
+  }
+  if (raw.headers && typeof raw.headers === "object" && !Array.isArray(raw.headers)) {
+    const headers = {};
+    for (const [k, v] of Object.entries(raw.headers)) {
+      const key = String(k || "").trim();
+      if (key) headers[key] = String(v ?? "");
+    }
+    if (Object.keys(headers).length) next.headers = headers;
+  }
+  if (description) next.description = description;
+  for (const [k, v] of Object.entries(raw)) {
+    if (["url", "command", "args", "env", "headers", "description"].includes(k)) continue;
+    next[k] = v;
+  }
+  return next;
+}
+
+function readCursorMcpServers(userCtx = {}) {
+  const config = readCursorMcpConfig();
+  const privateConfig = readUserMcpPrivate(userCtx);
+  const rawServers = config.mcpServers && typeof config.mcpServers === "object" && !Array.isArray(config.mcpServers)
+    ? config.mcpServers
+    : {};
+  const servers = Object.entries(rawServers).map(([name, value]) => {
+    const publicValue = normalizeMcpServerConfig(value);
+    const privateValue = privateConfig.servers?.[name] && typeof privateConfig.servers[name] === "object" ? privateConfig.servers[name] : {};
+    const privateEnv = privateValue.env && typeof privateValue.env === "object" && !Array.isArray(privateValue.env) ? privateValue.env : {};
+    const privateHeaders = privateValue.headers && typeof privateValue.headers === "object" && !Array.isArray(privateValue.headers) ? privateValue.headers : {};
+    const privateMeta = privateKeyMetadataFromConfig(publicValue);
+    const privateEnvKeys = Array.from(new Set([...privateMeta.env, ...Object.keys(privateEnv)]));
+    const privateHeaderKeys = Array.from(new Set([...privateMeta.headers, ...Object.keys(privateHeaders)]));
+    const configValue = {
+      ...publicValue,
+      env: { ...withPrivatePlaceholders(publicValue.env || {}, privateEnvKeys), ...privateEnv },
+      headers: { ...withPrivatePlaceholders(publicValue.headers || {}, privateHeaderKeys), ...privateHeaders },
+    };
+    return {
+      name,
+      type: configValue.url ? "url" : "command",
+      url: typeof configValue.url === "string" ? configValue.url : "",
+      command: typeof configValue.command === "string" ? configValue.command : "",
+      args: Array.isArray(configValue.args) ? configValue.args : [],
+      env: configValue.env && typeof configValue.env === "object" ? configValue.env : {},
+      headers: configValue.headers && typeof configValue.headers === "object" ? configValue.headers : {},
+      description: typeof configValue.description === "string" ? configValue.description : "",
+      raw: configValue,
+      privateEnvKeys,
+      privateHeaderKeys,
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  return { path: cursorMcpConfigPath(), servers };
+}
+
+function writeCursorMcpServer(payload = {}, userCtx = {}) {
+  const name = String(payload?.name || "").trim();
+  const nextName = String(payload?.nextName || payload?.name || "").trim();
+  if (!/^[A-Za-z0-9_.-]+$/.test(nextName)) throw new Error("Invalid MCP name");
+  const server = normalizeMcpServerConfig(payload?.server);
+  if (!server.url && !server.command) throw new Error("MCP server requires url or command");
+  const privateEnvKeys = normalizeMcpPrivateKeys(payload?.privateEnvKeys);
+  const privateHeaderKeys = normalizeMcpPrivateKeys(payload?.privateHeaderKeys);
+  const privateEnv = pickObjectKeys(server.env || {}, privateEnvKeys);
+  const privateHeaders = pickObjectKeys(server.headers || {}, privateHeaderKeys);
+  const publicServer = {
+    ...server,
+    env: omitObjectKeys(server.env || {}, privateEnvKeys),
+    headers: omitObjectKeys(server.headers || {}, privateHeaderKeys),
+  };
+  publicServer.env = withPrivatePlaceholders(publicServer.env, privateEnvKeys);
+  publicServer.headers = withPrivatePlaceholders(publicServer.headers, privateHeaderKeys);
+  if (privateEnvKeys.size || privateHeaderKeys.size) {
+    publicServer.__agentflowPrivateKeys = {
+      ...(privateEnvKeys.size ? { env: Array.from(privateEnvKeys) } : {}),
+      ...(privateHeaderKeys.size ? { headers: Array.from(privateHeaderKeys) } : {}),
+    };
+  } else {
+    delete publicServer.__agentflowPrivateKeys;
+  }
+  if (!Object.keys(publicServer.env).length) delete publicServer.env;
+  if (!Object.keys(publicServer.headers).length) delete publicServer.headers;
+  const p = cursorMcpConfigPath();
+  const config = readCursorMcpConfig();
+  const mcpServers = config.mcpServers && typeof config.mcpServers === "object" && !Array.isArray(config.mcpServers)
+    ? { ...config.mcpServers }
+    : {};
+  if (name && name !== nextName) delete mcpServers[name];
+  mcpServers[nextName] = publicServer;
+  const next = { ...config, mcpServers };
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  const privateConfig = readUserMcpPrivate(userCtx);
+  const privateServers = { ...(privateConfig.servers || {}) };
+  if (name && name !== nextName) delete privateServers[name];
+  if (Object.keys(privateEnv).length || Object.keys(privateHeaders).length) {
+    privateServers[nextName] = {
+      ...(Object.keys(privateEnv).length ? { env: privateEnv } : {}),
+      ...(Object.keys(privateHeaders).length ? { headers: privateHeaders } : {}),
+    };
+  } else {
+    delete privateServers[nextName];
+  }
+  writeUserMcpPrivate(userCtx, { servers: privateServers });
+  return readCursorMcpServers(userCtx);
+}
+
+function deleteCursorMcpServer(name, userCtx = {}) {
+  const key = String(name || "").trim();
+  if (!key) throw new Error("Missing MCP name");
+  const p = cursorMcpConfigPath();
+  const config = readCursorMcpConfig();
+  const mcpServers = config.mcpServers && typeof config.mcpServers === "object" && !Array.isArray(config.mcpServers)
+    ? { ...config.mcpServers }
+    : {};
+  delete mcpServers[key];
+  const next = { ...config, mcpServers };
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  const privateConfig = readUserMcpPrivate(userCtx);
+  const privateServers = { ...(privateConfig.servers || {}) };
+  delete privateServers[key];
+  writeUserMcpPrivate(userCtx, { servers: privateServers });
+  return readCursorMcpServers(userCtx);
+}
+
+function compactErrorMessage(error) {
+  const text = String(error?.message || error || "").trim();
+  return text.length > 260 ? `${text.slice(0, 257)}...` : text;
+}
+
+function parseMcpSsePayload(text) {
+  const events = [];
+  let data = [];
+  for (const rawLine of String(text || "").split(/\r?\n/g)) {
+    const line = rawLine.trimEnd();
+    if (!line) {
+      if (data.length) {
+        const joined = data.join("\n").trim();
+        if (joined) events.push(joined);
+        data = [];
+      }
+      continue;
+    }
+    if (line.startsWith("data:")) data.push(line.slice(5).trimStart());
+  }
+  if (data.length) events.push(data.join("\n").trim());
+  for (const event of events) {
+    try {
+      const parsed = JSON.parse(event);
+      if (parsed && typeof parsed === "object") return parsed;
+    } catch {}
+  }
+  return null;
+}
+
+async function mcpHttpRequest(url, headers, body, sessionId = "") {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 8000);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json, text/event-stream",
+        "Content-Type": "application/json",
+        ...(headers || {}),
+        ...(sessionId ? { "Mcp-Session-Id": sessionId } : {}),
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    if (!response.ok) throw new Error(`${response.status} ${response.statusText}: ${text.slice(0, 180)}`);
+    const contentType = String(response.headers.get("content-type") || "").toLowerCase();
+    const parsed = contentType.includes("text/event-stream") ? parseMcpSsePayload(text) : JSON.parse(text || "{}");
+    return { message: parsed, sessionId: response.headers.get("mcp-session-id") || sessionId };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function checkMcpHttpServer(server) {
+  const url = String(server?.raw?.url || server?.url || "").trim();
+  if (!url) throw new Error("Missing MCP URL");
+  const headers = server?.raw?.headers && typeof server.raw.headers === "object" ? server.raw.headers : {};
+  const init = await mcpHttpRequest(url, headers, {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "agentflow", version: "0.1.0" },
+    },
+  });
+  if (init.message?.error) throw new Error(init.message.error.message || "MCP initialize failed");
+  await mcpHttpRequest(url, headers, {
+    jsonrpc: "2.0",
+    method: "notifications/initialized",
+    params: {},
+  }, init.sessionId).catch(() => null);
+  const tools = await mcpHttpRequest(url, headers, {
+    jsonrpc: "2.0",
+    id: 2,
+    method: "tools/list",
+    params: {},
+  }, init.sessionId);
+  if (tools.message?.error) throw new Error(tools.message.error.message || "MCP tools/list failed");
+  return Array.isArray(tools.message?.result?.tools) ? tools.message.result.tools : [];
+}
+
+async function checkMcpStdioServer(server) {
+  const command = String(server?.raw?.command || server?.command || "").trim();
+  if (!command) throw new Error("Missing MCP command");
+  const args = Array.isArray(server?.raw?.args) ? server.raw.args.map(String) : [];
+  const env = server?.raw?.env && typeof server.raw.env === "object" ? server.raw.env : {};
+  const child = spawn(command, args, {
+    cwd: os.homedir(),
+    env: { ...process.env, ...env },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  let buffer = "";
+  let stderr = "";
+  let processError = null;
+  const pending = new Map();
+  let nextId = 1;
+  const cleanup = () => {
+    for (const [, request] of pending) clearTimeout(request.timer);
+    pending.clear();
+    if (!child.killed) child.kill("SIGTERM");
+  };
+  const rejectPending = (error) => {
+    for (const [, request] of pending) {
+      clearTimeout(request.timer);
+      request.reject(error);
+    }
+    pending.clear();
+  };
+  child.on("error", (error) => {
+    processError = error;
+    rejectPending(error);
+  });
+  child.stdin.on("error", (error) => {
+    processError = error;
+    rejectPending(error);
+  });
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr += String(chunk || "");
+    if (stderr.length > 2000) stderr = stderr.slice(-2000);
+  });
+  child.stdout.on("data", (chunk) => {
+    buffer += String(chunk || "");
+    const lines = buffer.split(/\r?\n/g);
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      const text = line.trim();
+      if (!text) continue;
+      let message = null;
+      try {
+        message = JSON.parse(text);
+      } catch {
+        continue;
+      }
+      const request = pending.get(message.id);
+      if (request) {
+        pending.delete(message.id);
+        clearTimeout(request.timer);
+        request.resolve(message);
+      }
+    }
+  });
+  const send = (method, params = {}, timeoutMs = 8000) => new Promise((resolve, reject) => {
+    if (processError) {
+      reject(processError);
+      return;
+    }
+    const id = nextId++;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`${method} timed out${stderr.trim() ? `: ${stderr.trim().slice(-220)}` : ""}`));
+    }, timeoutMs);
+    pending.set(id, { resolve, reject, timer });
+    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n", (error) => {
+      if (!error) return;
+      pending.delete(id);
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+  const notify = (method, params = {}) => {
+    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+  };
+  try {
+    const init = await send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "agentflow", version: "0.1.0" },
+    });
+    if (init?.error) throw new Error(init.error.message || "MCP initialize failed");
+    notify("notifications/initialized", {});
+    const tools = await send("tools/list", {}, 8000);
+    if (tools?.error) throw new Error(tools.error.message || "MCP tools/list failed");
+    return Array.isArray(tools?.result?.tools) ? tools.result.tools : [];
+  } finally {
+    cleanup();
+  }
+}
+
+async function checkMcpServer(server) {
+  const startedAt = Date.now();
+  try {
+    const tools = server?.type === "url" || server?.raw?.url
+      ? await checkMcpHttpServer(server)
+      : await checkMcpStdioServer(server);
+    return {
+      name: server.name,
+      ok: true,
+      status: "enabled",
+      toolCount: tools.length,
+      tools: tools.map((tool) => ({
+        name: String(tool?.name || ""),
+        description: String(tool?.description || ""),
+      })).filter((tool) => tool.name),
+      checkedAt: new Date().toISOString(),
+      elapsedMs: Date.now() - startedAt,
+    };
+  } catch (error) {
+    return {
+      name: server?.name || "",
+      ok: false,
+      status: "error",
+      error: compactErrorMessage(error),
+      toolCount: 0,
+      tools: [],
+      checkedAt: new Date().toISOString(),
+      elapsedMs: Date.now() - startedAt,
+    };
+  }
+}
+
+async function checkCursorMcpServers(name = "", userCtx = {}) {
+  const { servers } = readCursorMcpServers(userCtx);
+  const targetName = String(name || "").trim();
+  const targets = targetName ? servers.filter((server) => server.name === targetName) : servers;
+  if (targetName && targets.length === 0) throw new Error("MCP server not found");
+  const results = [];
+  for (const server of targets) {
+    results.push(await checkMcpServer(server));
+  }
+  return { results };
+}
+
 function readModelListsFromDisk(workspaceRoot) {
   const p = getModelListsAbs();
   const empty = {
@@ -344,6 +827,8 @@ function readModelListsFromDisk(workspaceRoot) {
 }
 
 const SKILLHUB_TIMEOUT_MS = 60_000;
+const SKILLHUB_API_BASE = String(process.env.SKILLHUB_API_BASE || "https://skillhub.bigo.sg/api/v1").replace(/\/+$/, "");
+const skillhubCollectionInfoCache = new Map();
 
 function runSkillhub(args, opts = {}) {
   return new Promise((resolve) => {
@@ -369,6 +854,72 @@ function runSkillhub(args, opts = {}) {
   });
 }
 
+function readSkillhubAuthToken() {
+  try {
+    const p = path.join(os.homedir(), ".skillhub", "auth.json");
+    if (!fs.existsSync(p)) return "";
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    return String(data?.token || data?.accessToken || data?.access_token || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+function normalizeSkillhubCollectionInfo(raw, collectionId) {
+  const data = raw?.data && typeof raw.data === "object"
+    ? raw.data
+    : raw?.collection && typeof raw.collection === "object"
+      ? raw.collection
+      : raw?.item && typeof raw.item === "object"
+        ? raw.item
+        : raw && typeof raw === "object"
+          ? raw
+          : {};
+  const id = String(data.id ?? collectionId ?? "").trim();
+  const name = String(data.name ?? data.displayName ?? data.display_name ?? data.title ?? "").trim();
+  const summary = String(data.description ?? data.summary ?? data.subtitle ?? "").trim();
+  const version = String(data.version ?? data.latestVersion ?? data.latest_version ?? "").trim();
+  const tags = Array.isArray(data.tags) ? data.tags.map(String).filter(Boolean) : [];
+  if (!id && !name) return null;
+  return {
+    id: id || String(collectionId || ""),
+    collection: id || String(collectionId || ""),
+    kind: "collection",
+    slug: "",
+    name: name || `Collection ${collectionId}`,
+    summary: summary || "按 Collection ID 安装该合集中的全部 Skills。",
+    version,
+    tags,
+  };
+}
+
+async function fetchSkillhubCollectionInfo(collectionId) {
+  const id = String(collectionId || "").trim();
+  if (!id) return null;
+  const cached = skillhubCollectionInfoCache.get(id);
+  if (cached) return cached;
+  if (typeof fetch !== "function") return null;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 8000);
+  try {
+    const token = readSkillhubAuthToken();
+    const headers = token ? { Authorization: `Bearer ${token}` } : {};
+    const r = await fetch(`${SKILLHUB_API_BASE}/collections/${encodeURIComponent(id)}`, {
+      headers,
+      signal: controller.signal,
+    });
+    if (!r.ok) return null;
+    const raw = await r.json().catch(() => null);
+    const info = normalizeSkillhubCollectionInfo(raw, id);
+    if (info) skillhubCollectionInfoCache.set(id, info);
+    return info;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 function parseJsonText(text, fallback = null) {
   const s = String(text || "").trim();
   if (!s) return fallback;
@@ -394,11 +945,13 @@ function normalizeSkillhubSearchPayload(raw) {
       const slug = String(x.slug ?? x.name ?? x.displayName ?? x.display_name ?? id ?? "").trim();
       return {
         id: String(id || slug),
+        skillId: String(id || ""),
         slug,
         name: String(x.displayName ?? x.display_name ?? x.name ?? slug),
         summary: String(x.summary ?? x.description ?? ""),
         version: String(x.version ?? x.latestVersion ?? x.latest_version ?? ""),
         tags: Array.isArray(x.tags) ? x.tags.map(String) : [],
+        kind: "skill",
       };
     }).filter((x) => x.slug || x.name),
   };
@@ -602,6 +1155,21 @@ function resolveWorkspaceScopeRoot(workspaceRoot, params = {}, opts = {}) {
   return { root: path.resolve(result.path), flowId, flowSource, archived };
 }
 
+function workspaceSearchGuardrailsBlock() {
+  return [
+    "## 检索约束",
+    "",
+    "默认不要读取、搜索或 Glob 历史运行产物；除非用户明确要求分析历史 run/log，否则必须排除：",
+    "- `**/runBuild/**`",
+    "- `**/logs/**`",
+    "- `.workspace/agentflow/**/runBuild/**`",
+    "- `~/agentflow/runBuild/**`",
+    "- `node_modules/**`、`dist/**` 等依赖或构建产物",
+    "",
+    "使用 grep/rg/find/Glob 等工具时，应把上述路径作为 exclude/glob ignore；不要从历史 runBuild/logs 中推断业务事实、指标资产或 skill 文档。",
+  ].join("\n");
+}
+
 function buildWorkspaceGeneratePrompt(payload) {
   const userPrompt = String(payload?.prompt || "").trim();
   const outputKind = String(payload?.outputKind || payload?.kind || "markdown").trim().toLowerCase();
@@ -652,6 +1220,7 @@ function buildWorkspaceGeneratePrompt(payload) {
     allowFlowYaml
       ? "用户已允许你考虑正式 flow.yaml；如需修改仍必须明确说明影响。"
       : "默认不要修改正式 flow.yaml；优先在 workspace 文件、workspace.graph.json 或回复内容中完成任务。",
+    workspaceSearchGuardrailsBlock(),
     workspaceGraph ? `\n## 当前 workspace graph\n\n${JSON.stringify(workspaceGraph, null, 2)}` : "",
     selectedNodeIds.length > 0 ? `\n## 当前用户选中的 workspace 节点\n\n${selectedNodeIds.map((id) => `- ${id}`).join("\n")}` : "",
     skillsBlock ? `\n## Selected Skills\n\n${skillsBlock}` : "",
@@ -661,6 +1230,47 @@ function buildWorkspaceGeneratePrompt(payload) {
   ].filter(Boolean).join("\n");
 }
 
+function buildWorkspaceNodeChatPrompt(payload) {
+  const node = payload?.node && typeof payload.node === "object" ? payload.node : {};
+  const userMessage = String(payload?.message || "").trim();
+  const currentContent = String(payload?.currentContent || "").trim();
+  const nodeKind = String(payload?.nodeKind || payload?.kind || "markdown").trim().toLowerCase();
+  const history = Array.isArray(payload?.messages) ? payload.messages : [];
+  const historyBlock = history
+    .slice(-8)
+    .map((msg) => {
+      const role = String(msg?.role || "user").trim() === "assistant" ? "assistant" : "user";
+      const text = String(msg?.text || "").trim();
+      return text ? `${role}: ${text}` : "";
+    })
+    .filter(Boolean)
+    .join("\n\n");
+  const outputRule =
+    nodeKind === "html"
+      ? "只输出完整或片段 HTML，不要解释，不要包裹 Markdown 代码围栏。"
+      : nodeKind === "image"
+        ? "只输出新的图片 src，可以是 URL、data URL 或文件路径，不要解释。"
+        : nodeKind === "mermaid"
+          ? "只输出 Mermaid 源码，不要解释，不要包裹 Markdown 代码围栏。"
+          : nodeKind === "ascii"
+            ? "只输出 ASCII 正文，不要解释，不要包裹 Markdown 代码围栏。"
+            : "只输出新的 Markdown 正文，不要解释，不要包裹 Markdown 代码围栏。";
+  return [
+    "你正在微调 AgentFlow Workspace 画布中的单个展示节点。",
+    "根据用户 follow-up 和当前节点内容，生成一个可直接替换当前节点展示内容的候选版本。",
+    outputRule,
+    "",
+    "## 当前节点",
+    `- id: ${String(node.id || "").trim() || "(unknown)"}`,
+    `- label: ${String(node.label || "").trim() || "(unnamed)"}`,
+    `- definitionId: ${String(node.definitionId || "").trim() || "(unknown)"}`,
+    `- kind: ${nodeKind}`,
+    currentContent ? `\n## 当前展示内容\n\n${currentContent}` : "",
+    historyBlock ? `\n## 本节点对话历史\n\n${historyBlock}` : "",
+    `\n## 用户 follow-up\n\n${userMessage}`,
+  ].filter(Boolean).join("\n");
+}
+
 function workspaceSlotValue(slot) {
   if (!slot || typeof slot !== "object") return "";
   for (const key of ["value", "default"]) {
@@ -717,9 +1327,82 @@ function workspaceDisplayKind(definitionId) {
   if (id === "display_ascii") return "ascii";
   if (id === "display_html") return "html";
   if (id === "display_image") return "image";
+  if (id === "display_chart") return "chart";
   return "";
 }
 
+function normalizeHtmlDisplayContent(content) {
+  let text = String(content || "").trim();
+  if (!text) return "";
+  const fenced = text.match(/```(?:html|HTML)?\s*\n?([\s\S]*?)```/);
+  if (fenced && fenced[1]) text = fenced[1].trim();
+  else {
+    const openFence = text.match(/```(?:html|HTML)?\s*\n?([\s\S]*)$/);
+    if (openFence && openFence[1]) text = openFence[1].trim();
+  }
+  text = text.replace(/^html\s*\n/i, "").replace(/```\s*$/g, "").trim();
+  const markerPatterns = [
+    /<!doctype\b/i,
+    /<html\b/i,
+    /<head\b/i,
+    /<body\b/i,
+    /<style\b/i,
+    /<script\b/i,
+    /<main\b/i,
+    /<section\b/i,
+    /<article\b/i,
+    /<div\b/i,
+    /<svg\b/i,
+    /<canvas\b/i,
+  ];
+  const firstHtmlIndex = markerPatterns.reduce((best, pattern) => {
+    const match = pattern.exec(text);
+    if (!match) return best;
+    return best < 0 ? match.index : Math.min(best, match.index);
+  }, -1);
+  if (firstHtmlIndex > 0) text = text.slice(firstHtmlIndex).trim();
+  return text;
+}
+
+function workspaceDownstreamDisplayRequirements(graph, nodeId) {
+  const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
+  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
+  const kinds = new Set();
+  for (const edge of edges) {
+    if (String(edge?.source || "") !== String(nodeId)) continue;
+    const target = instances[String(edge?.target || "")];
+    const kind = workspaceDisplayKind(target?.definitionId);
+    if (kind) kinds.add(kind);
+  }
+  if (kinds.size === 0) return "";
+  const rules = [];
+  if (kinds.has("html")) {
+    rules.push("- 下游连接了 HTML 展示节点：输出可直接放入 iframe 渲染的 HTML。可以是完整 HTML 文档或 HTML fragment；不要使用 Markdown 代码围栏；不要解释生成过程。");
+  }
+  if (kinds.has("markdown")) {
+    rules.push("- 下游连接了 Markdown 展示节点：输出 Markdown 正文；不要包裹在代码围栏中，除非正文确实需要代码块。");
+  }
+  if (kinds.has("mermaid")) {
+    rules.push("- 下游连接了 Mermaid 展示节点：只输出 Mermaid 图表代码，例如 flowchart/sequenceDiagram；不要使用 Markdown 代码围栏；不要附加解释。");
+  }
+  if (kinds.has("ascii")) {
+    rules.push("- 下游连接了 ASCII 展示节点：输出纯文本/ASCII 图或表格；不要输出 HTML 或 Markdown 装饰。");
+  }
+  if (kinds.has("image")) {
+    rules.push("- 下游连接了图片展示节点：输出可作为 img src 使用的图片地址、data URL 或 base64 data URL；不要输出 Markdown 图片语法或解释文字。");
+  }
+  if (kinds.has("chart")) {
+    rules.push('- 下游连接了 Chart 展示节点：只输出 ChartSpec JSON 对象，不要 Markdown 代码围栏，不要解释文字。格式必须包含 `"type":"chart"`、`"version":"1.0"`、`"renderer":"echarts"`、`"option"`；`option.series[].type` 只使用 line/bar/pie/scatter/radar/heatmap/tree/treemap/sunburst/sankey/graph/gauge/funnel；不要输出 HTML、script、iframe 或 JS 函数。');
+  }
+  return [
+    "## 下游输出要求",
+    "",
+    ...rules,
+    "",
+    "如果用户任务与下游展示格式没有冲突，优先满足上述格式要求；如果用户明确指定了其他格式，以用户任务为准。",
+  ].join("\n");
+}
+
 function workspaceRunPlan(graph, runNodeId) {
   const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
   const edges = Array.isArray(graph?.edges) ? graph.edges : [];
@@ -786,6 +1469,37 @@ function workspaceUpstreamText(graph, nodeId, outputs) {
   return workspaceInstanceText(instances[sourceId]);
 }
 
+function workspaceHandleIndex(handle, prefix) {
+  const match = String(handle || "").match(new RegExp(`^${prefix}-(\\d+)$`));
+  return match ? Number(match[1]) : 0;
+}
+
+function workspaceTargetSlotForEdge(graph, edge) {
+  const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
+  const target = instances[String(edge?.target || "")];
+  const input = Array.isArray(target?.input) ? target.input : [];
+  return input[workspaceHandleIndex(edge?.targetHandle, "input")] || null;
+}
+
+function isWorkspaceSemanticInputSlot(slot) {
+  const name = String(slot?.name || "");
+  const type = String(slot?.type || "");
+  return type === "node" || name === "prev" || name === "next" || name === "skillsContext" || name === "mcpContext" || name === "workspaceContext" || name === "gitContext";
+}
+
+function workspaceTaskUpstreamText(graph, nodeId, outputs) {
+  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
+  const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
+  const incoming = edges.filter((edge) => String(edge?.target || "") === String(nodeId));
+  const contentEdges = incoming.filter((edge) => !isWorkspaceSemanticInputSlot(workspaceTargetSlotForEdge(graph, edge)));
+  const contentEdge = contentEdges.find((edge) => String(edge?.targetHandle || "") === "input-1") || contentEdges[0];
+  if (!contentEdge) return "";
+  const sourceId = String(contentEdge.source || "");
+  const out = outputs.get(sourceId);
+  if (out != null && String(out).trim()) return String(out);
+  return workspaceInstanceText(instances[sourceId]);
+}
+
 function parseWorkspaceSkillKeys(raw) {
   const text = String(raw || "").trim();
   if (!text) return [];
@@ -806,19 +1520,119 @@ function selectedSkillKeysFromInstance(instance) {
   return parseWorkspaceSkillKeys(workspaceSlotValue(slot) || "");
 }
 
+function selectedMcpServerNamesFromInstance(instance) {
+  const bodyNames = parseWorkspaceSkillKeys(instance?.body || "");
+  if (bodyNames.length > 0) return bodyNames;
+  const slots = [...(Array.isArray(instance?.input) ? instance.input : []), ...(Array.isArray(instance?.output) ? instance.output : [])];
+  const slot = slots.find((item) => item?.name === "mcpContext") || slots.find((item) => item?.name === "serverNames");
+  return parseWorkspaceSkillKeys(workspaceSlotValue(slot) || "");
+}
+
 function workspaceUpstreamSkillBlocks(graph, nodeId, outputs) {
   const edges = Array.isArray(graph?.edges) ? graph.edges : [];
-  return edges
+  const blocks = edges
     .filter((edge) => String(edge?.target || "") === String(nodeId))
+    .filter((edge) => {
+      const slot = workspaceTargetSlotForEdge(graph, edge);
+      return String(slot?.name || "") === "skillsContext";
+    })
     .map((edge) => String(outputs.get(String(edge.source || "")) || ""))
-    .filter((text) => text.includes("##") || text.includes("Skill"))
-    .join("\n\n---\n\n");
+    .filter((text) => text.includes("Skill") || text.includes("skill"))
+    .flatMap((text) => text.split(/\n\s*---\s*\n/g))
+    .map((text) => text.trim())
+    .filter(Boolean);
+  return Array.from(new Set(blocks)).join("\n\n---\n\n");
+}
+
+function workspaceUpstreamMcpBlocks(graph, nodeId, outputs) {
+  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
+  const blocks = edges
+    .filter((edge) => String(edge?.target || "") === String(nodeId))
+    .filter((edge) => {
+      const slot = workspaceTargetSlotForEdge(graph, edge);
+      return String(slot?.name || "") === "mcpContext";
+    })
+    .map((edge) => String(outputs.get(String(edge.source || "")) || ""))
+    .filter((text) => text.includes("MCP") || text.includes("mcp"))
+    .flatMap((text) => text.split(/\n\s*---\s*\n/g))
+    .map((text) => text.trim())
+    .filter(Boolean);
+  return Array.from(new Set(blocks)).join("\n\n---\n\n");
+}
+
+function mergeWorkspaceSkillBlocks(...values) {
+  const blocks = values
+    .map((value) => String(value || ""))
+    .filter(Boolean)
+    .flatMap((text) => text.split(/\n\s*---\s*\n/g))
+    .map((text) => text.trim())
+    .filter(Boolean);
+  return Array.from(new Set(blocks)).join("\n\n---\n\n");
+}
+
+function buildWorkspaceSkillManifestBlock(skills, selectedKeys = []) {
+  const normalizedKeys = Array.from(new Set((selectedKeys || []).map((x) => String(x || "").trim()).filter(Boolean)));
+  const rows = (Array.isArray(skills) ? skills : []).map((skill) => {
+    const id = String(skill?.id || "").trim();
+    const absPath = String(skill?.absPath || "").trim();
+    if (!id && !absPath) return "";
+    return `- \`${id || path.basename(absPath)}\`${absPath ? `: ${absPath}` : ""}`;
+  }).filter(Boolean);
+  if (!rows.length && !normalizedKeys.length) return "";
+  return [
+    "### Workspace Skills Manifest",
+    "",
+    "这些 skills 已在当前 workspace 中可用。不要默认展开或复述其内容；仅当节点任务明确需要时，按路径 Read 对应 SKILL.md。",
+    "",
+    ...(
+      rows.length
+        ? rows
+        : normalizedKeys.map((key) => `- \`${key}\``)
+    ),
+  ].join("\n");
+}
+
+function buildWorkspaceMcpManifestBlock(results, servers = [], selectedNames = []) {
+  const serverByName = new Map((Array.isArray(servers) ? servers : []).map((server) => [String(server?.name || ""), server]));
+  const normalizedNames = Array.from(new Set((selectedNames || []).map((x) => String(x || "").trim()).filter(Boolean)));
+  const targets = (Array.isArray(results) ? results : []).filter((item) => !normalizedNames.length || normalizedNames.includes(String(item?.name || "")));
+  const rows = [];
+  for (const result of targets) {
+    const name = String(result?.name || "").trim();
+    if (!name) continue;
+    const server = serverByName.get(name) || {};
+    const description = String(server?.description || "").trim();
+    if (!result?.ok) {
+      rows.push(`- MCP server \`${name}\`: unavailable${result?.error ? ` (${String(result.error)})` : ""}`);
+      continue;
+    }
+    rows.push(`- MCP server \`${name}\`${description ? `: ${description}` : ""}`);
+    const tools = Array.isArray(result?.tools) ? result.tools : [];
+    if (!tools.length) {
+      rows.push("  - no tools reported");
+      continue;
+    }
+    for (const tool of tools.slice(0, 80)) {
+      const toolName = String(tool?.name || "").trim();
+      if (!toolName) continue;
+      const toolDescription = String(tool?.description || "").trim();
+      rows.push(`  - tool \`${toolName}\`${toolDescription ? `: ${toolDescription}` : ""}`);
+    }
+  }
+  if (!rows.length && !normalizedNames.length) return "";
+  return [
+    "### Workspace MCP Manifest",
+    "",
+    "这些 MCP servers/tools 已在当前 Agent 运行器中可用。需要外部工具能力时，优先使用下列 MCP 工具；不要声称调用了工具，除非实际工具调用成功。",
+    "",
+    ...(rows.length ? rows : normalizedNames.map((name) => `- MCP server \`${name}\``)),
+  ].join("\n");
 }
 
 function workspaceWriteDisplayContent(instance, content) {
   const next = { ...(instance || {}) };
-  const text = String(content || "");
   const kind = workspaceDisplayKind(next.definitionId);
+  const text = kind === "html" ? normalizeHtmlDisplayContent(content) : String(content || "");
   const primaryName = kind === "image" ? "src" : "content";
   next.body = text;
   next.input = (Array.isArray(next.input) ? next.input : []).map((slot) => (
@@ -849,15 +1663,19 @@ function workspaceUpdateDirectDisplays(graph, sourceId, content) {
   return updated;
 }
 
-function workspaceNodePrompt(graph, nodeId, upstreamText, skillsBlock) {
+function workspaceNodePrompt(graph, nodeId, upstreamText, skillsBlock, mcpBlock = "") {
   const instance = graph.instances[nodeId] || {};
   const body = String(instance.body || "").trim();
   const label = String(instance.label || nodeId).trim();
+  const downstreamRequirements = workspaceDownstreamDisplayRequirements(graph, nodeId);
   return [
     "你正在执行 AgentFlow Workspace 画布中的一个临时节点。",
     "只输出该节点要传给下游展示/后续节点的正文，不要解释运行过程。",
-    skillsBlock ? `\n## Selected Skills\n\n${skillsBlock}` : "",
+    workspaceSearchGuardrailsBlock(),
+    skillsBlock ? `\n## Available Skills\n\n${skillsBlock}` : "",
+    mcpBlock ? `\n## Available MCP\n\n${mcpBlock}` : "",
     upstreamText ? `\n## 上游上下文\n\n${upstreamText}` : "",
+    downstreamRequirements ? `\n${downstreamRequirements}` : "",
     `\n## 当前节点\n\n- id: ${nodeId}\n- label: ${label}\n- definitionId: ${instance.definitionId || ""}`,
     `\n## 节点任务\n\n${body || upstreamText}`,
   ].filter(Boolean).join("\n");
@@ -867,6 +1685,14 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
   const graph = normalizeWorkspaceGraphPayload(payload.graph || {});
   const runNodeId = String(payload?.runNodeId || "").trim();
   const { order, pauseNodeIds } = workspaceRunPlan(graph, runNodeId);
+  const signal = opts.signal || null;
+  const throwIfAborted = () => {
+    if (signal?.aborted) {
+      const err = new Error("Workspace run stopped");
+      err.code = "WORKSPACE_RUN_ABORTED";
+      throw err;
+    }
+  };
   const fallbackSelectedSkillKeys = Array.isArray(payload?.selectedSkills)
     ? payload.selectedSkills.map((x) => String(x || "").trim()).filter(Boolean)
     : [];
@@ -879,21 +1705,42 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       ? loadResourcesForSkillKeys(normalized, PACKAGE_ROOT, scopedRoot)
       : { skills: [], references: [] };
     const block = normalized.length > 0
-      ? buildSkillCompactInjectionBlock(selectedSkillResources.skills, selectedSkillResources.references)
+      ? buildWorkspaceSkillManifestBlock(selectedSkillResources.skills, normalized)
       : "";
     skillsBlockCache.set(cacheKey, block);
     return block;
   };
+  const mcpBlockCache = new Map();
+  const loadMcpBlockForNames = async (names) => {
+    const normalized = Array.from(new Set((names || []).map((x) => String(x || "").trim()).filter(Boolean)));
+    if (!normalized.length) return "";
+    const cacheKey = normalized.join("\n");
+    if (mcpBlockCache.has(cacheKey)) return mcpBlockCache.get(cacheKey);
+    const { servers } = readCursorMcpServers(userCtx);
+    const results = [];
+    for (const name of normalized) {
+      const checked = await checkCursorMcpServers(name, userCtx);
+      results.push(...(Array.isArray(checked.results) ? checked.results : []));
+    }
+    const block = buildWorkspaceMcpManifestBlock(results, servers, normalized);
+    mcpBlockCache.set(cacheKey, block);
+    return block;
+  };
   const outputs = new Map();
   const events = [];
   const emit = (event) => {
     events.push(event);
     if (typeof opts.onEvent === "function") opts.onEvent(event);
   };
+  const emitTiming = (nodeId, label, startedAt, extra = {}) => {
+    const elapsedMs = Math.max(0, Date.now() - startedAt);
+    emit({ type: "status", nodeId, line: `Timing ${label}: ${elapsedMs}ms`, timing: { label, elapsedMs, ...extra } });
+  };
   let cwd = scopedRoot;
   const modelKey = typeof payload?.model === "string" ? payload.model.trim() : "";
 
   for (const nodeId of order) {
+    throwIfAborted();
     const instance = graph.instances[nodeId];
     if (!instance) continue;
     const defId = String(instance.definitionId || "");
@@ -904,9 +1751,11 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     }
 
     if (defId === "control_load_skills") {
+      const skillStartedAt = Date.now();
       const nodeSkillKeys = selectedSkillKeysFromInstance(instance);
       const activeSkillKeys = nodeSkillKeys.length > 0 ? nodeSkillKeys : fallbackSelectedSkillKeys;
       const skillsBlock = loadSkillsBlockForKeys(activeSkillKeys);
+      emitTiming(nodeId, "load-skills", skillStartedAt, { skillCount: activeSkillKeys.length, charCount: skillsBlock.length });
       graph.instances[nodeId] = {
         ...instance,
         output: (Array.isArray(instance.output) ? instance.output : []).map((slot) => (
@@ -922,6 +1771,26 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       continue;
     }
 
+    if (defId === "control_load_mcp") {
+      const mcpStartedAt = Date.now();
+      const serverNames = selectedMcpServerNamesFromInstance(instance);
+      const mcpBlock = await loadMcpBlockForNames(serverNames);
+      emitTiming(nodeId, "load-mcp", mcpStartedAt, { serverCount: serverNames.length, charCount: mcpBlock.length });
+      graph.instances[nodeId] = {
+        ...instance,
+        output: (Array.isArray(instance.output) ? instance.output : []).map((slot) => (
+          String(slot?.name || "") === "mcpContext" || String(slot?.type || "") === "text"
+            ? { ...slot, default: mcpBlock, value: mcpBlock }
+            : slot
+        )),
+      };
+      outputs.set(nodeId, mcpBlock);
+      workspaceUpdateDirectDisplays(graph, nodeId, mcpBlock);
+      emit({ type: "graph", nodeId, graph });
+      emit({ type: "node-done", nodeId, definitionId: defId });
+      continue;
+    }
+
     if (workspaceDisplayKind(defId)) {
       const content = workspaceUpstreamText(graph, nodeId, outputs);
       graph.instances[nodeId] = workspaceWriteDisplayContent(instance, content);
@@ -1057,7 +1926,10 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       const rawWorktreePath = workspaceSlotValue(workspaceSlotByName(instance, "worktreePath")).trim();
       const worktreePath = rawWorktreePath ? workspaceResolvePath(cwd, rawWorktreePath) : (gitContext?.worktreePath ? path.resolve(gitContext.worktreePath) : "");
       const previousCwd = cwd;
-      const result = loadGitWorktree({ repoPath, branch, worktreePath, pipelineWorkspace: scopedRoot });
+      const force = ["true", "1", "yes", "on"].includes(workspaceSlotValue(workspaceSlotByName(instance, "force")).trim().toLowerCase());
+      const pruneMissingRaw = workspaceSlotValue(workspaceSlotByName(instance, "pruneMissing")).trim().toLowerCase();
+      const pruneMissing = pruneMissingRaw !== "false";
+      const result = loadGitWorktree({ repoPath, branch, worktreePath, pipelineWorkspace: scopedRoot, force, pruneMissing });
       const outGitContext = buildGitContext({
         repoPath: result.repoRoot,
         worktreePath: result.worktreePath,
@@ -1154,18 +2026,25 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       continue;
     }
 
-    const upstreamText = workspaceUpstreamText(graph, nodeId, outputs);
+    const prepareStartedAt = Date.now();
+    const upstreamText = workspaceTaskUpstreamText(graph, nodeId, outputs);
     const body = String(instance.body || "").trim();
     if (defId === "agent_subAgent" && !body && !String(upstreamText || "").trim()) {
       throw new Error(`Workspace node ${nodeId} has no task. Fill the node body or connect upstream text.`);
     }
     const upstreamSkillBlocks = workspaceUpstreamSkillBlocks(graph, nodeId, outputs);
-    const prompt = workspaceNodePrompt(graph, nodeId, upstreamText, upstreamSkillBlocks || loadSkillsBlockForKeys(fallbackSelectedSkillKeys));
+    const promptSkillsBlock = mergeWorkspaceSkillBlocks(upstreamSkillBlocks, upstreamSkillBlocks ? "" : loadSkillsBlockForKeys(fallbackSelectedSkillKeys));
+    const promptMcpBlock = workspaceUpstreamMcpBlocks(graph, nodeId, outputs);
+    const prompt = workspaceNodePrompt(graph, nodeId, upstreamText, promptSkillsBlock, promptMcpBlock);
+    emitTiming(nodeId, "prepare-agent-prompt", prepareStartedAt, { promptChars: prompt.length, upstreamChars: String(upstreamText || "").length, skillsChars: promptSkillsBlock.length, mcpChars: promptMcpBlock.length });
+    emit({ type: "natural", kind: "prompt", nodeId, text: prompt });
     let content = "";
     const maxAttempts = 3;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       let attemptContent = "";
       try {
+        const spawnStartedAt = Date.now();
+        let firstAgentEventSeen = false;
         const handle = startComposerAgent({
           uiWorkspaceRoot: scopedRoot,
           cliWorkspace: cwd,
@@ -1173,21 +2052,36 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
           modelKey,
           agentflowUserId: userCtx.userId || "",
           onStreamEvent: (ev) => {
+            if (!firstAgentEventSeen) {
+              firstAgentEventSeen = true;
+              emitTiming(nodeId, "agent-first-event", spawnStartedAt, { attempt, firstType: ev?.type || "" });
+            }
             emit({ ...ev, nodeId });
             if (ev?.type === "natural" && ev.kind === "assistant" && typeof ev.text === "string") {
               attemptContent += (attemptContent ? "\n" : "") + ev.text;
-              const updatedDisplays = workspaceUpdateDirectDisplays(graph, nodeId, attemptContent);
-              if (updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
             }
           },
+          onToolCall: (subtype, toolName) => {
+            const sub = subtype ? String(subtype) : "";
+            const tool = toolName ? String(toolName) : "";
+            emit({ type: "status", nodeId, line: `工具 ${tool || "thinking"}${sub ? ` (${sub})` : ""}` });
+          },
         });
-        await handle.finished;
+        if (typeof opts.onActiveChild === "function") opts.onActiveChild(handle.child || null);
+        emitTiming(nodeId, "spawn-agent", spawnStartedAt, { attempt });
+        try {
+          await handle.finished;
+        } finally {
+          if (typeof opts.onActiveChild === "function") opts.onActiveChild(null);
+        }
+        throwIfAborted();
         content = attemptContent.trim();
         break;
       } catch (e) {
+        if (signal?.aborted || e?.code === "WORKSPACE_RUN_ABORTED") throwIfAborted();
         if (attempt < maxAttempts && isTransientAgentNetworkError(e)) {
           emit({ type: "status", nodeId, line: `Workspace node retry ${attempt + 1}/${maxAttempts} after network error` });
-          await sleepMs(Math.min(1500 * attempt, 5000));
+          await sleepMs(Math.min(1500 * attempt, 5000), signal);
           continue;
         }
         throw e;
@@ -1205,6 +2099,10 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
   return { graph, events, order, pauseNodeIds };
 }
 
+function isWorkspaceRunAbortError(err) {
+  return err?.code === "WORKSPACE_RUN_ABORTED" || /Workspace run stopped/i.test(String(err?.message || ""));
+}
+
 function isTransientAgentNetworkError(err) {
   const text = [
     err?.message,
@@ -1221,8 +2119,17 @@ function isTransientAgentNetworkError(err) {
     /socket hang up/i.test(text);
 }
 
-function sleepMs(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function sleepMs(ms, signal = null) {
+  if (signal?.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearTimeout(timer);
+        resolve();
+      }, { once: true });
+    }
+  });
 }
 
 /** ZIP 本地头：PK\x03\x04 / \x05\x06 / \x07\x08 */
@@ -1327,6 +2234,12 @@ function broadcastFlowEditorSync(flowId, flowSource, flowArchived = false, userI
 
 /** 正在执行的 flow run（flowId → { child, runUuid }）；同一 flow 只允许一个 run */
 const activeFlowRuns = new Map();
+/** 正在执行的 Workspace 临时 run（flowId → { controller, child }）；同一 flow 只允许一个 run */
+const activeWorkspaceRuns = new Map();
+
+function workspaceRunKey(userCtx, flowSource, flowId) {
+  return `${userCtx?.userId || ""}:${flowSource || "user"}:${flowId}`;
+}
 
 /** Cursor/OpenCode 执行目录统一使用当前 UI 启动 workspace。 */
 function composerCliWorkspaceForFlowDir(workspaceRoot, _flowDir) {
@@ -1461,7 +2374,16 @@ export function startUiServer({
 
     if (url.pathname === "/api/auth/me" && req.method === "GET") {
       const user = getAuthUserFromRequest(req);
-      json(res, 200, { authenticated: Boolean(user), user: user || null, setupRequired: authSetupRequired() });
+      const allowed = user ? isAuthUserAllowed(user) : true;
+      const allowlist = readUserAllowlist();
+      json(res, 200, {
+        authenticated: Boolean(user && allowed),
+        user: user && allowed ? user : null,
+        setupRequired: authSetupRequired(),
+        allowlistEnabled: allowlist.enabled,
+        forbidden: Boolean(user && !allowed),
+        error: user && !allowed ? "用户不在白名单中，请联系管理员开通访问权限" : "",
+      });
       return;
     }
 
@@ -1475,7 +2397,7 @@ export function startUiServer({
       }
       const result = loginOrCreateUser(payload?.username, payload?.password);
       if (!result.ok) {
-        json(res, 401, { error: result.error || "Login failed", setupRequired: authSetupRequired() });
+        json(res, result.forbidden ? 403 : 401, { error: result.error || "Login failed", setupRequired: authSetupRequired() });
         return;
       }
       const body = JSON.stringify({ authenticated: true, user: result.user, setupRequired: false, migration: result.migration || null });
@@ -1506,6 +2428,10 @@ export function startUiServer({
       json(res, 401, { error: "Authentication required", setupRequired: authSetupRequired() });
       return;
     }
+    if (url.pathname.startsWith("/api/") && authUser && !isAuthUserAllowed(authUser)) {
+      json(res, 403, { error: "用户不在白名单中，请联系管理员开通访问权限" });
+      return;
+    }
 
     if (url.pathname === "/api/flows") {
       if (req.method === "GET") {
@@ -1841,6 +2767,34 @@ export function startUiServer({
           return;
         }
         const wantsStream = /\bapplication\/x-ndjson\b/i.test(req.headers.accept || "") || payload.stream === true;
+        const flowId = String(payload.flowId || "").trim();
+        if (!flowId) {
+          json(res, 400, { error: "Missing flowId" });
+          return;
+        }
+        const runKey = workspaceRunKey(userCtx, scoped.flowSource || payload.flowSource || "user", flowId);
+        if (activeWorkspaceRuns.has(runKey)) {
+          json(res, 409, { error: "该 Workspace 正在运行" });
+          return;
+        }
+        const controller = new AbortController();
+        const runEntry = {
+          controller,
+          child: null,
+          stopChild() {
+            if (this.child && !this.child.killed) {
+              try { this.child.kill("SIGTERM"); } catch (_) {}
+            }
+          },
+        };
+        activeWorkspaceRuns.set(runKey, runEntry);
+        const setActiveChild = (child) => {
+          runEntry.child = child || null;
+          if (controller.signal.aborted) runEntry.stopChild();
+        };
+        const clearActiveRun = () => {
+          if (activeWorkspaceRuns.get(runKey) === runEntry) activeWorkspaceRuns.delete(runKey);
+        };
         if (wantsStream) {
           const graphPath = workspaceGraphPath(scoped.root);
           res.writeHead(200, {
@@ -1849,29 +2803,77 @@ export function startUiServer({
             "X-Accel-Buffering": "no",
           });
           const writeEvent = (event) => {
-            res.write(JSON.stringify(event) + "\n");
+            try { res.write(JSON.stringify(event) + "\n"); } catch (_) {}
           };
           try {
-            const result = await runWorkspaceGraph(root, scoped.root, payload, userCtx, { onEvent: writeEvent });
+            const result = await runWorkspaceGraph(root, scoped.root, payload, userCtx, {
+              onEvent: writeEvent,
+              signal: controller.signal,
+              onActiveChild: setActiveChild,
+            });
             fs.writeFileSync(graphPath, JSON.stringify(result.graph, null, 2) + "\n", "utf-8");
             writeEvent({ type: "done", ok: true, path: graphPath, graph: result.graph, order: result.order, pauseNodeIds: result.pauseNodeIds || [] });
             res.end();
           } catch (e) {
-            writeEvent({ type: "error", error: (e && e.message) || String(e) });
+            if (isWorkspaceRunAbortError(e) || controller.signal.aborted) {
+              writeEvent({ type: "stopped", ok: false, stopped: true, message: "Workspace run stopped" });
+            } else {
+              writeEvent({ type: "error", error: (e && e.message) || String(e) });
+            }
             res.end();
+          } finally {
+            clearActiveRun();
           }
           return;
         }
-        const result = await runWorkspaceGraph(root, scoped.root, payload, userCtx);
-        const graphPath = workspaceGraphPath(scoped.root);
-        fs.writeFileSync(graphPath, JSON.stringify(result.graph, null, 2) + "\n", "utf-8");
-        json(res, 200, { ok: true, path: graphPath, ...result });
+        try {
+          const result = await runWorkspaceGraph(root, scoped.root, payload, userCtx, {
+            signal: controller.signal,
+            onActiveChild: setActiveChild,
+          });
+          const graphPath = workspaceGraphPath(scoped.root);
+          fs.writeFileSync(graphPath, JSON.stringify(result.graph, null, 2) + "\n", "utf-8");
+          json(res, 200, { ok: true, path: graphPath, ...result });
+        } catch (e) {
+          if (isWorkspaceRunAbortError(e) || controller.signal.aborted) {
+            json(res, 200, { ok: false, stopped: true, message: "Workspace run stopped" });
+          } else {
+            throw e;
+          }
+        } finally {
+          clearActiveRun();
+        }
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/run/stop") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const flowId = typeof payload.flowId === "string" ? payload.flowId.trim() : "";
+      if (!flowId) {
+        json(res, 400, { error: "Missing flowId" });
+        return;
+      }
+      const runKey = workspaceRunKey(userCtx, payload.flowSource || "user", flowId);
+      const entry = activeWorkspaceRuns.get(runKey);
+      if (!entry) {
+        json(res, 404, { error: "该 Workspace 未在运行" });
+        return;
+      }
+      try { entry.controller?.abort(); } catch (_) {}
+      try { entry.stopChild?.(); } catch (_) {}
+      json(res, 200, { ok: true, stopped: true });
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/workspace/file") {
       try {
         const scoped = resolveWorkspaceScopeRoot(root, {
@@ -2091,6 +3093,61 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/node-chat") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const message = String(payload?.message || "").trim();
+      if (!message) {
+        json(res, 400, { error: "Missing message" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        const promptText = buildWorkspaceNodeChatPrompt(payload);
+        const modelKey = typeof payload?.model === "string" ? payload.model.trim() : "";
+        let content = "";
+        const events = [];
+        const handle = startComposerAgent({
+          uiWorkspaceRoot: scoped.root,
+          cliWorkspace: scoped.root,
+          prompt: promptText,
+          modelKey,
+          agentflowUserId: userCtx.userId || "",
+          onStreamEvent: (ev) => {
+            events.push(ev);
+            if (ev?.type === "natural" && ev.kind === "assistant" && typeof ev.text === "string") {
+              content += (content ? "\n" : "") + ev.text;
+            }
+          },
+        });
+        await handle.finished;
+        const candidateContent = content.trim();
+        json(res, 200, {
+          ok: true,
+          sessionId: String(payload?.sessionId || "") || `nodechat_${Date.now()}`,
+          reply: candidateContent,
+          candidateContent,
+          events,
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/pipeline-files") {
       const flowId = url.searchParams.get("flowId");
       const flowSource = url.searchParams.get("flowSource") || "user";
@@ -2307,6 +3364,64 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/mcps") {
+      try {
+        json(res, 200, readCursorMcpServers(userCtx));
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/mcps") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        json(res, 200, writeCursorMcpServer(payload, userCtx));
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/mcps/delete") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        json(res, 200, deleteCursorMcpServer(payload?.name, userCtx));
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/mcps/check") {
+      let payload;
+      try {
+        const raw = await readBody(req);
+        payload = raw && String(raw).trim() ? JSON.parse(raw) : {};
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        json(res, 200, await checkCursorMcpServers(payload?.name || "", userCtx));
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/user-env") {
       try {
         json(res, 200, { env: readUserEnvRows(userCtx.userId) });
@@ -2384,16 +3499,41 @@ export function startUiServer({
 
     if (req.method === "GET" && url.pathname === "/api/skillhub/search") {
       const q = (url.searchParams.get("q") || "").trim();
+      const mode = (url.searchParams.get("mode") || "keyword").trim();
       if (!q) {
         json(res, 200, { total: 0, items: [] });
         return;
       }
+      if (mode === "collectionId") {
+        const info = await fetchSkillhubCollectionInfo(q);
+        json(res, 200, {
+          total: 1,
+          mode,
+          items: [info || {
+            id: `collection:${q}`,
+            collection: q,
+            kind: "collection",
+            slug: "",
+            name: `Collection ${q}`,
+            summary: "按 Collection ID 安装该合集中的全部 Skills。",
+            version: "",
+            tags: [],
+          }],
+        });
+        return;
+      }
       const result = await runSkillhub(["search", "-q", q], { cwd: root });
       if (!result.ok) {
         json(res, 500, { error: result.error, stdout: result.stdout });
         return;
       }
-      json(res, 200, normalizeSkillhubSearchPayload(parseJsonText(result.stdout, {})));
+      const payload = normalizeSkillhubSearchPayload(parseJsonText(result.stdout, {}));
+      if (mode === "skillId") {
+        const filtered = payload.items.filter((item) => item.skillId === q || item.id === q);
+        json(res, 200, { ...payload, mode, total: filtered.length, items: filtered });
+        return;
+      }
+      json(res, 200, { ...payload, mode });
       return;
     }
 
@@ -2410,12 +3550,19 @@ export function startUiServer({
         json(res, 400, { error: "Missing skill slug or collection" });
         return;
       }
+      const beforeSkills = payload?.collection ? listComposerSkills(PACKAGE_ROOT, root) : [];
       const result = await runSkillhub(args, { cwd: root, timeoutMs: 180_000, maxBuffer: 4 * 1024 * 1024 });
       if (!result.ok) {
         json(res, 500, { error: result.error, stdout: result.stdout });
         return;
       }
-      json(res, 200, { ok: true, stdout: result.stdout });
+      let skillCollections = null;
+      if (payload?.collection) {
+        const afterSkills = listComposerSkills(PACKAGE_ROOT, root);
+        const collectionName = String(payload.collectionName || payload.name || "").trim();
+        skillCollections = upsertSkillhubCollectionGroup(userCtx, payload.collection, beforeSkills, afterSkills, collectionName);
+      }
+      json(res, 200, { ok: true, stdout: result.stdout, skillCollections });
       return;
     }
 
@@ -2437,7 +3584,8 @@ export function startUiServer({
         json(res, 500, { error: result.error, stdout: result.stdout });
         return;
       }
-      json(res, 200, { ok: true, stdout: result.stdout });
+      const skillCollections = payload?.collection ? removeSkillhubCollectionGroup(userCtx, payload.collection, root) : null;
+      json(res, 200, { ok: true, stdout: result.stdout, skillCollections });
       return;
     }