buddy-workbench 0.1.48 → 0.1.50

package/package.json

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

package/server/routes/branch-sync.js

@@ -114,6 +114,7 @@ async function checkBranchPair(parsedRepo, sourceBranch, targetBranch, headers)
     merged: false,
     unmergedCommitCount: 0,
     openPr: null,
+    conflicted: false,
     error: null
   };
 
@@ -160,7 +161,19 @@ 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}`
             };
+
+            // A PR can be open but still have merge conflicts. Bitbucket exposes
+            // that state through the PR mergeability endpoint.
+            try {
+              const mergeabilityUrl = `${protocol}://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${existingPr.id}/merge`;
+              const mergeabilityRes = await httpClient.get(mergeabilityUrl, { headers });
+              if (mergeabilityRes.status >= 200 && mergeabilityRes.status < 300) {
+                result.conflicted = Boolean(mergeabilityRes.data?.conflicted);
+              }
+            } catch (err) {
+              recordApiError({ source: 'Bitbucket API (Branch Sync)', method: 'GET', message: err.message || 'Failed to check PR mergeability.' });
             }
+          }
         } 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 });

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/routes/pr-conflicts.js

@@ -0,0 +1,314 @@
+import https from 'node:https';
+import { existsSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import axios from 'axios';
+import { Router } from 'express';
+import { readSettings } from '../repositories/settings.js';
+import { readPackageUpgradeData } from '../repositories/package-upgrade.js';
+import { getGitRemoteUrl } from '../services/git.js';
+
+const router = Router();
+const execFileAsync = promisify(execFile);
+const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+const client = axios.create({ httpsAgent, validateStatus: () => true });
+
+function parsePrUrl(value) {
+  const match = String(value || '').match(/https?:\/\/([^/]+)\/(?:projects\/([^/]+)|users\/([^/]+))\/repos\/([^/]+)\/pull-requests\/(\d+)/i);
+  if (!match) return null;
+  return { host: match[1], projectKey: match[2] || `~${match[3]}`, repositorySlug: match[4], pullRequestId: match[5] };
+}
+
+function authHeaders() {
+  const token = readSettings().bitbucketAccessToken;
+  return { Accept: 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) };
+}
+
+function configuredBitbucketHost() {
+  const domain = readSettings().domain || '';
+  if (!domain) return '';
+  return domain.includes('bitbucket') ? domain : `bitbucket.${domain}`;
+}
+
+function webPullRequestUrl(host, pr) {
+  const project = pr.toRef?.repository?.project?.key;
+  const repository = pr.toRef?.repository?.slug;
+  if (!project || !repository || !pr.id) return '';
+  const projectPath = String(project).startsWith('~') ? `users/${String(project).slice(1)}` : `projects/${project}`;
+  return `https://${host}/${projectPath}/repos/${repository}/pull-requests/${pr.id}`;
+}
+
+async function git(folder, args, options = {}) {
+  const result = await execFileAsync('git', args, {
+    cwd: folder,
+    timeout: 10 * 60 * 1000,
+    maxBuffer: 4 * 1024 * 1024,
+    ...options
+  });
+  return result.stdout;
+}
+
+function remoteIdentity(remoteUrl) {
+  const raw = String(remoteUrl || '').replace(/\.git$/i, '');
+  let pathname = '';
+  try {
+    const url = new URL(raw.startsWith('git@') ? `ssh://${raw.replace(/^git@/, '').replace(':', '/')}` : raw.replace(/^ssh:\/\//i, 'https://'));
+    pathname = url.pathname;
+  } catch {
+    pathname = raw.split(':').at(-1) || raw;
+  }
+  const parts = pathname.split('/').filter(Boolean);
+  if (parts[0] === 'scm') return { projectKey: parts[1], repositorySlug: parts[2] };
+  if (parts[0] === 'projects' || parts[0] === 'users') return { projectKey: parts[1], repositorySlug: parts[3] };
+  return { projectKey: parts.at(-2), repositorySlug: parts.at(-1) };
+}
+
+async function findWorkspaceRepository(parsed) {
+  const data = readPackageUpgradeData();
+  if (!data.workspaceDir) throw new Error('Configure a workspace directory in Package Upgrade settings first.');
+  const workspaceDir = resolve(data.workspaceDir);
+  if (!existsSync(workspaceDir) || !statSync(workspaceDir).isDirectory()) {
+    throw new Error(`Workspace directory does not exist: ${workspaceDir}`);
+  }
+
+  const candidates = new Set();
+  if (existsSync(join(workspaceDir, '.git'))) candidates.add(workspaceDir);
+  for (const repo of data.repos || []) {
+    const folder = resolve(workspaceDir, repo.directory || basename(String(repo.url || '').replace(/\.git$/i, '')));
+    if (existsSync(join(folder, '.git'))) candidates.add(folder);
+  }
+  for (const entry of readdirSync(workspaceDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const folder = join(workspaceDir, entry.name);
+      if (existsSync(join(folder, '.git'))) candidates.add(folder);
+    }
+  }
+
+  for (const folder of candidates) {
+    const identity = remoteIdentity(await getGitRemoteUrl(folder));
+    if (identity.projectKey === parsed.projectKey && identity.repositorySlug === parsed.repositorySlug) return folder;
+  }
+  throw new Error(`Could not find ${parsed.projectKey}/${parsed.repositorySlug} in workspace: ${workspaceDir}`);
+}
+
+function validateRelativeFilePath(filePath) {
+  const value = String(filePath || '').replace(/^\/+/, '');
+  if (!value || value.includes('\0') || value.includes('\\') || value.split('/').includes('..')) {
+    throw new Error(`Invalid repository file path: ${filePath}`);
+  }
+  return value;
+}
+
+async function readGitFile(folder, ref, filePath) {
+  try {
+    const { stdout } = await execFileAsync('git', ['show', `${ref}:${filePath}`], {
+      cwd: folder,
+      timeout: 60 * 1000,
+      maxBuffer: 100 * 1024 * 1024,
+      encoding: 'buffer'
+    });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+
+function pathOf(change) {
+  return change?.path?.toString || change?.path?.name || change?.path || change?.src?.toString || '';
+}
+
+async function readFile({ host, projectKey, repositorySlug, commit, path }) {
+  if (!commit || !path) return '';
+  const url = `https://${host}/rest/api/latest/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repositorySlug)}/browse/${path.split('/').map(encodeURIComponent).join('/')}?at=${encodeURIComponent(commit)}&raw=true`;
+  const response = await client.get(url, { headers: authHeaders(), responseType: 'text' });
+  if (response.status < 200 || response.status >= 300) return '';
+  if (typeof response.data === 'string') return response.data;
+  return (response.data.lines || []).map((line) => line.text ?? line).join('\n');
+}
+
+router.post('/load', async (req, res) => {
+  const parsed = parsePrUrl(req.body?.prUrl);
+  if (!parsed) return res.status(400).json({ error: 'Invalid Bitbucket Server Pull Request URL.' });
+
+  const base = `https://${parsed.host}/rest/api/latest/projects/${encodeURIComponent(parsed.projectKey)}/repos/${encodeURIComponent(parsed.repositorySlug)}/pull-requests/${parsed.pullRequestId}`;
+  try {
+    const [prResponse, mergeResponse, changesResponse] = await Promise.all([
+      client.get(base, { headers: authHeaders() }),
+      client.get(`${base}/merge`, { headers: authHeaders() }),
+      client.get(`${base}/changes?limit=1000`, { headers: authHeaders() })
+    ]);
+    if (prResponse.status < 200 || prResponse.status >= 300) return res.status(prResponse.status).json({ error: 'Unable to load Pull Request details.' });
+    if (mergeResponse.status < 200 || mergeResponse.status >= 300) return res.status(mergeResponse.status).json({ error: 'Unable to load Pull Request mergeability.' });
+    const pr = prResponse.data;
+    const changes = changesResponse.data?.values || [];
+    const sourceCommit = pr.fromRef?.latestCommit || pr.fromRef?.id;
+    const targetCommit = pr.toRef?.latestCommit || pr.toRef?.id;
+    const files = await Promise.all(changes.map(async (change) => {
+      const path = pathOf(change);
+      const [sourceContent, targetContent] = await Promise.all([
+        readFile({ ...parsed, commit: sourceCommit, path }),
+        readFile({ ...parsed, commit: targetCommit, path })
+      ]);
+      return { path, sourceContent, targetContent, defaultChoice: 'source' };
+    }));
+    res.json({ conflicted: Boolean(mergeResponse.data.conflicted), pr: { title: pr.title, sourceBranch: pr.fromRef?.displayId, targetBranch: pr.toRef?.displayId }, files: files.filter((file) => file.path) });
+  } catch (error) {
+    res.status(500).json({ error: `Unable to load conflict data: ${error.message}` });
+  }
+});
+
+router.get('/my-conflicts', async (_req, res) => {
+  const host = configuredBitbucketHost();
+  if (!host) return res.json({ values: [] });
+  const dashboardUrl = `https://${host}/rest/api/latest/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
+  try {
+    const response = await client.get(dashboardUrl, { headers: authHeaders() });
+    if (response.status < 200 || response.status >= 300) return res.status(response.status).json({ error: `Unable to load authored Pull Requests (${response.status}).` });
+    const values = Array.isArray(response.data?.values) ? response.data.values : [];
+    const conflicts = await Promise.all(values.map(async (pr) => {
+      const project = pr.toRef?.repository?.project?.key;
+      const repository = pr.toRef?.repository?.slug;
+      if (!project || !repository || !pr.id) return null;
+      const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
+      const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
+      if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
+      return {
+        id: pr.id,
+        title: pr.title || `Pull Request #${pr.id}`,
+        sourceBranch: pr.fromRef?.displayId || pr.fromRef?.id,
+        targetBranch: pr.toRef?.displayId || pr.toRef?.id,
+        updatedDate: pr.updatedDate,
+        url: webPullRequestUrl(host, pr)
+      };
+    }));
+    res.json({ values: conflicts.filter(Boolean).sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0)) });
+  } catch (error) {
+    res.status(500).json({ error: `Unable to load authored Pull Requests: ${error.message}` });
+  }
+});
+
+router.post('/resolve', async (req, res) => {
+  const parsed = parsePrUrl(req.body?.prUrl);
+  const files = Array.isArray(req.body?.files) ? req.body.files : [];
+  const choices = req.body?.choices || {};
+  const commitMessage = typeof req.body?.commitMessage === 'string' ? req.body.commitMessage.trim() : '';
+  const createNewBranch = req.body?.createNewBranch === true;
+  const newBranchName = typeof req.body?.newBranchName === 'string' ? req.body.newBranchName.trim() : '';
+  if (!parsed) return res.status(400).json({ error: 'Invalid Bitbucket Server Pull Request URL.' });
+  if (files.length === 0) return res.status(400).json({ error: 'At least one resolved file is required.' });
+  if (!commitMessage) return res.status(400).json({ error: 'Commit message is required.' });
+  if (createNewBranch && !newBranchName) return res.status(400).json({ error: 'New branch name is required.' });
+  if (files.some((file) => !['source', 'target'].includes(choices[file.path]))) {
+    return res.status(400).json({ error: 'Every resolved file must have a source or target choice.' });
+  }
+
+  let folder;
+  let originalBranch = null;
+  let originalHead = null;
+  try {
+    folder = await findWorkspaceRepository(parsed);
+    originalBranch = String(await git(folder, ['branch', '--show-current'])).trim() || null;
+    originalHead = String(await git(folder, ['rev-parse', 'HEAD'])).trim();
+    // The workspace is disposable for this workflow: discard all tracked and
+    // untracked local changes before switching branches and resolving files.
+    await git(folder, ['reset', '--hard', 'HEAD']);
+    await git(folder, ['clean', '-fd']);
+
+    const prUrl = `https://${parsed.host}/rest/api/latest/projects/${encodeURIComponent(parsed.projectKey)}/repos/${encodeURIComponent(parsed.repositorySlug)}/pull-requests/${parsed.pullRequestId}`;
+    const prResponse = await client.get(prUrl, { headers: authHeaders() });
+    if (prResponse.status < 200 || prResponse.status >= 300) return res.status(prResponse.status).json({ error: `Unable to load Pull Request details (${prResponse.status}).` });
+    const pr = prResponse.data;
+    const sourceBranch = pr.fromRef?.displayId;
+    const targetBranch = pr.toRef?.displayId;
+    if (!sourceBranch || !targetBranch) return res.status(400).json({ error: 'Pull Request source or target branch could not be determined.' });
+
+    await git(folder, ['fetch', 'origin', '--prune']);
+    const sourceRef = `origin/${sourceBranch}`;
+    const targetRef = `origin/${targetBranch}`;
+    await git(folder, ['rev-parse', '--verify', sourceRef]);
+    await git(folder, ['rev-parse', '--verify', targetRef]);
+    await git(folder, ['checkout', '-B', sourceBranch, sourceRef]);
+
+    let commitBranch = sourceBranch;
+    if (createNewBranch) {
+      await git(folder, ['check-ref-format', '--branch', newBranchName]);
+      try {
+        await git(folder, ['rev-parse', '--verify', `refs/heads/${newBranchName}`]);
+        return res.status(409).json({ error: `Local branch already exists: ${newBranchName}` });
+      } catch {}
+      try {
+        await git(folder, ['ls-remote', '--exit-code', '--heads', 'origin', newBranchName]);
+        return res.status(409).json({ error: `Remote branch already exists: ${newBranchName}` });
+      } catch {}
+      await git(folder, ['checkout', '-b', newBranchName]);
+      commitBranch = newBranchName;
+    }
+
+    const resolvedPaths = [];
+    for (const file of files) {
+      const filePath = validateRelativeFilePath(file.path);
+      const choiceRef = choices[file.path] === 'target' ? targetRef : sourceRef;
+      const content = await readGitFile(folder, choiceRef, filePath);
+      const absolutePath = join(folder, filePath);
+      if (content === null) {
+        if (choices[file.path] === 'target' && existsSync(absolutePath)) rmSync(absolutePath);
+        else if (choices[file.path] === 'source') throw new Error(`File not found on source branch: ${filePath}`);
+      } else {
+        writeFileSync(absolutePath, content);
+      }
+      resolvedPaths.push(filePath);
+    }
+
+    await git(folder, ['add', '--', ...resolvedPaths]);
+    const staged = String(await git(folder, ['diff', '--cached', '--name-only'])).trim();
+    if (!staged) return res.status(409).json({ error: 'No file changes to commit. The selected versions already match the source branch.' });
+    await git(folder, ['commit', '-m', commitMessage]);
+    await git(folder, ['push', 'origin', commitBranch]);
+    const commitId = String(await git(folder, ['rev-parse', 'HEAD'])).trim();
+    const commitUrl = `https://${parsed.host}/projects/${encodeURIComponent(parsed.projectKey)}/repos/${encodeURIComponent(parsed.repositorySlug)}/commits/${commitId}`;
+    let resolutionPrUrl = '';
+    if (createNewBranch) {
+      const createPrUrl = `https://${parsed.host}/rest/api/latest/projects/${encodeURIComponent(parsed.projectKey)}/repos/${encodeURIComponent(parsed.repositorySlug)}/pull-requests`;
+      const createPrResponse = await client.post(createPrUrl, {
+        title: commitMessage,
+        description: `Resolution Pull Request created from ${commitBranch}.\n\nThis branch contains the selected resolutions for Pull Request #${parsed.pullRequestId}.`,
+        fromRef: {
+          id: `refs/heads/${commitBranch}`,
+          repository: { slug: parsed.repositorySlug, project: { key: parsed.projectKey } }
+        },
+        toRef: {
+          id: `refs/heads/${targetBranch}`,
+          repository: { slug: parsed.repositorySlug, project: { key: parsed.projectKey } }
+        }
+      }, { headers: { ...authHeaders(), 'Content-Type': 'application/json' } });
+      if (createPrResponse.status < 200 || createPrResponse.status >= 300) {
+        const detail = createPrResponse.data?.errors?.[0]?.message || createPrResponse.data?.message || `Bitbucket returned status ${createPrResponse.status}.`;
+        throw new Error(`Resolution branch was pushed, but creating the Pull Request failed: ${detail}`);
+      }
+      const createdPr = createPrResponse.data || {};
+      resolutionPrUrl = `https://${parsed.host}/${String(parsed.projectKey).startsWith('~') ? `users/${String(parsed.projectKey).slice(1)}` : `projects/${encodeURIComponent(parsed.projectKey)}`}/repos/${encodeURIComponent(parsed.repositorySlug)}/pull-requests/${createdPr.id}`;
+    }
+
+    res.json({
+      success: true,
+      message: `Resolution commit created successfully on ${commitBranch}.`,
+      commitUrl,
+      commitUrls: [commitUrl],
+      branch: commitBranch,
+      commitId,
+      prUrl: resolutionPrUrl
+    });
+  } catch (error) {
+    res.status(500).json({ error: `Unable to create resolution commit: ${error.stderr || error.message}` });
+  } finally {
+    if (folder) {
+      try {
+        if (originalBranch) await git(folder, ['checkout', originalBranch]);
+        else if (originalHead) await git(folder, ['checkout', '--detach', originalHead]);
+      } catch {}
+    }
+  }
+});
+
+export default router;

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) {

package/server.js

@@ -13,6 +13,7 @@ import groupTaskRoutes from './server/routes/group-tasks.js';
 import portDiagnosticsRoutes from './server/routes/port-diagnostics.js';
 import settingsRoutes from './server/routes/settings.js';
 import prReviewRoutes from './server/routes/pr-review.js';
+import prConflictRoutes from './server/routes/pr-conflicts.js';
 import jiraFiltersRoutes from './server/routes/jira-filters.js';
 import todoRoutes from './server/routes/todos.js';
 import staticPagesRoutes from './server/routes/static-pages.js';
@@ -88,6 +89,7 @@ app.use('/api/group-tasks', groupTaskRoutes);
 app.use('/api/port-diagnostics', portDiagnosticsRoutes);
 app.use('/api/settings', settingsRoutes);
 app.use('/api/pr-review', prReviewRoutes);
+app.use('/api/pr-conflicts', prConflictRoutes);
 app.use('/api/jira-filters', jiraFiltersRoutes);
 app.use('/api/todos', todoRoutes);
 app.use('/api/static-pages', staticPagesRoutes);