@yemi33/minions 0.1.2265 → 0.1.2267

package/dashboard.js

@@ -590,6 +590,126 @@ let _prRefVerifierOverride = null;   // test seam
 // (prRef, project) and returns true | false | null.
 function _setPrRefVerifierForTest(fn) { _prRefVerifierOverride = (typeof fn === 'function') ? fn : null; }
 
+// ── Live PR fetch helpers (W-mqtrnp7y00056bc8) ───────────────────────────────
+//
+// When GET /api/prs/:id is called for a PR that is not in the local tracker
+// (e.g. merged before the engine started tracking, or from an unpolled repo),
+// attempt a live fetch from the platform API and return a shaped record with
+// _liveOnly: true. Falls back to the existing 404 when both lookups fail.
+
+const LIVE_PR_FETCH_TIMEOUT_MS = 8000;
+
+// Test seam: when set, replaces the real _fetchLivePrRecord call so unit tests
+// can inject a mock without standing up a real gh CLI or ADO endpoint.
+let _livePrFetchForTest = null;
+function _setLivePrFetchForTest(fn) {
+  _livePrFetchForTest = typeof fn === 'function' ? fn : null;
+}
+
+function _mapGhPrToRecord(ghPr, canonicalId) {
+  const isMerged = !!ghPr.merged_at;
+  const status = isMerged ? 'merged' : ghPr.state === 'closed' ? 'closed' : 'active';
+  return {
+    id: canonicalId,
+    prNumber: ghPr.number,
+    title: (ghPr.title || `PR #${ghPr.number}`).slice(0, 120),
+    agent: (ghPr.user && ghPr.user.login) ? String(ghPr.user.login).toLowerCase() : 'unknown',
+    branch: (ghPr.head && ghPr.head.ref) || '',
+    status,
+    url: ghPr.html_url || '',
+    description: typeof ghPr.body === 'string' ? ghPr.body.slice(0, 500) : '',
+    _liveOnly: true,
+  };
+}
+
+function _mapAdoPrToRecord(adoPr, canonicalId, ref) {
+  const status = adoPr.status === 'completed' ? 'merged'
+    : adoPr.status === 'abandoned' ? 'abandoned'
+    : 'active';
+  const branch = typeof adoPr.sourceRefName === 'string'
+    ? adoPr.sourceRefName.replace(/^refs\/heads\//, '')
+    : '';
+  const author = (adoPr.createdBy && (adoPr.createdBy.uniqueName || adoPr.createdBy.displayName)) || 'unknown';
+  const prUrl = `https://dev.azure.com/${encodeURIComponent(ref.org)}/${encodeURIComponent(ref.project)}/_git/${encodeURIComponent(ref.repo)}/pullrequest/${ref.number}`;
+  return {
+    id: canonicalId,
+    prNumber: adoPr.pullRequestId || ref.number,
+    title: (adoPr.title || `PR #${ref.number}`).slice(0, 120),
+    agent: String(author).toLowerCase(),
+    branch,
+    status,
+    url: prUrl,
+    description: typeof adoPr.description === 'string' ? adoPr.description.slice(0, 500) : '',
+    _liveOnly: true,
+  };
+}
+
+// Exported for unit testing — fetch a PR live from the platform API and return
+// a tracker-shaped record. Returns null when the canonical id is not parseable
+// or the host is unrecognized. Throws on fetch errors so callers can decide
+// whether to log-and-degrade or propagate.
+//
+// opts: test seams only — production callers pass no opts.
+//   _resolveTokenForSlug(slug) → token string or null
+//   _shellSafeGh(args, opts)   → stdout string (argv-form gh CLI)
+//   _adoFetch(url, token)      → parsed JSON object
+//   _adoToken                  → ADO bearer token string (skips ado.getAdoToken())
+async function _fetchLivePrRecord(canonicalId, opts) {
+  const o = opts || {};
+  const parsed = shared.parseCanonicalPrId(canonicalId);
+  if (!parsed) return null; // bare number or unknown format
+  const { scope, prNumber } = parsed;
+  const colonIdx = scope.indexOf(':');
+  const host = scope.slice(0, colonIdx).toLowerCase();
+  const scopeSlug = scope.slice(colonIdx + 1);
+
+  if (host === 'github') {
+    const [owner, repo] = scopeSlug.split('/');
+    if (!owner || !repo) return null;
+    const ghSlug = shared.validateGhSlug(`${owner}/${repo}`);
+    const num = String(prNumber);
+    const resolveToken = o._resolveTokenForSlug || ghToken.resolveTokenForSlug;
+    const token = resolveToken(`${owner}/${repo}`);
+    const ghOpts = { timeout: LIVE_PR_FETCH_TIMEOUT_MS };
+    if (token) ghOpts.env = { ...process.env, GH_TOKEN: token };
+    const shellGh = o._shellSafeGh || shared.shellSafeGh;
+    const raw = await shellGh(['api', `repos/${ghSlug}/pulls/${num}`], ghOpts);
+    const ghPr = JSON.parse(raw);
+    return _mapGhPrToRecord(ghPr, canonicalId);
+  }
+
+  if (host === 'ado') {
+    const segs = scopeSlug.split('/');
+    if (segs.length < 3) return null;
+    const [org, project, repo] = segs;
+    const ref = { host: 'ado', slug: scopeSlug, org, project, repo, number: prNumber, id: canonicalId };
+    const doFetch = o._adoFetch || (async (url, adoToken) => {
+      const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${adoToken}`, 'Content-Type': 'application/json' },
+        signal: AbortSignal.timeout(LIVE_PR_FETCH_TIMEOUT_MS),
+      });
+      if (!res.ok) throw new Error(`ADO API ${res.status}: ${res.statusText}`);
+      const text = await res.text();
+      if (!text || text.trimStart().startsWith('<')) {
+        throw new Error(`ADO returned HTML instead of JSON for ${url.split('?')[0]}`);
+      }
+      return JSON.parse(text);
+    });
+    const adoTok = o._adoToken != null ? o._adoToken : await ado.getAdoToken();
+    if (!adoTok) throw new Error(`Could not acquire ADO token for ${canonicalId}`);
+    const orgBase = `https://dev.azure.com/${encodeURIComponent(org)}`;
+    const projEnc = encodeURIComponent(project);
+    const repoEnc = encodeURIComponent(repo);
+    const adoPr = await doFetch(
+      `${orgBase}/${projEnc}/_apis/git/repositories/${repoEnc}/pullRequests/${prNumber}?api-version=7.1`,
+      adoTok,
+    );
+    return _mapAdoPrToRecord(adoPr, canonicalId, ref);
+  }
+
+  return null; // unknown host
+}
+
 function _findTrackedPrRecord(prRef, project) {
   if (!project) return null;
   try {
@@ -2055,10 +2175,6 @@ function _compareVersions(a, b) {
   return 0;
 }
 
-// Kick off first npm check on startup, then re-check every 4 hours
-checkNpmVersion().catch(() => {});
-setInterval(() => checkNpmVersion().catch(() => {}), _getVersionCheckInterval()).unref();
-
 // Cache disk version + git commit (only changes on deploy/pull, not per-request)
 let _diskVersionCache = null;
 let _diskVersionCacheTs = 0;
@@ -6398,16 +6514,35 @@ const server = http.createServer(async (req, res) => {
 
   // GET /api/prs/<id> — return a single fully-enriched PR record by canonical
   // id (`<host>:<slug>#<number>`) or by bare number (P-79b47b0c). The in-stack
-  // PR modal (renderPrs.openPrDetail) calls this on demand. Always returns the
-  // record exactly as queries.getPullRequests() produces it (no slimming).
+  // PR modal (renderPrs.openPrDetail) calls this on demand. Returns the local
+  // tracker record when found; falls back to a live platform fetch (GitHub REST
+  // or ADO) for PRs that were never added to the tracker. The live record
+  // carries _liveOnly: true so the UI can optionally surface a "start tracking"
+  // offer. Returns {"error":"pr not found"} when both lookups fail.
   async function handlePrsById(req, res, match) {
     try {
       const id = decodeURIComponent(match[1] || '').trim();
       if (!id) return jsonReply(res, 400, { error: 'id required' });
       const prs = queries.getPullRequests();
       const found = prs.find(p => p && (p.id === id || String(p.number) === id));
-      if (!found) return jsonReply(res, 404, { error: 'pr not found' });
-      return jsonReply(res, 200, { pr: found });
+      if (found) return jsonReply(res, 200, { pr: found });
+
+      // Not in local tracker — attempt live fetch from platform API.
+      const liveFetch = _livePrFetchForTest || _fetchLivePrRecord;
+      let liveRecord = null;
+      try {
+        liveRecord = await Promise.race([
+          liveFetch(id),
+          new Promise((_, rej) => {
+            const t = setTimeout(() => rej(new Error(`live PR fetch timed out for ${id}`)), LIVE_PR_FETCH_TIMEOUT_MS + 1000);
+            if (t.unref) t.unref();
+          }),
+        ]);
+      } catch (e) {
+        shared.log('warn', `handlePrsById: live fetch failed for ${id}: ${e.message}`);
+      }
+      if (liveRecord) return jsonReply(res, 200, { pr: liveRecord });
+      return jsonReply(res, 404, { error: 'pr not found' });
     } catch (e) { return jsonReply(res, 500, { error: e.message }); }
   }
 
@@ -14166,6 +14301,8 @@ function _installCrashHandlers() {
 module.exports = {
   getMcpServers,
   _setPrRefVerifierForTest, // issue #246 — inject a fake loose-PR-ref verifier in handler tests
+  _setLivePrFetchForTest,   // W-mqtrnp7y00056bc8 — inject a mock live fetch for unit tests
+  _fetchLivePrRecord,       // W-mqtrnp7y00056bc8 — exported for direct unit testing
   _parseClaudeMcpListLine,
   _parseCopilotMcpListJson,
   _readWorkspaceMcpServers,
@@ -14322,6 +14459,13 @@ if (require.main === module) {
   // boot-time set. See shared.ensureAgentCopilotHome. Fail-open.
   try { process.env.COPILOT_HOME = shared.ensureAgentCopilotHome(MINIONS_DIR, CONFIG?.engine); } catch {}
 
+  // Kick off first npm check on startup, then re-check every 4 hours.
+  // Guarded here so that requiring dashboard as a module (unit tests, _withDashServer)
+  // does not spawn npm child processes that keep the event loop alive past test teardown
+  // and cause exit-without-summary flakiness on the Windows CI runner (W-mqtrby890001cb04).
+  checkNpmVersion().catch(() => {});
+  setInterval(() => checkNpmVersion().catch(() => {}), _getVersionCheckInterval()).unref();
+
   // Pre-warm the per-project git-status cache before accepting requests so
   // the first /api/status after restart already returns gitState='ok' with a
   // real branch instead of the ~8s pending gap that hides the projects-bar

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2265",
+  "version": "0.1.2267",
   "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"