buddy-workbench 0.1.45 → 0.1.47

package/README.md

@@ -70,7 +70,7 @@ Create a manifest at `plugins/<plugin-name>/plugin.json` to add an item to the s
 { "name": "My feature", "icon": "✦", "view": "view.html" }
 ```
 
-Plugins are discovered automatically. `view` points to an HTML fragment in the plugin directory. See `plugins/example`; place your HTML, scripts, and styles in an isolated plugin folder. Add API routes as needed for server-side capabilities.
+Plugins are discovered automatically. `view` points to an HTML fragment in the plugin directory. Place your HTML, scripts, and styles in an isolated plugin folder. Add API routes as needed for server-side capabilities.
 
 ## Scripts and logs
 

package/package.json

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

package/server/lib/api-errors.js

@@ -0,0 +1,16 @@
+import { addErrorRecord } from '../repositories/errors.js';
+
+function cleanUrl(url) {
+  return String(url || '').replace(/([?&](?:token|access_token|api_token|authorization)=)[^&]+/gi, '$1[REDACTED]');
+}
+
+export function recordApiError({ source = 'Server API', method = '', url = '', status, message = '', details = '' } = {}) {
+  const location = [method, cleanUrl(url)].filter(Boolean).join(' ');
+  const statusText = status !== undefined && status !== null ? `HTTP ${status}` : '';
+  const detailLines = [location && `Target: ${location}`, statusText, details].filter(Boolean);
+  addErrorRecord({
+    source,
+    message: message || statusText || 'API request failed.',
+    details: detailLines.join('\n')
+  });
+}

package/server/routes/branch-sync.js

@@ -2,6 +2,7 @@ import https from 'node:https';
 import axios from 'axios';
 import { Router } from 'express';
 import { readSettings } from '../repositories/settings.js';
+import { recordApiError } from '../lib/api-errors.js';
 import {
   createBranchSyncApp,
   listBranchSyncApps,
@@ -116,19 +117,21 @@ async function checkBranchPair(parsedRepo, sourceBranch, targetBranch, headers)
     error: null
   };
 
+    const commitsUrl = `${protocol}://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/commits?until=${encodeURIComponent(sourceBranch)}&since=${encodeURIComponent(targetBranch)}&limit=1`;
   try {
     // 1. Check commits in sourceBranch not in targetBranch (i.e. whether targetBranch contains sourceBranch head commit)
-    const commitsUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/commits?until=${encodeURIComponent(sourceBranch)}&since=${encodeURIComponent(targetBranch)}&limit=1`;
     const commitsRes = await httpClient.get(commitsUrl, { headers });
 
     if (commitsRes.status === 401) {
       result.error = 'Unauthorized. Please check your Bitbucket Access Token in Settings.';
+      recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'GET', url: commitsUrl, status: commitsRes.status, message: result.error });
       return result;
     }
 
     if (commitsRes.status < 200 || commitsRes.status >= 300) {
       const errDetail = commitsRes.data?.errors?.[0]?.message || commitsRes.data?.message || commitsRes.statusText;
       result.error = `Failed to check commits (${commitsRes.status}): ${errDetail}`;
+      recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'GET', url: commitsUrl, status: commitsRes.status, message: result.error });
       return result;
     }
 
@@ -141,8 +144,8 @@ async function checkBranchPair(parsedRepo, sourceBranch, targetBranch, headers)
       result.unmergedCommitCount = commitsRes.data?.size || commits.length;
 
       // 2. Check if an open PR already exists
+      const prUrl = `${protocol}://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/pull-requests?at=refs/heads/${encodeURIComponent(sourceBranch)}&direction=OUTGOING&state=OPEN`;
       try {
-        const prUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests?at=refs/heads/${encodeURIComponent(sourceBranch)}&direction=OUTGOING&state=OPEN`;
         const prRes = await httpClient.get(prUrl, { headers });
         if (prRes.status >= 200 && prRes.status < 300) {
           const prs = prRes.data?.values || [];
@@ -157,12 +160,18 @@ async function checkBranchPair(parsedRepo, sourceBranch, targetBranch, headers)
               title: existingPr.title,
               url: existingPr.links?.self?.[0]?.href || `${protocol}://${host}/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${existingPr.id}`
             };
-          }
+            }
+        } else {
+          const message = `Failed to check open pull requests (${prRes.status}): ${prRes.data?.errors?.[0]?.message || prRes.data?.message || prRes.statusText}`;
+          recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'GET', url: prUrl, status: prRes.status, message });
         }
