buddy-workbench 0.2.4 → 0.2.5

package/package.json

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

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';
@@ -67,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);
   }
@@ -250,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;
@@ -263,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() {
@@ -361,7 +365,7 @@ function launchMacClipboardImageHelper(binaryPath, outputDirectory) {
     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) => {
@@ -460,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
   };
@@ -529,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 }));
       }
     }
   }
@@ -684,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);
@@ -715,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) {
@@ -765,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
 }