buddy-workbench 0.1.69 → 0.1.71

package/package.json

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

package/server/routes/clipboard.js

@@ -1,6 +1,6 @@
 import express, { Router } from 'express';
 import { existsSync, readFileSync } from 'node:fs';
-import { clipboardDates, clipboardItems, clipboardOriginal, deleteClipboardItem, saveClipboardImage, clipboardImagePath, allTaggedClipboardItems, updateClipboardItemTags, markClipboardCopied } from '../services/clipboard-history.js';
+import { clipboardDates, clipboardItems, clipboardOriginal, deleteClipboardItem, saveClipboardImage, clipboardImagePath, allTaggedClipboardItems, updateClipboardItemTags, markClipboardCopied, copyClipboardImage } from '../services/clipboard-history.js';
 
 const router = Router();
 router.get('/', (req, res) => res.json({ dates: clipboardDates(), items: clipboardItems(req.query.date) }));
@@ -48,5 +48,13 @@ router.post('/:date/:id/copied', async (req, res) => {
     res.status(500).json({ error: error.message });
   }
 });
+router.post('/:date/:id/copy-image', async (req, res) => {
+  try {
+    await copyClipboardImage(req.params.date, req.params.id);
+    res.json({ ok: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
 router.delete('/:date/:id', (req, res) => { if (!deleteClipboardItem(req.params.date, req.params.id)) return res.status(404).json({ error: 'Clipboard entry not found.' }); res.status(204).end(); });
 export default router;

package/server/routes/jira-filters.js

@@ -54,6 +54,131 @@ async function getJiraIssueSummary(issueKey) {
   return summary;
 }
 
+function transformFieldValue(val) {
+  if (val === null || val === undefined) return undefined;
+
+  if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') {
+    return val;
+  }
+
+  if (Array.isArray(val)) {
+    if (val.length === 0) return undefined;
+    const items = val.map((item) => transformFieldValue(item)).filter((item) => item !== undefined);
+    return items.length > 0 ? items : undefined;
+  }
+
+  if (typeof val === 'object') {
+    const keys = Object.keys(val);
+    if (keys.length === 0) return undefined;
+
+    // Support cascading select (parent value + child value)
+    if (val.value !== undefined && val.child && typeof val.child === 'object') {
+      const childVal = transformFieldValue(val.child);
+      if (childVal) {
+        return { value: String(val.value), child: childVal };
+      }
+    }
+
+    if (val.id !== undefined && val.id !== null) {
+      return { id: String(val.id) };
+    }
+    if (val.accountId !== undefined && val.accountId !== null) {
+      return { accountId: String(val.accountId) };
+    }
+    if (val.value !== undefined && val.value !== null) {
+      return { value: String(val.value) };
+    }
+    if (val.key !== undefined && val.key !== null) {
+      return { key: String(val.key) };
+    }
+    if (val.name !== undefined && val.name !== null) {
+      return { name: String(val.name) };
+    }
+  }
+
+  return undefined;
+}
+
+function extractCloneableFields(origFields) {
+  if (!origFields || typeof origFields !== 'object') return {};
+
+  const fields = {};
+
+  // Standard fields
+  if (origFields.description !== undefined && origFields.description !== null) {
+    fields.description = origFields.description;
+  }
+
+  if (origFields.priority) {
+    if (origFields.priority.id) {
+      fields.priority = { id: String(origFields.priority.id) };
+    } else if (origFields.priority.name) {
+      fields.priority = { name: String(origFields.priority.name) };
+    }
+  }
+
+  if (Array.isArray(origFields.components) && origFields.components.length > 0) {
+    const components = origFields.components
+      .map((c) => (c.id ? { id: String(c.id) } : c.name ? { name: String(c.name) } : null))
+      .filter(Boolean);
+    if (components.length > 0) fields.components = components;
+  }
+
+  if (Array.isArray(origFields.labels) && origFields.labels.length > 0) {
+    const labels = origFields.labels.map((l) => String(l)).filter(Boolean);
+    if (labels.length > 0) fields.labels = labels;
+  }
+
+  if (Array.isArray(origFields.fixVersions) && origFields.fixVersions.length > 0) {
+    const fixVersions = origFields.fixVersions
+      .map((v) => (v.id ? { id: String(v.id) } : v.name ? { name: String(v.name) } : null))
+      .filter(Boolean);
+    if (fixVersions.length > 0) fields.fixVersions = fixVersions;
+  }
+
+  if (Array.isArray(origFields.versions) && origFields.versions.length > 0) {
+    const versions = origFields.versions
+      .map((v) => (v.id ? { id: String(v.id) } : v.name ? { name: String(v.name) } : null))
+      .filter(Boolean);
+    if (versions.length > 0) fields.versions = versions;
+  }
+
+  if (typeof origFields.environment === 'string' && origFields.environment) {
+    fields.environment = origFields.environment;
+  }
+
+  if (typeof origFields.duedate === 'string' && origFields.duedate) {
+    fields.duedate = origFields.duedate;
+  }
+
+  if (origFields.security) {
+    if (origFields.security.id) fields.security = { id: String(origFields.security.id) };
+    else if (origFields.security.name) fields.security = { name: String(origFields.security.name) };
+  }
+
+  if (origFields.parent) {
+    if (origFields.parent.id) fields.parent = { id: String(origFields.parent.id) };
+    else if (origFields.parent.key) fields.parent = { key: String(origFields.parent.key) };
+  }
+
+  if (origFields.assignee) {
+    if (origFields.assignee.accountId) fields.assignee = { accountId: String(origFields.assignee.accountId) };
+    else if (origFields.assignee.name) fields.assignee = { name: String(origFields.assignee.name) };
+  }
+
+  // Custom fields starting with customfield_
+  for (const [key, val] of Object.entries(origFields)) {
+    if (key.startsWith('customfield_') && val !== null && val !== undefined) {
+      const transformed = transformFieldValue(val);
+      if (transformed !== undefined) {
+        fields[key] = transformed;
+      }
+    }
+  }
+
+  return fields;
+}
+
 // List all filters
 router.get('/', (_req, res) => {
   res.json(listJiraFilters());
@@ -271,12 +396,11 @@ router.post('/issues/clone', async (req, res) => {
         recordApiError({ source: 'Jira API (Clone Issue)', method: 'GET', url: myselfUrl, message: error.message || 'Failed to fetch current user.' });
     }
 
-    // Fetch original issue details to preserve issue type, project, description, priority
+    // Fetch original issue details to preserve issue type, project, description, priority, components, labels, fixVersions, versions, environment, duedate, security, parent, custom fields
+    let origFields = null;
     let origIssueType = null;
     let origProjectKey = null;
     let origSummary = null;
-    let origDescription = null;
-    let origPriority = null;
 
     if (issueKey) {
       const issueUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}`;
@@ -286,29 +410,19 @@ router.post('/issues/clone', async (req, res) => {
           recordApiError({ source: 'Jira API (Clone Issue)', method: 'GET', url: issueUrl, status: origRes.status, message: `Jira issue API returned ${origRes.status}: ${origRes.statusText || 'Failed to fetch original issue.'}` });
         }
         if (origRes.status === 200 && origRes.data?.fields) {
-          const fields = origRes.data.fields;
-          if (fields.issuetype) {
-            if (fields.issuetype.id) {
-              origIssueType = { id: fields.issuetype.id };
-            } else if (fields.issuetype.name) {
-              origIssueType = { name: fields.issuetype.name };
+          origFields = origRes.data.fields;
+          if (origFields.issuetype) {
+            if (origFields.issuetype.id) {
+              origIssueType = { id: String(origFields.issuetype.id) };
+            } else if (origFields.issuetype.name) {
+              origIssueType = { name: String(origFields.issuetype.name) };
             }
           }
-          if (fields.project?.key) {
-            origProjectKey = fields.project.key;
-          }
-          if (fields.summary) {
-            origSummary = String(fields.summary).trim();
+          if (origFields.project?.key) {
+            origProjectKey = origFields.project.key;
           }
-          if (fields.description) {
-            origDescription = fields.description;
-          }
-          if (fields.priority) {
-            if (fields.priority.id) {
-              origPriority = { id: fields.priority.id };
-            } else if (fields.priority.name) {
-              origPriority = { name: fields.priority.name };
-            }
+          if (origFields.summary) {
+            origSummary = String(origFields.summary).trim();
           }
         }
       } catch (error) {
@@ -321,26 +435,60 @@ router.post('/issues/clone', async (req, res) => {
     const projectKey = origProjectKey || (issueKey ? issueKey.split('-')[0] : '');
     const requestedSummary = summary.trim();
     const cloneSummary = origSummary || requestedSummary;
+
+    // Extract all cloneable standard & custom fields from original issue
+    const cloneableFields = extractCloneableFields(origFields);
+
+    // Override assignee with current authenticated user if resolved
+    if (assigneeField) {
+      cloneableFields.assignee = assigneeField;
+    }
+
+    // Core fields required for issue creation
+    const coreFields = {
+      summary: cloneSummary,
+      ...(projectKey ? { project: { key: projectKey } } : {}),
+      issuetype: targetIssueType
+    };
+
+    let activeFields = { ...cloneableFields, ...coreFields };
+    let pendingPutFields = {};
+
     const url = `https://${jiraHost}/rest/api/2/issue`;
-    const payload = {
-      fields: {
-        summary: cloneSummary,
-        ...(projectKey ? { project: { key: projectKey } } : {}),
-        issuetype: targetIssueType,
-        ...(assigneeField ? { assignee: assigneeField } : {}),
-        ...(origDescription ? { description: origDescription } : {}),
-        ...(origPriority ? { priority: origPriority } : {})
+    let response = await httpClient.post(url, { fields: activeFields }, { headers });
+
+    // Handle field rejection on POST creation (e.g. fields not configured on Create Screen)
+    let maxRetries = 3;
+    while (response.status !== 201 && response.status !== 200 && maxRetries > 0) {
+      maxRetries--;
+      const errFields = response.data?.errors ? Object.keys(response.data.errors) : [];
+      if (errFields.length > 0) {
+        let strippedAny = false;
+        for (const errField of errFields) {
+          if (activeFields[errField] !== undefined && !['summary', 'project', 'issuetype'].includes(errField)) {
+            pendingPutFields[errField] = activeFields[errField];
+            delete activeFields[errField];
+            strippedAny = true;
+          }
+        }
+        if (strippedAny) {
+          response = await httpClient.post(url, { fields: activeFields }, { headers });
+          continue;
+        }
       }
-    };
+      break;
+    }
 
-    let response = await httpClient.post(url, payload, { headers });
-    // Fallback if optional fields like description or priority caused issue creation rejection
-    if (response.status !== 201 && response.status !== 200 && (origPriority || origDescription)) {
+    // Fallback attempt with minimal core fields if POST creation still failed
+    if (response.status !== 201 && response.status !== 200) {
+      for (const [k, v] of Object.entries(activeFields)) {
+        if (!['summary', 'project', 'issuetype'].includes(k)) {
+          pendingPutFields[k] = v;
+        }
+      }
       const fallbackPayload = {
         fields: {
-          summary: cloneSummary,
-          ...(projectKey ? { project: { key: projectKey } } : {}),
-          issuetype: targetIssueType,
+          ...coreFields,
           ...(assigneeField ? { assignee: assigneeField } : {})
         }
       };
@@ -358,7 +506,28 @@ router.post('/issues/clone', async (req, res) => {
     const created = response.data || {};
     const createdKey = created.key || issueKey;
 
-    // Fallback: Assign explicitly if not assigned during creation
+    // Apply pending fields via PUT update if any fields could not be set on creation screen
+    if (createdKey && Object.keys(pendingPutFields).length > 0) {
+      const updateUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(createdKey)}`;
+      try {
+        let putRes = await httpClient.put(updateUrl, { fields: pendingPutFields }, { headers });
+        if (putRes.status < 200 || putRes.status >= 300) {
+          const putErrFields = putRes.data?.errors ? Object.keys(putRes.data.errors) : [];
+          if (putErrFields.length > 0) {
+            for (const ef of putErrFields) {
+              delete pendingPutFields[ef];
+            }
+            if (Object.keys(pendingPutFields).length > 0) {
+              await httpClient.put(updateUrl, { fields: pendingPutFields }, { headers });
+            }
+          }
+        }
+      } catch (err) {
+        recordApiError({ source: 'Jira API (Clone Issue PUT fields)', method: 'PUT', url: `https://${jiraHost}/rest/api/2/issue/${createdKey}`, message: err.message || 'Failed to PUT cloned fields.' });
+      }
+    }
+
+    // Fallback: Assign explicitly if not assigned during creation/PUT
     if (createdKey && assigneeField) {
       const assignUrl = `https://${jiraHost}/rest/api/2/issue/${createdKey}/assignee`;
       try {

package/server/routes/updates.js

@@ -83,29 +83,55 @@ function buildReleaseList(metadata) {
 }
 
 async function readNpmPackageMetadata() {
-  // Do not depend on npm being present in the server process PATH. On Windows,
-  // a UI launched from a shortcut often has a reduced PATH and `npm.cmd view`
-  // fails even though npm works in an interactive terminal.
-  const registry = String(process.env.npm_config_registry || 'https://registry.npmjs.org/')
-    .trim()
-    .replace(/\/+$/, '');
-  const response = await fetch(`${registry}/${encodeURIComponent(PACKAGE_NAME)}`, {
-    headers: { Accept: 'application/json' },
-    signal: AbortSignal.timeout(8000)
-  });
-  if (!response.ok) {
-    throw new Error(`The configured npm registry returned HTTP ${response.status}.`);
-  }
-  const packageMetadata = await response.json();
-  const metadata = {
-    version: packageMetadata?.['dist-tags']?.latest,
-    time: packageMetadata?.time,
-    devbuddyChangelog: packageMetadata?.devbuddyChangelog
-  };
-  if (!metadata.version) {
-    throw new Error('The configured npm registry did not return package version metadata.');
+  // npm knows about the user's ~/.npmrc, including private registries,
+  // proxies, authentication and custom CA settings. This matters in the
+  // internal-network desktop build, where those settings are not necessarily
+  // exposed as npm_config_* environment variables.
+  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  try {
+    const { stdout } = await execFileAsync(
+      npmCommand,
+      ['view', `${PACKAGE_NAME}@latest`, 'version', 'time', 'devbuddyChangelog', '--json'],
+      {
+        timeout: 8000,
+        maxBuffer: 1024 * 1024,
+        shell: process.platform === 'win32',
+        windowsHide: true
+      }
+    );
+    const metadata = JSON.parse(stdout);
+    if (!metadata || typeof metadata !== 'object' || !metadata.version) {
+      throw new Error('The configured npm registry did not return package version metadata.');
+    }
+    return metadata;
+  } catch (npmError) {
+    // Keep a fallback for desktop launchers whose reduced PATH cannot find
+    // npm. It is intentionally secondary so it cannot bypass ~/.npmrc.
+    const registry = String(process.env.npm_config_registry || 'https://registry.npmjs.org/')
+      .trim()
+      .replace(/\/+$/, '');
+    try {
+      const response = await fetch(`${registry}/${encodeURIComponent(PACKAGE_NAME)}`, {
+        headers: { Accept: 'application/json' },
+        signal: AbortSignal.timeout(8000)
+      });
+      if (!response.ok) {
+        throw new Error(`The configured npm registry returned HTTP ${response.status}.`);
+      }
+      const packageMetadata = await response.json();
+      const metadata = {
+        version: packageMetadata?.['dist-tags']?.latest,
+        time: packageMetadata?.time,
+        devbuddyChangelog: packageMetadata?.devbuddyChangelog
+      };
+      if (!metadata.version) {
+        throw new Error('The configured npm registry did not return package version metadata.');
+      }
+      return metadata;
+    } catch {
+      throw npmError;
+    }
   }
-  return metadata;
 }
 
 async function checkForUpdates() {

package/server/services/clipboard-history.js

@@ -13,6 +13,7 @@ const execFileAsync = promisify(execFile);
 const previewLimit = 2000;
 let lastValue = '';
 let lastImageHash = '';
+let suppressImageCaptureUntil = 0;
 let mozjpegWasmModule = null;
 
 async function compressMozjpeg(rgbaBuf, width, height, quality = 75) {
@@ -304,7 +305,7 @@ export async function captureClipboard() {
   } catch {}
 
   // 2. Image capture (Mac only & clipboardImageEnabled !== false)
-  if (process.platform === 'darwin' && settings.clipboardImageEnabled !== false) {
+  if (process.platform === 'darwin' && settings.clipboardImageEnabled !== false && Date.now() >= suppressImageCaptureUntil) {
     try {
       const imageData = await getMacClipboardImageData();
       if (imageData && imageData.rgbaBuf.length > 0) {
@@ -389,24 +390,13 @@ export async function markClipboardCopied(date, id) {
   if (!item) return null;
 
   if (item.imageFile) {
-    try {
-      const imageData = await getMacClipboardImageData();
-      if (imageData && imageData.rgbaBuf.length > 0) {
-        const currentHash = createHash('md5').update(imageData.rgbaBuf).digest('hex');
-        lastImageHash = currentHash;
-
-        const existingHashes = Array.isArray(item.imageHashes)
-          ? item.imageHashes
-          : [item.imageHash, item.fileHash].filter(Boolean);
-
-        if (!existingHashes.includes(currentHash)) {
-          const updatedItem = { ...item, imageHashes: [...existingHashes, currentHash] };
-          const nextItems = items.map((entry) => (entry.id === id ? updatedItem : entry));
-          writeJson(dayFile(targetDate), nextItems);
-          return updatedItem;
-        }
-      }
-    } catch {}
+    // Set the monitor's last hash before the browser writes the image. This
+    // prevents copying an existing image from being captured as a new item.
+    suppressImageCaptureUntil = Date.now() + 5000;
+    const existingHashes = Array.isArray(item.imageHashes)
+      ? item.imageHashes
+      : [item.imageHash, item.fileHash].filter(Boolean);
+    lastImageHash = existingHashes[0] || '';
   } else {
     const text = clipboardOriginal(targetDate, id) || item.text || item.preview || '';
     if (text) {
@@ -416,6 +406,37 @@ export async function markClipboardCopied(date, id) {
   return item;
 }
 
+export async function copyClipboardImage(date, id) {
+  if (process.platform !== 'darwin') throw new Error('Native image clipboard is only supported on macOS.');
+
+  let item = dayItems(date).find((entry) => entry.id === id);
+  if (!item) {
+    for (const d of clipboardDates()) {
+      item = dayItems(d).find((entry) => entry.id === id);
+      if (item) break;
+    }
+  }
+  if (!item?.imageFile) throw new Error('Clipboard image entry not found.');
+
+  await markClipboardCopied(date, id);
+  const imagePath = clipboardImagePath(item.imageFile);
+  const swiftCode = `
+import Cocoa
+let path = CommandLine.arguments[1]
+if let image = NSImage(contentsOfFile: path),
+   let tiff = image.tiffRepresentation,
+   let rep = NSBitmapImageRep(data: tiff),
+   let png = rep.representation(using: .png, properties: [:]) {
+    let pasteboard = NSPasteboard.general
+    pasteboard.clearContents()
+    if !pasteboard.setData(png, forType: .png) { exit(1) }
+} else {
+    exit(1)
+}
+`;
+  await execFileAsync('swift', ['-e', swiftCode, imagePath], { timeout: 5000 });
+}
+
 export function saveClipboardImage(buffer, ext = 'png', imageHash = '') {
   const date = today();
   const id = randomUUID();