-      } catch {}
+      } catch (err) {
+        recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'GET', url: prUrl, message: err.message || 'Failed to check open pull requests.' });
+      }
     }
   } catch (err) {
     result.error = err.message || 'Network error checking branch status.';
+    recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'GET', url: commitsUrl, message: result.error });
   }
 
   return result;
@@ -196,7 +205,7 @@ router.get('/branches', async (req, res) => {
   }
 
   try {
-    const branchesUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/branches?limit=200`;
+    const branchesUrl = `${protocol}://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/branches?limit=200`;
     const response = await httpClient.get(branchesUrl, { headers });
 
     if (response.status >= 200 && response.status < 300) {
@@ -351,7 +360,7 @@ router.post('/create-pr', async (req, res) => {
   };
 
   try {
-    const prUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests`;
+    const prUrl = `${protocol}://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/pull-requests`;
     const prRes = await httpClient.post(prUrl, prPayload, { headers });
 
     if (prRes.status >= 200 && prRes.status < 300) {
@@ -389,7 +398,7 @@ async function createBranchForRepo(repoStr, sourceBranch, targetBranch, headers)
   }
 
   const startPoint = sourceBranch.startsWith('refs/') ? sourceBranch : `refs/heads/${sourceBranch}`;
-  const branchUrl = `${protocol}://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/branches`;
+  const branchUrl = `${protocol}://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/branches`;
   const payload = {
     name: targetBranch,
     startPoint
@@ -401,9 +410,12 @@ async function createBranchForRepo(repoStr, sourceBranch, targetBranch, headers)
       return { success: true, branch: targetBranch, id: res.data?.id };
     }
     const errDetail = res.data?.errors?.[0]?.message || res.data?.message || `Bitbucket returned status ${res.status}: ${res.statusText}`;
+    recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'POST', url: branchUrl, status: res.status, message: errDetail });
     return { success: false, error: errDetail };
   } catch (err) {
-    return { success: false, error: err.message || 'Network error creating branch.' };
+    const message = err.message || 'Network error creating branch.';
+    recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'POST', url: branchUrl, message });
+    return { success: false, error: message };
   }
 }
 

package/server/routes/jira-filters.js

@@ -1,6 +1,7 @@
 import https from 'node:https';
 import axios from 'axios';
 import { Router } from 'express';
+import { recordApiError } from '../lib/api-errors.js';
 import { readSettings } from '../repositories/settings.js';
 import { listJiraFilters, saveJiraFilters, listJiraTemplates, saveJiraTemplates, listRecentlyCreatedJiraIssues, saveRecentlyCreatedJiraIssues } from '../repositories/jira-filters.js';
 
