@ian2018cs/agenthub 0.1.70 → 0.1.72

package/server/claude-sdk.js

@@ -12,7 +12,7 @@
  * - WebSocket message streaming
  */
 
-import { query, renameSession } from '@anthropic-ai/claude-agent-sdk';
+import { query, renameSession, forkSession } from '@anthropic-ai/claude-agent-sdk';
 // Used to mint unique approval request IDs when randomUUID is not available.
 // This keeps parallel tool approvals from colliding; it does not add any crypto/security guarantees.
 import crypto from 'crypto';
@@ -24,6 +24,7 @@ import { getUserPaths } from './services/user-directories.js';
 import { usageDb } from './database/db.js';
 import { calculateCost, normalizeModelName } from './services/pricing.js';
 import { evaluate as evaluateToolGuard } from './services/tool-guard/index.js';
+import { loadProjectConfig, addProjectManually } from './projects.js';
 
 // Session tracking: Map of session IDs to active query instances
 const activeSessions = new Map();
@@ -77,6 +78,30 @@ const pendingToolApprovals = new Map();
 // introduced to avoid hanging the run when no decision arrives.
 const TOOL_APPROVAL_TIMEOUT_MS = parseInt(process.env.CLAUDE_TOOL_APPROVAL_TIMEOUT_MS, 10) || 55000;
 
+// ─── 分享项目模板：pending 请求管理 ───
+const pendingShareTemplateRequests = new Map();
+const SHARE_TEMPLATE_TIMEOUT_MS = 5 * 60 * 1000; // 5 分钟（用户需要时间审阅和修改模板）
+
+function waitForShareTemplateResponse(requestId) {
+  return new Promise(resolve => {
+    let settled = false;
+    const finalize = (result) => {
+      if (settled) return;
+      settled = true;
+      pendingShareTemplateRequests.delete(requestId);
+      clearTimeout(timeout);
+      resolve(result);
+    };
+    const timeout = setTimeout(() => finalize(null), SHARE_TEMPLATE_TIMEOUT_MS);
+    pendingShareTemplateRequests.set(requestId, finalize);
+  });
+}
+
+function resolveShareTemplateRequest(requestId, result) {
+  const resolver = pendingShareTemplateRequests.get(requestId);
+  if (resolver) resolver(result);
+}
+
 // Generate a stable request ID for UI approval flows.
 // This does not encode tool details or get shown to users; it exists so the UI
 // can respond to the correct pending request without collisions.
