buddy-workbench 0.1.49 → 0.1.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "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

@@ -91,6 +91,8 @@ async function runRepo(task, 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 });
+    await git(folder, ['reset', '--hard', 'HEAD']);
+    await git(folder, ['clean', '-fd']);
     await git(folder, ['fetch', 'origin', '--prune']);
     const remoteTargetRef = `refs/remotes/origin/${task.targetBranch}`;
     const localTargetRef = `refs/heads/${task.targetBranch}`;

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.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);