buddy-workbench 0.1.47 → 0.1.49

package/package.json

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

package/server/routes/overview.js

@@ -4,6 +4,7 @@ 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();
@@ -15,6 +16,16 @@ 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(/\/+$/, '');
@@ -184,11 +195,11 @@ 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: {} });
+    return res.json({ configured: false, missingTokens, fetchedAt: new Date().toISOString(), categories: { presentations: getPresentationInsights() } });
   }
   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: {} });
+  if (!jira || !bitbucket) return res.json({ configured: false, missingTokens: ['domain'], fetchedAt: new Date().toISOString(), categories: { presentations: getPresentationInsights() } });
 
   const sections = await Promise.all([
     requestSection('Jira', () => loadJiraData(jira, settings.jiraAccessToken)),
@@ -210,7 +221,8 @@ router.get('/', async (_req, res) => {
       authoredPrs: authoredPrs.items || [],
       failedBuilds: failedBuilds.items || [],
       activity: jiraData.items?.activity || [],
-      blockedIssues: jiraData.items?.blocked || []
+      blockedIssues: jiraData.items?.blocked || [],
+      presentations: getPresentationInsights()
     },
     errors
   });

package/server/routes/package-upgrade.js

@@ -1,3 +1,4 @@
+import https from 'node:https';
 import axios from 'axios';
 import { Router } from 'express';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -11,6 +12,11 @@ import { recordApiError } from '../lib/api-errors.js';
 const router = Router();
 const exec = promisify(execFile);
 const running = new Set();
+const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+const httpClient = axios.create({
+  httpsAgent,
+  validateStatus: () => true
+});
 
 function repoName(url) { return basename(String(url || '').replace(/[\\/]$/, '').replace(/\.git$/i, '').replace(/[:/]+$/, '')) || 'repo'; }
 function repoPath(data, repo) { return join(data.workspaceDir, repo.directory || repoName(repo.url)); }
@@ -24,6 +30,35 @@ function parseBitbucket(url) {
   if (parts[0] === 'projects' || parts[0] === 'users') return { protocol, host: u.host, project: parts[1], slug: parts[3] };
   return parts.length >= 2 ? { protocol, host: u.host, project: parts.at(-2), slug: parts.at(-1) } : null;
 }
+function bitbucketHeaders() {
+  const settings = readSettings();
+  const headers = { Accept: 'application/json' };
+  if (settings.bitbucketAccessToken) headers.Authorization = `Bearer ${settings.bitbucketAccessToken}`;
+  return headers;
+}
+function branchTimestamp(commit) {
+  const value = commit?.committerTimestamp || commit?.authorTimestamp || commit?.committer?.timestamp || commit?.author?.timestamp || commit?.date;
+  const timestamp = typeof value === 'number' ? value : Date.parse(value || '');
+  return Number.isNaN(timestamp) ? 0 : timestamp;
+}
+async function fetchRemoteBranches(repo) {
+  const parsed = parseBitbucket(repo.url);
+  if (!parsed) throw new Error(`Could not parse Bitbucket repository URL for ${repo.name || repoName(repo.url)}.`);
+  const base = `${parsed.protocol}://${parsed.host}/rest/api/latest/projects/${encodeURIComponent(parsed.project)}/repos/${encodeURIComponent(parsed.slug)}`;
+  const response = await httpClient.get(`${base}/branches?limit=200&orderBy=MODIFICATION`, { headers: bitbucketHeaders() });
+  if (response.status < 200 || response.status >= 300) throw new Error(response.data?.errors?.[0]?.message || `Bitbucket branches failed (${response.status})`);
+  const values = Array.isArray(response.data?.values) ? response.data.values : [];
+  return { base, branches: values.map((branch, index) => ({ name: branch.displayId || branch.id?.replace(/^refs\/heads\//, ''), latestCommit: branch.latestCommit, rank: index })).filter((branch) => branch.name) };
+}
+async function fetchBranchUpdatedAt(base, branch) {
+  if (!branch.latestCommit) return { name: branch.name, updatedAt: 0, rank: branch.rank };
+  try {
+    const response = await httpClient.get(`${base}/commits/${encodeURIComponent(branch.latestCommit)}`, { headers: bitbucketHeaders() });
+    return { name: branch.name, updatedAt: response.status >= 200 && response.status < 300 ? branchTimestamp(response.data) : 0, rank: branch.rank };
+  } catch {
+    return { name: branch.name, updatedAt: 0, rank: branch.rank };
+  }
+}
 function updateTask(taskId, updater) {
   const data = readPackageUpgradeData(); const task = data.tasks.find((item) => item.id === taskId);
   if (!task) return;
@@ -82,7 +117,7 @@ async function runRepo(task, repo) {
     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/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 });
+    const response = await httpClient.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) }));
@@ -117,6 +152,26 @@ router.post('/repos/packages', (req, res) => {
   });
   res.json([...packageNames].sort((a, b) => a.localeCompare(b)));
 });
