@ian2018cs/agenthub 0.1.74 → 0.1.75

package/server/index.js

@@ -670,8 +670,9 @@ app.put('/api/projects/:projectName/file', authenticateToken, async (req, res) =
 app.get('/api/projects/:projectName/files', authenticateToken, async (req, res) => {
     try {
         // Query parameters for lazy loading
-        const { dirPath, depth = '1' } = req.query;
+        const { dirPath, depth = '1', showHidden = 'false' } = req.query;
         const maxDepth = Math.min(parseInt(depth) || 1, 10); // Limit max depth to 10
+        const showHiddenFiles = showHidden === 'true';
 
         // Use extractProjectDirectory to get the actual project path
         let projectPath;
@@ -701,7 +702,7 @@ app.get('/api/projects/:projectName/files', authenticateToken, async (req, res)
             return res.status(404).json({ error: `Path not found: ${targetPath}` });
         }
 
-        const files = await getFileTree(targetPath, maxDepth, 0, true);
+        const files = await getFileTree(targetPath, maxDepth, 0, showHiddenFiles);
         res.json(files);
     } catch (error) {
         console.error('[ERROR] File tree error:', error.message);
@@ -2361,14 +2362,36 @@ async function getFileTree(dirPath, maxDepth = 1, currentDepth = 0, showHidden =
         for (const entry of entries) {
             // Skip heavy build directories and VCS directories
             if (SKIP_DIRECTORIES.has(entry.name)) continue;
+            // Skip hidden files/dirs when showHidden is false
+            if (!showHidden && entry.name.startsWith('.')) continue;
 
             const itemPath = path.join(dirPath, entry.name);
+            const isSymlink = entry.isSymbolicLink();
             const item = {
                 name: entry.name,
                 path: itemPath,
-                type: entry.isDirectory() ? 'directory' : 'file'
+                type: entry.isDirectory() ? 'directory' : 'file',
+                isSymlink,
             };
 
+            // Resolve symlink target and actual type
+            if (isSymlink) {
+                try {
+                    item.symlinkTarget = await fsPromises.readlink(itemPath);
+                } catch {
+                    item.symlinkTarget = null;
+                }
+                try {
+                    // stat() follows the symlink to get target info
+                    const targetStats = await fsPromises.stat(itemPath);
+                    item.type = targetStats.isDirectory() ? 'directory' : 'file';
+                } catch {
+                    // Broken symlink — keep as 'file', mark broken
+                    item.type = 'file';
+                    item.isBrokenSymlink = true;
+                }
+            }
+
             // Get file stats for additional metadata
             try {
                 const stats = await fsPromises.stat(itemPath);
@@ -2383,14 +2406,14 @@ async function getFileTree(dirPath, maxDepth = 1, currentDepth = 0, showHidden =
                 item.permissions = ((mode >> 6) & 7).toString() + ((mode >> 3) & 7).toString() + (mode & 7).toString();
                 item.permissionsRwx = permToRwx(ownerPerm) + permToRwx(groupPerm) + permToRwx(otherPerm);
             } catch (statError) {
-                // If stat fails, provide default values
+                // If stat fails (e.g. broken symlink), provide default values
                 item.size = 0;
                 item.modified = null;
                 item.permissions = '000';
                 item.permissionsRwx = '---------';
             }
 
-            if (entry.isDirectory()) {
+            if (item.type === 'directory') {
                 // For lazy loading: check if directory has children without loading them
                 if (currentDepth >= maxDepth) {
                     // Don't load children, just check if they exist

package/server/projects.js

@@ -903,6 +903,9 @@ async function deleteProject(projectName, userUuid, options = {}) {
       actualProjectDir = await extractProjectDirectory(projectName, userUuid);
     }
 
+    // Also resolve the actual path to clean up .claude.json project-scoped MCPs
+    const resolvedProjectDir = actualProjectDir || await extractProjectDirectory(projectName, userUuid).catch(() => null);
+
     // Remove the Claude sessions directory
     try {
       await fs.rm(sessionDir, { recursive: true, force: true });
@@ -917,6 +920,21 @@ async function deleteProject(projectName, userUuid, options = {}) {
     delete config[projectName];
     await saveProjectConfig(config, userUuid);
 
+    // Clean up project-scoped MCP servers from .claude.json
+    if (resolvedProjectDir) {
+      try {
+        const claudeJsonPath = path.join(getUserPaths(userUuid).claudeDir, '.claude.json');
+        const claudeConfig = JSON.parse(await fs.readFile(claudeJsonPath, 'utf-8'));
+        if (claudeConfig.projects?.[resolvedProjectDir]) {
+          delete claudeConfig.projects[resolvedProjectDir];
+          await fs.writeFile(claudeJsonPath, JSON.stringify(claudeConfig, null, 2), 'utf-8');
+        }
+      } catch (err) {
+        // Non-fatal: log and continue
+        console.error(`[deleteProject] Failed to clean up .claude.json for ${resolvedProjectDir}:`, err.message);
+      }
+    }
+
     // Optionally delete the actual project folder
     if (deleteFolder && actualProjectDir) {
       try {

package/server/routes/agents.js

@@ -197,7 +197,7 @@ async function ensureSkillRepo(repoUrl, userUuid) {
 /**
  * Install a single skill by name from a given repo URL.
  */
-async function installSkill(skillName, repoUrl, userUuid) {
+async function installSkill(skillName, repoUrl, userUuid, projectPath) {
   const publicRepoPath = await ensureSkillRepo(repoUrl, userUuid);
   const userPaths = getUserPaths(userUuid);
 
@@ -208,7 +208,11 @@ async function installSkill(skillName, repoUrl, userUuid) {
     return false;
   }
 
-  const linkPath = path.join(userPaths.skillsDir, skillName);
+  const targetDir = projectPath
+    ? path.join(projectPath, '.claude', 'skills')
+    : userPaths.skillsDir;
+  await fs.mkdir(targetDir, { recursive: true });
+  const linkPath = path.join(targetDir, skillName);
   try { await fs.unlink(linkPath); } catch {}
   await fs.symlink(skillPath, linkPath);
   return true;
@@ -359,8 +363,9 @@ async function ensureMcpRepo(repoUrl, userUuid) {
 
 /**
  * Install a single MCP server by service dir name from a given repo URL.
+ * If projectPath is provided, installs as project-scoped (local); otherwise user-scoped.
  */
-async function installMcp(mcpName, repoUrl, userUuid) {
+async function installMcp(mcpName, repoUrl, userUuid, projectPath) {
   const publicRepoPath = await ensureMcpRepo(repoUrl, userUuid);
   const userPaths = getUserPaths(userUuid);
 
@@ -383,7 +388,18 @@ async function installMcp(mcpName, repoUrl, userUuid) {
   } catch {
     claudeConfig = { hasCompletedOnboarding: true };
   }
-  claudeConfig.mcpServers = { ...(claudeConfig.mcpServers || {}), ...mcpJson };
+
+  if (projectPath) {
+    // Project-scoped: write to projects[projectPath].mcpServers
+    if (!claudeConfig.projects) claudeConfig.projects = {};
+    if (!claudeConfig.projects[projectPath]) claudeConfig.projects[projectPath] = {};
+    if (!claudeConfig.projects[projectPath].mcpServers) claudeConfig.projects[projectPath].mcpServers = {};
+    Object.assign(claudeConfig.projects[projectPath].mcpServers, mcpJson);
+  } else {
+    // User-scoped (fallback)
+    claudeConfig.mcpServers = { ...(claudeConfig.mcpServers || {}), ...mcpJson };
+  }
+
   await fs.writeFile(claudeJsonPath, JSON.stringify(claudeConfig, null, 2), 'utf-8');
   return true;
 }
@@ -549,7 +565,7 @@ router.post('/install', async (req, res) => {
     for (const skill of agent.skills || []) {
       if (!skill.name || !skill.repo) continue;
       try {
-        const ok = await installSkill(skill.name, skill.repo, userUuid);
+        const ok = await installSkill(skill.name, skill.repo, userUuid, projectDir);
         skillResults.push({ name: skill.name, success: ok });
       } catch (err) {
         console.error(`[AgentInstall] Failed to install skill "${skill.name}":`, err.message);
@@ -557,12 +573,12 @@ router.post('/install', async (req, res) => {
       }
     }
 
-    // Install MCPs
+    // Install MCPs (project-scoped to the newly created project directory)
     const mcpResults = [];
     for (const mcp of agent.mcps || []) {
       if (!mcp.name || !mcp.repo) continue;
       try {
-        const ok = await installMcp(mcp.name, mcp.repo, userUuid);
+        const ok = await installMcp(mcp.name, mcp.repo, userUuid, projectDir);
         mcpResults.push({ name: mcp.name, success: ok });
       } catch (err) {
         console.error(`[AgentInstall] Failed to install MCP "${mcp.name}":`, err.message);

package/server/routes/mcp-repos.js

@@ -451,7 +451,7 @@ router.post('/install', async (req, res) => {
     const userUuid = req.user?.uuid;
     if (!userUuid) return res.status(401).json({ error: 'User authentication required' });
 
-    const { servicePath, scope = 'user' } = req.body;
+    const { servicePath, scope = 'user', projectPath } = req.body;
     if (!servicePath) return res.status(400).json({ error: 'servicePath is required' });
 
     // Security: ensure servicePath is within mcp-repo directory (public or user symlink dir)
@@ -476,11 +476,29 @@ router.post('/install', async (req, res) => {
     const installedServers = [];
     const errors = [];
 
-    // Install each server entry using claude mcp add-json
+    // Install each server entry
     for (const [serverName, serverConfig] of Object.entries(mcpJson)) {
       try {
-        await addMcpServerViaJson(serverName, serverConfig, scope, userPaths.claudeDir);
-        installedServers.push(serverName);
+        if (scope === 'local' && projectPath) {
+          // Bypass Claude CLI for local scope: directly write to .claude.json projects[projectPath].mcpServers
+          // (Claude CLI --scope local uses git root as key, which breaks in multi-user deployments)
+          const claudeJsonPath = path.join(userPaths.claudeDir, '.claude.json');
+          let claudeConfig = {};
+          try {
+            claudeConfig = JSON.parse(await fs.readFile(claudeJsonPath, 'utf-8'));
+          } catch {
+            claudeConfig = { hasCompletedOnboarding: true };
+          }
+          if (!claudeConfig.projects) claudeConfig.projects = {};
+          if (!claudeConfig.projects[projectPath]) claudeConfig.projects[projectPath] = {};
+          if (!claudeConfig.projects[projectPath].mcpServers) claudeConfig.projects[projectPath].mcpServers = {};
+          claudeConfig.projects[projectPath].mcpServers[serverName] = serverConfig;
+          await fs.writeFile(claudeJsonPath, JSON.stringify(claudeConfig, null, 2), 'utf-8');
+          installedServers.push(serverName);
+        } else {
+          await addMcpServerViaJson(serverName, serverConfig, scope, userPaths.claudeDir);
+          installedServers.push(serverName);
+        }
       } catch (err) {
         console.error(`[MCP Repos] CLI install failed for "${serverName}", using fallback:`, err.message);
         // Fallback: directly write to .claude.json

package/server/routes/skills.js

@@ -6,6 +6,7 @@ import multer from 'multer';
 import AdmZip from 'adm-zip';
 import { getUserPaths, getPublicPaths, DATA_DIR } from '../services/user-directories.js';
 import { ensureSystemRepo, SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME, SYSTEM_REPO_URL } from '../services/system-repo.js';
+import { loadProjectConfig, extractProjectDirectory } from '../projects.js';
 
 const router = express.Router();
 
@@ -443,13 +444,54 @@ router.get('/', async (req, res) => {
           enabled: true,
           source,
           repository,
-          path: realPath
+          path: realPath,
+          scope: 'user'
         });
       } catch (err) {
         console.error(`Error reading skill ${entry.name}:`, err.message);
       }
     }
 
+    // Also scan project-scoped skills from each project's .claude/skills/
+    try {
+      const projectConfig = await loadProjectConfig(userUuid);
+      for (const projectName of Object.keys(projectConfig)) {
+        let projectDir = null;
+        try { projectDir = await extractProjectDirectory(projectName, userUuid); } catch { continue; }
+        if (!projectDir) continue;
+        const projectSkillsDir = path.join(projectDir, '.claude', 'skills');
+        let projectEntries;
+        try { projectEntries = await fs.readdir(projectSkillsDir, { withFileTypes: true }); } catch { continue; }
+        for (const entry of projectEntries) {
+          if (entry.name.startsWith('.') || entry.name.toLowerCase().startsWith('readme')) continue;
+          const skillPath = path.join(projectSkillsDir, entry.name);
+          let realPath = skillPath;
+          let source = 'repo';
+          let repository = null;
+          try {
+            const stat = await fs.lstat(skillPath);
+            if (stat.isSymbolicLink()) {
+              try { realPath = await fs.realpath(skillPath); }
+              catch (e) { if (e.code === 'ENOENT') await fs.unlink(skillPath).catch(() => {}); continue; }
+              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]}`;
+              }
+            }
+            if (!await isValidSkill(realPath)) continue;
+            const metadata = await parseSkillMetadata(realPath);
+            skills.push({ name: entry.name, title: metadata.title, description: metadata.description, enabled: true, source, repository, path: realPath, scope: 'local', projectPath: projectDir });
+          } catch (err) {
+            console.error(`Error reading project skill ${entry.name}:`, err.message);
+          }
+        }
+      }
+    } catch (err) {
+      console.error('[Skills] Error scanning project-scoped skills:', err.message);
+    }
+
     // Compute sync status for each skill
     // For builtin skills, batch-check git status once
     const builtinChangedSkills = new Set();
@@ -472,6 +514,11 @@ router.get('/', async (req, res) => {
     }
 
     for (const skill of skills) {
+      if (skill.scope === 'local') {
+        skill.syncable = false;
+        skill.syncType = null;
+        continue;
+      }
       if (skill.source === 'imported' || skill.source === 'unknown') {
         skill.syncable = true;
         skill.syncType = 'local';
@@ -814,13 +861,16 @@ router.delete('/:name', async (req, res) => {
     }
 
     const { name } = req.params;
+    const { projectPath } = req.query;
 
     if (!SKILL_NAME_REGEX.test(name)) {
       return res.status(400).json({ error: 'Invalid skill name' });
     }
 
     const userPaths = getUserPaths(userUuid);
-    const linkPath = path.join(userPaths.skillsDir, name);
+    const linkPath = projectPath
+      ? path.join(projectPath, '.claude', 'skills', name)
+      : path.join(userPaths.skillsDir, name);
 
     // Check the symlink target to determine source
     let realPath = null;
@@ -1057,7 +1107,7 @@ router.post('/install/:name', async (req, res) => {
     }
 
     const { name } = req.params;
-    const { skillPath } = req.body;
+    const { skillPath, projectPath } = req.body;
 
     if (!SKILL_NAME_REGEX.test(name)) {
       return res.status(400).json({ error: 'Invalid skill name' });
@@ -1074,8 +1124,12 @@ router.post('/install/:name', async (req, res) => {
       return res.status(404).json({ error: 'Skill not found or invalid' });
     }
 
-    // Create symlink directly from user's skills directory to skill in repo
-    const userSkillLink = path.join(userPaths.skillsDir, name);
+    // Determine target directory: project-scoped or user global
+    const targetDir = projectPath
+      ? path.join(projectPath, '.claude', 'skills')
+      : userPaths.skillsDir;
+    await fs.mkdir(targetDir, { recursive: true });
+    const userSkillLink = path.join(targetDir, name);
 
     try {
       await fs.unlink(userSkillLink);