buddy-workbench 0.1.91 → 0.1.93

package/package.json

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

package/server/routes/pr-conflicts.js

@@ -310,7 +310,9 @@ export function UserProfile({ userId }: { userId: string }) {
 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=ALL&limit=1000`;
+  // Bitbucket Server does not accept `state=ALL` for this endpoint; use the
+  // supported open state, matching the PR review/dashboard routes.
+  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}).` });

package/server/services/clipboard-history.js

@@ -15,15 +15,34 @@ const previewLimit = 2000;
 let lastValue = '';
 let lastImageHash = '';
 let suppressImageCaptureUntil = 0;
+// Swift startup/permission failures can persist for the lifetime of the
+// process (for example when the app has no GUI/clipboard access). Avoid
+// recompiling Swift and incrementing the same error counter every poll.
+let swiftClipboardRetryAt = 0;
 let mozjpegWasmModule = null;
+const clipboardErrorCounts = new Map();
 const clipboardErrorLogTimes = new Map();
 
-function logClipboardError(stage, error) {
+function markClipboardSuccess(...stages) {
+  for (const stage of stages) {
+    clipboardErrorCounts.delete(stage);
+  }
+}
+
+function logClipboardError(stage, error, threshold = 3) {
   // Ignore benign failures due to timeout or process termination (e.g., system sleep / screen lock / display off)
   if (error?.killed || error?.timedOut || error?.signal === 'SIGTERM' || error?.code === 'ETIMEDOUT') {
     return;
   }
 
+  const count = (clipboardErrorCounts.get(stage) || 0) + 1;
+  clipboardErrorCounts.set(stage, count);
+
+  // Transient filter: only log if failures happen consecutively past threshold
+  if (count < threshold) {
+    return;
+  }
+
   // Clipboard polling runs continuously. Avoid filling Error Log with the
   // same native-tool failure every two seconds while retaining diagnostics.
   const now = Date.now();
@@ -33,7 +52,7 @@ function logClipboardError(stage, error) {
   const details = String(error?.stderr || error?.stdout || error?.stack || error?.message || error || '').trim();
   addErrorRecord({
     source: 'Clipboard Monitor',
-    message: `Failed during ${stage}.`,
+    message: `Failed during ${stage} (consecutive failures: ${count}).`,
     details: details || 'The native clipboard operation returned an unknown error.'
   });
 }
@@ -85,6 +104,7 @@ async function getMacClipboardImageData() {
   try {
     const { stdout } = await execFileAsync('osascript', ['-l', 'JavaScript', '-e', jsaScript], { timeout: 3000 });
     const str = stdout.trim();
+    markClipboardSuccess('macOS image clipboard read (osascript)');
     if (!str) return null;
     const firstColon = str.indexOf(':');
     const secondColon = str.indexOf(':', firstColon + 1);
@@ -96,11 +116,17 @@ async function getMacClipboardImageData() {
     return { width, height, rgbaBuf: Buffer.from(base64, 'base64') };
   } catch (error) {
     logClipboardError('macOS image clipboard read (osascript)', error);
+    // If osascript failed with an error, attempt the Swift fallback for image capture
+    const rawBuffer = await getMacClipboardImageBuffer();
+    if (rawBuffer && rawBuffer.length > 0) {
+      return { rawBuffer };
+    }
     return null;
   }
 }
 
 async function getMacClipboardImageBuffer() {
+  if (Date.now() < swiftClipboardRetryAt) return null;
   const swiftCode = `
 import Cocoa
 let pb = NSPasteboard.general
@@ -117,9 +143,19 @@ if let data = pb.data(forType: .png) {
 `;
   try {
     const { stdout } = await execFileAsync('swift', ['-e', swiftCode], { encoding: 'buffer', timeout: 3000 });
-    if (stdout && stdout.length > 0) return stdout;
+    if (stdout && stdout.length > 0) {
+      markClipboardSuccess('macOS image clipboard read (Swift)');
+      swiftClipboardRetryAt = 0;
+      return stdout;
+    }
   } catch (error) {
+    // Back off before trying Swift again. A failed `swift -e` invocation is
+    // commonly persistent and clipboard polling runs every two seconds.
+    swiftClipboardRetryAt = Date.now() + 5 * 60 * 1000;
     logClipboardError('macOS image clipboard read (Swift)', error);
+    // This failure is now rate-limited by the retry window; don't let the
+    // displayed "consecutive failures" grow without bound.
+    clipboardErrorCounts.delete('macOS image clipboard read (Swift)');
     try {
       const jsaScript = `
         ObjC.import("AppKit");
@@ -141,7 +177,10 @@ if let data = pb.data(forType: .png) {
       `;
       const { stdout } = await execFileAsync('osascript', ['-l', 'JavaScript', '-e', jsaScript], { timeout: 3000 });
       const str = stdout.trim();
-      if (str) return Buffer.from(str, 'base64');
+      if (str) {
+        markClipboardSuccess('macOS image clipboard fallback read (osascript)');
+        return Buffer.from(str, 'base64');
+      }
     } catch (fallbackError) {
       logClipboardError('macOS image clipboard fallback read (osascript)', fallbackError);
     }
@@ -334,7 +373,12 @@ export async function captureClipboard() {
   if (process.platform === 'darwin' && settings.clipboardImageEnabled !== false && Date.now() >= suppressImageCaptureUntil) {
     try {
       const imageData = await getMacClipboardImageData();
-      if (imageData && imageData.rgbaBuf.length > 0) {
+      if (!imageData) {
+        // No image on clipboard (or transient capture failed and will retry next tick)
+        return;
+      }
+
+      if (imageData.rgbaBuf && imageData.rgbaBuf.length > 0) {
         const hash = createHash('md5').update(imageData.rgbaBuf).digest('hex');
         if (hash !== lastImageHash) {
           let isDuplicate = false;
@@ -356,12 +400,14 @@ export async function captureClipboard() {
             try {
               const mozjpegBuf = await compressMozjpeg(imageData.rgbaBuf, imageData.width, imageData.height, 75);
               saveClipboardImage(mozjpegBuf, 'jpg', hash);
+              markClipboardSuccess('image compression or save (WASM/JPEG)', 'image save');
             } catch (error) {
               logClipboardError('image compression or save (WASM/JPEG)', error);
               const rawBuf = await getMacClipboardImageBuffer();
               if (rawBuf) {
                 try {
                   saveClipboardImage(rawBuf, 'png', hash);
+                  markClipboardSuccess('raw image save after compression fallback', 'image save');
                 } catch (fallbackError) {
                   logClipboardError('raw image save after compression fallback', fallbackError);
                 }
@@ -369,32 +415,30 @@ export async function captureClipboard() {
             }
           }
         }
-      } else {
-        const imageBuffer = await getMacClipboardImageBuffer();
-        if (imageBuffer && imageBuffer.length > 0) {
-          const hash = createHash('md5').update(imageBuffer).digest('hex');
-          if (hash !== lastImageHash) {
-            let isDuplicate = false;
-            const dates = clipboardDates();
-            for (const d of dates) {
-              const dayList = dayItems(d);
-              if (dayList.some(item => {
-                if (item.imageHash === hash || item.fileHash === hash) return true;
-                if (Array.isArray(item.imageHashes) && item.imageHashes.includes(hash)) return true;
-                return false;
-              })) {
-                isDuplicate = true;
-                break;
-              }
+      } else if (imageData.rawBuffer && imageData.rawBuffer.length > 0) {
+        const hash = createHash('md5').update(imageData.rawBuffer).digest('hex');
+        if (hash !== lastImageHash) {
+          let isDuplicate = false;
+          const dates = clipboardDates();
+          for (const d of dates) {
+            const dayList = dayItems(d);
+            if (dayList.some(item => {
+              if (item.imageHash === hash || item.fileHash === hash) return true;
+              if (Array.isArray(item.imageHashes) && item.imageHashes.includes(hash)) return true;
+              return false;
+            })) {
+              isDuplicate = true;
+              break;
             }
+          }
 
-            lastImageHash = hash;
-            if (!isDuplicate) {
-              try {
-                saveClipboardImage(imageBuffer, 'png', hash);
-              } catch (error) {
-                logClipboardError('image save', error);
-              }
+          lastImageHash = hash;
+          if (!isDuplicate) {
+            try {
+              saveClipboardImage(imageData.rawBuffer, 'png', hash);
+              markClipboardSuccess('image save');
+            } catch (error) {
+              logClipboardError('image save', error);
             }
           }
         }