buddy-workbench 0.1.100 → 0.1.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.100",
+  "version": "0.1.102",
   "private": false,
   "type": "module",
   "bin": {

package/server/config.js

@@ -35,6 +35,7 @@ export const paths = {
   errors: join(userDataDir, 'errors.json'),
   postman: join(userDataDir, 'postman.json'),
   branchSync: join(userDataDir, 'branch-sync.json'),
+  branchHealthHistory: join(userDataDir, 'branch-health-history.json'),
   packageUpgrade: join(userDataDir, 'package-upgrade.json'),
   presentations: join(userDataDir, 'presentations.json'),
   mindMaps: join(userDataDir, 'mind-maps'),

package/server/lib/free-port.js

@@ -5,8 +5,15 @@ const execFileAsync = promisify(execFile);
 const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 
 async function portPids(port) {
-  const { stdout } = await execFileAsync('lsof', ['-ti', `:${port}`]);
-  return [...new Set(stdout.trim().split(/\s+/).filter(Boolean))];
+  try {
+    const { stdout } = await execFileAsync('lsof', ['-ti', `:${port}`], { timeout: 1500 });
+    return [...new Set(stdout.trim().split(/\s+/).filter(Boolean))];
+  } catch (error) {
+    // Port cleanup is best-effort. Some managed environments block lsof or
+    // do not expose the process list; the server can still attempt to bind.
+    if (['ETIMEDOUT', 'EPERM', 'EACCES'].includes(error.code) || error.killed) return [];
+    throw error;
+  }
 }
 
 export async function freePort(port) {

package/server/repositories/branch-health-history.js

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import crypto from 'node:crypto';
+import { paths } from '../config.js';
+
+export function listBranchHealthHistory() {
+  if (!existsSync(paths.branchHealthHistory)) return [];
+  try {
+    const records = JSON.parse(readFileSync(paths.branchHealthHistory, 'utf8'));
+    return Array.isArray(records) ? records : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveBranchHealthHistory(records) {
+  mkdirSync(dirname(paths.branchHealthHistory), { recursive: true });
+  writeFileSync(paths.branchHealthHistory, JSON.stringify(records, null, 2));
+}
+
+export function addBranchHealthHistory({ repository, branch, targets, status }) {
+  const successfulTargets = Array.isArray(targets) ? targets.filter(Boolean) : [];
+  if (!repository?.name || !branch || successfulTargets.length === 0) return null;
+
+  const record = {
+    id: crypto.randomUUID(),
+    deletedAt: new Date().toISOString(),
+    repository: {
+      name: String(repository.name),
+      path: String(repository.path || ''),
+      remoteUrl: repository.remoteUrl || null
+    },
+    branch: String(branch),
+    targets: successfulTargets,
+    status: status === 'partial' ? 'partial' : 'success'
+  };
+  const records = listBranchHealthHistory();
+  records.push(record);
+  saveBranchHealthHistory(records);
+  return record;
+}

package/server/routes/branch-health.js

@@ -0,0 +1,362 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+import { addBranchHealthHistory, listBranchHealthHistory } from '../repositories/branch-health-history.js';
+
+const router = Router();
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT = 30 * 1000;
+
+async function git(folder, args, options = {}) {
+  try {
+    const result = await execFileAsync('git', args, {
+      cwd: folder,
+      timeout: GIT_TIMEOUT,
+      maxBuffer: 4 * 1024 * 1024
+    });
+    return result.stdout.trim();
+  } catch (error) {
+    if (options.allowFailure) return '';
+    throw new Error(error.stderr?.trim() || error.message || 'Git command failed.');
+  }
+}
+
+function repositoryName(folder) {
+  return basename(folder) || folder;
+}
+
+function workspaceRepositoryCandidates(workspaceDir) {
+  const root = resolve(String(workspaceDir || ''));
+  if (!existsSync(root) || !statSync(root).isDirectory()) {
+    throw new Error(`Workspace directory does not exist: ${root}`);
+  }
+
+  const folders = [];
+  if (existsSync(join(root, '.git'))) folders.push(root);
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    const folder = join(root, entry.name);
+    if (existsSync(join(folder, '.git'))) folders.push(folder);
+  }
+
+  return folders.map((folder) => ({
+    name: repositoryName(folder),
+    path: folder
+  }));
+}
+
+function parseRefList(raw) {
+  return raw.split(/\r?\n/).filter(Boolean).map((line) => {
+    const separatorIndex = line.indexOf(' ');
+    const ref = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+    const hash = separatorIndex === -1 ? '' : line.slice(separatorIndex + 1).trim();
+    if (!ref || !hash) return null;
+    const remote = ref.startsWith('refs/remotes/');
+    const remoteMatch = ref.match(/^refs\/remotes\/([^/]+)\/(.+)$/);
+    const name = remote ? remoteMatch?.[2] : ref.replace(/^refs\/heads\//, '');
+    if (!name || name === 'HEAD' || name.endsWith('/HEAD')) return null;
+    return { ref, name, hash, remote, remoteName: remoteMatch?.[1] || null };
+  }).filter(Boolean);
+}
+
+function parseCommit(raw) {
+  const [hash, shortHash, subject, authorName, authorEmail, authoredAt, committedAt, committerName, committerEmail] = raw.split('\x1f');
+  if (!hash) return null;
+  return {
+    hash,
+    shortHash,
+    subject,
+    author: { name: authorName, email: authorEmail },
+    committer: { name: committerName, email: committerEmail },
+    authoredAt,
+    committedAt
+  };
+}
+
+function parseFirstCommit(raw) {
+  const [timestamp, date, name, email] = raw.split('\x1f');
+  const numericTimestamp = Number(timestamp);
+  return {
+    createdAt: Number.isFinite(numericTimestamp) ? new Date(numericTimestamp * 1000).toISOString() : date || null,
+    creator: { name: name || '', email: email || '' }
+  };
+}
+
+function isProtectedBranch(name) {
+  return /^(main|master|develop|development|trunk|release(?:\/|$))/i.test(name);
+}
+
+function dateAgeDays(date) {
+  if (!date) return null;
+  const timestamp = Date.parse(date);
+  if (Number.isNaN(timestamp)) return null;
+  return Math.max(0, Math.floor((Date.now() - timestamp) / 86400000));
+}
+
+function healthForBranch({ merged, ahead, ageDays, isCurrent, isProtected, hasRemote }) {
+  if (isCurrent || isProtected) return { status: 'blocked', label: 'Blocked', score: 0 };
+  if (ahead > 0) return { status: 'keep', label: 'Keep', score: 20 };
+
+  let score = 0;
+  if (merged) score += 50;
+  if (ageDays >= 180) score += 30;
+  else if (ageDays >= 90) score += 25;
+  else if (ageDays >= 30) score += 15;
+  if (!hasRemote) score += 5;
+
+  if (merged && ageDays >= 90) return { status: 'safe', label: 'Safe to delete', score };
+  if (score >= 45) return { status: 'review', label: 'Review', score };
+  return { status: 'keep', label: 'Keep', score };
+}
+
+async function readBranchDetails(folder, branch, refs, targetRef, currentBranch) {
+  const ref = branch.localRef || branch.remoteRef;
+  const commit = parseCommit(await git(folder, [
+    'show', '-s', '--format=%H%x1f%h%x1f%s%x1f%an%x1f%ae%x1f%aI%x1f%cI%x1f%cn%x1f%ce', ref
+  ], { allowFailure: true }));
+  if (!commit) return null;
+
+  let firstCommit = parseFirstCommit(await git(folder, [
+    'log', '--reverse', '--format=%ct%x1f%aI%x1f%an%x1f%ae', '-1', ref
+  ], { allowFailure: true }));
+  let createdAtSource = 'first commit (inferred)';
+
+  if (branch.localRef) {
+    const reflog = await git(folder, ['reflog', 'show', '--format=%ct%x1f%cI%x1f%gs', branch.localRef], { allowFailure: true });
+    const earliestEntry = reflog.split(/\r?\n/).filter(Boolean).at(-1);
+    if (earliestEntry) {
+      const [timestamp, date] = earliestEntry.split('\x1f');
+      const numericTimestamp = Number(timestamp);
+      if (Number.isFinite(numericTimestamp)) {
+        firstCommit = { ...firstCommit, createdAt: new Date(numericTimestamp * 1000).toISOString() };
+        createdAtSource = 'local reflog';
+      } else if (date) {
+        firstCommit = { ...firstCommit, createdAt: date };
+        createdAtSource = 'local reflog';
+      }
+    }
+  }
+
+  const branchCount = Number(await git(folder, ['rev-list', '--count', ref], { allowFailure: true })) || 0;
+  const containingRefs = parseRefList(await git(folder, [
+    'for-each-ref', '--contains', commit.hash, '--format=%(refname) %(objectname)', 'refs/heads', 'refs/remotes'
+  ], { allowFailure: true }));
+  const containingNames = [...new Set(containingRefs.map((item) => item.name).filter((name) => name !== branch.name))];
+  const protectedContaining = containingNames.filter(isProtectedBranch);
+  // A child branch containing main's commit is not evidence that main was
+  // merged into that child. Only protected/default targets count as merge
+  // evidence for cleanup decisions in this local-only phase.
+  const mergedInto = protectedContaining[0] || null;
+  const merged = Boolean(mergedInto);
+
+  let ahead = 0;
+  let behind = 0;
+  if (targetRef && ref !== targetRef) {
+    const counts = (await git(folder, ['rev-list', '--left-right', '--count', `${targetRef}...${ref}`], { allowFailure: true })).split(/\s+/).map(Number);
+    behind = Number.isFinite(counts[0]) ? counts[0] : 0;
+    ahead = Number.isFinite(counts[1]) ? counts[1] : 0;
+  }
+
+  const ageDays = dateAgeDays(commit.committedAt || commit.authoredAt);
+  const isCurrent = !branch.remote && currentBranch === branch.name;
+  const isProtected = isProtectedBranch(branch.name);
+  const health = healthForBranch({ merged, ahead, ageDays, isCurrent, isProtected, hasRemote: Boolean(branch.remoteRef) });
+
+  return {
+    id: branch.name,
+    name: branch.name,
+    source: branch.localRef && branch.remoteRef ? 'local + remote' : branch.localRef ? 'local' : 'remote',
+    hasLocal: Boolean(branch.localRef),
+    hasRemote: Boolean(branch.remoteRef),
+    current: isCurrent,
+    protected: isProtected,
+    createdAt: firstCommit?.createdAt || null,
+    createdAtSource,
+    creator: firstCommit?.creator || { name: '', email: '' },
+    lastCommit: commit,
+    ageDays,
+    commitCount: branchCount,
+    ahead,
+    behind,
+    merged,
+    mergedInto,
+    mergedIntoAll: protectedContaining,
+    mergeSource: merged ? 'local ancestry (inferred)' : 'not found in local refs',
+    openPullRequest: null,
+    health,
+    reasons: [
+      merged ? `Merged into ${mergedInto}` : 'No containing target branch found',
+      ageDays >= 90 ? `${ageDays} days since last commit` : null,
+      ahead > 0 ? `${ahead} commits not in the default branch` : null,
+      isCurrent ? 'Currently checked out' : null,
+      isProtected ? 'Matches a protected branch pattern' : null
+    ].filter(Boolean),
+    refs: { local: branch.localRef || null, remote: branch.remoteRef || null }
+  };
+}
+
+async function scanRepository(folder) {
+  const root = resolve(folder);
+  if (!existsSync(join(root, '.git'))) throw new Error(`Not a Git repository: ${root}`);
+
+  const [currentBranch, remoteUrl, refsRaw] = await Promise.all([
+    git(root, ['branch', '--show-current'], { allowFailure: true }),
+    git(root, ['remote', 'get-url', 'origin'], { allowFailure: true }),
+    git(root, ['for-each-ref', '--format=%(refname) %(objectname)', 'refs/heads', 'refs/remotes'])
+  ]);
+  const refs = parseRefList(refsRaw);
+
+  // Remote refs are normalized to their branch name so local and origin/main
+  // are presented as one row when both are available.
+  const normalized = new Map();
+  refs.forEach((item) => {
+    const name = item.name;
+    const branch = normalized.get(name) || { name, localRef: null, remoteRef: null };
+    if (item.remote && item.remoteName === 'origin') branch.remoteRef = item.ref;
+    if (!item.remote) branch.localRef = item.ref;
+    normalized.set(name, branch);
+  });
+
+  const preferredTargets = ['main', 'master', 'develop', 'development', 'trunk'];
+  const targetName = preferredTargets.find((name) => normalized.has(name)) || [...normalized.keys()].find(isProtectedBranch) || null;
+  const targetBranch = targetName ? normalized.get(targetName) : null;
+  const targetRef = targetBranch?.localRef || targetBranch?.remoteRef || null;
+  const details = [];
+  for (const branch of normalized.values()) {
+    const detail = await readBranchDetails(root, branch, refs, targetRef, currentBranch);
+    if (detail) details.push(detail);
+  }
+
+  details.sort((a, b) => b.health.score - a.health.score || (b.ageDays || 0) - (a.ageDays || 0) || a.name.localeCompare(b.name));
+  return {
+    repository: { name: repositoryName(root), path: root, remoteUrl: remoteUrl || null, currentBranch: currentBranch || null },
+    defaultBranch: targetName,
+    branches: details,
+    scannedAt: new Date().toISOString(),
+    analysis: {
+      source: 'local Git',
+      mergeEvidence: 'Local ref ancestry; remote PR history is not queried in this phase.',
+      creationEvidence: 'Local reflog when available, otherwise first commit date.'
+    }
+  };
+}
+
+router.get('/repositories', (req, res) => {
+  try {
+    const workspaceDir = String(req.query.workspaceDir || '').trim();
+    if (!workspaceDir) return res.status(400).json({ error: 'Workspace directory is required.', repositories: [] });
+    res.json({ workspaceDir: resolve(workspaceDir), repositories: workspaceRepositoryCandidates(workspaceDir) });
+  } catch (error) {
+    res.status(400).json({ error: error.message, repositories: [] });
+  }
+});
+
+router.get('/history', (_req, res) => {
+  res.json({ history: listBranchHealthHistory().slice().reverse() });
+});
+
+function deletionChecks(branch) {
+  const blockers = [];
+  if (!branch.hasLocal && !branch.hasRemote) blockers.push('Branch no longer exists in local or origin refs.');
+  if (branch.current) blockers.push('The current branch cannot be deleted.');
+  if (branch.protected) blockers.push('Protected branch patterns cannot be deleted.');
+  if (!branch.merged) blockers.push('The branch head is not contained in another local ref.');
+  if (branch.ahead > 0) blockers.push(`${branch.ahead} commit(s) are not in the default branch.`);
+
+  return {
+    hasLocal: branch.hasLocal,
+    hasRemote: branch.hasRemote,
+    current: branch.current,
+    protected: branch.protected,
+    merged: branch.merged,
+    ahead: branch.ahead,
+    localDeletionAllowed: branch.hasLocal && blockers.length === 0,
+    remoteDeletionAllowed: branch.hasRemote && blockers.length === 0,
+    blockers
+  };
+}
+
+router.post('/preflight', async (req, res) => {
+  try {
+    const folder = String(req.body?.folder || '').trim();
+    const branchName = String(req.body?.branch || '').trim();
+    if (!folder || !branchName) return res.status(400).json({ error: 'Repository folder and branch are required.' });
+    const result = await scanRepository(folder);
+    const branch = result.branches.find((item) => item.name === branchName);
+    if (!branch) return res.status(404).json({ error: `Branch not found: ${branchName}` });
+    const checks = deletionChecks(branch);
+    res.json({ branch, checks, canDelete: checks.localDeletionAllowed || checks.remoteDeletionAllowed });
+  } catch (error) {
+    res.status(400).json({ error: error.message || 'Unable to preflight branch deletion.' });
+  }
+});
+
+router.post('/delete', async (req, res) => {
+  try {
+    const folder = String(req.body?.folder || '').trim();
+    const branchName = String(req.body?.branch || '').trim();
+    const confirmName = String(req.body?.confirmName || '').trim();
+    const deleteLocal = req.body?.deleteLocal === true;
+    const deleteRemote = req.body?.deleteRemote === true;
+    if (!folder || !branchName) return res.status(400).json({ error: 'Repository folder and branch are required.' });
+    if (!deleteLocal && !deleteRemote) return res.status(400).json({ error: 'Select at least one deletion target.' });
+    if (confirmName !== branchName) return res.status(400).json({ error: 'Type the exact branch name to confirm deletion.' });
+
+    // Re-scan immediately before mutating refs so a stale page cannot delete a
+    // branch after it has changed ownership, merge state, or checkout state.
+    const before = await scanRepository(folder);
+    const branch = before.branches.find((item) => item.name === branchName);
+    if (!branch) return res.status(404).json({ error: `Branch not found: ${branchName}` });
+    const checks = deletionChecks(branch);
+    if (checks.blockers.length) return res.status(409).json({ error: checks.blockers.join(' '), checks, branch });
+    if (deleteLocal && !checks.localDeletionAllowed) return res.status(409).json({ error: 'Local branch deletion is not allowed after the latest preflight.', checks, branch });
+    if (deleteRemote && !checks.remoteDeletionAllowed) return res.status(409).json({ error: 'Remote branch deletion is not allowed after the latest preflight.', checks, branch });
+
+    const results = [];
+    if (deleteLocal) {
+      try {
+        await git(resolve(folder), ['branch', '-d', '--', branchName]);
+        results.push({ target: 'local', success: true });
+      } catch (error) {
+        results.push({ target: 'local', success: false, error: error.message });
+      }
+    }
+    if (deleteRemote) {
+      try {
+        if (!branch.hasRemote) throw new Error('Origin branch does not exist.');
+        await git(resolve(folder), ['push', 'origin', '--delete', branchName]);
+        results.push({ target: 'remote', success: true });
+      } catch (error) {
+        results.push({ target: 'remote', success: false, error: error.message });
+      }
+    }
+
+    const success = results.length > 0 && results.every((item) => item.success);
+    const successfulTargets = results.filter((item) => item.success).map((item) => item.target);
+    const historyRecord = addBranchHealthHistory({
+      repository: before.repository,
+      branch: branchName,
+      targets: successfulTargets,
+      status: success ? 'success' : 'partial'
+    });
+    const after = await scanRepository(folder);
+    res.status(success ? 200 : 207).json({ success, branch: branchName, results, historyRecord, ...after });
+  } catch (error) {
+    res.status(400).json({ error: error.message || 'Unable to delete branch.' });
+  }
+});
+
+router.post('/scan', async (req, res) => {
+  try {
+    const folder = String(req.body?.folder || '').trim();
+    if (!folder) return res.status(400).json({ error: 'Repository folder is required.' });
+    res.json(await scanRepository(folder));
+  } catch (error) {
+    res.status(400).json({ error: error.message || 'Unable to scan repository branches.' });
+  }
+});
+
+export { deletionChecks, scanRepository };
+export default router;

package/server/routes/settings.js

@@ -102,6 +102,14 @@ router.post('/open-folder', (req, res) => {
   openInSystemFolder(folderPath);
   res.json({ success: true });
 });
+router.post('/reveal-folder', (req, res) => {
+  const { path } = req.body || {};
+  const targetPath = typeof path === 'string' ? path.trim() : '';
+  if (!targetPath) return res.status(400).json({ error: 'Path must be a non-empty string.' });
+  if (!existsSync(targetPath)) return res.status(404).json({ error: 'Path does not exist.' });
+  revealInSystemFolder(targetPath);
+  res.json({ success: true });
+});
 router.post('/open-data-dir', (req, res) => {
   const targetPath = paths.dataDir;
   if (!existsSync(targetPath)) {

package/server/services/dev-configurations.js

@@ -117,6 +117,22 @@ async function runNvm(script, timeout = 5000) {
   throw new Error('NVM is not installed or could not be loaded from the shell.');
 }
 
+async function getGlobalNpmRoot() {
+  try { return await run('npm', ['root', '--global'], 10000); }
+  catch {
+    try { return await runNvm('npm root --global', 10000); }
+    catch { return ''; }
+  }
+}
+
+function globalPackageEntries(packageJson, globalRoot) {
+  return Object.entries(packageJson.dependencies || {}).map(([name, info]) => ({
+    name,
+    version: info.version || '',
+    directory: globalRoot ? join(globalRoot, name) : ''
+  }));
+}
+
 function parseNvmVersions(output) {
   return [...new Set(String(output).split('\n').map((line) => line.match(/v\d+(?:\.\d+){0,2}/)?.[0]).filter(Boolean))];
 }
@@ -222,19 +238,21 @@ async function readGitConfig(key) {
 }
 
 async function readGlobalNpmPackages() {
+  const globalRoot = await getGlobalNpmRoot();
   try {
     const stdout = await run('npm', ['ls', '--global', '--depth=0', '--json'], 10000);
     const packageJson = parseJsonOutput(stdout);
-    return Object.entries(packageJson.dependencies || {}).map(([name, info]) => ({ name, version: info.version || '' }));
+    return globalPackageEntries(packageJson, globalRoot);
   } catch (error) {
     try {
       const packageJson = parseJsonOutput(error.stdout || '');
-      return Object.entries(packageJson.dependencies || {}).map(([name, info]) => ({ name, version: info.version || '' }));
+      return globalPackageEntries(packageJson, globalRoot);
     } catch {
       try {
         const output = await runNvm('npm ls --global --depth=0 --json', 10000);
         const packageJson = parseJsonOutput(output);
-        return Object.entries(packageJson.dependencies || {}).map(([name, info]) => ({ name, version: info.version || '' }));
+        const nvmRoot = await runNvm('npm root --global', 10000).catch(() => globalRoot);
+        return globalPackageEntries(packageJson, nvmRoot);
       } catch { return []; }
     }
   }

package/server/services/process-manager.js

@@ -14,6 +14,7 @@ const launchHistory = [];
 const savedPortHistory = new Map(listPortHistory().map((record) => [record.port, record]));
 const supervisorPath = fileURLToPath(new URL('./script-supervisor.js', import.meta.url));
 const execFileAsync = promisify(execFile);
+const PROCESS_INSPECTION_TIMEOUT = 2500;
 const keyFor = (launcherId, scriptId) => `${launcherId}:${scriptId}`;
 export function countErrorBlocks(text, isStderr = false) {
   if (!text) return 0;
@@ -130,7 +131,7 @@ async function listeningProcesses() {
     }
   }
   try {
-    const { stdout } = await execFileAsync('lsof', ['-nP', '-iTCP', '-sTCP:LISTEN', '-F', 'pcn'], { maxBuffer: 1024 * 1024 });
+    const { stdout } = await execFileAsync('lsof', ['-nP', '-iTCP', '-sTCP:LISTEN', '-F', 'pcn'], { maxBuffer: 1024 * 1024, timeout: PROCESS_INSPECTION_TIMEOUT });
     const rows = [];
     let current = {};
     for (const line of stdout.split('\n')) {
@@ -145,7 +146,7 @@ async function listeningProcesses() {
     }
     return rows.filter((item) => item.pid && item.port);
   } catch (error) {
-    if (error.code === 1) return [];
+    if (error.code === 1 || ['ETIMEDOUT', 'EPERM', 'EACCES'].includes(error.code) || error.killed) return [];
     throw new Error('Unable to inspect listening ports. Ensure lsof is available.');
   }
 }
@@ -155,7 +156,7 @@ async function processGroupFor(pid) {
   // on some installations that resolves through a visible shell window.
   if (process.platform === 'win32') return null;
   try {
-    const { stdout } = await execFileAsync('ps', ['-o', 'pgid=', '-p', String(pid)]);
+    const { stdout } = await execFileAsync('ps', ['-o', 'pgid=', '-p', String(pid)], { timeout: PROCESS_INSPECTION_TIMEOUT });
     return Number(stdout.trim());
   } catch { return null; }
 }

package/server.js

@@ -23,6 +23,7 @@ import postmanRoutes from './server/routes/postman.js';
 import bookmarkSyncRoutes from './server/routes/bookmark-sync.js';
 import fileOrganizerRoutes from './server/routes/file-organizer.js';
 import branchSyncRoutes from './server/routes/branch-sync.js';
+import branchHealthRoutes from './server/routes/branch-health.js';
 import updateRoutes from './server/routes/updates.js';
 import dataBackupRoutes from './server/routes/data-backup.js';
 import presentationsRoutes from './server/routes/presentations.js';
@@ -101,6 +102,7 @@ app.use('/api/postman', postmanRoutes);
 app.use('/api/bookmark-sync', bookmarkSyncRoutes);
 app.use('/api/file-organizer', fileOrganizerRoutes);
 app.use('/api/branch-sync', branchSyncRoutes);
+app.use('/api/branch-health', branchHealthRoutes);
 app.use('/api/updates', updateRoutes);
 app.use('/api/data-backup', dataBackupRoutes);
 app.use('/api/presentations', presentationsRoutes);