@@ -253,9 +254,12 @@ router.post('/issues/clone', async (req, res) => {
   try {
     // Fetch current authenticated user's info from Jira
     let assigneeField = null;
+    const myselfUrl = `https://${jiraHost}/rest/api/2/myself`;
     try {
-      const myselfUrl = `https://${jiraHost}/rest/api/2/myself`;
       const myselfRes = await httpClient.get(myselfUrl, { headers });
+      if (myselfRes.status < 200 || myselfRes.status >= 300) {
+        recordApiError({ source: 'Jira API (Clone Issue)', method: 'GET', url: myselfUrl, status: myselfRes.status, message: `Jira user API returned ${myselfRes.status}: ${myselfRes.statusText || 'Failed to fetch current user.'}` });
+      }
       if (myselfRes.status === 200 && myselfRes.data) {
         if (myselfRes.data.accountId) {
           assigneeField = { accountId: myselfRes.data.accountId };
@@ -263,8 +267,8 @@ router.post('/issues/clone', async (req, res) => {
           assigneeField = { name: myselfRes.data.name };
         }
       }
-    } catch {
-      // Ignore if fetching current user fails
+      } catch (error) {
+        recordApiError({ source: 'Jira API (Clone Issue)', method: 'GET', url: myselfUrl, message: error.message || 'Failed to fetch current user.' });
     }
 
     // Fetch original issue details to preserve issue type, project, description, priority
@@ -275,9 +279,12 @@ router.post('/issues/clone', async (req, res) => {
     let origPriority = null;
 
     if (issueKey) {
+      const issueUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}`;
       try {
-        const issueUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}`;
         const origRes = await httpClient.get(issueUrl, { headers });
+        if (origRes.status < 200 || origRes.status >= 300) {
+          recordApiError({ source: 'Jira API (Clone Issue)', method: 'GET', url: issueUrl, status: origRes.status, message: `Jira issue API returned ${origRes.status}: ${origRes.statusText || 'Failed to fetch original issue.'}` });
+        }
         if (origRes.status === 200 && origRes.data?.fields) {
           const fields = origRes.data.fields;
           if (fields.issuetype) {
@@ -304,8 +311,8 @@ router.post('/issues/clone', async (req, res) => {
             }
           }
         }
-      } catch {
-        // Ignore if fetching original issue fails
+      } catch (error) {
+        recordApiError({ source: 'Jira API (Clone Issue)', method: 'GET', url: issueUrl, message: error.message || 'Failed to fetch original issue.' });
       }
     }
 
@@ -353,11 +360,14 @@ router.post('/issues/clone', async (req, res) => {
 
     // Fallback: Assign explicitly if not assigned during creation
     if (createdKey && assigneeField) {
+      const assignUrl = `https://${jiraHost}/rest/api/2/issue/${createdKey}/assignee`;
       try {
-        const assignUrl = `https://${jiraHost}/rest/api/2/issue/${createdKey}/assignee`;
-        await httpClient.put(assignUrl, assigneeField, { headers });
-      } catch {
-        // Ignore fallback assign error
+        const assignRes = await httpClient.put(assignUrl, assigneeField, { headers });
+        if (assignRes.status < 200 || assignRes.status >= 300) {
+          recordApiError({ source: 'Jira API (Clone Issue)', method: 'PUT', url: assignUrl, status: assignRes.status, message: `Jira assignee API returned ${assignRes.status}: ${assignRes.statusText || 'Failed to assign issue.'}` });
+        }
+      } catch (error) {
+        recordApiError({ source: 'Jira API (Clone Issue)', method: 'PUT', url: assignUrl, message: error.message || 'Failed to assign issue.' });
       }
     }
 

package/server/routes/overview.js

@@ -0,0 +1,219 @@
+import https from 'node:https';
+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 { recordApiError } from '../lib/api-errors.js';
+
+const router = Router();
+const httpClient = axios.create({
+  httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+  validateStatus: () => true,
+  timeout: 15000
+});
+
+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;
+
+function jiraHost(domain) {
+  const clean = String(domain || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+  if (!clean) return '';
+  return clean.includes('jira') || clean.includes('.atlassian.net') ? clean : `jira.${clean}`;
+}
+
+function bitbucketHost(domain) {
+  const clean = String(domain || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+  if (!clean) return '';
+  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 {
+    return { items: await loader() };
+  } catch (error) {
+    recordApiError({ source: `Overview (${name})`, message: error.message || `Failed to load ${name}.` });
+    return { items: [], error: error.message || `Failed to load ${name}.` };
+  }
+}
+
+async function searchJira(host, token, jql, fields, maxResults = 25) {
+  const url = jiraUrl(host, `/search?jql=${encodeURIComponent(jql)}&maxResults=${maxResults}&fields=${encodeURIComponent(fields)}`);
+  const response = await httpClient.get(url, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
+  if (!isSuccess(response)) throw new Error(`Jira search failed (${response.status}): ${apiMessage(response, 'Request failed')}`);
+  return response.data?.issues || [];
+}
+
+function mapJiraIssue(issue) {
+  const fields = issue.fields || {};
+  return {
+    id: issue.id,
+    key: issue.key,
+    summary: fields.summary || issue.key,
+    status: fields.status?.name || '',
+    priority: fields.priority?.name || '',
+    dueDate: fields.duedate || null,
+    updated: fields.updated || null,
+    url: null
+  };
+}
+
+function issueUrl(host, key) { return `https://${host}/browse/${encodeURIComponent(key)}`; }
+
+async function loadJiraData(host, token) {
+  const headers = { Accept: 'application/json', Authorization: `Bearer ${token}` };
+  const meUrl = jiraUrl(host, '/myself');
+  const meResponse = await httpClient.get(meUrl, { headers });
+  if (!isSuccess(meResponse)) throw new Error(`Jira identity lookup failed (${meResponse.status}): ${apiMessage(meResponse, 'Request failed')}`);
+  const me = meResponse.data || {};
+  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([
+    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)
+  ]);
+
+  const activityItems = [];
+  for (const issue of activity.slice(0, 15)) {
+    const key = issue.key;
+    const commentsUrl = jiraUrl(host, `/issue/${encodeURIComponent(key)}/comment?orderBy=-updated&maxResults=10`);
+    const commentsResponse = await httpClient.get(commentsUrl, { headers });
+    if (!isSuccess(commentsResponse)) {
+      recordApiError({ source: 'Overview (Jira Activity)', method: 'GET', url: commentsUrl, status: commentsResponse.status, message: apiMessage(commentsResponse, 'Failed to fetch comments.') });
+      continue;
+    }
+    const comments = commentsResponse.data?.comments || [];
+    const relevant = comments.find((comment) => {
+      const author = comment.author || {};
+      const body = typeof comment.body === 'string' ? comment.body : JSON.stringify(comment.body || '');
+      const mentionsMe = [identity.name, identity.accountId, identity.displayName].filter(Boolean).some((value) => body.includes(value));
+      const writtenBySomeoneElse = author.name !== identity.name && author.accountId !== identity.accountId;
+      return mentionsMe || writtenBySomeoneElse;
+    });
+    if (relevant) {
+      activityItems.push({
+        ...mapJiraIssue(issue),
+        activityType: [identity.name, identity.accountId, identity.displayName].filter(Boolean).some((value) => String(relevant.body || '').includes(value)) ? 'Mentioned' : 'Commented',
+        activityAt: relevant.updated || relevant.created || issue.fields?.updated
+      });
+    }
+  }
+
+  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) }))
+  };
+}
+
+async function loadPullRequests(host, token, role) {
+  const url = `https://${host}/rest/api/latest/dashboard/pull-requests?role=${role}&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')}`);
+  return (response.data?.values || []).map((pr) => ({
+    id: pr.id,
+    title: pr.title || `Pull request #${pr.id}`,
+    author: pr.author?.user?.displayName || pr.author?.displayName || '',
+    repository: pr.toRef?.repository?.name || pr.toRef?.repository?.slug || '',
+    updated: pr.updatedDate ? new Date(pr.updatedDate).toISOString() : null,
+    url: pr.links?.self?.[0]?.href || `https://${host}/projects/${pr.toRef?.repository?.project?.key || ''}/repos/${pr.toRef?.repository?.slug || ''}/pull-requests/${pr.id}`
+  }));
+}
+
+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`]);
+  if (missingTokens.length > 0) {
+    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: {} });
+
+  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))
+  ]);
+  const [jiraData, reviewPrs, authoredPrs, failedBuilds] = 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({
+    configured: true,
+    missingTokens: [],
+    fetchedAt: new Date().toISOString(),
+    categories: {
+      jiraDueToday: jiraData.items?.dueToday || [],
+      assignedTodos: todos,
+      reviewPrs: reviewPrs.items || [],
+      authoredPrs: authoredPrs.items || [],
+      failedBuilds: failedBuilds.items || [],
+      activity: jiraData.items?.activity || [],
+      blockedIssues: jiraData.items?.blocked || []
+    },
+    errors
+  });
+});
+
+export default router;

package/server/routes/package-upgrade.js

@@ -6,6 +6,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { readSettings } from '../repositories/settings.js';
 import { readPackageUpgradeData, savePackageUpgradeData } from '../repositories/package-upgrade.js';
+import { recordApiError } from '../lib/api-errors.js';
 
 const router = Router();
 const exec = promisify(execFile);
@@ -80,12 +81,13 @@ async function runRepo(task, repo) {
     const parsed = parseBitbucket(repo.url); const settings = readSettings();
     if (!parsed) throw new Error('Could not parse Bitbucket repository URL');
     const headers = { Accept: 'application/json', 'Content-Type': 'application/json' }; if (settings.bitbucketAccessToken) headers.Authorization = `Bearer ${settings.bitbucketAccessToken}`;
-    const api = `${parsed.protocol}://${parsed.host}/rest/api/1.0/projects/${encodeURIComponent(parsed.project)}/repos/${encodeURIComponent(parsed.slug)}/pull-requests`;
+    const api = `${parsed.protocol}://${parsed.host}/rest/api/latest/projects/${encodeURIComponent(parsed.project)}/repos/${encodeURIComponent(parsed.slug)}/pull-requests`;
     const response = await axios.post(api, { title: task.commitMessage, description: `Upgrade ${task.packageName} to ${task.version}`, fromRef: { id: `refs/heads/${task.sourceBranch}` }, toRef: { id: `refs/heads/${task.targetBranch}` } }, { headers, validateStatus: () => true });
     if (response.status < 200 || response.status >= 300) throw new Error(response.data?.errors?.[0]?.message || `Bitbucket PR failed (${response.status})`);
     const prUrl = response.data?.links?.self?.[0]?.href || `${parsed.protocol}://${parsed.host}/projects/${parsed.project}/repos/${parsed.slug}/pull-requests/${response.data.id}`;
     updateTask(task.id, (t) => ({ ...t, repos: t.repos.map((r) => r.repoId === repo.id ? { ...result, status: 'success', prUrl } : r) }));
   } catch (error) {
+    recordApiError({ source: `Package Upgrade (${name})`, message: error.stderr || error.message || 'Package upgrade task failed.', details: `Task: ${task.id}\nRepository: ${repo.url}` });
     updateTask(task.id, (t) => ({ ...t, repos: t.repos.map((r) => r.repoId === repo.id ? { ...result, status: 'failed', message: error.stderr || error.message } : r) }));
   }
 }

package/server/routes/postman.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 import https from 'node:https';
 import axios from 'axios';
+import { recordApiError } from '../lib/api-errors.js';
 import { getPostmanData, savePostmanData } from '../repositories/postman.js';
 import { parsePostmanCollection } from '../services/postman-parser.js';
 
@@ -252,6 +253,11 @@ router.post('/send', async (req, res) => {
         maxContentLength: 10 * 1024 * 1024 // 10MB limit
       });
 
+      if (response.status >= 400) {
+        const upstreamMessage = response.data?.error || response.data?.message || response.statusText || `Upstream API returned ${response.status}`;
+        recordApiError({ source: 'Postman Upstream API', method, url: resolvedUrl, status: response.status, message: upstreamMessage });
+      }
+
       const durationMs = Date.now() - startTime;
       let responseBody = response.data;
       const responseHeaders = response.headers || {};

package/server/routes/pr-review.js

@@ -2,6 +2,7 @@ import https from 'node:https';
 import axios from 'axios';
 import { Router } from 'express';
 import { readSettings } from '../repositories/settings.js';
+import { recordApiError } from '../lib/api-errors.js';
 
 const router = Router();
 const previewLimit = 2000;
@@ -416,7 +417,11 @@ router.post('/check', async (req, res) => {
       if (sinceCommit) diffUrl += `&since=${encodeURIComponent(sinceCommit)}`;
 
       const diffRes = await httpClient.get(diffUrl, { headers });
-      if (diffRes.status < 200 || diffRes.status >= 300) continue; // skip file if diff cannot be retrieved
+      if (diffRes.status < 200 || diffRes.status >= 300) {
+        const message = `Bitbucket diff API returned ${diffRes.status}: ${diffRes.statusText || 'Failed to retrieve diff'}`;
+        recordApiError({ source: 'Bitbucket API (PR Review)', method: 'GET', url: diffUrl, status: diffRes.status, message });
+        continue;
+      }
 
       const diffData = diffRes.data;
       let hunks = diffData.hunks;

package/server.js

@@ -25,6 +25,7 @@ import updateRoutes from './server/routes/updates.js';
 import dataBackupRoutes from './server/routes/data-backup.js';
 import presentationsRoutes from './server/routes/presentations.js';
 import packageUpgradeRoutes from './server/routes/package-upgrade.js';
+import overviewRoutes from './server/routes/overview.js';
 import { addErrorRecord } from './server/repositories/errors.js';
 import { startClipboardCapture } from './server/services/clipboard-history.js';
 import { compression } from './server/middleware/compression.js';
@@ -49,7 +50,7 @@ app.use((req, res, next) => {
 app.use((req, res, next) => {
   const originalJson = res.json;
   res.json = function (body) {
-    if (res.statusCode >= 400 && body && body.error && !req.path.startsWith('/api/errors')) {
+    if (res.statusCode >= 400 && !req.path.startsWith('/api/errors')) {
       const host = req.get('host') || req.headers.host || `localhost:${port}`;
       const fullUrl = `${req.protocol}://${host}${req.originalUrl || req.url}`;
       
@@ -59,13 +60,14 @@ app.use((req, res, next) => {
       }
       detailsLines.push(`Endpoint: ${req.method} ${fullUrl}`);
       detailsLines.push(`HTTP Status: ${res.statusCode}`);
-      if (typeof body.error === 'string' && body.error !== `HTTP ${res.statusCode} Error`) {
-        detailsLines.push(`Error: ${body.error}`);
+      const responseError = body?.error;
+      if (typeof responseError === 'string' && responseError !== `HTTP ${res.statusCode} Error`) {
+        detailsLines.push(`Error: ${responseError}`);
       }
 
       addErrorRecord({
         source: `Backend API (${req.method} ${req.path})`,
-        message: typeof body.error === 'string' ? body.error : `HTTP ${res.statusCode} Error`,
+        message: typeof responseError === 'string' ? responseError : `HTTP ${res.statusCode} Error`,
         details: detailsLines.join('\n')
       });
     }
@@ -98,6 +100,7 @@ app.use('/api/updates', updateRoutes);
 app.use('/api/data-backup', dataBackupRoutes);
 app.use('/api/presentations', presentationsRoutes);
 app.use('/api/package-upgrade', packageUpgradeRoutes);
+app.use('/api/overview', overviewRoutes);
 
 app.use((err, req, res, _next) => {
   addErrorRecord({