+router.post('/repos/branches', async (req, res) => {
+  const data = readPackageUpgradeData();
+  const repoIds = Array.isArray(req.body?.repoIds) ? req.body.repoIds : [];
+  const repos = repoIds.map((repoId) => data.repos.find((repo) => repo.id === repoId)).filter(Boolean);
+  if (!repos.length) return res.json([]);
+  try {
+    const remote = await Promise.all(repos.map((repo) => fetchRemoteBranches(repo)));
+    const branchSets = remote.map(({ branches }) => new Set(branches.map((branch) => branch.name)));
+    const commonNames = remote[0].branches.map((branch) => branch.name).filter((name) => branchSets.every((branches) => branches.has(name)));
+    const commonBranches = await Promise.all(commonNames.map(async (name) => {
+      const branches = remote.map(({ base, branches: items }) => ({ base, branch: items.find((item) => item.name === name) })).filter(({ branch }) => branch);
+      const updated = await Promise.all(branches.map(({ base, branch }) => fetchBranchUpdatedAt(base, branch)));
+      return { name, updatedAt: Math.max(...updated.map((item) => item.updatedAt)), rank: Math.min(...updated.map((item) => item.rank)) };
+    }));
+    commonBranches.sort((a, b) => b.updatedAt - a.updatedAt || a.rank - b.rank || a.name.localeCompare(b.name));
+    res.json(commonBranches.map(({ name, updatedAt }) => ({ name, updatedAt: updatedAt ? new Date(updatedAt).toISOString() : null })));
+  } catch (error) {
+    res.status(502).json({ error: error.message || 'Failed to fetch common repository branches.' });
+  }
+});
 router.post('/repos/:id/clone', async (req, res) => { const data = readPackageUpgradeData(); const repo = data.repos.find((item) => item.id === req.params.id); if (!repo) return res.status(404).json({ error: 'Repository not found.' }); if (!data.workspaceDir) return res.status(400).json({ error: 'Configure a workspace directory first.' }); const folder = repoPath(data, repo); try { mkdirSync(data.workspaceDir, { recursive: true }); if (!existsSync(join(folder, '.git'))) await exec('git', ['clone', repo.url, folder], { cwd: data.workspaceDir, timeout: 20 * 60 * 1000, maxBuffer: 2 * 1024 * 1024 }); res.json({ ...repo, cloned: true }); } catch (error) { res.status(400).json({ error: error.stderr || error.message }); } });
 router.delete('/repos/:id', (req, res) => { const data = readPackageUpgradeData(); data.repos = data.repos.filter((r) => r.id !== req.params.id); savePackageUpgradeData(data); res.status(204).end(); });
 router.post('/tasks', (req, res) => { const body = req.body || {}; const required = ['sourceBranch', 'targetBranch', 'packageName', 'version', 'commitMessage']; if (required.some((key) => !String(body[key] || '').trim()) || !Array.isArray(body.repoIds) || !body.repoIds.length) return res.status(400).json({ error: 'All fields and at least one repository are required.' }); const data = readPackageUpgradeData(); if (!data.workspaceDir) return res.status(400).json({ error: 'Configure a workspace directory first.' }); const repoIds = body.repoIds.filter((id) => data.repos.some((repo) => repo.id === id)); if (!repoIds.length) return res.status(400).json({ error: 'Select at least one configured repository.' }); const task = { id: `task-${Date.now()}`, ...Object.fromEntries(required.map((key) => [key, String(body[key]).trim()])), repoIds, repos: repoIds.map((repoId) => ({ repoId, status: 'queued' })), status: 'running', createdAt: new Date().toISOString() }; data.tasks.unshift(task); savePackageUpgradeData(data); void execute(task); res.status(201).json(task); });

package/server/services/clipboard-history.js

@@ -138,6 +138,27 @@ function getEditorUrl(editor = 'vscode', path = '') {
 }
 
 function dayItems(date) { return readJson(dayFile(date), []); }
+
+async function getClipboardText() {
+  const commands = process.platform === 'darwin'
+    ? [['pbpaste', []]]
+    : process.platform === 'win32'
+      ? [['powershell.exe', ['-NoProfile', '-Command', 'Get-Clipboard -Format Text -Raw']]]
+      : [
+          ['wl-paste', ['--no-newline', '--type', 'text']],
+          ['xclip', ['-selection', 'clipboard', '-o', '-t', 'UTF8_STRING']],
+          ['xsel', ['--clipboard', '--output']]
+        ];
+
+  for (const [command, args] of commands) {
+    try {
+      const { stdout } = await execFileAsync(command, args, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
+      return stdout;
+    } catch {}
+  }
+  return '';
+}
+
 export function clipboardItems(date = today()) {
   const settings = readSettings();
   const editor = settings.defaultEditor || 'vscode';
@@ -208,7 +229,7 @@ export function deleteClipboardItem(date, id) {
     const contentPath = join(paths.clipboardDir, 'content', item.contentFile);
     if (existsSync(contentPath)) unlinkSync(contentPath);
   }
-  if (item.imageFile) {
+  if (item.imageFile && process.platform === 'darwin') {
     const imagePath = join(paths.clipboardDir, 'content', item.imageFile);
     if (existsSync(imagePath)) unlinkSync(imagePath);
   }
@@ -216,13 +237,12 @@ export function deleteClipboardItem(date, id) {
 }
 
 export async function captureClipboard() {
-  if (process.platform !== 'darwin') return;
   const settings = readSettings();
   if (settings.clipboardEnabled === false) return;
 
   // 1. Text capture
   try {
-    const { stdout } = await execFileAsync('pbpaste');
+    const stdout = await getClipboardText();
     const text = stdout.trim();
     if (text && text !== lastValue) {
       lastValue = text;
@@ -277,7 +297,7 @@ export async function captureClipboard() {
   } catch {}
 
   // 2. Image capture (Mac only & clipboardImageEnabled !== false)
-  if (settings.clipboardImageEnabled !== false) {
+  if (process.platform === 'darwin' && settings.clipboardImageEnabled !== false) {
     try {
       const imageData = await getMacClipboardImageData();
       if (imageData && imageData.rgbaBuf.length > 0) {