buddy-workbench 0.2.3 → 0.2.5

package/package.json

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

package/server/routes/jira-filters.js

@@ -328,6 +328,31 @@ async function searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, fields
   return [];
 }
 
+async function searchJiraWithFallbacksPaginated(jiraHost, headers, jqlCandidates, fields, maxResults = 100) {
+  for (const jql of jqlCandidates) {
+    if (!jql) continue;
+    try {
+      const issues = [];
+      let startAt = 0;
+      let total = 0;
+      do {
+        const searchUrl = `https://${jiraHost}/rest/api/2/search?jql=${encodeURIComponent(jql)}&startAt=${startAt}&maxResults=${maxResults}&fields=${encodeURIComponent(fields)}`;
+        const response = await httpClient.get(searchUrl, { headers });
+        if (response.status !== 200 || !Array.isArray(response.data?.issues)) throw new Error(`Jira search returned ${response.status}`);
+        const page = response.data.issues;
+        issues.push(...page);
+        total = Number(response.data.total) || issues.length;
+        startAt += page.length;
+        if (page.length === 0) break;
+      } while (startAt < total);
+      return issues;
+    } catch {
+      // Try the next JQL form when this Jira instance does not support the current one.
+    }
+  }
+  return [];
+}
+
 async function fetchCommentsForIssue(jiraHost, headers, issueKey, maxResults = 50) {
   try {
     const url = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?maxResults=${maxResults}`;
@@ -365,6 +390,9 @@ router.get('/recently-commented', async (_req, res) => {
     const identity = await getJiraIdentity(jiraHost, token);
 
     const jqlCandidates = [];
+    // This function targets issues where the current user authored a comment. The
+    // text search fallbacks below can miss comments that do not mention the author.
+    jqlCandidates.push('commentedBy(currentUser()) ORDER BY updated DESC');
     if (identity.name) {
       jqlCandidates.push(`comment ~ "\\"${identity.name}\\"" ORDER BY updated DESC`);
       jqlCandidates.push(`comment ~ "${identity.name}" ORDER BY updated DESC`);
@@ -378,10 +406,10 @@ router.get('/recently-commented', async (_req, res) => {
     jqlCandidates.push('(assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) AND updated >= -60d ORDER BY updated DESC');
     jqlCandidates.push('updated >= -60d ORDER BY updated DESC');
 
-    const issues = await searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter', 40);
+    const issues = await searchJiraWithFallbacksPaginated(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter');
     const results = [];
 
-    const issueCommentsPromises = issues.slice(0, 30).map(async (issue) => {
+    const issueCommentsPromises = issues.map(async (issue) => {
       const key = issue.key;
       const fields = issue.fields || {};
       const comments = await fetchCommentsForIssue(jiraHost, headers, key, 50);

package/server/services/clipboard-history.js

@@ -1,6 +1,6 @@
 import { execFile, spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
@@ -23,7 +23,10 @@ let suppressImageCaptureUntil = 0;
 let swiftClipboardRetryAt = 0;
 let mozjpegWasmModule = null;
 let macClipboardHelper = null;
+let macClipboardHelperStarting = false;
 let macClipboardHelperRestartTimer = null;
+let macClipboardHelperRestartDelay = 5000;
+let macClipboardHelperBinary = null;
 let macClipboardHelperWatchdog = null;
 let macClipboardHelperExitHookRegistered = false;
 const clipboardErrorCounts = new Map();
@@ -64,7 +67,7 @@ function logClipboardError(stage, error, threshold = 3) {
 
 async function compressMozjpeg(rgbaBuf, width, height, quality = 75) {
   if (!mozjpegWasmModule) {
-    const wasmPath = fileURLToPath(import.meta.resolve('../../ui/dist/assets/mozjpeg_enc-DO-zoExo.wasm'));
+    const wasmPath = fileURLToPath(import.meta.resolve('@jsquash/jpeg/codec/enc/mozjpeg_enc.wasm'));
     mozjpegWasmModule = await WebAssembly.compile(readFileSync(wasmPath));
     await initMozjpeg(mozjpegWasmModule);
   }
@@ -229,6 +232,7 @@ function handleMacClipboardHelperMessage(state, line) {
 
   if (message.kind === 'ready') {
     state.ready = true;
+    macClipboardHelperRestartDelay = 5000;
     markClipboardSuccess('native image helper startup', 'native image helper process');
     return;
   }
@@ -246,7 +250,7 @@ function handleMacClipboardHelperMessage(state, line) {
   if (message.kind !== 'image') return;
 
   const filename = String(message.filename || '');
-  const validFilename = /^capture-[0-9a-f-]+\.jpg$/i.test(filename);
+  const validFilename = /^capture-[0-9a-f-]+\.rgba$/i.test(filename);
   if (validFilename && Date.now() < suppressImageCaptureUntil) {
     try { unlinkSync(join(paths.clipboardDir, 'content', filename)); } catch {}
     return;
@@ -259,40 +263,44 @@ function handleMacClipboardHelperMessage(state, line) {
       || !Number.isInteger(width) || width <= 0
       || !Number.isInteger(height) || height <= 0
       || width * height > 40_000_000
-      || !Number.isInteger(reportedBytes) || reportedBytes <= 0 || reportedBytes > macClipboardCommandMaxBuffer) {
+      || !Number.isInteger(reportedBytes) || reportedBytes !== width * height * 4) {
     if (tempPath) { try { unlinkSync(tempPath); } catch {} }
     logClipboardError('native image helper protocol', new Error('Native image helper returned invalid image metadata.'));
     return;
   }
 
-  try {
-    const jpeg = readFileSync(tempPath);
-    if (!jpeg.length || jpeg.length !== reportedBytes || jpeg.length > macClipboardCommandMaxBuffer) {
-      throw new Error('Temporary JPEG size did not match the helper metadata.');
-    }
-    const hash = createHash('md5').update(jpeg).digest('hex');
-    persistCapturedClipboardImage(jpeg, hash, 'jpg');
-    const elapsedMs = Number(message.elapsedMs);
-    if (Number.isFinite(elapsedMs) && elapsedMs >= 3000) {
-      addErrorRecord({
-        source: 'Clipboard Monitor',
-        level: 'warning',
-        message: `Clipboard image capture took ${elapsedMs} ms.`,
-        details: `${width} × ${height}, source type ${String(message.sourceType || 'unknown')}, JPEG ${jpeg.length} bytes.`
-      });
+  const processImage = async () => {
+    const processingStartedAt = Date.now();
+    try {
+      const rgba = readFileSync(tempPath);
+      if (rgba.length !== reportedBytes) throw new Error('Temporary RGBA size did not match the helper metadata.');
+      const hash = createHash('md5').update(rgba).digest('hex');
+      const jpeg = await compressMozjpeg(rgba, width, height, 75);
+      persistCapturedClipboardImage(jpeg, hash, 'jpg');
+      const captureMs = Number(message.elapsedMs);
+      const totalMs = (Number.isFinite(captureMs) ? captureMs : 0) + Date.now() - processingStartedAt;
+      if (totalMs >= 3000) {
+        addErrorRecord({
+          source: 'Clipboard Monitor',
+          level: 'warning',
+          message: `Clipboard image capture took ${totalMs} ms.`,
+          details: `${width} × ${height}, source type ${String(message.sourceType || 'unknown')}, MozJPEG ${jpeg.length} bytes.`
+        });
+      }
+      markClipboardSuccess(
+        'native clipboard pasteboard read',
+        'native clipboard image validation',
+        'native clipboard image decode',
+        'native clipboard JPEG encode',
+        'native clipboard JPEG save'
+      );
+    } catch (error) {
+      logClipboardError('native clipboard MozJPEG encode', error);
+    } finally {
+      try { unlinkSync(tempPath); } catch {}
     }
-    markClipboardSuccess(
-      'native clipboard pasteboard read',
-      'native clipboard image validation',
-      'native clipboard image decode',
-      'native clipboard JPEG encode',
-      'native clipboard JPEG save'
-    );
-  } catch (error) {
-    logClipboardError('native clipboard JPEG handoff', error);
-  } finally {
-    try { unlinkSync(tempPath); } catch {}
-  }
+  };
+  state.imageProcessing = (state.imageProcessing || Promise.resolve()).then(processImage);
 }
 
 function scheduleMacClipboardHelperRestart() {
@@ -300,7 +308,8 @@ function scheduleMacClipboardHelperRestart() {
   macClipboardHelperRestartTimer = setTimeout(() => {
     macClipboardHelperRestartTimer = null;
     startMacClipboardImageHelper();
-  }, 5000);
+  }, macClipboardHelperRestartDelay);
+  macClipboardHelperRestartDelay = Math.min(macClipboardHelperRestartDelay * 2, 5 * 60 * 1000);
   macClipboardHelperRestartTimer.unref();
 }
 
@@ -315,7 +324,7 @@ function stopMacClipboardImageHelper() {
 }
 
 function startMacClipboardImageHelper() {
-  if (process.platform !== 'darwin' || macClipboardHelper || macClipboardHelperRestartTimer) return;
+  if (process.platform !== 'darwin' || macClipboardHelper || macClipboardHelperStarting || macClipboardHelperRestartTimer) return;
   const outputDirectory = join(paths.clipboardDir, 'content');
   mkdirSync(outputDirectory, { recursive: true, mode: 0o700 });
   try { chmodSync(outputDirectory, 0o700); } catch (error) {
@@ -323,16 +332,40 @@ function startMacClipboardImageHelper() {
     return;
   }
   const scriptPath = fileURLToPath(new URL('./mac-clipboard-helper.swift', import.meta.url));
+  const binaryPath = macClipboardHelperBinary || join(outputDirectory, 'mac-clipboard-helper');
+  macClipboardHelperStarting = true;
+  void (async () => {
+    try {
+      if (!macClipboardHelperBinary) {
+        await execFileAsync('swiftc', ['-O', scriptPath, '-o', binaryPath], {
+          timeout: 120 * 1000,
+          maxBuffer: 10 * 1024 * 1024
+        });
+        chmodSync(binaryPath, 0o700);
+        macClipboardHelperBinary = binaryPath;
+      }
+      launchMacClipboardImageHelper(binaryPath, outputDirectory);
+    } catch (error) {
+      logClipboardError('native image helper compile', error);
+      scheduleMacClipboardHelperRestart();
+    } finally {
+      macClipboardHelperStarting = false;
+    }
+  })();
+}
+
+function launchMacClipboardImageHelper(binaryPath, outputDirectory) {
   let child;
   try {
-    child = spawn('swift', [scriptPath, outputDirectory], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    child = spawn(binaryPath, [outputDirectory], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
   } catch (error) {
     logClipboardError('native image helper startup', error);
+    macClipboardHelperBinary = null;
     scheduleMacClipboardHelperRestart();
     return;
   }
 
-  const state = { child, ready: false, lastMessageAt: Date.now(), lineBuffer: '', stderr: '' };
+  const state = { child, ready: false, lastMessageAt: Date.now(), lineBuffer: '', stderr: '', imageProcessing: Promise.resolve() };
   macClipboardHelper = state;
   child.stdout.setEncoding('utf8');
   child.stdout.on('data', (chunk) => {
@@ -363,6 +396,7 @@ function startMacClipboardImageHelper() {
       const details = state.stderr.trim();
       logClipboardError('native image helper process', new Error(details || `Helper exited with code ${code ?? signal ?? 'unknown'}.`));
     }
+    if (!state.ready) macClipboardHelperBinary = null;
     scheduleMacClipboardHelperRestart();
   });
 
@@ -430,11 +464,17 @@ function getClipboardEditorDetails() {
 }
 
 function withClipboardEditorDetails(item, date, editorDetails) {
-  const itemWithDate = date ? { ...item, date } : item;
-  if (!item.contentFile) return itemWithDate;
+  const itemWithMetadata = {
+    ...item,
+    ...(date ? { date } : {}),
+    ...(item.imageFile ? { imageSize: (() => {
+      try { return statSync(clipboardImagePath(item.imageFile)).size; } catch { return null; }
+    })() } : {})
+  };
+  if (!item.contentFile) return itemWithMetadata;
   const { editor, editorName } = editorDetails || getClipboardEditorDetails();
   return {
-    ...itemWithDate,
+    ...itemWithMetadata,
     editorUrl: getEditorUrl(editor, join(paths.clipboardDir, 'content', item.contentFile)),
     editorName
   };
@@ -499,16 +539,7 @@ export function allTaggedClipboardItems() {
     const items = dayItems(date);
     for (const item of items) {
       if (Array.isArray(item.tags) && item.tags.length > 0) {
-        result.push(
-          item.contentFile
-            ? {
-                ...item,
-                date,
-                editorUrl: getEditorUrl(editor, join(paths.clipboardDir, 'content', item.contentFile)),
-                editorName
-              }
-            : { ...item, date }
-        );
+        result.push(withClipboardEditorDetails(item, date, { editor, editorName }));
       }
     }
   }
@@ -654,6 +685,7 @@ export function startClipboardCapture() {
 }
 
 export async function markClipboardCopied(date, id) {
+  let textToCopy = null;
   let targetDate = date;
   let items = dayItems(targetDate);
   let item = items.find((entry) => entry.id === id);
@@ -685,10 +717,36 @@ export async function markClipboardCopied(date, id) {
   } else {
     const text = clipboardOriginal(targetDate, id) || item.text || item.preview || '';
     if (text) {
+      textToCopy = text;
       lastValue = text.trim();
+      if (targetDate !== today()) {
+        const todayDate = today();
+        const todayItems = dayItems(todayDate);
+        const alreadyInToday = todayItems.some((entry) => {
+          if (entry.text !== undefined) return entry.text === text;
+          if (!entry.contentFile) return false;
+          try {
+            return readFileSync(join(paths.clipboardDir, 'content', entry.contentFile), 'utf8') === text;
+          } catch {
+            return false;
+          }
+        });
+        if (!alreadyInToday) {
+          const newId = randomUUID();
+          const isLong = text.length > previewLimit;
+          if (isLong) {
+            mkdirSync(join(paths.clipboardDir, 'content'), { recursive: true });
+            writeFileSync(join(paths.clipboardDir, 'content', newId), text, 'utf8');
+          }
+          const copiedItem = isLong
+            ? { id: newId, preview: `${text.slice(0, previewLimit)}…`, contentFile: newId, createdAt: new Date().toISOString() }
+            : { id: newId, text, createdAt: new Date().toISOString() };
+          writeJson(dayFile(todayDate), [copiedItem, ...todayItems].slice(0, 200));
+        }
+      }
     }
   }
-  return item;
+  return textToCopy === null ? item : { ...item, copyText: textToCopy };
 }
 
 export async function copyClipboardImage(date, id) {
@@ -735,6 +793,7 @@ export function saveClipboardImage(buffer, ext = 'png', imageHash = '') {
   const item = {
     id,
     imageFile: filename,
+    imageSize: buffer.length,
     imageHash: hash,
     fileHash,
     imageHashes: Array.from(new Set([hash, fileHash].filter(Boolean))),

package/server/services/mac-clipboard-helper.swift

@@ -63,21 +63,30 @@ func captureImage(_ pasteboard: NSPasteboard, changeCount: Int, startedAt: Date)
         return .complete
     }
 
-    let jpeg = NSMutableData()
-    guard let destination = CGImageDestinationCreateWithData(jpeg, "public.jpeg" as CFString, 1, nil) else {
-        emit(["kind": "error", "stage": "JPEG encode", "message": "ImageIO could not create a JPEG encoder.", "changeCount": changeCount, "elapsedMs": Int(Date().timeIntervalSince(startedAt) * 1000)])
-        return .complete
+    let bytesPerRow = width * 4
+    var rgba = Data(count: bytesPerRow * height)
+    let rendered = rgba.withUnsafeMutableBytes { buffer -> Bool in
+        guard let context = CGContext(
+            data: buffer.baseAddress,
+            width: width,
+            height: height,
+            bitsPerComponent: 8,
+            bytesPerRow: bytesPerRow,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue
+        ) else { return false }
+        context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
+        return true
     }
-    CGImageDestinationAddImage(destination, image, [kCGImageDestinationLossyCompressionQuality: 0.75] as CFDictionary)
-    guard CGImageDestinationFinalize(destination), jpeg.length > 0 else {
-        emit(["kind": "error", "stage": "JPEG encode", "message": "ImageIO could not finish JPEG encoding.", "changeCount": changeCount, "elapsedMs": Int(Date().timeIntervalSince(startedAt) * 1000)])
+    guard rendered else {
+        emit(["kind": "error", "stage": "image decode", "message": "Core Graphics could not render clipboard image pixels.", "changeCount": changeCount, "elapsedMs": Int(Date().timeIntervalSince(startedAt) * 1000)])
         return .complete
     }
 
-    let filename = "capture-\(UUID().uuidString).jpg"
+    let filename = "capture-\(UUID().uuidString).rgba"
     let outputURL = outputDirectory.appendingPathComponent(filename, isDirectory: false)
     do {
-        try (jpeg as Data).write(to: outputURL, options: .atomic)
+        try rgba.write(to: outputURL, options: .atomic)
         try FileManager.default.setAttributes([.posixPermissions: 0o600], ofItemAtPath: outputURL.path)
         emit([
             "kind": "image",
@@ -85,13 +94,13 @@ func captureImage(_ pasteboard: NSPasteboard, changeCount: Int, startedAt: Date)
             "sourceType": type.rawValue,
             "width": width,
             "height": height,
-            "bytes": jpeg.length,
+            "bytes": rgba.count,
             "elapsedMs": Int(Date().timeIntervalSince(startedAt) * 1000),
             "filename": filename
         ])
     } catch {
         try? FileManager.default.removeItem(at: outputURL)
-        emit(["kind": "error", "stage": "JPEG save", "message": "Could not write the temporary JPEG.", "changeCount": changeCount, "elapsedMs": Int(Date().timeIntervalSince(startedAt) * 1000)])
+        emit(["kind": "error", "stage": "image save", "message": "Could not write temporary RGBA pixels.", "changeCount": changeCount, "elapsedMs": Int(Date().timeIntervalSince(startedAt) * 1000)])
     }
     return .complete
 }