buddy-workbench 0.1.31 → 0.1.33

package/README.md

@@ -12,6 +12,20 @@ npm start
 
 Open `http://localhost:3100`. To use another port, run `PORT=4000 npm start`. Startup attempts to stop any process currently using the selected port.
 
+When using the `devbuddy` CLI, pass the port directly with `--port`:
+
+```bash
+devbuddy start --port 4000
+devbuddy restart --port 4000
+```
+
+Update the globally installed CLI from npm:
+
+```bash
+devbuddy self-update
+devbuddy self-update 0.1.32
+```
+
 ## Running on macOS
 
 ### Double-click Launcher (Terminal)

package/bin/devbuddy.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { execSync, spawn } from 'node:child_process';
+import { execFileSync, execSync, spawn } from 'node:child_process';
 import { existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -13,6 +13,85 @@ const dataDir = join(root, 'data');
 const pidFile = join(dataDir, 'devbuddy.pid');
 const logFile = join(dataDir, 'devbuddy.log');
 const serverJs = join(root, 'server.js');
+const packageJsonFile = join(root, 'package.json');
+const defaultPort = 3100;
+
+function parsePort(args) {
+  let port;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--port') {
+      if (port !== undefined || args[index + 1] === undefined) {
+        throw new Error('Usage: --port <number>');
+      }
+      port = args[++index];
+    } else if (arg.startsWith('--port=')) {
+      if (port !== undefined) throw new Error('Port was specified more than once.');
+      port = arg.slice('--port='.length);
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  const value = port ?? process.env.PORT ?? defaultPort;
+  if (!/^\d+$/.test(String(value)) || Number(value) < 1 || Number(value) > 65535) {
+    throw new Error('Port must be a number between 1 and 65535.');
+  }
+  return Number(value);
+}
+
+function packageDetails() {
+  return JSON.parse(readFileSync(packageJsonFile, 'utf8'));
+}
+
+function npmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function parseUpdateVersion(args) {
+  if (args.length > 1) throw new Error('Usage: devbuddy self-update [version]');
+  if (!args[0]) return 'latest';
+  if (args[0].startsWith('-') || /\s/.test(args[0])) {
+    throw new Error('Version must be a package version, tag, or dist-tag.');
+  }
+  return args[0];
+}
+
+function latestPublishedVersion(packageName) {
+  try {
+    return execFileSync(npmCommand(), ['view', packageName, 'version'], {
+      cwd: root,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+  } catch {
+    throw new Error(`Unable to query the latest ${packageName} version from npm.`);
+  }
+}
+
+function selfUpdate(args) {
+  const details = packageDetails();
+  const version = parseUpdateVersion(args);
+  const currentVersion = details.version;
+  const targetVersion = version === 'latest' ? latestPublishedVersion(details.name) : version;
+
+  if (version === 'latest' && targetVersion === currentVersion) {
+    console.log(`${details.name} is already up to date (${currentVersion}).`);
+    return;
+  }
+
+  console.log(`Updating ${details.name} from ${currentVersion} to ${version}…`);
+  try {
+    execFileSync(npmCommand(), ['install', '--global', `${details.name}@${version}`], {
+      cwd: root,
+      stdio: 'inherit'
+    });
+  } catch {
+    throw new Error(`Unable to install ${details.name}@${version}. Check npm permissions and network access.`);
+  }
+  console.log(`Updated ${details.name} to ${targetVersion}.`);
+}
 
 function isProcessRunning(pid) {
   try {
@@ -58,11 +137,11 @@ function sendSignal(pid, signal) {
   }
 }
 
-async function start() {
+async function start(port) {
   const existingPid = getRunningPid();
   if (existingPid) {
     console.log(`DevBuddy is already running (PID ${existingPid}).`);
-    console.log(`URL: http://localhost:${process.env.PORT || 3100}`);
+    console.log(`URL: http://localhost:${port}`);
     return;
   }
 
@@ -75,7 +154,7 @@ async function start() {
     detached: true,
     stdio: ['ignore', out, err],
     cwd: root,
-    env: { ...process.env }
+    env: { ...process.env, PORT: String(port) }
   });
 
   if (!child.pid) {
@@ -90,7 +169,6 @@ async function start() {
   await new Promise((resolve) => setTimeout(resolve, 800));
 
   if (isProcessRunning(child.pid)) {
-    const port = process.env.PORT || 3100;
     console.log(`DevBuddy started successfully (PID ${child.pid}).`);
     console.log(`URL: http://localhost:${port}`);
     console.log(`Logs: ${logFile}`);
@@ -133,10 +211,9 @@ async function stop() {
   console.log('DevBuddy stopped.');
 }
 
-function status() {
+function status(port) {
   const pid = getRunningPid();
   if (pid) {
-    const port = process.env.PORT || 3100;
     console.log(`DevBuddy is running (PID ${pid}).`);
     console.log(`URL: http://localhost:${port}`);
   } else {
@@ -149,33 +226,47 @@ function help() {
 DevBuddy CLI
 
 Usage:
-  devbuddy <command>
+  devbuddy <command> [--port <number>]
 
 Commands:
   start     Start DevBuddy in the background
   stop      Stop the running DevBuddy instance
   status    Check the status of DevBuddy
   restart   Restart DevBuddy
+  self-update [version]
+            Update the globally installed DevBuddy CLI
   help      Display this help message
+
+Options:
+  --port <number>  Port to listen on (default: 3100)
+
+Examples:
+  devbuddy start --port 4000
 `);
 }
 
 async function main() {
   const command = process.argv[2] || 'help';
+  const args = process.argv.slice(3);
 
   switch (command.toLowerCase()) {
     case 'start':
-      await start();
+      await start(parsePort(args));
       break;
     case 'stop':
       await stop();
       break;
     case 'status':
-      status();
+      status(parsePort(args));
       break;
     case 'restart':
       await stop();
-      await start();
+      await start(parsePort(args));
+      break;
+    case 'self-update':
+    case 'selfupdate':
+    case 'selfupgrade':
+      selfUpdate(args);
       break;
     case 'help':
     case '-h':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "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/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();
+}