@@ -246,7 +271,28 @@ function mapCliOptionsToSDK(options = {}) {
   console.log(`Using model: ${sdkOptions.model}`);
 
   // Map system prompt configuration
-  const baseAppend = PRODUCT_SYSTEM_DESC;
+  const SHARE_PROJECT_TEMPLATE_TOOL_DESC = `
+
+## 分享项目模板工具
+
+当用户想要分享项目、创建项目模板、发布共享项目时，使用以下 Bash 命令打开分享弹窗：
+
+\`\`\`bash
+__share_project_template__ '{"path":"/项目路径","displayName":"显示名称","description":"描述","updateNotes":"更新说明","skills":["skill1"],"mcps":["mcp1"],"files":["file1.md"]}'
+\`\`\`
+
+参数说明：
+- path (必填): 项目文件夹路径，可以是当前项目、子文件夹或其他项目路径
+- displayName (可选): 模板显示名称，仅首次创建时使用（更新时忽略）
+- description (可选): 模板描述，仅首次创建时使用（更新时忽略）
+- updateNotes (可选): 更新说明，仅更新已有模板时使用
+- skills (可选): 要包含的技能名称数组，空数组=让用户在弹窗中选择
+- mcps (可选): 要包含的 MCP 服务名称数组，空数组=让用户在弹窗中选择
+- files (可选): 要包含的文件相对路径数组，空数组=让用户在弹窗中选择
+
+该命令会打开一个 UI 弹窗供用户确认和修改，等待用户操作完成后返回结果。
+`;
+  const baseAppend = PRODUCT_SYSTEM_DESC + SHARE_PROJECT_TEMPLATE_TOOL_DESC;
   const extraAppend = options.appendSystemPrompt ? `\n\n${options.appendSystemPrompt}` : '';
   sdkOptions.systemPrompt = {
     type: 'preset',
@@ -601,6 +647,98 @@ async function queryClaudeSDK(command, options = {}, ws) {
           ...((sdkOptions.hooks || {}).PreToolUse || []),
           {
             hooks: [async (hookInput) => {
+              // ===== 分享项目模板拦截（在 ToolGuard 之前，匹配后直接 return） =====
+              if (hookInput.tool_name === 'Bash' &&
+                  hookInput.tool_input?.command?.trimStart().startsWith('__share_project_template__')) {
+                try {
+                  // 检测飞书模式：MutableWriter.current 有 .ws 属性（WebSocketWriter），FakeSendWriter 没有
+                  if (!mutableWriter?.current?.ws) {
+                    return {
+                      hookSpecificOutput: {
+                        hookEventName: 'PreToolUse',
+                        permissionDecision: 'deny',
+                        permissionDecisionReason: '分享项目模板功能仅支持网页端使用。',
+                      }
+                    };
+                  }
+
+                  // 解析参数
+                  const rawArgs = hookInput.tool_input.command.replace(/^\s*__share_project_template__\s*/, '');
+                  let jsonStr = rawArgs.trim();
+                  if ((jsonStr.startsWith("'") && jsonStr.endsWith("'")) ||
+                      (jsonStr.startsWith('"') && jsonStr.endsWith('"'))) {
+                    jsonStr = jsonStr.slice(1, -1);
+                  }
+                  const params = JSON.parse(jsonStr);
+
+                  if (!params.path) {
+                    return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny',
+                      permissionDecisionReason: '缺少必需参数 path（项目路径）。' } };
+                  }
+
+                  // 解析 path → projectKey，并判断是否为已有项目
+                  const config = await loadProjectConfig(userUuid);
+                  let projectKey = null;
+                  let isExistingProject = false;
+                  for (const [key, entry] of Object.entries(config)) {
+                    if ((entry.originalPath || key.replace(/-/g, '/')) === params.path) {
+                      projectKey = key;
+                      isExistingProject = true;
+                      break;
+                    }
+                  }
+                  if (!projectKey) {
+                    // 路径不在项目列表中（可能是子文件夹），自动添加为新项目
+                    try {
+                      const project = await addProjectManually(params.path, params.displayName, userUuid);
+                      projectKey = project.name;
+                      isExistingProject = false;
+                    } catch (e) {
+                      return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny',
+                        permissionDecisionReason: `无法解析项目路径: ${e.message}` } };
+                    }
+                  }
+
+                  // 发送 WebSocket 消息打开分享弹窗
+                  const shareRequestId = createRequestId();
+                  mutableWriter.send({
+                    type: 'share-project-template-request',
+                    requestId: shareRequestId,
+                    prefillData: {
+                      projectKey,
+                      projectPath: params.path,
+                      isExistingProject,
+                      displayName: params.displayName || '',
+                      description: params.description || '',
+                      updateNotes: params.updateNotes || '',
+                      skills: params.skills || [],
+                      mcps: params.mcps || [],
+                      files: params.files || [],
+                    }
+                  });
+
+                  // 等待前端响应（5 分钟超时）
+                  const response = await waitForShareTemplateResponse(shareRequestId);
+
+                  let reason;
+                  if (!response) {
+                    reason = '分享项目模板请求超时（5分钟内未收到响应）。';
+                  } else if (response.cancelled) {
+                    reason = '用户取消了分享项目模板操作。';
+                  } else if (response.success) {
+                    reason = `项目模板已成功提交！提交 ID: ${response.submissionId}。${response.message || ''}`;
+                  } else {
+                    reason = `提交失败: ${response.error || '未知错误'}`;
+                  }
+
+                  return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason } };
+                } catch (err) {
+                  return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny',
+                    permissionDecisionReason: `分享项目模板失败: ${err.message}` } };
+                }
+              }
+
+              // ===== 安全守卫（Tool Guard）=====
               try {
                 const guardResult = await evaluateToolGuard(hookInput.tool_name, hookInput.tool_input, {
                   userUuid,
@@ -969,6 +1107,20 @@ async function renameSessionForUser(sessionId, title, userUuid) {
   await renameSession(sessionId, title);
 }
 
+/**
+ * Fork a session at a given message, creating a new branch conversation.
+ * @param {string} sessionId - Session to fork
+ * @param {string} userUuid - User UUID for directory isolation
+ * @param {object} opts - Fork options (upToMessageId, title)
+ * @returns {Promise<string>} New session UUID
+ */
+async function forkSessionForUser(sessionId, userUuid, opts = {}) {
+  const userPaths = getUserPaths(userUuid);
+  process.env.CLAUDE_CONFIG_DIR = userPaths.claudeDir;
+  const result = await forkSession(sessionId, opts);
+  return result.sessionId;
+}
+
 // Export public API
 export {
   queryClaudeSDK,
@@ -976,6 +1128,8 @@ export {
   isClaudeSDKSessionActive,
   getActiveClaudeSDKSessions,
   resolveToolApproval,
+  resolveShareTemplateRequest,
   renameSessionForUser,
+  forkSessionForUser,
   updateSessionWriter
 };

package/server/index.js

@@ -43,7 +43,7 @@ import fetch from 'node-fetch';
 import mime from 'mime-types';
 
 import { getProjects, getSessions, getSessionMessages, renameProject, deleteSession, deleteProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache, updateProjectLastActivity } from './projects.js';
-import { queryClaudeSDK, abortClaudeSDKSession, isClaudeSDKSessionActive, getActiveClaudeSDKSessions, resolveToolApproval, renameSessionForUser, updateSessionWriter } from './claude-sdk.js';
+import { queryClaudeSDK, abortClaudeSDKSession, isClaudeSDKSessionActive, getActiveClaudeSDKSessions, resolveToolApproval, resolveShareTemplateRequest, renameSessionForUser, forkSessionForUser, updateSessionWriter } from './claude-sdk.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
 import mcpUtilsRoutes from './routes/mcp-utils.js';
@@ -455,6 +455,22 @@ app.put('/api/projects/:projectName/sessions/:sessionId/rename', authenticateTok
     }
 });
 
+// Fork session endpoint — creates a new branch conversation from a given point
+app.post('/api/projects/:projectName/sessions/:sessionId/fork', authenticateToken, async (req, res) => {
+    try {
+        const { sessionId } = req.params;
+        const opts = {};
+        if (req.body?.upToMessageId) {
+            opts.upToMessageId = req.body.upToMessageId;
+        }
+        const newSessionId = await forkSessionForUser(sessionId, req.user.uuid, opts);
+        res.json({ newSessionId });
+    } catch (error) {
+        console.error(`[API] Error forking session ${req.params.sessionId}:`, error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
 // Delete project endpoint
 app.delete('/api/projects/:projectName', authenticateToken, async (req, res) => {
     try {
@@ -803,6 +819,17 @@ function handleChatConnection(ws, userData) {
                         rememberEntry: data.rememberEntry
                     });
                 }
+            } else if (data.type === 'share-project-template-response') {
+                // Relay the user's share-project-template decision back to the PreToolUse hook.
+                if (data.requestId) {
+                    resolveShareTemplateRequest(data.requestId, {
+                        success: Boolean(data.success),
+                        cancelled: Boolean(data.cancelled),
+                        submissionId: data.submissionId || null,
+                        message: data.message || '',
+                        error: data.error || '',
+                    });
+                }
             } else if (data.type === 'check-session-status') {
                 // Check if a specific session is currently processing
                 const sessionId = data.sessionId;

package/server/routes/agents.js

@@ -5,7 +5,7 @@ import path from 'path';
 import { spawn } from 'child_process';
 import AdmZip from 'adm-zip';
 import { getUserPaths, getPublicPaths } from '../services/user-directories.js';
-import { scanAgents, ensureAgentRepo, incrementPatchVersion, publishAgentToRepo } from '../services/system-agent-repo.js';
+import { scanAgents, ensureAgentRepo, incrementPatchVersion, publishAgentToRepo, invalidateAgentCache } from '../services/system-agent-repo.js';
 import { ensureSystemRepo, SYSTEM_REPO_URL } from '../services/system-repo.js';
 import { ensureSystemMcpRepo, SYSTEM_MCP_REPO_URL } from '../services/system-mcp-repo.js';
 import { addProjectManually, loadProjectConfig, saveProjectConfig } from '../projects.js';
@@ -444,8 +444,7 @@ router.get('/', async (req, res) => {
  */
 router.post('/refresh', async (_req, res) => {
   try {
-    await ensureAgentRepo();
-    const agents = await scanAgents();
+    const agents = await scanAgents(true);
     res.json({ success: true, agentCount: agents.length });
   } catch (error) {
     console.error('Error refreshing agent repo:', error);
@@ -1295,7 +1294,7 @@ router.post('/submissions/:id/approve', async (req, res) => {
     if (updateAllUsers) {
       // Force-update all users who have this agent installed
       try {
-        const freshAgents = await scanAgents();
+        const freshAgents = await scanAgents(true);
         const publishedAgent = freshAgents.find(a =>
           a.dirName === submission.agent_name || a.name === submission.agent_name
         );

package/server/routes/skills.js

@@ -5,7 +5,7 @@ import { spawn } from 'child_process';
 import multer from 'multer';
 import AdmZip from 'adm-zip';
 import { getUserPaths, getPublicPaths, DATA_DIR } from '../services/user-directories.js';
-import { SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME } from '../services/system-repo.js';
+import { ensureSystemRepo, SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME, SYSTEM_REPO_URL } from '../services/system-repo.js';
 
 const router = express.Router();
 
@@ -292,6 +292,83 @@ function updateRepository(repoPath) {
   });
 }
 
+/**
+ * Run a git command and return a promise
+ */
+function runGit(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const opts = { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } };
+    if (cwd) opts.cwd = cwd;
+    const proc = spawn('git', args, opts);
+    let stderr = '';
+    proc.stderr.on('data', d => { stderr += d.toString(); });
+    proc.on('close', code => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || `git ${args[0]} failed with code ${code}`));
+    });
+    proc.on('error', err => reject(err));
+  });
+}
+
+/**
+ * Run a git command and return stdout as a string
+ */
+function runGitOutput(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const opts = { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } };
+    if (cwd) opts.cwd = cwd;
+    const proc = spawn('git', args, opts);
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', d => { stdout += d.toString(); });
+    proc.stderr.on('data', d => { stderr += d.toString(); });
+    proc.on('close', code => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr || `git ${args[0]} failed with code ${code}`));
+    });
+    proc.on('error', err => reject(err));
+  });
+}
+
+/**
+ * Recursively copy all files and directories from src to dst.
+ */
+async function copyDirRecursive(src, dst) {
+  await fs.mkdir(dst, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const dstPath = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive(srcPath, dstPath);
+    } else {
+      await fs.copyFile(srcPath, dstPath);
+    }
+  }
+}
+
+/**
+ * Find a skill directory in the system repo (supports direct and nested structures).
+ * Returns absolute path to skill directory, or null if not found.
+ */
+async function findSkillInSystemRepo(systemRepoPath, skillName) {
+  // Direct: {systemRepoPath}/{skillName}/SKILL.md
+  const directPath = path.join(systemRepoPath, skillName);
+  try {
+    await fs.access(path.join(directPath, 'SKILL.md'));
+    return directPath;
+  } catch {}
+
+  // Nested: {systemRepoPath}/skills/{skillName}/SKILL.md
+  const nestedPath = path.join(systemRepoPath, 'skills', skillName);
+  try {
+    await fs.access(path.join(nestedPath, 'SKILL.md'));
+    return nestedPath;
+  } catch {}
+
+  return null;
+}
+
 /**
  * GET /api/skills
  * List user's installed skills
@@ -373,6 +450,43 @@ router.get('/', async (req, res) => {
       }
     }
 
+    // Compute sync status for each skill
+    // For builtin skills, batch-check git status once
+    const builtinChangedSkills = new Set();
+    const systemRepoTag = `${SYSTEM_REPO_OWNER}/${SYSTEM_REPO_NAME}`;
+    const hasBuiltinSkills = skills.some(s => s.repository === systemRepoTag);
+    if (hasBuiltinSkills) {
+      const publicPaths = getPublicPaths();
+      const systemRepoPath = path.join(publicPaths.skillsRepoDir, SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME);
+      try {
+        const statusOutput = await runGitOutput(['status', '--porcelain'], systemRepoPath);
+        for (const line of statusOutput.split('\n')) {
+          if (!line) continue;
+          const filePath = line.slice(3).trim();
+          const topDir = filePath.split('/')[0];
+          if (topDir) builtinChangedSkills.add(topDir);
+        }
+      } catch {
+        // System repo may not exist locally or git may fail — skip sync detection
+      }
+    }
+
+    for (const skill of skills) {
+      if (skill.source === 'imported' || skill.source === 'unknown') {
+        skill.syncable = true;
+        skill.syncType = 'local';
+      } else if (skill.repository === systemRepoTag) {
+        skill.syncable = builtinChangedSkills.has(skill.name);
+        skill.syncType = 'builtin';
+      } else if (skill.source === 'repo') {
+        skill.syncable = true;
+        skill.syncType = 'external';
+      } else {
+        skill.syncable = false;
+        skill.syncType = null;
+      }
+    }
+
     res.json({ skills, count: skills.length });
   } catch (error) {
     console.error('Error listing skills:', error);
@@ -506,6 +620,149 @@ router.get('/:name/download', async (req, res) => {
   }
 });
 
+/**
+ * POST /api/skills/:name/sync
+ * Sync a skill to the built-in system repository
+ */
+router.post('/:name/sync', async (req, res) => {
+  try {
+    const userUuid = req.user?.uuid;
+    if (!userUuid) {
+      return res.status(401).json({ error: 'User authentication required' });
+    }
+
+    const { name } = req.params;
+    if (!SKILL_NAME_REGEX.test(name)) {
+      return res.status(400).json({ error: 'Invalid skill name' });
+    }
+
+    const userPaths = getUserPaths(userUuid);
+    const publicPaths = getPublicPaths();
+    const linkPath = path.join(userPaths.skillsDir, name);
+
+    // Resolve skill info
+    let realPath;
+    let source = 'unknown';
+    let repository = null;
+    let isSymlink = false;
+
+    try {
+      const stat = await fs.lstat(linkPath);
+      isSymlink = stat.isSymbolicLink();
+      if (isSymlink) {
+        realPath = await fs.realpath(linkPath);
+        if (realPath.includes('/skills-import/')) {
+          source = 'imported';
+        } else if (realPath.includes('/skills-repo/')) {
+          source = 'repo';
+          const repoMatch = realPath.match(/skills-repo\/([^/]+)\/([^/]+)/);
+          if (repoMatch) repository = `${repoMatch[1]}/${repoMatch[2]}`;
+        }
+      } else {
+        realPath = linkPath;
+      }
+    } catch {
+      return res.status(404).json({ error: 'Skill not found' });
+    }
+
+    if (!await isValidSkill(realPath)) {
+      return res.status(400).json({ error: 'Invalid skill: missing SKILL.md' });
+    }
+
+    const systemRepoTag = `${SYSTEM_REPO_OWNER}/${SYSTEM_REPO_NAME}`;
+    const username = req.user?.email || req.user?.username || req.user?.uuid;
+    const now = new Date();
+    const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+
+    // === Case 2: Built-in system repo skill — push local changes ===
+    if (source === 'repo' && repository === systemRepoTag) {
+      const systemRepoPath = path.join(publicPaths.skillsRepoDir, SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME);
+      try {
+        await runGit(['add', name], systemRepoPath);
+        await runGit(['commit', '-m', `feat: update skill ${name} by user ${username} at ${timestamp}`], systemRepoPath);
+        await runGit(['push'], systemRepoPath);
+        console.log(`[SkillSync] Pushed changes for built-in skill "${name}" by ${username}`);
+      } catch (e) {
+        console.error(`[SkillSync] Failed to push skill "${name}":`, e.message);
+        return res.status(500).json({ error: `Git push failed: ${e.message}` });
+      }
+      return res.json({ success: true, message: '技能修改已同步到云端' });
+    }
+
+    // === Case 1 & 3: Local/imported or external repo skill — migrate to system repo ===
+    let skillRepoPath;
+    try {
+      skillRepoPath = await ensureSystemRepo();
+    } catch (e) {
+      console.error('[SkillSync] Failed to ensure system repo:', e.message);
+      return res.status(500).json({ error: `无法访问系统仓库: ${e.message}` });
+    }
+
+    const destSkillDir = path.join(skillRepoPath, name);
+
+    // Copy skill files to system repo (overwrite if exists)
+    await fs.rm(destSkillDir, { recursive: true, force: true });
+    await copyDirRecursive(realPath, destSkillDir);
+    console.log(`[SkillSync] Copied skill "${name}" to system repo`);
+
+    // Git: add, commit, push
+    try {
+      await runGit(['add', name], skillRepoPath);
+      await runGit(['commit', '-m', `feat: add skill ${name} by user ${username} at ${timestamp}`], skillRepoPath);
+      await runGit(['push'], skillRepoPath);
+      console.log(`[SkillSync] Pushed skill "${name}" to system repo`);
+    } catch (e) {
+      // Rollback: remove the files we just copied
+      await fs.rm(destSkillDir, { recursive: true, force: true }).catch(() => {});
+      console.error(`[SkillSync] Git push failed for skill "${name}":`, e.message);
+      return res.status(500).json({ error: `Git push failed: ${e.message}` });
+    }
+
+    // For external repo: restore original files via git checkout
+    if (source === 'repo' && repository && repository !== systemRepoTag) {
+      const repoMatch = repository.match(/^([^/]+)\/(.+)$/);
+      if (repoMatch) {
+        const externalRepoPath = path.join(publicPaths.skillsRepoDir, repoMatch[1], repoMatch[2]);
+        const skillRelPath = path.relative(externalRepoPath, realPath);
+        try {
+          await runGit(['checkout', '--', skillRelPath], externalRepoPath);
+          console.log(`[SkillSync] Restored external repo skill "${name}" via git checkout`);
+        } catch (e) {
+          console.warn(`[SkillSync] git checkout on external repo failed (non-fatal):`, e.message);
+        }
+      }
+    }
+
+    // Clean up local import directory (Case 1: imported)
+    if (source === 'imported') {
+      try {
+        await fs.rm(path.join(userPaths.skillsImportDir, name), { recursive: true, force: true });
+      } catch {}
+    }
+
+    // Remove current symlink/directory
+    if (isSymlink) {
+      await fs.unlink(linkPath);
+    } else {
+      await fs.rm(linkPath, { recursive: true, force: true });
+    }
+
+    // Re-install from system repo: find skill path and create symlink
+    const newSkillPath = await findSkillInSystemRepo(skillRepoPath, name);
+    if (newSkillPath) {
+      await fs.symlink(newSkillPath, linkPath);
+      console.log(`[SkillSync] Re-installed skill "${name}" from system repo`);
+    } else {
+      console.warn(`[SkillSync] Could not find skill "${name}" in system repo after push — skipping re-install`);
+    }
+
+    return res.json({ success: true, message: '技能已成功同步到共享仓库' });
+  } catch (error) {
+    console.error('Error syncing skill:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 /**
  * DELETE /api/skills/disable/:name
  * Disable a skill by removing symlink

package/server/services/system-agent-repo.js

@@ -7,6 +7,14 @@ export const SYSTEM_AGENT_REPO_URL = 'git@git.amberweather.com:mcp-server/hupoer
 export const SYSTEM_AGENT_REPO_OWNER = 'mcp-server';
 export const SYSTEM_AGENT_REPO_NAME = 'hupoer-agents';
 
+// ─── In-memory cache ──────────────────────────────────────────────────────────
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+let agentCache = { agents: null, cachedAt: 0 };
+
+export function invalidateAgentCache() {
+  agentCache = { agents: null, cachedAt: 0 };
+}
+
 function runGit(args, cwd = null) {
   return new Promise((resolve, reject) => {
     const opts = {
@@ -153,15 +161,23 @@ async function parseAgentYaml(agentDir) {
 
 /**
  * Scan the agent repo for available agents.
+ * @param {boolean} force - When true, always git pull and re-scan (bypasses cache).
+ *                          When false (default), returns cached result if < 5 min old.
  * Returns array of agent metadata objects.
  */
-export async function scanAgents() {
+export async function scanAgents(force = false) {
+  // Return cached result if fresh and not forced
+  if (!force && agentCache.agents !== null && Date.now() - agentCache.cachedAt < CACHE_TTL_MS) {
+    return agentCache.agents;
+  }
+
   let repoPath;
   try {
     repoPath = await ensureAgentRepo();
   } catch (err) {
     console.error('[AgentRepo] Could not access agent repo:', err.message);
-    return [];
+    // Return stale cache on network error rather than empty list
+    return agentCache.agents ?? [];
   }
 
   const agents = [];
@@ -195,6 +211,7 @@ export async function scanAgents() {
     });
   }
 
+  agentCache = { agents, cachedAt: Date.now() };
   return agents;
 }