buddy-workbench 0.1.70 → 0.1.72

package/package.json

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

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/services/dev-configurations.js

@@ -1,12 +1,25 @@
 import { execFile } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 
 const execFileAsync = promisify(execFile);
 const NPM_KEYS = ['prefix', 'registry', 'strict-ssl', 'cache', 'proxy', 'https-proxy'];
-const NVM_LOAD = 'if [ -s "$NVM_DIR/nvm.sh" ]; then . "$NVM_DIR/nvm.sh"; elif [ -s "$HOME/.nvm/nvm.sh" ]; then . "$HOME/.nvm/nvm.sh"; fi; ';
+
+function getNvmDir() {
+  const home = homedir();
+  const candidates = [
+    process.env.NVM_DIR,
+    join(home, '.nvm'),
+    '/opt/homebrew/opt/nvm',
+    '/usr/local/opt/nvm'
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    if (existsSync(join(dir, 'nvm.sh'))) return dir;
+  }
+  return process.env.NVM_DIR || join(home, '.nvm');
+}
 
 function getEnrichedEnv() {
   const home = homedir();
@@ -22,7 +35,7 @@ function getEnrichedEnv() {
       '/usr/sbin',
       '/sbin'
     ];
-  const nvmDir = process.env.NVM_DIR || join(home, '.nvm');
+  const nvmDir = getNvmDir();
   if (existsSync(nvmDir)) {
     try {
       const versionsDir = join(nvmDir, 'versions', 'node');
@@ -86,9 +99,18 @@ async function runNvm(script, timeout = 5000) {
   if (process.platform === 'win32') {
     throw new Error('Unix NVM shell is not supported on Windows.');
   }
-  for (const shell of ['zsh', 'bash']) {
+  const nvmDir = getNvmDir();
+  const nvmSh = join(nvmDir, 'nvm.sh');
+  const nvmLoad = existsSync(nvmSh) ? `. "${nvmSh}"; ` : '';
+  const fullScript = `${nvmLoad}${script}`;
+  for (const shell of ['bash', 'sh', 'zsh']) {
     try {
-      const { stdout } = await execFileAsync(shell, ['-ilc', `${NVM_LOAD}${script}`], { timeout, maxBuffer: 4 * 1024 * 1024, env: getEnrichedEnv(), windowsHide: false });
+      const { stdout } = await execFileAsync(shell, ['-c', fullScript], {
+        timeout,
+        maxBuffer: 4 * 1024 * 1024,
+        env: { ...getEnrichedEnv(), NVM_DIR: nvmDir },
+        windowsHide: false
+      });
       return stdout.trim();
     } catch {}
   }
@@ -100,22 +122,90 @@ function parseNvmVersions(output) {
 }
 
 export async function readNvmConfiguration() {
-  try {
-    const output = await runNvm('if ! command -v nvm >/dev/null 2>&1; then exit 1; fi; printf "__VERSION__%s\\n" "$(nvm --version)"; printf "__CURRENT__%s\\n" "$(nvm current)"; printf "__DEFAULT__%s\\n" "$(nvm alias default 2>/dev/null)"; printf "__DIR__%s\\n" "${NVM_DIR:-$HOME/.nvm}"; printf "__MIRROR__%s\\n" "${NVM_NODEJS_ORG_MIRROR:-}"; printf "__LIST__\\n"; nvm ls --no-colors');
-    const value = (key) => output.match(new RegExp(`__${key}__(.*)`))?.[1]?.trim() || '';
-    const defaultLine = value('DEFAULT');
+  const nvmDir = getNvmDir();
+  const nvmSh = join(nvmDir, 'nvm.sh');
+  if (!existsSync(nvmSh)) {
     return {
-      installed: true,
-      version: value('VERSION'),
-      currentVersion: value('CURRENT'),
-      defaultVersion: defaultLine.match(/->\s+(?:v)?(\d+(?:\.\d+){0,2}|node|lts\/[\w.-]+)/)?.[1] || '',
-      nvmDir: value('DIR'),
-      nodeJsMirror: value('MIRROR'),
-      installedVersions: parseNvmVersions(output.split('__LIST__')[1] || '')
+      installed: false,
+      version: '',
+      currentVersion: '',
+      defaultVersion: '',
+      nvmDir: '',
+      nodeJsMirror: '',
+      installedVersions: []
     };
-  } catch {
-    return { installed: false, version: '', currentVersion: '', defaultVersion: '', nvmDir: '', nodeJsMirror: '', installedVersions: [] };
   }
+
+  let version = '';
+  try {
+    const pkgFile = join(nvmDir, 'package.json');
+    if (existsSync(pkgFile)) {
+      const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'));
+      version = pkg.version || '';
+    }
+  } catch {}
+
+  const installedVersions = [];
+  const versionsDir = join(nvmDir, 'versions', 'node');
+  if (existsSync(versionsDir)) {
+    try {
+      for (const entry of readdirSync(versionsDir)) {
+        if (/^v?\d+/.test(entry)) {
+          installedVersions.push(entry.startsWith('v') ? entry : `v${entry}`);
+        }
+      }
+    } catch {}
+  }
+  try {
+    for (const entry of readdirSync(nvmDir)) {
+      if (/^v\d+\.\d+\.\d+$/.test(entry) && existsSync(join(nvmDir, entry, 'bin', 'node'))) {
+        if (!installedVersions.includes(entry)) installedVersions.push(entry);
+      }
+    }
+  } catch {}
+  installedVersions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true, sensitivity: 'base' }));
+
+  let defaultVersion = '';
+  try {
+    const defaultAliasFile = join(nvmDir, 'alias', 'default');
+    if (existsSync(defaultAliasFile)) {
+      defaultVersion = readFileSync(defaultAliasFile, 'utf8').trim();
+    }
+  } catch {}
+
+  let currentVersion = process.version || '';
+  try {
+    const currentLink = join(nvmDir, 'current');
+    if (existsSync(currentLink)) {
+      const real = basename(realpathSync(currentLink));
+      if (/^v?\d+/.test(real)) {
+        currentVersion = real.startsWith('v') ? real : `v${real}`;
+      }
+    }
+  } catch {}
+
+  let nodeJsMirror = process.env.NVM_NODEJS_ORG_MIRROR || '';
+  if (!nodeJsMirror) {
+    try {
+      const shellFile = basename(process.env.SHELL || '') === 'bash' ? '.bashrc' : '.zshrc';
+      const file = join(homedir(), shellFile);
+      if (existsSync(file)) {
+        const content = readFileSync(file, 'utf8');
+        const match = content.match(/export\s+NVM_NODEJS_ORG_MIRROR="([^"]*)"/);
+        if (match) nodeJsMirror = match[1];
+      }
+    } catch {}
+  }
+
+  return {
+    installed: true,
+    version,
+    currentVersion,
+    defaultVersion,
+    nvmDir,
+    nodeJsMirror,
+    installedVersions
+  };
 }
 
 async function readNpmConfig(key) {