@yemi33/minions 0.1.1896 → 0.1.1898

package/dashboard/js/render-other.js

@@ -85,18 +85,18 @@ function renderMcpServers(servers) {
   const countEl = document.getElementById('mcp-count');
   countEl.textContent = servers.length;
   if (!servers.length) {
-    el.innerHTML = '<p class="empty">No MCP servers found. Add them to <code>~/.claude.json</code> or <code>~/.copilot/mcp-config.json</code> and they\'ll appear here automatically.</p>';
+    el.innerHTML = '<p class="empty">No MCP servers found. Add them via <code>claude mcp add</code> / <code>copilot mcp add</code>, install a plugin that ships one, or drop a <code>.mcp.json</code> into a registered project — they\'ll appear here automatically.</p>';
     return;
   }
   el.innerHTML = '<div style="display:flex;flex-wrap:wrap;gap:6px;margin-bottom:8px">' +
     servers.map(s =>
-      '<div style="font-size:11px;padding:5px 10px;background:var(--surface2);border:1px solid var(--border);border-radius:6px;color:var(--text)" title="' + escHtml([s.source, s.args || s.command].filter(Boolean).join(': ')) + '">' +
+      '<div style="font-size:11px;padding:5px 10px;background:var(--surface2);border:1px solid var(--border);border-radius:6px;color:var(--text)" title="' + escHtml([s.source, s.status, s.args || s.command].filter(Boolean).join(' · ')) + '">' +
         escHtml(s.name) +
         (s.source ? ' <span style="color:var(--muted)">(' + escHtml(s.source) + ')</span>' : '') +
       '</div>'
     ).join('') +
   '</div>' +
-  '<p style="font-size:10px;color:var(--muted);margin:0">Synced from <code style="color:var(--blue)">~/.claude.json</code> and <code style="color:var(--blue)">~/.copilot/mcp-config.json</code>.</p>';
+  '<p style="font-size:10px;color:var(--muted);margin:0">Mirrors <code style="color:var(--blue)">claude mcp list</code> + <code style="color:var(--blue)">copilot mcp list --json</code>, plus workspace <code>.mcp.json</code> from each registered project. Cached ~5 min.</p>';
 }
 
 function renderMetrics(metrics) {

package/dashboard/js/render-plans.js

@@ -412,13 +412,16 @@ async function planExecute(file, project, btn) {
     const data = await res.json();
     if (res.ok) {
       // Inject into local work items so the next render immediately hides Execute
-      if (!data.alreadyQueued) {
+      if (!data.alreadyQueued && data.id) {
         (window._lastWorkItems = window._lastWorkItems || []).push({
           id: data.id, type: 'plan-to-prd', status: 'pending', planFile: file
         });
       }
       closeModal();
-      showToast('cmd-toast', data.alreadyQueued ? 'Already queued (' + data.id + ')' : 'Queued ' + data.id + ' — agent will convert plan to PRD', true);
+      // Fall back to a clean message if the server didn't return an id (#2375).
+      const idLabel = data.id ? ' (' + data.id + ')' : '';
+      const queuedLabel = data.id ? 'Queued ' + data.id + ' — agent will convert plan to PRD' : 'Plan queued — agent will convert plan to PRD';
+      showToast('cmd-toast', data.alreadyQueued ? 'Already queued' + idLabel : queuedLabel, true);
       wakeEngine();
       refreshPlans();
     } else {

package/dashboard.js

@@ -1198,27 +1198,146 @@ function getDiskVersion() {
   return _diskVersionCache;
 }
 
-function readMcpServersFromConfig(configPath, source) {
-  const data = safeJsonObj(configPath);
-  const servers = data.mcpServers || {};
-  return Object.entries(servers).map(([name, cfg]) => ({
-    name,
-    source,
-    command: cfg.command || cfg.url || '',
-    args: (cfg.args || []).slice(-1)[0] || '',
-  }));
+// ── MCP server discovery ─────────────────────────────────────────────────────
+// Mirrors what each CLI actually loads at runtime:
+//   • `claude mcp list`         → user + plugin (+ workspace if cwd in project)
+//   • `copilot mcp list --json` → user + workspace + plugin + builtin (merged)
+//   • Each registered project's `<localPath>/.mcp.json` → workspace scope
+//
+// CLI calls are slow (claude health-checks every server on stdio), so we cache
+// for ~5 minutes and refresh in the background. getMcpServers() always returns
+// synchronously from cache; first call before background fill returns [].
+
+const _MCP_CACHE_TTL = 5 * 60 * 1000;
+const _MCP_CLAUDE_TIMEOUT = 30000;
+const _MCP_COPILOT_TIMEOUT = 15000;
+let _mcpServersCache = null;
+let _mcpServersCacheTs = 0;
+let _mcpRefreshInflight = null;
+
+function _parseClaudeMcpListLine(line) {
+  const trimmed = (line || '').trim();
+  if (!trimmed) return null;
+  if (/^Checking\b/i.test(trimmed)) return null;
+  if (/^No MCP servers/i.test(trimmed)) return null;
+  const nameSep = trimmed.indexOf(': ');
+  if (nameSep < 0) return null;
+  const rawName = trimmed.slice(0, nameSep);
+  let rest = trimmed.slice(nameSep + 2);
+  let status = '';
+  const statusSep = rest.lastIndexOf(' - ');
+  if (statusSep >= 0) {
+    status = rest.slice(statusSep + 3).trim();
+    rest = rest.slice(0, statusSep).trim();
+  }
+  let source = 'Claude user';
+  let displayName = rawName;
+  if (rawName.startsWith('plugin:')) {
+    const parts = rawName.split(':');
+    source = parts.length >= 3 ? `Claude plugin: ${parts[1]}` : 'Claude plugin';
+    displayName = parts.slice(2).join(':') || parts[1];
+  } else if (rawName.startsWith('project:')) {
+    const parts = rawName.split(':');
+    source = parts.length >= 3 ? `Claude workspace: ${parts[1]}` : 'Claude workspace';
+    displayName = parts.slice(2).join(':') || parts[1];
+  }
+  return { name: displayName, source, command: rest, args: '', status };
+}
+
+function _parseCopilotMcpListJson(raw) {
+  try {
+    const data = JSON.parse(raw);
+    const servers = data?.mcpServers || {};
+    return Object.entries(servers).map(([name, cfg]) => ({
+      name,
+      source: 'Copilot',
+      command: cfg.command || cfg.url || '',
+      args: Array.isArray(cfg.args) ? cfg.args.join(' ') : (cfg.args || ''),
+    }));
+  } catch { return []; }
+}
+
+function _runCliAsync(cmd, args, timeoutMs) {
+  return new Promise(resolve => {
+    try {
+      const { exec } = require('child_process');
+      // exec() runs through the shell so Windows resolves .cmd/.exe shims off
+      // PATH. Args are static so there's no injection surface.
+      const line = [cmd, ...args].join(' ');
+      exec(line, {
+        timeout: timeoutMs, windowsHide: true, encoding: 'utf8',
+        maxBuffer: 1024 * 1024,
+      }, (err, stdout) => resolve(err ? null : stdout));
+    } catch { resolve(null); }
+  });
+}
+
+function _readWorkspaceMcpServers(projects) {
+  const out = [];
+  for (const p of (projects || [])) {
+    if (!p?.localPath) continue;
+    const data = safeJsonObj(path.join(p.localPath, '.mcp.json'));
+    const servers = data.mcpServers || {};
+    for (const [name, cfg] of Object.entries(servers)) {
+      out.push({
+        name,
+        source: `Workspace: ${p.name}`,
+        command: cfg.command || cfg.url || '',
+        args: Array.isArray(cfg.args) ? cfg.args.join(' ') : (cfg.args || ''),
+      });
+    }
+  }
+  return out;
+}
+
+function _dedupeMcpServers(entries) {
+  const seen = new Set();
+  const out = [];
+  for (const e of entries) {
+    const key = `${e.source}::${e.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(e);
+  }
+  return out;
+}
+
+async function _refreshMcpServersCache() {
+  if (_mcpRefreshInflight) return _mcpRefreshInflight;
+  _mcpRefreshInflight = (async () => {
+    try {
+      const [claudeOut, copilotOut] = await Promise.all([
+        _runCliAsync('claude', ['mcp', 'list'], _MCP_CLAUDE_TIMEOUT),
+        _runCliAsync('copilot', ['mcp', 'list', '--json'], _MCP_COPILOT_TIMEOUT),
+      ]);
+      const claudeEntries = (claudeOut || '').split(/\r?\n/).map(_parseClaudeMcpListLine).filter(Boolean);
+      const copilotEntries = _parseCopilotMcpListJson(copilotOut || '{}');
+      const workspaceEntries = _readWorkspaceMcpServers(PROJECTS);
+      _mcpServersCache = _dedupeMcpServers([...claudeEntries, ...copilotEntries, ...workspaceEntries]);
+      _mcpServersCacheTs = Date.now();
+    } catch (e) {
+      console.error('[mcp-discovery] refresh failed:', e.message?.split('\n')?.[0]);
+      if (!_mcpServersCache) _mcpServersCache = [];
+      _mcpServersCacheTs = Date.now();
+    } finally {
+      _mcpRefreshInflight = null;
+    }
+  })();
+  return _mcpRefreshInflight;
 }
 
 function getMcpServers() {
-  try {
-    const home = os.homedir();
-    return [
-      ...readMcpServersFromConfig(path.join(home, '.claude.json'), 'Claude'),
-      ...readMcpServersFromConfig(path.join(home, '.copilot', 'mcp-config.json'), 'Copilot'),
-    ];
-  } catch { return []; }
+  const now = Date.now();
+  if (!_mcpServersCache || (now - _mcpServersCacheTs) >= _MCP_CACHE_TTL) {
+    _refreshMcpServersCache().catch(() => {});
+  }
+  return _mcpServersCache || [];
 }
 
+// Kick off first discovery on startup so the dashboard has data before the
+// first slow-state rebuild.
+_refreshMcpServersCache().catch(() => {});
+
 function parsePinnedEntries(content) {
   if (!content) return [];
   const entries = [];
@@ -4574,7 +4693,7 @@ const server = http.createServer(async (req, res) => {
         const projectTarget = resolveProjectSourceTarget(projectName, PROJECTS, { allowCentral: false });
         const targetProject = projectTarget.project || (PROJECTS.length === 1 ? PROJECTS[0] : null);
         if (targetProject) {
-          diffAwareQueued = shared.queuePlanToPrd({
+          const diffAwareResult = shared.queuePlanToPrd({
             planFile: plan.source_plan, prdFile: body.file,
             title: `Update PRD from revised plan: ${plan.source_plan}`,
             description: `mode: diff-aware-update\nPlan file: plans/${plan.source_plan}\nPRD file: prd/${body.file}\n\n` +
@@ -4584,6 +4703,7 @@ const server = http.createServer(async (req, res) => {
             project: targetProject.name, createdBy: 'dashboard:plan-resume',
             extra: { _existingPrdFile: body.file },
           });
+          diffAwareQueued = diffAwareResult.queued;
         }
       }
 
@@ -4731,15 +4851,15 @@ const server = http.createServer(async (req, res) => {
           '\n\nA prior PRD already exists for this plan. Read it, apply this feedback, and overwrite the PRD with the corrected version.';
       }
 
-      const queued = shared.queuePlanToPrd({
+      const queueResult = shared.queuePlanToPrd({
         planFile: body.file,
         title: 'Convert plan to PRD: ' + body.file.replace('.md', ''),
         description,
         project: declaredProject || body.project || '', createdBy: 'dashboard:execute',
       });
-      if (!queued) return jsonReply(res, 200, { ok: true, alreadyQueued: true });
+      if (!queueResult.queued) return jsonReply(res, 200, { ok: true, alreadyQueued: true, id: queueResult.id });
       invalidateStatusCache();
-      return jsonReply(res, 200, { ok: true });
+      return jsonReply(res, 200, { ok: true, id: queueResult.id });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
@@ -7782,6 +7902,10 @@ function _installCrashHandlers() {
 // Production entry points use the closures directly; tests import via require('./dashboard').
 module.exports = {
   getMcpServers,
+  _parseClaudeMcpListLine,
+  _parseCopilotMcpListJson,
+  _readWorkspaceMcpServers,
+  _dedupeMcpServers,
   readBody,
   _filterCcTabSessions,
   _getVersionCheckInterval,

package/engine/shared.js

@@ -1628,17 +1628,30 @@ function trackReviewMetric(pr, newReviewStatus, config) {
   } catch (err) { log('warn', `Metrics update: ${err.message}`); }
 }
 
-/** Queue a plan-to-prd work item with dedup check inside lock. Returns true if queued. */
+/**
+ * Queue a plan-to-prd work item with dedup check inside lock.
+ *
+ * Returns { queued, alreadyQueued, id, item } so callers (e.g. POST /api/plans/execute)
+ * can surface the new or existing work item id back to the dashboard. Returning
+ * just a boolean caused the toast to render "queued undefined" (issue #2375).
+ */
 function queuePlanToPrd({ planFile, prdFile, title, description, project, createdBy, extra }) {
   // Use MINIONS_DIR (honors MINIONS_TEST_DIR override) instead of resolving from
   // __dirname — otherwise tests that exercise this helper leak work items into
   // the real package-root work-items.json even after createTestMinionsDir().
   const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
   let queued = false;
+  let id = null;
+  let item = null;
   mutateJsonFileLocked(centralWiPath, items => {
     if (!Array.isArray(items)) items = [];
-    if (items.some(w => w.type === 'plan-to-prd' && w.planFile === planFile && (w.status === 'pending' || w.status === 'dispatched'))) return items;
-    items.push({
+    const existing = items.find(w => w.type === 'plan-to-prd' && w.planFile === planFile && (w.status === 'pending' || w.status === 'dispatched'));
+    if (existing) {
+      id = existing.id;
+      item = existing;
+      return items;
+    }
+    const newItem = {
       id: 'W-' + uid(),
       title,
       type: 'plan-to-prd',
@@ -1650,11 +1663,14 @@ function queuePlanToPrd({ planFile, prdFile, title, description, project, create
       project,
       planFile,
       ...(extra || {}),
-    });
+    };
+    items.push(newItem);
     queued = true;
+    id = newItem.id;
+    item = newItem;
     return items;
   }, { defaultValue: [] });
-  return queued;
+  return { queued, alreadyQueued: !queued, id, item };
 }
 
 function extractPlanDeclaredProject(planContent) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1896",
+  "version": "0.1.1898",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"