buddy-workbench 0.1.32 → 0.1.34

package/bin/devbuddy.js

@@ -2,6 +2,7 @@
 
 import { execFileSync, execSync, spawn } from 'node:child_process';
 import { existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -9,7 +10,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const root = dirname(__dirname);
 
-const dataDir = join(root, 'data');
+const dataDir = join(homedir(), '.devbuddy', 'data');
 const pidFile = join(dataDir, 'devbuddy.pid');
 const logFile = join(dataDir, 'devbuddy.log');
 const serverJs = join(root, 'server.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "private": false,
   "type": "module",
   "bin": {
@@ -24,6 +24,15 @@
     "version": "node -e \"const v=process.env.npm_package_version; const fs=require('fs'); ['ui/package.json', 'ui/package-lock.json'].forEach(p=>{if(fs.existsSync(p)){const j=JSON.parse(fs.readFileSync(p)); j.version=v; if(j.packages&&j.packages['']){j.packages[''].version=v;} fs.writeFileSync(p, JSON.stringify(j,null,2)+'\\n');}});\" && git add ui/package.json ui/package-lock.json"
   },
   "devbuddyChangelog": [
+    {
+      "version": "0.1.33",
+      "name": "Developer configuration management",
+      "notes": [
+        "Added system-level NPM, Git, and NVM configuration management.",
+        "Added NVM detection, Node.js version installation, download mirror configuration, and current runtime details.",
+        "Added global NPM package search, version selection with publish dates, install confirmation, upgrade, and uninstall actions."
+      ]
+    },
     {
       "version": "0.1.28",
       "name": "Presentation planning and presenter tools",

package/server/config.js

@@ -1,24 +1,41 @@
+import { cpSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 export const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const legacyDataDir = join(root, 'data');
+const userDataDir = join(homedir(), '.devbuddy', 'data');
+
+function migrateLegacyData() {
+  mkdirSync(userDataDir, { recursive: true, mode: 0o700 });
+  if (!existsSync(legacyDataDir) || legacyDataDir === userDataDir) return;
+  for (const entry of readdirSync(legacyDataDir)) {
+    const source = join(legacyDataDir, entry);
+    const target = join(userDataDir, entry);
+    if (!existsSync(target)) cpSync(source, target, { recursive: true });
+  }
+}
+
+migrateLegacyData();
+
 export const paths = {
-  dataDir: join(root, 'data'),
-  launchers: join(root, 'data', 'launchers.json'),
-  portHistory: join(root, 'data', 'port-history.json'),
-  groupTasks: join(root, 'data', 'group-tasks.json'),
-  settings: join(root, 'data', 'settings.json'),
-  jiraFilters: join(root, 'data', 'jira-filters.json'),
-  todos: join(root, 'data', 'todos.json'),
-  staticPages: join(root, 'data', 'static-pages.json'),
-  errors: join(root, 'data', 'errors.json'),
-  postman: join(root, 'data', 'postman.json'),
-  branchSync: join(root, 'data', 'branch-sync.json'),
-  presentations: join(root, 'data', 'presentations.json'),
-  shutdownLog: join(root, 'data', 'shutdown.log'),
-  clipboardDir: join(root, 'data', 'clipboard'),
+  dataDir: userDataDir,
+  launchers: join(userDataDir, 'launchers.json'),
+  portHistory: join(userDataDir, 'port-history.json'),
+  groupTasks: join(userDataDir, 'group-tasks.json'),
+  settings: join(userDataDir, 'settings.json'),
+  jiraFilters: join(userDataDir, 'jira-filters.json'),
+  todos: join(userDataDir, 'todos.json'),
+  staticPages: join(userDataDir, 'static-pages.json'),
+  errors: join(userDataDir, 'errors.json'),
+  postman: join(userDataDir, 'postman.json'),
+  branchSync: join(userDataDir, 'branch-sync.json'),
+  presentations: join(userDataDir, 'presentations.json'),
+  shutdownLog: join(userDataDir, 'shutdown.log'),
+  clipboardDir: join(userDataDir, 'clipboard'),
   plugins: join(root, 'plugins'),
   pages: join(root, 'pages'),
-  dataPages: join(root, 'data', 'pages'),
+  dataPages: join(userDataDir, 'pages'),
   ui: join(root, 'ui', 'dist')
 };

package/server/routes/settings.js

@@ -2,12 +2,35 @@ import { existsSync, mkdirSync } from 'node:fs';
 import { Router } from 'express';
 import { paths } from '../config.js';
 import { saveAccessToken, saveClipboardDeduplicateMinutes, saveClipboardEnabled, saveClipboardImageEnabled, saveDefaultBrowser, saveDefaultEditor, saveDomain, saveJiraIssuePrefix, saveTheme, settingsStatus } from '../repositories/settings.js';
+import { getNpmPackageVersions, installNvmVersion, manageGlobalNpmPackage, readDevConfigurations, readNvmConfiguration, saveDevConfigurations, searchNpmPackages } from '../services/dev-configurations.js';
 import { openInSystemBrowser, openInSystemEditor, openInSystemFolder } from '../services/browser.js';
 import { selectDirectory } from '../services/dialog.js';
 
 const router = Router();
 
 router.get('/', (_req, res) => res.json(settingsStatus()));
+router.get('/dev-configurations', async (_req, res) => {
+  try { res.json({ ...(await readDevConfigurations()), nvm: await readNvmConfiguration() }); } catch (error) { res.status(500).json({ error: error.message }); }
+});
+router.put('/dev-configurations', async (req, res) => {
+  const { npm, git } = req.body || {};
+  if (!npm || typeof npm !== 'object' || !git || typeof git !== 'object') {
+    return res.status(400).json({ error: 'NPM and GIT configurations are required.' });
+  }
+  try { res.json({ ...(await saveDevConfigurations({ npm, git, nvm: req.body.nvm })), nvm: await readNvmConfiguration() }); } catch (error) { res.status(500).json({ error: error.message }); }
+});
+router.post('/dev-configurations/nvm/install', async (req, res) => {
+  try { res.json(await installNvmVersion(req.body?.version)); } catch (error) { res.status(400).json({ error: error.message }); }
+});
+router.post('/dev-configurations/npm/search', async (req, res) => {
+  try { res.json(await searchNpmPackages(req.body?.query)); } catch (error) { res.status(400).json({ error: error.message }); }
+});
+router.post('/dev-configurations/npm/versions', async (req, res) => {
+  try { res.json(await getNpmPackageVersions(req.body?.packageName)); } catch (error) { res.status(400).json({ error: error.message }); }
+});
+router.post('/dev-configurations/npm/:action', async (req, res) => {
+  try { res.json(await manageGlobalNpmPackage(req.params.action, req.body?.packageName)); } catch (error) { res.status(400).json({ error: error.message }); }
+});
 router.put('/domain', (req, res) => {
   const { domain } = req.body || {};
   if (typeof domain !== 'string') return res.status(400).json({ error: 'Domain must be a string.' });

package/server/services/dev-configurations.js

@@ -0,0 +1,206 @@
+import { execFile } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, 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; ';
+
+async function run(command, args) {
+  const { stdout } = await execFileAsync(command, args, { timeout: 5000, maxBuffer: 1024 * 1024 });
+  return stdout.trim();
+}
+
+async function runNvm(script, timeout = 5000) {
+  for (const shell of ['zsh', 'bash']) {
+    try {
+      const { stdout } = await execFileAsync(shell, ['-ilc', `${NVM_LOAD}${script}`], { timeout, maxBuffer: 2 * 1024 * 1024 });
+      return stdout.trim();
+    } catch {}
+  }
+  throw new Error('NVM is not installed or could not be loaded from the shell.');
+}
+
+function parseNvmVersions(output) {
+  return [...new Set(String(output).split('\n').map((line) => line.match(/v\d+(?:\.\d+){0,2}/)?.[0]).filter(Boolean))];
+}
+
+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');
+    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] || '')
+    };
+  } catch {
+    return { installed: false, version: '', currentVersion: '', defaultVersion: '', nvmDir: '', nodeJsMirror: '', installedVersions: [] };
+  }
+}
+
+async function readNpmConfig(key) {
+  try {
+    const value = await run('npm', ['config', 'get', key]);
+    return value === 'undefined' || value === 'null' ? '' : value;
+  } catch {
+    return '';
+  }
+}
+
+async function readGitConfig(key) {
+  try { return await run('git', ['config', '--global', '--get', key]); } catch { return ''; }
+}
+
+async function readGlobalNpmPackages() {
+  try {
+    const { stdout } = await execFileAsync('npm', ['ls', '--global', '--depth=0', '--json'], { timeout: 10000, maxBuffer: 4 * 1024 * 1024 });
+    const packageJson = JSON.parse(stdout);
+    return Object.entries(packageJson.dependencies || {}).map(([name, info]) => ({ name, version: info.version || '' }));
+  } catch (error) {
+    try {
+      const packageJson = JSON.parse(error.stdout || '');
+      return Object.entries(packageJson.dependencies || {}).map(([name, info]) => ({ name, version: info.version || '' }));
+    } catch { return []; }
+  }
+}
+
+function validateNpmPackageName(packageName) {
+  const value = String(packageName || '').trim();
+  if (!/^(@[a-z0-9._~-]+\/)?[a-z0-9._~-]+(?:@[a-z0-9.*^~<>=| -]+)?$/i.test(value)) throw new Error('Invalid npm package name.');
+  return value;
+}
+
+export async function manageGlobalNpmPackage(action, packageName) {
+  const name = validateNpmPackageName(packageName);
+  const args = action === 'install'
+    ? ['install', '--global', name]
+    : action === 'upgrade'
+    ? ['update', '--global', name]
+    : ['uninstall', '--global', name];
+  if (!['install', 'upgrade', 'uninstall'].includes(action)) throw new Error('Unsupported npm package action.');
+  await execFileAsync('npm', args, { timeout: 10 * 60 * 1000, maxBuffer: 4 * 1024 * 1024 });
+  return readGlobalNpmPackages();
+}
+
+export async function searchNpmPackages(query) {
+  const term = String(query || '').trim();
+  if (!term || term.length > 100) throw new Error('Enter a package search term.');
+  const { stdout } = await execFileAsync('npm', ['search', term, '--json', '--long'], { timeout: 30 * 1000, maxBuffer: 8 * 1024 * 1024 });
+  const results = JSON.parse(stdout);
+  return (Array.isArray(results) ? results : []).slice(0, 20).map((item) => ({
+    name: item.name,
+    version: item.version || '',
+    description: item.description || ''
+  }));
+}
+
+export async function getNpmPackageVersions(packageName) {
+  const name = validateNpmPackageName(packageName).replace(/@[^@]+$/, '');
+  const [{ stdout: versionsOutput }, { stdout: timeOutput }] = await Promise.all([
+    execFileAsync('npm', ['view', name, 'versions', '--json'], { timeout: 30 * 1000, maxBuffer: 4 * 1024 * 1024 }),
+    execFileAsync('npm', ['view', name, 'time', '--json'], { timeout: 30 * 1000, maxBuffer: 4 * 1024 * 1024 })
+  ]);
+  const versions = JSON.parse(versionsOutput);
+  const publishTimes = JSON.parse(timeOutput) || {};
+  return (Array.isArray(versions) ? versions : versions ? [versions] : []).slice(-100).reverse().map((version) => ({ version, publishedAt: publishTimes[version] || '' }));
+}
+
+function sshKeyFromCommand(command) {
+  const match = String(command || '').match(/(?:^|\s)-i\s+(?:"([^"]+)"|'([^']+)'|(\S+))/);
+  return match ? (match[1] || match[2] || match[3]) : '';
+}
+
+export async function readDevConfigurations() {
+  const values = await Promise.all(NPM_KEYS.map(readNpmConfig));
+  const [name, email, sshCommand, globalPackages, nodeVersion, npmVersion] = await Promise.all([readGitConfig('user.name'), readGitConfig('user.email'), readGitConfig('core.sshCommand'), readGlobalNpmPackages(), run('node', ['--version']).catch(() => ''), run('npm', ['--version']).catch(() => '')]);
+  const npm = Object.fromEntries(NPM_KEYS.map((key, index) => [key, values[index]]));
+  return {
+    npm: {
+      prefix: npm.prefix,
+      registry: npm.registry || 'https://registry.npmjs.org/',
+      strictSsl: npm['strict-ssl'] !== 'false',
+      cache: npm.cache,
+      proxy: npm.proxy,
+      httpsProxy: npm['https-proxy'],
+      globalPackages,
+      nodeVersion,
+      npmVersion
+    },
+    git: { name, email, sshKey: sshKeyFromCommand(sshCommand) }
+  };
+}
+
+async function setNpmConfig(key, value) {
+  if (value === '') {
+    await run('npm', ['config', 'delete', key]);
+  } else {
+    await run('npm', ['config', 'set', key, value]);
+  }
+}
+
+export async function saveDevConfigurations(configurations = {}) {
+  const npm = configurations.npm || {};
+  const git = configurations.git || {};
+  const npmValues = {
+    prefix: String(npm.prefix || '').trim(),
+    registry: String(npm.registry || '').trim() || 'https://registry.npmjs.org/',
+    'strict-ssl': npm.strictSsl === false ? 'false' : 'true',
+    cache: String(npm.cache || '').trim(),
+    proxy: String(npm.proxy || '').trim(),
+    'https-proxy': String(npm.httpsProxy || '').trim()
+  };
+  for (const key of NPM_KEYS) await setNpmConfig(key, npmValues[key]);
+  const gitValues = { name: String(git.name || '').trim(), email: String(git.email || '').trim() };
+  for (const [key, value] of Object.entries(gitValues)) {
+    if (value) await run('git', ['config', '--global', `user.${key}`, value]);
+    else {
+      try { await run('git', ['config', '--global', '--unset', `user.${key}`]); } catch {}
+    }
+  }
+  const sshKey = String(git.sshKey || '').trim();
+  if (sshKey) {
+    const resolvedKey = sshKey.startsWith('~/') ? `${homedir()}/${sshKey.slice(2)}` : sshKey;
+    const quotedKey = `"${resolvedKey.replaceAll('"', '\\"')}"`;
+    await run('git', ['config', '--global', 'core.sshCommand', `ssh -i ${quotedKey} -o IdentitiesOnly=yes`]);
+  } else {
+    try { await run('git', ['config', '--global', '--unset', 'core.sshCommand']); } catch {}
+  }
+  const nvm = configurations.nvm || {};
+  const mirror = String(nvm.nodeJsMirror || '').trim().replace(/\/$/, '');
+  if (mirror && !/^https?:\/\/[^\s]+$/i.test(mirror)) throw new Error('Invalid NVM Node.js download mirror URL.');
+  updateNvmMirror(mirror);
+  if (String(nvm.defaultVersion || '').trim()) {
+    const version = String(nvm.defaultVersion).trim();
+    if (!/^(?:v?\d+(?:\.\d+){0,2}|node|lts\/[\w.-]+)$/.test(version)) throw new Error('Invalid NVM default version.');
+    await runNvm(`nvm alias default ${shellQuote(version)}`);
+  }
+  return readDevConfigurations();
+}
+
+function updateNvmMirror(mirror) {
+  const shellFile = basename(process.env.SHELL || '') === 'bash' ? '.bashrc' : '.zshrc';
+  const file = join(homedir(), shellFile);
+  const marker = '# DevBuddy NVM Node.js mirror';
+  let content = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  const block = new RegExp(`\\n?${marker}\\nexport NVM_NODEJS_ORG_MIRROR="[^"]*"\\n?`, 'g');
+  content = content.replace(block, '\n');
+  if (mirror) content = `${content.trimEnd()}\n\n${marker}\nexport NVM_NODEJS_ORG_MIRROR="${mirror.replaceAll('"', '\\\"')}"\n`;
+  writeFileSync(file, content, { mode: 0o600 });
+}
+
+function shellQuote(value) { return `'${String(value).replaceAll("'", "'\\''")}'`; }
+
+export async function installNvmVersion(version) {
+  const target = String(version || '').trim();
+  if (!/^(?:v?\d+(?:\.\d+){0,2}|node|lts\/[\w.-]+|--lts)$/.test(target)) throw new Error('Invalid NVM version.');
+  await runNvm(`nvm install ${shellQuote(target)}`, 10 * 60 * 1000);
+  return readNvmConfiguration();
+}