@ian2018cs/agenthub 0.1.69 → 0.1.70

package/server/routes/mcp.js

@@ -70,67 +70,67 @@ router.post('/cli/add', async (req, res) => {
       return res.status(401).json({ error: 'User authentication required' });
     }
 
-    console.log(`➕ Adding MCP server using Claude CLI (${scope} scope):`, name);
+    console.log(`➕ Adding MCP server (${scope} scope):`, name);
 
     const userPaths = getUserPaths(userUuid);
+
+    // For local scope, bypass Claude CLI and directly write to .claude.json.
+    // Claude CLI resolves the project key by walking up to the git root, which in
+    // our multi-user deployment always resolves to the app root — not the user's
+    // actual project directory. We write directly to avoid this mis-keying.
+    if (scope === 'local' && projectPath) {
+      const claudeJsonPath = path.join(userPaths.claudeDir, '.claude.json');
+      let claudeConfig = {};
+      try {
+        claudeConfig = JSON.parse(await fs.readFile(claudeJsonPath, 'utf-8'));
+      } catch { /* start fresh if missing */ }
+
+      // Build the server entry in the same shape Claude CLI would write
+      let serverEntry = {};
+      if (type === 'http' || type === 'sse') {
+        serverEntry = { transport: type, url, ...(Object.keys(headers).length ? { headers } : {}) };
+      } else {
+        serverEntry = { command, ...(args?.length ? { args } : {}), ...(Object.keys(env).length ? { env } : {}) };
+      }
+
+      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[name] = serverEntry;
+
+      await fs.writeFile(claudeJsonPath, JSON.stringify(claudeConfig, null, 2), 'utf-8');
+      console.log(`[MCP] Wrote local-scoped MCP "${name}" for project ${projectPath}`);
+      return res.json({ success: true, message: `MCP server "${name}" added successfully` });
+    }
+
     const { spawn } = await import('child_process');
-    
-    let cliArgs = ['mcp', 'add'];
-    
-    // Add scope flag
-    cliArgs.push('--scope', scope);
-    
+
+    let cliArgs = ['mcp', 'add', '--scope', scope];
+
     if (type === 'http') {
       cliArgs.push('--transport', 'http', name, url);
-      // Add headers if provided
-      Object.entries(headers).forEach(([key, value]) => {
-        cliArgs.push('--header', `${key}: ${value}`);
-      });
+      Object.entries(headers).forEach(([key, value]) => { cliArgs.push('--header', `${key}: ${value}`); });
     } else if (type === 'sse') {
       cliArgs.push('--transport', 'sse', name, url);
-      // Add headers if provided
-      Object.entries(headers).forEach(([key, value]) => {
-        cliArgs.push('--header', `${key}: ${value}`);
-      });
+      Object.entries(headers).forEach(([key, value]) => { cliArgs.push('--header', `${key}: ${value}`); });
     } else {
-      // stdio (default): claude mcp add --scope user <name> <command> [args...]
       cliArgs.push(name);
-      // Add environment variables
-      Object.entries(env).forEach(([key, value]) => {
-        cliArgs.push('-e', `${key}=${value}`);
-      });
+      Object.entries(env).forEach(([key, value]) => { cliArgs.push('-e', `${key}=${value}`); });
       cliArgs.push(command);
-      if (args && args.length > 0) {
-        cliArgs.push(...args);
-      }
+      if (args?.length) cliArgs.push(...args);
     }
-    
+
     console.log('🔧 Running Claude CLI command:', 'claude', cliArgs.join(' '));
 
-    // For local scope, we need to run the command in the project directory
-    const spawnOptions = {
+    const cliProcess = spawn('claude', cliArgs, {
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env, CLAUDE_CONFIG_DIR: userPaths.claudeDir }
-    };
-
-    if (scope === 'local' && projectPath) {
-      spawnOptions.cwd = projectPath;
-      console.log('📁 Running in project directory:', projectPath);
-    }
-
-    const cliProcess = spawn('claude', cliArgs, spawnOptions);
+    });
 
     let stdout = '';
     let stderr = '';
