postar-pipe-mcp 0.0.2 → 1.0.1

package/dist/server.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { ZodOptional as ZodOptional$2, z } from "zod";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import require$$0, { existsSync, readdirSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import require$$0$1, { resolve as resolve$3, dirname, join } from "path";
 import require$$0$2 from "child_process";
-import require$$0$1, { dirname, resolve as resolve$3 } from "path";
-import require$$0, { existsSync, readdirSync, readFileSync } from "fs";
 import process$1 from "node:process";
 import { PassThrough } from "node:stream";
 import { fileURLToPath } from "url";
@@ -21101,12 +21102,14 @@ async function getProxiedTools() {
     try {
       const tools = await manager2.listTools(mainJenkins);
       for (const tool of tools.tools || []) {
+        const proxiedToolName = `${prefix}${tool.name}`;
         const proxiedTool = {
           ...tool,
-          name: `${prefix}${tool.name}`,
+          name: proxiedToolName,
           description: `[${mainJenkins}] ${tool.description || ""}`
         };
         allTools.push(proxiedTool);
+        toolSchemaCache.set(proxiedToolName, tool.inputSchema);
       }
       console.error(`[MCP-PIPE] 已代理 ${mainJenkins} 的 ${tools.tools?.length || 0} 个工具`);
     } catch (error2) {
@@ -21119,12 +21122,14 @@ async function getProxiedTools() {
     const jenkinsTools = allTools.filter((t) => t.name.startsWith(sourcePrefix));
     for (const tool of jenkinsTools) {
       const originalToolName = tool.name.slice(sourcePrefix.length);
+      const proxiedToolName = `${prefix}${originalToolName}`;
       const proxiedTool = {
         ...tool,
-        name: `${prefix}${originalToolName}`,
+        name: proxiedToolName,
         description: `[${serverName}] ${tool.description || ""}`
       };
       allTools.push(proxiedTool);
+      toolSchemaCache.set(proxiedToolName, tool.inputSchema);
     }
     console.error(`[MCP-PIPE] 已为 ${serverName} 生成 ${jenkinsTools.length} 个工具别名`);
   }
@@ -21133,12 +21138,14 @@ async function getProxiedTools() {
     try {
       const tools = await manager2.listTools(serverName);
       for (const tool of tools.tools || []) {
+        const proxiedToolName = `${prefix}${tool.name}`;
         const proxiedTool = {
           ...tool,
-          name: `${prefix}${tool.name}`,
+          name: proxiedToolName,
           description: `[${serverName}] ${tool.description || ""}`
         };
         allTools.push(proxiedTool);
+        toolSchemaCache.set(proxiedToolName, tool.inputSchema);
       }
       console.error(`[MCP-PIPE] 已代理 ${serverName} 的 ${tools.tools?.length || 0} 个工具`);
     } catch (error2) {
@@ -21147,9 +21154,40 @@ async function getProxiedTools() {
   }
   return allTools;
 }
+function fixArgumentTypes(args, toolSchema) {
+  if (!args || typeof args !== "object") return args;
+  const fixedArgs = { ...args };
+  if (!toolSchema?.properties) {
+    console.warn(`[MCP-PIPE] 警告: 工具缺少 schema,跳过类型修复`);
+    return fixedArgs;
+  }
+  for (const [key, schema] of Object.entries(toolSchema.properties)) {
+    if (key in fixedArgs && typeof fixedArgs[key] === "string") {
+      const propSchema = schema;
+      if (propSchema.type === "number" || propSchema.type === "integer") {
+        const num = Number(fixedArgs[key]);
+        if (!isNaN(num)) {
+          fixedArgs[key] = num;
+          console.debug(`[MCP-PIPE] 类型转换: ${key} "${fixedArgs[key]}" → ${num} (number)`);
+        }
+      }
+      if (propSchema.type === "boolean") {
+        const str = fixedArgs[key].toLowerCase();
+        if (str === "true" || str === "false") {
+          fixedArgs[key] = str === "true";
+          console.debug(`[MCP-PIPE] 类型转换: ${key} "${str}" → ${fixedArgs[key]} (boolean)`);
+        }
+      }
+    }
+  }
+  return fixedArgs;
+}
+const toolSchemaCache = /* @__PURE__ */ new Map();
 async function handleProxiedTool(name, args) {
   const manager2 = getMCPClientManager();
   const servers = getRegisteredServers();
+  const toolSchema = toolSchemaCache.get(name);
+  const fixedArgs = fixArgumentTypes(args, toolSchema);
   if (name.startsWith("mcp_jenkins_")) {
     let targetMCP = null;
     const otherJenkinsServers = servers.filter((s) => s.startsWith("jenkins-"));
@@ -21167,7 +21205,7 @@ async function handleProxiedTool(name, args) {
       const prefix = getToolPrefix(targetMCP);
       const originalToolName = name.slice(prefix.length);
       try {
-        const result = await manager2.callTool(targetMCP, originalToolName, args);
+        const result = await manager2.callTool(targetMCP, originalToolName, fixedArgs);
         return result;
       } catch (error2) {
         return {
@@ -21182,7 +21220,7 @@ async function handleProxiedTool(name, args) {
     if (name.startsWith(prefix)) {
       const originalToolName = name.slice(prefix.length);
       try {
-        const result = await manager2.callTool(serverName, originalToolName, args);
+        const result = await manager2.callTool(serverName, originalToolName, fixedArgs);
         return result;
       } catch (error2) {
         return {
@@ -21197,15 +21235,88 @@ async function handleProxiedTool(name, args) {
 const skillCache = /* @__PURE__ */ new Map();
 const skillMetadataCache = /* @__PURE__ */ new Map();
 let remoteSkillsList = null;
+function parseSkillSource(url, index) {
+  const questionMarkIndex = url.indexOf("?");
+  let cleanUrl = url;
+  let skillsList;
+  if (questionMarkIndex !== -1) {
+    cleanUrl = url.substring(0, questionMarkIndex);
+    const queryString = url.substring(questionMarkIndex + 1);
+    const params = new URLSearchParams(queryString);
+    const skillsParam = params.get("skills");
+    if (skillsParam) {
+      skillsList = skillsParam.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    }
+  }
+  const rawUrl = cleanUrl.replace("/tree/", "/raw/").replace(/\/$/, "");
+  const match = cleanUrl.match(/\/([^\/]+)\/[^\/]+\/tree\//);
+  const name = match ? match[1] : `source-${index}`;
+  return {
+    name,
+    baseUrl: rawUrl,
+    originalUrl: cleanUrl,
+    skillsList
+  };
+}
+function parseCommandLineArgs() {
+  const result = {};
+  const skillUrls = [];
+  for (let i = 0; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === "--skill-url" && i + 1 < process.argv.length) {
+      skillUrls.push(process.argv[i + 1]);
+    } else if (arg.startsWith("--skill-url=")) {
+      skillUrls.push(arg.split("=")[1]);
+    }
+    if (arg.startsWith("--skills-urls=")) {
+      result.skillsUrls = arg.split("=")[1];
+    } else if (arg === "--skills-urls" && i + 1 < process.argv.length) {
+      result.skillsUrls = process.argv[i + 1];
+    }
+    if (arg.startsWith("--skills-url=")) {
+      result.skillsUrl = arg.split("=")[1];
+    } else if (arg === "--skills-url" && i + 1 < process.argv.length) {
+      result.skillsUrl = process.argv[i + 1];
+    }
+  }
+  if (skillUrls.length > 0) {
+    result.skillUrls = skillUrls;
+  }
+  return result;
+}
 function getSkillsConfig() {
-  const skillsUrl = process.env.SKILLS_URL;
+  const cliArgs = parseCommandLineArgs();
+  if (cliArgs.skillUrls && cliArgs.skillUrls.length > 0) {
+    const sources = cliArgs.skillUrls.map((url, index) => parseSkillSource(url.trim(), index)).filter((source) => source.originalUrl.length > 0);
+    if (sources.length > 0) {
+      return {
+        source: "remote",
+        sources,
+        baseUrl: sources[0].baseUrl,
+        originalUrl: sources[0].originalUrl
+      };
+    }
+  }
+  const skillsUrls = cliArgs.skillsUrls || process.env.SKILLS_URLS;
+  if (skillsUrls) {
+    const sources = skillsUrls.split(",").map((url, index) => parseSkillSource(url.trim(), index)).filter((source) => source.originalUrl.length > 0);
+    if (sources.length > 0) {
+      return {
+        source: "remote",
+        sources,
+        baseUrl: sources[0].baseUrl,
+        originalUrl: sources[0].originalUrl
+      };
+    }
+  }
+  const skillsUrl = cliArgs.skillsUrl || process.env.SKILLS_URL;
   if (skillsUrl) {
-    const rawUrl = skillsUrl.replace("/tree/", "/raw/").replace(/\/$/, "");
+    const source = parseSkillSource(skillsUrl, 0);
     return {
       source: "remote",
-      baseUrl: rawUrl,
-      originalUrl: skillsUrl
-      // 保留原始 URL 用于解析
+      sources: [source],
+      baseUrl: source.baseUrl,
+      originalUrl: source.originalUrl
     };
   }
   return {
@@ -21283,21 +21394,69 @@ async function fetchRemoteSkillsFromDirectory(config2) {
     return [];
   }
 }
+const skillSourceMap = /* @__PURE__ */ new Map();
+const CACHE_TTL_MINUTES = process.env.SKILLS_CACHE_TTL ? parseInt(process.env.SKILLS_CACHE_TTL) : 30;
+const CACHE_TTL = CACHE_TTL_MINUTES * 60 * 1e3;
+function isCacheExpired(timestamp) {
+  return Date.now() - timestamp > CACHE_TTL;
+}
 async function fetchRemoteSkillsList(config2) {
-  if (remoteSkillsList) {
-    return remoteSkillsList;
+  if (remoteSkillsList && !isCacheExpired(remoteSkillsList.timestamp)) {
+    return remoteSkillsList.data;
   }
+  console.error(`[SKILL-LOADER] Skills 列表缓存过期或不存在,重新加载...`);
   const skillsListEnv = process.env.SKILLS_LIST;
   if (skillsListEnv) {
-    const skills2 = skillsListEnv.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-    remoteSkillsList = skills2;
-    console.error(`[SKILL-LOADER] 从环境变量加载 skills: ${skills2.join(", ")}`);
-    return skills2;
+    const skills = skillsListEnv.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    remoteSkillsList = { data: skills, timestamp: Date.now() };
+    console.error(`[SKILL-LOADER] 从环境变量加载 skills: ${skills.join(", ")}`);
+    return skills;
+  }
+  console.error(`[SKILL-LOADER] 未配置 SKILLS_LIST,检查各源独立配置...`);
+  const allSkills = [];
+  skillSourceMap.clear();
+  if (config2.sources && config2.sources.length > 0) {
+    for (const source of config2.sources) {
+      console.error(`[SKILL-LOADER] 扫描源: ${source.name} (${source.originalUrl})`);
+      if (source.skillsList && source.skillsList.length > 0) {
+        console.error(`[SKILL-LOADER] 源 ${source.name} 使用独立 skills 列表: ${source.skillsList.join(", ")}`);
+        for (const skillName of source.skillsList) {
+          if (!allSkills.includes(skillName)) {
+            allSkills.push(skillName);
+          }
+          skillSourceMap.set(skillName, source);
+        }
+      } else {
+        console.error(`[SKILL-LOADER] 源 ${source.name} 未配置独立 skills,自动遍历目录...`);
+        const sourceConfig = {
+          source: "remote",
+          baseUrl: source.baseUrl,
+          originalUrl: source.originalUrl
+        };
+        const skills = await fetchRemoteSkillsFromDirectory(sourceConfig);
+        console.error(`[SKILL-LOADER] 源 ${source.name} 发现 skills: ${skills.join(", ")}`);
+        for (const skillName of skills) {
+          if (!allSkills.includes(skillName)) {
+            allSkills.push(skillName);
+          }
+          skillSourceMap.set(skillName, source);
+        }
+      }
+    }
+  } else if (config2.baseUrl && config2.originalUrl) {
+    const skills = await fetchRemoteSkillsFromDirectory(config2);
+    for (const skillName of skills) {
+      allSkills.push(skillName);
+      skillSourceMap.set(skillName, {
+        name: "default",
+        baseUrl: config2.baseUrl,
+        originalUrl: config2.originalUrl
+      });
+    }
   }
-  console.error(`[SKILL-LOADER] 未配置 SKILLS_LIST,自动遍历远程目录...`);
-  const skills = await fetchRemoteSkillsFromDirectory(config2);
-  remoteSkillsList = skills;
-  return skills;
+  console.error(`[SKILL-LOADER] 汇总所有 skills: ${allSkills.join(", ")}`);
+  remoteSkillsList = { data: allSkills, timestamp: Date.now() };
+  return allSkills;
 }
 async function loadRemoteSkillContent(skillName, baseUrl) {
   const skillUrl = `${baseUrl}/${skillName}/SKILL.md`;
@@ -21357,8 +21516,20 @@ async function getAvailableSkills() {
 }
 async function loadSkillContent(skillName) {
   const config2 = getSkillsConfig();
-  if (config2.source === "remote" && config2.baseUrl) {
-    return loadRemoteSkillContent(skillName, config2.baseUrl);
+  if (config2.source === "remote") {
+    const source = skillSourceMap.get(skillName);
+    if (source) {
+      console.error(`[SKILL-LOADER] 从源 ${source.name} 加载 skill: ${skillName}`);
+      return loadRemoteSkillContent(skillName, source.baseUrl);
+    }
+    if (config2.sources && config2.sources.length > 0) {
+      const firstSource = config2.sources[0];
+      console.error(`[SKILL-LOADER] 未找到来源映射，使用默认源 ${firstSource.name} 加载: ${skillName}`);
+      return loadRemoteSkillContent(skillName, firstSource.baseUrl);
+    }
+    if (config2.baseUrl) {
+      return loadRemoteSkillContent(skillName, config2.baseUrl);
+    }
   }
   const skillPath = resolve$3(getSkillsDir(), skillName, "SKILL.md");
   try {
@@ -21370,13 +21541,16 @@ Skill 文件加载失败，请检查安装。`;
   }
 }
 async function getSkillContent(skillName) {
-  if (!skillCache.has(skillName)) {
-    const content = await loadSkillContent(skillName);
-    skillCache.set(skillName, content);
+  const cached2 = skillCache.get(skillName);
+  if (cached2 && !isCacheExpired(cached2.timestamp)) {
+    return cached2.data;
   }
-  return skillCache.get(skillName);
+  console.error(`[SKILL-LOADER] Skill 缓存过期或不存在,重新加载: ${skillName}`);
+  const content = await loadSkillContent(skillName);
+  skillCache.set(skillName, { data: content, timestamp: Date.now() });
+  return content;
 }
-function parseFrontmatter(content) {
+async function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
   if (!match) {
@@ -21384,41 +21558,229 @@ function parseFrontmatter(content) {
   }
   const frontmatterText = match[1];
   const body = match[2];
-  const metadata2 = {};
-  const lines = frontmatterText.split("\n");
-  for (const line of lines) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex > 0) {
-      const key = line.slice(0, colonIndex).trim();
-      let value = line.slice(colonIndex + 1).trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        value = value.slice(1, -1);
+  try {
+    const yaml = await import("js-yaml");
+    const metadata2 = yaml.load(frontmatterText) || {};
+    return { metadata: metadata2, body };
+  } catch {
+    const metadata2 = {};
+    const lines = frontmatterText.split("\n");
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0 && !line.startsWith("-") && !line.startsWith(" ")) {
+        const key = line.slice(0, colonIndex).trim();
+        let value = line.slice(colonIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        metadata2[key] = value;
       }
-      metadata2[key] = value;
     }
+    return { metadata: metadata2, body };
   }
-  return { metadata: metadata2, body };
 }
 async function getSkillMetadata(skillName) {
-  if (!skillMetadataCache.has(skillName)) {
-    const content = await getSkillContent(skillName);
-    const { metadata: metadata2 } = parseFrontmatter(content);
-    const metadataObj = {
-      name: metadata2.name || skillName,
-      description: metadata2.description || `${skillName} skill`,
-      constraint: metadata2.constraint,
-      version: metadata2.version,
-      ...metadata2
-      // 包含其他自定义字段
-    };
-    skillMetadataCache.set(skillName, metadataObj);
-  }
-  return skillMetadataCache.get(skillName);
+  const cached2 = skillMetadataCache.get(skillName);
+  if (cached2 && !isCacheExpired(cached2.timestamp)) {
+    return cached2.data;
+  }
+  console.error(`[SKILL-LOADER] Skill 元数据缓存过期或不存在,重新加载: ${skillName}`);
+  const content = await getSkillContent(skillName);
+  const { metadata: metadata2 } = await parseFrontmatter(content);
+  const metadataObj = {
+    name: metadata2.name || skillName,
+    description: metadata2.description || `${skillName} skill`,
+    constraint: metadata2.constraint,
+    version: metadata2.version,
+    tools: metadata2.tools || [],
+    ...metadata2
+    // 包含其他自定义字段
+  };
+  skillMetadataCache.set(skillName, { data: metadataObj, timestamp: Date.now() });
+  return metadataObj;
 }
 async function getAllSkillsMetadata() {
   const skills = await getAvailableSkills();
   return Promise.all(skills.map((skillName) => getSkillMetadata(skillName)));
 }
+let globalTempSkillDir = null;
+function setTempSkillDir(tempDir) {
+  globalTempSkillDir = tempDir;
+}
+function getTempSkillDir() {
+  return globalTempSkillDir;
+}
+function getSkillResourceFiles(skillName) {
+  if (!globalTempSkillDir) {
+    return [];
+  }
+  const skillDir = resolve$3(globalTempSkillDir, skillName);
+  if (!existsSync(skillDir)) {
+    return [];
+  }
+  try {
+    return readdirSync(skillDir).filter((name) => name !== "SKILL.md");
+  } catch {
+    return [];
+  }
+}
+function getWorkspaceSkillDir(skillName) {
+  return resolve$3(globalTempSkillDir, skillName);
+}
+function copyDirectorySync(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = resolve$3(src, entry.name);
+    const destPath = resolve$3(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectorySync(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+async function downloadRemoteFile(url, targetPath) {
+  try {
+    const headers = {};
+    const gitlabToken = process.env.GITLAB_TOKEN;
+    if (gitlabToken) {
+      headers["PRIVATE-TOKEN"] = gitlabToken;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      console.error(`[SKILL-LOADER] 下载远程文件失败: ${url} - ${response.status}`);
+      return false;
+    }
+    const content = await response.text();
+    if (content.trim().startsWith("<!DOCTYPE") || content.trim().startsWith("<html")) {
+      console.error(`[SKILL-LOADER] 下载远程文件返回了 HTML 页面: ${url}`);
+      return false;
+    }
+    mkdirSync(dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, content, "utf-8");
+    return true;
+  } catch (error2) {
+    console.error(`[SKILL-LOADER] 下载远程文件异常: ${url}`, error2);
+    return false;
+  }
+}
+async function listRemoteSkillFiles(skillName, source) {
+  try {
+    const parsed = await parseGitLabUrl(source.originalUrl);
+    if (!parsed) {
+      console.error(`[SKILL-LOADER] 无法解析远程 URL: ${source.originalUrl}`);
+      return [];
+    }
+    const { host, projectPath, ref: ref2, path: basePath } = parsed;
+    const skillPath = basePath ? `${basePath}/${skillName}` : skillName;
+    const encodedProjectPath = encodeURIComponent(projectPath);
+    const apiUrl = `${host}/api/v4/projects/${encodedProjectPath}/repository/tree?ref=${encodeURIComponent(ref2)}&path=${encodeURIComponent(skillPath)}`;
+    const headers = {};
+    const gitlabToken = process.env.GITLAB_TOKEN;
+    if (gitlabToken) {
+      headers["PRIVATE-TOKEN"] = gitlabToken;
+    }
+    const response = await fetch(apiUrl, { headers });
+    if (!response.ok) {
+      console.error(`[SKILL-LOADER] 获取远程文件列表失败: ${response.status}`);
+      return [];
+    }
+    const items2 = await response.json();
+    return items2.filter((item) => item.type === "blob" && item.name !== "SKILL.md").map((item) => item.name);
+  } catch (error2) {
+    console.error(`[SKILL-LOADER] 获取远程文件列表异常:`, error2);
+    return [];
+  }
+}
+async function extractRemoteSkillResourcesToTempDir(skillName, source) {
+  const extractedPaths = [];
+  const files = await listRemoteSkillFiles(skillName, source);
+  if (files.length === 0) {
+    console.error(`[SKILL-LOADER] 远程 Skill ${skillName} 没有资源文件`);
+    return [];
+  }
+  console.error(`[SKILL-LOADER] 发现远程 Skill ${skillName} 的资源文件: ${files.join(", ")}`);
+  for (const fileName of files) {
+    const fileUrl = `${source.baseUrl}/${skillName}/${fileName}`;
+    const targetDir = getWorkspaceSkillDir(skillName);
+    const targetPath = resolve$3(targetDir, fileName);
+    const success = await downloadRemoteFile(fileUrl, targetPath);
+    if (success) {
+      extractedPaths.push(targetPath);
+      console.error(`[SKILL-LOADER] 已下载远程资源: ${skillName}/${fileName} -> ${targetPath}`);
+    } else {
+      console.error(`[SKILL-LOADER] 下载远程资源失败: ${skillName}/${fileName}`);
+    }
+  }
+  return extractedPaths;
+}
+async function extractSkillResourcesToTempDir(skillName) {
+  const config2 = getSkillsConfig();
+  if (config2.source === "remote") {
+    const source = skillSourceMap.get(skillName);
+    if (source) {
+      console.error(`[SKILL-LOADER] 从远程源 ${source.name} 提取 Skill ${skillName} 的资源`);
+      return extractRemoteSkillResourcesToTempDir(skillName, source);
+    }
+    if (config2.sources && config2.sources.length > 0) {
+      console.error(`[SKILL-LOADER] 使用默认远程源提取 Skill ${skillName} 的资源`);
+      return extractRemoteSkillResourcesToTempDir(skillName, config2.sources[0]);
+    }
+    console.error(`[SKILL-LOADER] 远程模式下找不到 Skill ${skillName} 的源配置`);
+    return [];
+  }
+  const skillDir = getSkillsDir();
+  const sourceDir = resolve$3(skillDir, skillName);
+  if (!existsSync(sourceDir)) {
+    console.error(`[SKILL-LOADER] Skill 目录不存在: ${sourceDir}`);
+    return [];
+  }
+  const extractedPaths = [];
+  try {
+    const entries = readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "SKILL.md") {
+        continue;
+      }
+      const sourcePath = resolve$3(sourceDir, entry.name);
+      const targetDir = getWorkspaceSkillDir(skillName);
+      const targetPath = resolve$3(targetDir, entry.name);
+      try {
+        mkdirSync(dirname(targetPath), { recursive: true });
+        if (entry.isDirectory()) {
+          copyDirectorySync(sourcePath, targetPath);
+        } else {
+          copyFileSync(sourcePath, targetPath);
+        }
+        extractedPaths.push(targetPath);
+        console.error(`[SKILL-LOADER] 已提取资源: ${skillName}/${entry.name} -> ${targetPath}`);
+      } catch (error2) {
+        console.error(`[SKILL-LOADER] 提取资源失败: ${skillName}/${entry.name}`, error2);
+      }
+    }
+  } catch (error2) {
+    console.error(`[SKILL-LOADER] 读取 Skill 目录失败: ${sourceDir}`, error2);
+  }
+  return extractedPaths;
+}
+async function extractAllSkillResourcesToTempDir(tempDir) {
+  setTempSkillDir(tempDir);
+  const skills = await getAvailableSkills();
+  const allExtracted = {};
+  console.error(`[SKILL-LOADER] 开始提取 ${skills.length} 个 Skill 的资源到临时目录: ${tempDir}`);
+  for (const skillName of skills) {
+    const paths = await extractSkillResourcesToTempDir(skillName);
+    if (paths.length > 0) {
+      allExtracted[skillName] = paths;
+    }
+  }
+  const totalCount = Object.values(allExtracted).flat().length;
+  console.error(`[SKILL-LOADER] 资源提取完成，共 ${totalCount} 个文件`);
+  return allExtracted;
+}
+const FIXED_SKILL_DIR = join(tmpdir(), "mcp-pipe-skills");
+let skillResourcesDir = FIXED_SKILL_DIR;
 async function createServer() {
   const server = new McpServer({
     name: "mcp-pipe",
@@ -21440,6 +21802,27 @@ async function createServer() {
         const skillLoaded = skills.includes(metadata2.name);
         const skillMetadata = await getSkillMetadata(metadata2.name);
         const skillContent = await getSkillContent(metadata2.name);
+        let injectedContent = skillContent;
+        const currentTempDir = getTempSkillDir();
+        if (currentTempDir) {
+          const skillResourceDir = join(currentTempDir, metadata2.name);
+          const resourceFiles = getSkillResourceFiles(metadata2.name);
+          let resourceNotice = `> 📁 **本 Skill 的资源文件**:
+`;
+          if (resourceFiles.length > 0) {
+            for (const file of resourceFiles) {
+              resourceNotice += `>   - \`${join(skillResourceDir, file)}\`
+`;
+            }
+          } else {
+            resourceNotice += ">   （无额外资源文件）\n";
+          }
+          resourceNotice += `> 
+> 💡 **提示**: 当 Skill 文档中提到读取配置文件或模板文件时，请使用上述完整路径
+
+`;
+          injectedContent = resourceNotice + skillContent;
+        }
         return {
           content: [{
             type: "text",
@@ -21447,7 +21830,7 @@ async function createServer() {
 
 📖 ${skillMetadata.description}
 
-${skillContent}
+${injectedContent}
 
 ---
 ${skillLoaded ? "✅" : "❌"} Skills 加载状态: ${skillLoaded ? `${metadata2.name} skill 已加载` : `${metadata2.name} skill 未加载`}
@@ -21511,8 +21894,34 @@ async function preloadSkills() {
     }
   }
 }
+function cleanupSkillDir() {
+  if (existsSync(skillResourcesDir)) {
+    try {
+      rmSync(skillResourcesDir, { recursive: true, force: true });
+      console.error(`[MCP-PIPE] Skill 资源目录已清理: ${skillResourcesDir}`);
+    } catch (error2) {
+      console.error(`[MCP-PIPE] 清理 Skill 资源目录失败: ${skillResourcesDir}`, error2);
+    }
+  }
+}
 async function main() {
+  process.on("exit", cleanupSkillDir);
+  process.on("SIGINT", () => {
+    console.error("[MCP-PIPE] 收到 SIGINT，正在清理...");
+    cleanupSkillDir();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.error("[MCP-PIPE] 收到 SIGTERM，正在清理...");
+    cleanupSkillDir();
+    process.exit(0);
+  });
+  if (!existsSync(skillResourcesDir)) {
+    mkdirSync(skillResourcesDir, { recursive: true });
+  }
+  console.error(`[MCP-PIPE] Skill 资源目录: ${skillResourcesDir}`);
   await preloadSkills();
+  await extractAllSkillResourcesToTempDir(skillResourcesDir);
   initMCPClients();
   const server = await createServer();
   const transport = new StdioServerTransport();
@@ -21521,5 +21930,6 @@ async function main() {
 }
 main().catch((error2) => {
   console.error("[MCP-PIPE] 致命错误:", error2);
+  cleanupSkillDir();
   process.exit(1);
 });