@ian2018cs/agenthub 0.1.69 → 0.1.71

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);
@@ -423,6 +537,232 @@ router.post('/enable/:name', async (req, res) => {
   }
 });
 
+/**
+ * Recursively add directory contents to a zip archive.
+ * Uses fs.stat (follows symlinks) so symlinked files are included transparently.
+ */
+async function addDirToZip(zip, dirPath, zipPrefix) {
+  let names;
+  try {
+    names = await fs.readdir(dirPath);
+  } catch {
+    return;
+  }
+
+  for (const name of names) {
+    if (name.startsWith('.')) continue;
+
+    const fullPath = path.join(dirPath, name);
+    const zipPath = zipPrefix + name;
+
+    let stat;
+    try {
+      stat = await fs.stat(fullPath); // follows symlinks
+    } catch {
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      await addDirToZip(zip, fullPath, zipPath + '/');
+    } else if (stat.isFile()) {
+      const data = await fs.readFile(fullPath);
+      zip.addFile(zipPath, data);
+    }
+  }
+}
+
+/**
+ * GET /api/skills/:name/download
+ * Download a skill as a zip file (symlinks are resolved transparently)
+ */
+router.get('/:name/download', 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 skillPath = path.join(userPaths.skillsDir, name);
+
+    // Resolve symlink to real directory
+    let realPath = skillPath;
+    try {
+      const stat = await fs.lstat(skillPath);
+      if (stat.isSymbolicLink()) {
+        realPath = await fs.realpath(skillPath);
+      }
+    } catch {
+      return res.status(404).json({ error: 'Skill not found' });
+    }
+
+    if (!await isValidSkill(realPath)) {
+      return res.status(404).json({ error: 'Skill not found or invalid' });
+    }
+
+    const zip = new AdmZip();
+    await addDirToZip(zip, realPath, `${name}/`);
+    const zipBuffer = zip.toBuffer();
+
+    res.setHeader('Content-Type', 'application/zip');
+    res.setHeader('Content-Disposition', `attachment; filename="${name}.zip"`);
+    res.setHeader('Content-Length', zipBuffer.length);
+    res.send(zipBuffer);
+  } catch (error) {
+    console.error('Error downloading skill:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * 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-mcp-repo.js

@@ -42,7 +42,7 @@ function updateRepository(repoPath) {
   });
 }
 
-async function ensureSystemMcpRepo() {
+export async function ensureSystemMcpRepo() {
   const publicPaths = getPublicPaths();
   const publicRepoPath = path.join(publicPaths.mcpRepoDir, SYSTEM_MCP_REPO_OWNER, SYSTEM_MCP_REPO_NAME);
 

package/server/services/system-repo.js

@@ -51,7 +51,7 @@ function updateRepository(repoPath) {
  * If already cloned, attempts to pull latest changes.
  * Returns the path to the public clone.
  */
-async function ensureSystemRepo() {
+export async function ensureSystemRepo() {
   const publicPaths = getPublicPaths();
   const publicRepoPath = path.join(publicPaths.skillsRepoDir, SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME);