buddy-workbench 0.1.71 → 0.1.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "private": false,
   "type": "module",
   "bin": {
@@ -59,5 +59,8 @@
     "@jsquash/jpeg": "1.6.0",
     "axios": "1.7.9",
     "express": "5.1.0"
+  },
+  "overrides": {
+    "content-type": "2.0.0"
   }
 }

package/server/routes/overview.js

@@ -3,8 +3,6 @@ import axios from 'axios';
 import { Router } from 'express';
 import { readSettings } from '../repositories/settings.js';
 import { listTodos } from '../repositories/todos.js';
-import { listBranchSyncApps } from '../repositories/branch-sync.js';
-import { getPresentations } from '../repositories/presentations.js';
 import { recordApiError } from '../lib/api-errors.js';
 
 const router = Router();
@@ -16,16 +14,6 @@ const httpClient = axios.create({
 
 const isSuccess = (response) => response.status >= 200 && response.status < 300;
 const apiMessage = (response, fallback) => response?.data?.errors?.[0]?.message || response?.data?.errorMessages?.[0] || response?.data?.message || response?.statusText || fallback;
-const getPresentationInsights = () => getPresentations().plans
-  .slice()
-  .sort((a, b) => Number(b.updatedAt || b.createdAt || 0) - Number(a.updatedAt || a.createdAt || 0))
-  .map((plan) => ({
-    id: plan.id,
-    title: plan.title || plan.name || 'Untitled presentation',
-    summary: `${Array.isArray(plan.sections) ? plan.sections.length : 0} sections`,
-    updated: plan.updatedAt || plan.createdAt || null,
-    url: '#/presentation-plan'
-  }));
 
 function jiraHost(domain) {
   const clean = String(domain || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
@@ -39,20 +27,7 @@ function bitbucketHost(domain) {
   return clean.includes('bitbucket') ? clean : `bitbucket.${clean}`;
 }
 
-function parseRepo(repo) {
-  const raw = String(repo || '').replace(/\.git$/i, '');
-  try {
-    const url = new URL(raw.startsWith('ssh://') ? raw.replace(/^ssh:\/\//i, 'https://') : raw);
-    const parts = url.pathname.split('/').filter(Boolean);
-    if (parts[0] === 'scm' && parts.length >= 3) return { host: url.host, project: parts[1], slug: parts[2] };
-    if ((parts[0] === 'projects' || parts[0] === 'users') && parts.length >= 4) return { host: url.host, project: parts[0] === 'users' ? `~${parts[1]}` : parts[1], slug: parts[3] };
-    if (parts.length >= 2) return { host: url.host, project: parts.at(-2), slug: parts.at(-1) };
-  } catch {}
-  return null;
-}
-
 function jiraUrl(host, path) { return `https://${host}/rest/api/2${path}`; }
-function bitbucketUrl(host, path) { return `https://${host}/rest/api/latest${path}`; }
 
 async function requestSection(name, loader) {
   try {
@@ -95,10 +70,9 @@ async function loadJiraData(host, token) {
   const identity = { accountId: me.accountId || '', name: me.name || '', displayName: me.displayName || '' };
   const fields = 'summary,status,priority,duedate,updated,assignee,reporter';
 
-  const [due, activity, blocked] = await Promise.all([
+  const [due, activity] = await Promise.all([
     searchJira(host, token, 'assignee = currentUser() AND due = startOfDay() AND resolution = Unresolved ORDER BY priority DESC', fields),
-    searchJira(host, token, 'updated >= -14d AND resolution = Unresolved AND (assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC', fields, 30),
-    searchJira(host, token, 'status = Blocked AND updated <= -3d AND resolution = Unresolved ORDER BY updated ASC', fields)
+    searchJira(host, token, 'updated >= -14d AND resolution = Unresolved AND (assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC', fields, 30)
   ]);
 
   const activityItems = [];
@@ -130,15 +104,14 @@ async function loadJiraData(host, token) {
   return {
     identity,
     dueToday: due.map((issue) => ({ ...mapJiraIssue(issue), url: issueUrl(host, issue.key) })),
-    activity: activityItems.map((item) => ({ ...item, url: issueUrl(host, item.key) })),
-    blocked: blocked.map((issue) => ({ ...mapJiraIssue(issue), url: issueUrl(host, issue.key) }))
+    activity: activityItems.map((item) => ({ ...item, url: issueUrl(host, item.key) }))
   };
 }
 
-async function loadPullRequests(host, token, role) {
-  const url = `https://${host}/rest/api/latest/dashboard/pull-requests?role=${role}&state=OPEN&limit=100`;
+async function loadAuthoredPullRequests(host, token) {
+  const url = `https://${host}/rest/api/latest/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
   const response = await httpClient.get(url, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
-  if (!isSuccess(response)) throw new Error(`Bitbucket ${role} pull requests failed (${response.status}): ${apiMessage(response, 'Request failed')}`);
+  if (!isSuccess(response)) throw new Error(`Bitbucket author pull requests failed (${response.status}): ${apiMessage(response, 'Request failed')}`);
   return (response.data?.values || []).map((pr) => ({
     id: pr.id,
     title: pr.title || `Pull request #${pr.id}`,
@@ -149,65 +122,21 @@ async function loadPullRequests(host, token, role) {
   }));
 }
 
-async function loadFailedBuilds(host, token) {
-  const settings = readSettings();
-  const apps = listBranchSyncApps();
-  const repos = [];
-  for (const app of apps) {
-    for (const branch of [...new Set([app.activeBranch, app.lastReleaseBranch, 'master'].filter(Boolean))]) {
-      repos.push({ name: app.name, repo: app.repo, branch });
-    }
-    for (const sub of app.subApps || []) {
-      for (const branch of [...new Set([sub.branch, app.activeBranch, 'master'].filter(Boolean))]) {
-        repos.push({ name: sub.name || sub.directory, repo: sub.repo, branch });
-      }
-    }
-  }
-  const unique = [...new Map(repos.map((item) => [`${item.repo}|${item.branch}`, item])).values()];
-  const failed = [];
-  for (const item of unique.slice(0, 30)) {
-    const parsed = parseRepo(item.repo);
-    if (!parsed || (parsed.host && parsed.host !== host && !parsed.host.includes('bitbucket'))) continue;
-    const commitUrl = bitbucketUrl(parsed.host || host, `/projects/${encodeURIComponent(parsed.project)}/repos/${encodeURIComponent(parsed.slug)}/commits?until=${encodeURIComponent(item.branch)}&limit=1`);
-    const commitResponse = await httpClient.get(commitUrl, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
-    if (!isSuccess(commitResponse)) {
-      recordApiError({ source: 'Overview (Bitbucket Builds)', method: 'GET', url: commitUrl, status: commitResponse.status, message: apiMessage(commitResponse, 'Failed to fetch branch commit.') });
-      continue;
-    }
-    const hash = commitResponse.data?.values?.[0]?.id;
-    if (!hash) continue;
-    const buildUrl = `https://${parsed.host || host}/rest/api/latest/projects/${encodeURIComponent(parsed.project)}/repos/${encodeURIComponent(parsed.slug)}/commits/${encodeURIComponent(hash)}/builds`;
-    const buildResponse = await httpClient.get(buildUrl, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
-    if (!isSuccess(buildResponse)) {
-      if (buildResponse.status !== 404) recordApiError({ source: 'Overview (Bitbucket Builds)', method: 'GET', url: buildUrl, status: buildResponse.status, message: apiMessage(buildResponse, 'Failed to fetch build status.') });
-      continue;
-    }
-    for (const build of buildResponse.data?.values || []) {
-      if (String(build.state || '').toUpperCase() === 'FAILED') {
-        failed.push({ name: item.name, branch: item.branch, repository: item.repo, build: build.name || build.key || 'Build', date: build.dateAdded || null, url: item.repo });
-      }
-    }
-  }
-  return failed;
-}
-
 router.get('/', async (_req, res) => {
   const settings = readSettings();
-  const missingTokens = ['jira', 'bitbucket', 'confluence'].filter((service) => !settings[`${service}AccessToken`]);
+  const missingTokens = ['jira', 'bitbucket'].filter((service) => !settings[`${service}AccessToken`]);
   if (missingTokens.length > 0) {
-    return res.json({ configured: false, missingTokens, fetchedAt: new Date().toISOString(), categories: { presentations: getPresentationInsights() } });
+    return res.json({ configured: false, missingTokens, fetchedAt: new Date().toISOString(), categories: {} });
   }
   const jira = jiraHost(settings.domain);
   const bitbucket = bitbucketHost(settings.domain);
-  if (!jira || !bitbucket) return res.json({ configured: false, missingTokens: ['domain'], fetchedAt: new Date().toISOString(), categories: { presentations: getPresentationInsights() } });
+  if (!jira || !bitbucket) return res.json({ configured: false, missingTokens: ['domain'], fetchedAt: new Date().toISOString(), categories: {} });
 
   const sections = await Promise.all([
     requestSection('Jira', () => loadJiraData(jira, settings.jiraAccessToken)),
-    requestSection('Bitbucket Review', () => loadPullRequests(bitbucket, settings.bitbucketAccessToken, 'reviewer')),
-    requestSection('Bitbucket Author', () => loadPullRequests(bitbucket, settings.bitbucketAccessToken, 'author')),
-    requestSection('Bitbucket Builds', () => loadFailedBuilds(bitbucket, settings.bitbucketAccessToken))
+    requestSection('Bitbucket Author', () => loadAuthoredPullRequests(bitbucket, settings.bitbucketAccessToken))
   ]);
-  const [jiraData, reviewPrs, authoredPrs, failedBuilds] = sections;
+  const [jiraData, authoredPrs] = sections;
   const todos = listTodos().filter((todo) => !todo.completed && !todo.archived).map((todo) => ({ ...todo, url: '#/todo-list' }));
   const errors = sections.filter((section) => section.error).map((section) => section.error);
   res.json({
@@ -215,14 +144,10 @@ router.get('/', async (_req, res) => {
     missingTokens: [],
     fetchedAt: new Date().toISOString(),
     categories: {
+      activity: jiraData.items?.activity || [],
       jiraDueToday: jiraData.items?.dueToday || [],
       assignedTodos: todos,
-      reviewPrs: reviewPrs.items || [],
-      authoredPrs: authoredPrs.items || [],
-      failedBuilds: failedBuilds.items || [],
-      activity: jiraData.items?.activity || [],
-      blockedIssues: jiraData.items?.blocked || [],
-      presentations: getPresentationInsights()
+      authoredPrs: authoredPrs.items || []
     },
     errors
   });

package/server/services/dev-configurations.js

@@ -1,12 +1,25 @@
 import { execFile } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 
 const execFileAsync = promisify(execFile);
 const NPM_KEYS = ['prefix', 'registry', 'strict-ssl', 'cache', 'proxy', 'https-proxy'];
-const NVM_LOAD = 'if [ -s "$NVM_DIR/nvm.sh" ]; then . "$NVM_DIR/nvm.sh"; elif [ -s "$HOME/.nvm/nvm.sh" ]; then . "$HOME/.nvm/nvm.sh"; fi; ';
+
+function getNvmDir() {
+  const home = homedir();
+  const candidates = [
+    process.env.NVM_DIR,
+    join(home, '.nvm'),
+    '/opt/homebrew/opt/nvm',
+    '/usr/local/opt/nvm'
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    if (existsSync(join(dir, 'nvm.sh'))) return dir;
+  }
+  return process.env.NVM_DIR || join(home, '.nvm');
+}
 
 function getEnrichedEnv() {
   const home = homedir();
@@ -22,7 +35,7 @@ function getEnrichedEnv() {
       '/usr/sbin',
       '/sbin'
     ];
-  const nvmDir = process.env.NVM_DIR || join(home, '.nvm');
+  const nvmDir = getNvmDir();
   if (existsSync(nvmDir)) {
     try {
       const versionsDir = join(nvmDir, 'versions', 'node');
@@ -86,9 +99,18 @@ async function runNvm(script, timeout = 5000) {
   if (process.platform === 'win32') {
     throw new Error('Unix NVM shell is not supported on Windows.');
   }
-  for (const shell of ['zsh', 'bash']) {
+  const nvmDir = getNvmDir();
+  const nvmSh = join(nvmDir, 'nvm.sh');
+  const nvmLoad = existsSync(nvmSh) ? `. "${nvmSh}"; ` : '';
+  const fullScript = `${nvmLoad}${script}`;
+  for (const shell of ['bash', 'sh', 'zsh']) {
     try {
-      const { stdout } = await execFileAsync(shell, ['-ilc', `${NVM_LOAD}${script}`], { timeout, maxBuffer: 4 * 1024 * 1024, env: getEnrichedEnv(), windowsHide: false });
+      const { stdout } = await execFileAsync(shell, ['-c', fullScript], {
+        timeout,
+        maxBuffer: 4 * 1024 * 1024,
+        env: { ...getEnrichedEnv(), NVM_DIR: nvmDir },
+        windowsHide: false
+      });
       return stdout.trim();
     } catch {}
   }
@@ -100,22 +122,90 @@ function parseNvmVersions(output) {
 }
 
 export async function readNvmConfiguration() {
-  try {
-    const output = await runNvm('if ! command -v nvm >/dev/null 2>&1; then exit 1; fi; printf "__VERSION__%s\\n" "$(nvm --version)"; printf "__CURRENT__%s\\n" "$(nvm current)"; printf "__DEFAULT__%s\\n" "$(nvm alias default 2>/dev/null)"; printf "__DIR__%s\\n" "${NVM_DIR:-$HOME/.nvm}"; printf "__MIRROR__%s\\n" "${NVM_NODEJS_ORG_MIRROR:-}"; printf "__LIST__\\n"; nvm ls --no-colors');
-    const value = (key) => output.match(new RegExp(`__${key}__(.*)`))?.[1]?.trim() || '';
-    const defaultLine = value('DEFAULT');
+  const nvmDir = getNvmDir();
+  const nvmSh = join(nvmDir, 'nvm.sh');
+  if (!existsSync(nvmSh)) {
     return {
-      installed: true,
-      version: value('VERSION'),
-      currentVersion: value('CURRENT'),
-      defaultVersion: defaultLine.match(/->\s+(?:v)?(\d+(?:\.\d+){0,2}|node|lts\/[\w.-]+)/)?.[1] || '',
-      nvmDir: value('DIR'),
-      nodeJsMirror: value('MIRROR'),
-      installedVersions: parseNvmVersions(output.split('__LIST__')[1] || '')
+      installed: false,
+      version: '',
+      currentVersion: '',
+      defaultVersion: '',
+      nvmDir: '',
+      nodeJsMirror: '',
+      installedVersions: []
     };
-  } catch {
-    return { installed: false, version: '', currentVersion: '', defaultVersion: '', nvmDir: '', nodeJsMirror: '', installedVersions: [] };
   }
+
+  let version = '';
+  try {
+    const pkgFile = join(nvmDir, 'package.json');
+    if (existsSync(pkgFile)) {
+      const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'));
+      version = pkg.version || '';
+    }
+  } catch {}
+
+  const installedVersions = [];
+  const versionsDir = join(nvmDir, 'versions', 'node');
+  if (existsSync(versionsDir)) {
+    try {
+      for (const entry of readdirSync(versionsDir)) {
+        if (/^v?\d+/.test(entry)) {
+          installedVersions.push(entry.startsWith('v') ? entry : `v${entry}`);
+        }
+      }
+    } catch {}
+  }
+  try {
+    for (const entry of readdirSync(nvmDir)) {
+      if (/^v\d+\.\d+\.\d+$/.test(entry) && existsSync(join(nvmDir, entry, 'bin', 'node'))) {
+        if (!installedVersions.includes(entry)) installedVersions.push(entry);
+      }
+    }
+  } catch {}
+  installedVersions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true, sensitivity: 'base' }));
+
+  let defaultVersion = '';
+  try {
+    const defaultAliasFile = join(nvmDir, 'alias', 'default');
+    if (existsSync(defaultAliasFile)) {
+      defaultVersion = readFileSync(defaultAliasFile, 'utf8').trim();
+    }
+  } catch {}
+
+  let currentVersion = process.version || '';
+  try {
+    const currentLink = join(nvmDir, 'current');
+    if (existsSync(currentLink)) {
+      const real = basename(realpathSync(currentLink));
+      if (/^v?\d+/.test(real)) {
+        currentVersion = real.startsWith('v') ? real : `v${real}`;
+      }
+    }
+  } catch {}
+
+  let nodeJsMirror = process.env.NVM_NODEJS_ORG_MIRROR || '';
+  if (!nodeJsMirror) {
+    try {
+      const shellFile = basename(process.env.SHELL || '') === 'bash' ? '.bashrc' : '.zshrc';
+      const file = join(homedir(), shellFile);
+      if (existsSync(file)) {
+        const content = readFileSync(file, 'utf8');
+        const match = content.match(/export\s+NVM_NODEJS_ORG_MIRROR="([^"]*)"/);
+        if (match) nodeJsMirror = match[1];
+      }
+    } catch {}
+  }
+
+  return {
+    installed: true,
+    version,
+    currentVersion,
+    defaultVersion,
+    nvmDir,
+    nodeJsMirror,
+    installedVersions
+  };
 }
 
 async function readNpmConfig(key) {