-
-    cliProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    cliProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
+    cliProcess.stdout.on('data', (data) => { stdout += data.toString(); });
+    cliProcess.stderr.on('data', (data) => { stderr += data.toString(); });
     cliProcess.on('close', (code) => {
       if (code === 0) {
         res.json({ success: true, output: stdout, message: `MCP server "${name}" added successfully` });
@@ -139,9 +139,7 @@ router.post('/cli/add', async (req, res) => {
         res.status(400).json({ error: 'Claude CLI command failed', details: stderr });
       }
     });
-
     cliProcess.on('error', (error) => {
-      console.error('Error running Claude CLI:', error);
       res.status(500).json({ error: 'Failed to run Claude CLI', details: error.message });
     });
   } catch (error) {
@@ -150,6 +148,7 @@ router.post('/cli/add', async (req, res) => {
   }
 });
 
+// POST /api/mcp/cli/add-json - Add MCP server using JSON format
 // POST /api/mcp/cli/add-json - Add MCP server using JSON format
 router.post('/cli/add-json', async (req, res) => {
   try {
@@ -167,74 +166,62 @@ router.post('/cli/add-json', async (req, res) => {
     try {
       parsedConfig = typeof jsonConfig === 'string' ? JSON.parse(jsonConfig) : jsonConfig;
     } catch (parseError) {
-      return res.status(400).json({
-        error: 'Invalid JSON configuration',
-        details: parseError.message
-      });
+      return res.status(400).json({ error: 'Invalid JSON configuration', details: parseError.message });
     }
 
-    // Validate required fields
     if (!parsedConfig.type) {
-      return res.status(400).json({
-        error: 'Invalid configuration',
-        details: 'Missing required field: type'
-      });
+      return res.status(400).json({ error: 'Invalid configuration', details: 'Missing required field: type' });
     }
-
     if (parsedConfig.type === 'stdio' && !parsedConfig.command) {
-      return res.status(400).json({
-        error: 'Invalid configuration',
-        details: 'stdio type requires a command field'
-      });
+      return res.status(400).json({ error: 'Invalid configuration', details: 'stdio type requires a command field' });
     }
-
     if ((parsedConfig.type === 'http' || parsedConfig.type === 'sse') && !parsedConfig.url) {
-      return res.status(400).json({
-        error: 'Invalid configuration',
-        details: `${parsedConfig.type} type requires a url field`
-      });
+      return res.status(400).json({ error: 'Invalid configuration', details: `${parsedConfig.type} type requires a url field` });
     }
 
     const userPaths = getUserPaths(userUuid);
-    const { spawn } = await import('child_process');
 
-    // Build the command: claude mcp add-json --scope <scope> <name> '<json>'
-    const cliArgs = ['mcp', 'add-json', '--scope', scope, name];
+    // For local scope, bypass Claude CLI (same reason as cli/add — git root mis-keying).
+    if (scope === 'local' && projectPath) {
+      const claudeJsonPath = path.join(userPaths.claudeDir, '.claude.json');
+      let claudeConfig = {};
+      try {
+        claudeConfig = JSON.parse(await fs.readFile(claudeJsonPath, 'utf-8'));
+      } catch { /* start fresh if missing */ }
+
+      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[name] = parsedConfig;
+
+      await fs.writeFile(claudeJsonPath, JSON.stringify(claudeConfig, null, 2), 'utf-8');
+      console.log(`[MCP] Wrote local-scoped MCP "${name}" (JSON) for project ${projectPath}`);
+
+      // Sync to Codex config.toml (fire-and-forget)
+      const codexConfigPath = path.join(userPaths.codexHomeDir, '.codex', 'config.toml');
+      addToCodexConfig(codexConfigPath, { [name]: parsedConfig }).catch(err =>
+        console.error('[MCP] Failed to sync to Codex config.toml:', err.message)
+      );
+      return res.json({ success: true, message: `MCP server "${name}" added successfully via JSON` });
+    }
 
-    // Add the JSON config as a properly formatted string
-    const jsonString = JSON.stringify(parsedConfig);
-    cliArgs.push(jsonString);
+    const { spawn } = await import('child_process');
 
-    console.log('🔧 Running Claude CLI command:', 'claude', cliArgs[0], cliArgs[1], cliArgs[2], cliArgs[3], cliArgs[4], jsonString);
+    const cliArgs = ['mcp', 'add-json', '--scope', scope, name, JSON.stringify(parsedConfig)];
+    console.log('🔧 Running Claude CLI command:', 'claude', cliArgs[0], cliArgs[1], cliArgs[2], cliArgs[3], cliArgs[4]);
 
-    // For local scope, we need to run the command in the project directory
-    const spawnOptions = {
+    const cliProcess = spawn('claude', cliArgs, {
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env, CLAUDE_CONFIG_DIR: userPaths.claudeDir }
-    };
-
-    if (scope === 'local' && projectPath) {
-      spawnOptions.cwd = projectPath;
-      console.log('📁 Running in project directory:', projectPath);
-    }
-
-    const cliProcess = spawn('claude', cliArgs, spawnOptions);
+    });
 
     let stdout = '';
     let stderr = '';
-
-    cliProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    cliProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
+    cliProcess.stdout.on('data', (data) => { stdout += data.toString(); });
+    cliProcess.stderr.on('data', (data) => { stderr += data.toString(); });
     cliProcess.on('close', (code) => {
       if (code === 0) {
         res.json({ success: true, output: stdout, message: `MCP server "${name}" added successfully via JSON` });
-        // Sync to Codex config.toml (fire-and-forget)
         const codexConfigPath = path.join(userPaths.codexHomeDir, '.codex', 'config.toml');
         addToCodexConfig(codexConfigPath, { [name]: parsedConfig }).catch(err =>
           console.error('[MCP] Failed to sync to Codex config.toml:', err.message)
@@ -244,9 +231,7 @@ router.post('/cli/add-json', async (req, res) => {
         res.status(400).json({ error: 'Claude CLI command failed', details: stderr });
       }
     });
-
     cliProcess.on('error', (error) => {
-      console.error('Error running Claude CLI:', error);
       res.status(500).json({ error: 'Failed to run Claude CLI', details: error.message });
     });
   } catch (error) {
@@ -259,42 +244,44 @@ router.post('/cli/add-json', async (req, res) => {
 router.delete('/cli/remove/:name', async (req, res) => {
   try {
     const { name } = req.params;
-    const { scope } = req.query; // Get scope from query params
+    const { scope, projectPath } = req.query;
 
     const userUuid = req.user?.uuid;
     if (!userUuid) {
       return res.status(401).json({ error: 'User authentication required' });
     }
 
-    // Handle the ID format (remove scope prefix if present)
-    let actualName = name;
-    let actualScope = scope;
-
-    // If the name includes a scope prefix like "local:test", extract it
-    if (name.includes(':')) {
-      const [prefix, serverName] = name.split(':');
-      actualName = serverName;
-      actualScope = actualScope || prefix; // Use prefix as scope if not provided in query
-    }
-
-    console.log('🗑️ Removing MCP server using Claude CLI:', actualName, 'scope:', actualScope);
+    const actualScope = scope || 'user';
+    console.log('🗑️ Removing MCP server:', name, 'scope:', actualScope);
 
     const userPaths = getUserPaths(userUuid);
-    const { spawn } = await import('child_process');
-
-    // Build command args based on scope
-    let cliArgs = ['mcp', 'remove'];
 
-    // Add scope flag if it's local scope
+    // For local scope, bypass Claude CLI and directly edit .claude.json.
     if (actualScope === 'local') {
-      cliArgs.push('--scope', 'local');
-    } else if (actualScope === 'user' || !actualScope) {
-      // User scope is default, but we can be explicit
-      cliArgs.push('--scope', 'user');
+      if (!projectPath) {
+        return res.status(400).json({ error: 'projectPath is required for local-scoped MCP removal' });
+      }
+      const claudeJsonPath = path.join(userPaths.claudeDir, '.claude.json');
+      try {
+        const claudeConfig = JSON.parse(await fs.readFile(claudeJsonPath, 'utf-8'));
+        const projectMcps = claudeConfig.projects?.[projectPath]?.mcpServers;
+        if (projectMcps && name in projectMcps) {
+          delete projectMcps[name];
+          await fs.writeFile(claudeJsonPath, JSON.stringify(claudeConfig, null, 2), 'utf-8');
+        }
+      } catch (e) {
+        return res.status(500).json({ error: 'Failed to update .claude.json', details: e.message });
+      }
+      // Sync removal to Codex (fire-and-forget)
+      const codexConfigPath = path.join(userPaths.codexHomeDir, '.codex', 'config.toml');
+      removeFromCodexConfig(codexConfigPath, name).catch(err =>
+        console.error('[MCP] Failed to sync removal to Codex config.toml:', err.message)
+      );
+      return res.json({ success: true, message: `MCP server "${name}" removed successfully` });
     }
 
-    cliArgs.push(actualName);
-
+    const { spawn } = await import('child_process');
+    const cliArgs = ['mcp', 'remove', '--scope', actualScope, name];
     console.log('🔧 Running Claude CLI command:', 'claude', cliArgs.join(' '));
 
     const cliProcess = spawn('claude', cliArgs, {
@@ -304,21 +291,13 @@ router.delete('/cli/remove/:name', async (req, res) => {
 
     let stdout = '';
     let stderr = '';
-
-    cliProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    cliProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
+    cliProcess.stdout.on('data', (data) => { stdout += data.toString(); });
+    cliProcess.stderr.on('data', (data) => { stderr += data.toString(); });
     cliProcess.on('close', (code) => {
       if (code === 0) {
         res.json({ success: true, output: stdout, message: `MCP server "${name}" removed successfully` });
-        // Sync removal to Codex config.toml (fire-and-forget)
         const codexConfigPath = path.join(userPaths.codexHomeDir, '.codex', 'config.toml');
-        removeFromCodexConfig(codexConfigPath, actualName).catch(err =>
+        removeFromCodexConfig(codexConfigPath, name).catch(err =>
           console.error('[MCP] Failed to sync removal to Codex config.toml:', err.message)
         );
       } else {
@@ -326,9 +305,7 @@ router.delete('/cli/remove/:name', async (req, res) => {
         res.status(400).json({ error: 'Claude CLI command failed', details: stderr });
       }
     });
-
     cliProcess.on('error', (error) => {
-      console.error('Error running Claude CLI:', error);
       res.status(500).json({ error: 'Failed to run Claude CLI', details: error.message });
     });
   } catch (error) {
@@ -464,26 +441,24 @@ router.get('/config/read', async (req, res) => {
       }
     }
     
-    // Check for local-scoped MCP servers (project-specific)
-    const currentProjectPath = process.cwd();
-    
-    // Check under 'projects' key
-    if (configData.projects && configData.projects[currentProjectPath]) {
-      const projectConfig = configData.projects[currentProjectPath];
-      if (projectConfig.mcpServers && typeof projectConfig.mcpServers === 'object' && Object.keys(projectConfig.mcpServers).length > 0) {
-        console.log(`🔍 Found local-scoped MCP servers for ${currentProjectPath}:`, Object.keys(projectConfig.mcpServers));
+    // Check for local-scoped MCP servers (project-specific) — iterate all projects
+    if (configData.projects && typeof configData.projects === 'object') {
+      for (const [projectPath, projectConfig] of Object.entries(configData.projects)) {
+        if (!projectConfig?.mcpServers || typeof projectConfig.mcpServers !== 'object') continue;
+        const mcpNames = Object.keys(projectConfig.mcpServers);
+        if (mcpNames.length === 0) continue;
+        console.log(`🔍 Found local-scoped MCP servers for ${projectPath}:`, mcpNames);
         for (const [name, config] of Object.entries(projectConfig.mcpServers)) {
           const server = {
-            id: `local:${name}`,  // Prefix with scope for uniqueness
-            name: name,           // Keep original name
-            type: 'stdio', // Default type
-            scope: 'local',  // Local scope - only for this project
-            projectPath: currentProjectPath,
+            id: name,
+            name: name,
+            type: 'stdio',
+            scope: 'local',
+            projectPath: projectPath,
             config: {},
-            raw: config // Include raw config for full details
+            raw: config
           };
-          
-          // Determine transport type and extract config
+
           if (config.command) {
             server.type = 'stdio';
             server.config.command = config.command;
@@ -494,7 +469,7 @@ router.get('/config/read', async (req, res) => {
             server.config.url = config.url;
             server.config.headers = config.headers || {};
           }
-          
+
           servers.push(server);
         }
       }

package/server/routes/skills.js

@@ -423,6 +423,89 @@ 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 });
+  }
+});
+
 /**
  * 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);