buddy-workbench 0.1.0

package/server/services/process-manager.js

@@ -0,0 +1,195 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { execFile } from 'node:child_process';
+import { listPortHistory, savePortHistory } from '../repositories/port-history.js';
+
+const running = new Map();
+const logs = new Map();
+const stoppingGroups = new Set();
+const processGroups = new Set();
+const launchHistory = [];
+const savedPortHistory = new Map(listPortHistory().map((record) => [record.port, record]));
+const supervisorPath = fileURLToPath(new URL('./script-supervisor.js', import.meta.url));
+const execFileAsync = promisify(execFile);
+const keyFor = (launcherId, scriptId) => `${launcherId}:${scriptId}`;
+const appendLog = (key, type, chunk) => {
+  const current = logs.get(key) || { output: '', error: '' };
+  current[type] = `${current[type]}${chunk}`.split(/\r?\n/).slice(-1000).join('\n');
+  logs.set(key, current);
+};
+
+export function runningScripts() { return [...running.keys()]; }
+export function scriptLogs(launcherId, scriptId) { return logs.get(keyFor(launcherId, scriptId))?.output || ''; }
+export function scriptErrorLogs(launcherId, scriptId) { return logs.get(keyFor(launcherId, scriptId))?.error || ''; }
+
+async function listeningProcesses() {
+  if (process.platform === 'win32') return [];
+  try {
+    const { stdout } = await execFileAsync('lsof', ['-nP', '-iTCP', '-sTCP:LISTEN', '-F', 'pcn'], { maxBuffer: 1024 * 1024 });
+    const rows = [];
+    let current = {};
+    for (const line of stdout.split('\n')) {
+      if (!line) continue;
+      const type = line[0]; const value = line.slice(1);
+      if (type === 'p') current = { pid: Number(value) };
+      else if (type === 'c') current.command = value;
+      else if (type === 'n') {
+        const match = value.match(/:(\d+)(?:\s|$)/);
+        if (match && current.pid) rows.push({ ...current, port: Number(match[1]) });
+      }
+    }
+    return rows.filter((item) => item.pid && item.port);
+  } catch (error) {
+    if (error.code === 1) return [];
+    throw new Error('Unable to inspect listening ports. Ensure lsof is available.');
+  }
+}
+
+async function processGroupFor(pid) {
+  try {
+    const { stdout } = await execFileAsync('ps', ['-o', 'pgid=', '-p', String(pid)]);
+    return Number(stdout.trim());
+  } catch { return null; }
+}
+
+async function observedListeners() {
+  const listeners = await listeningProcesses();
+  const groups = await Promise.all(listeners.map(async (listener) => [listener.pid, await processGroupFor(listener.pid)]));
+  return { listeners, groupByPid: new Map(groups) };
+}
+
+async function observeLauncherPorts() {
+  if (!launchHistory.length) return;
+  const { listeners, groupByPid } = await observedListeners();
+  const now = new Date().toISOString();
+  let changed = false;
+  for (const listener of listeners) {
+    const launch = launchHistory.find((item) => item.groupPid === groupByPid.get(listener.pid));
+    if (!launch) continue;
+    const previous = launch.ports.get(listener.port);
+    const record = { port: listener.port, pid: listener.pid, command: listener.command || 'unknown', firstSeenAt: previous?.firstSeenAt || now, lastSeenAt: now };
+    launch.ports.set(listener.port, record);
+    savedPortHistory.set(listener.port, { ...record, launcher: launch.launcher, script: launch.script, startedAt: launch.startedAt });
+    changed ||= !previous || previous.pid !== record.pid || previous.command !== record.command;
+  }
+  if (changed) savePortHistory([...savedPortHistory.values()].sort((a, b) => a.port - b.port));
+}
+
+setInterval(() => { void observeLauncherPorts().catch(() => {}); }, 1000).unref();
+
+export async function portDiagnostics() {
+  await observeLauncherPorts();
+  const { listeners, groupByPid } = await observedListeners();
+  const owned = new Map(listeners.map((item) => [`${groupByPid.get(item.pid)}:${item.port}`, item]));
+  const byPort = new Map(listeners.map((item) => [item.port, item]));
+  const records = launchHistory.flatMap((launch) => [...launch.ports.values()].map((record) => {
+    const listener = owned.get(`${launch.groupPid}:${record.port}`);
+    const occupyingProcess = byPort.get(record.port);
+    const scriptRunning = running.get(launch.key)?.pid === launch.groupPid;
+    return {
+      ...record,
+      launcher: launch.launcher,
+      script: launch.script,
+      startedAt: launch.startedAt,
+      scriptRunning,
+      listening: Boolean(listener),
+      ghost: Boolean(listener) && !scriptRunning,
+      reused: !listener && Boolean(occupyingProcess),
+      currentPid: listener?.pid,
+      currentCommand: listener?.command
+    };
+  }));
+  const latestByPort = new Map();
+  for (const record of records) {
+    const existing = latestByPort.get(record.port);
+    if (!existing || (record.listening && !existing.listening) || record.startedAt > existing.startedAt) latestByPort.set(record.port, record);
+  }
+  for (const [port, record] of savedPortHistory) {
+    if (latestByPort.has(port)) continue;
+    const occupyingProcess = byPort.get(port);
+    latestByPort.set(port, { ...record, listening: false, ghost: false, reused: Boolean(occupyingProcess), currentPid: occupyingProcess?.pid, currentCommand: occupyingProcess?.command });
+  }
+  return [...latestByPort.values()].sort((a, b) => a.port - b.port);
+}
+
+export async function portProcess(port) {
+  const listener = (await listeningProcesses()).find((item) => item.port === Number(port));
+  return listener ? { port: listener.port, pid: listener.pid, command: listener.command || 'unknown' } : null;
+}
+
+export async function killPortProcess(port, pid) {
+  const target = await portProcess(port);
+  if (target && target.pid !== Number(pid)) throw new Error('This port is now used by a different process. Refresh and try again.');
+  if (!target) throw new Error('This port is no longer active. Refresh and try again.');
+  try { process.kill(target.pid, 'SIGKILL'); }
+  catch (error) { throw new Error(error.code === 'ESRCH' ? 'The process has already exited.' : 'Unable to stop this port process.'); }
+}
+
+function terminateGroup(pid, signal) {
+  if (process.platform === 'win32') {
+    spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+    return;
+  }
+  try { process.kill(-pid, signal); }
+  catch { try { process.kill(pid, signal); } catch {} }
+}
+
+function groupExists(pid) {
+  if (process.platform === 'win32') return false;
+  try { process.kill(-pid, 0); return true; } catch { return false; }
+}
+
+function retireGroup(pid) {
+  setTimeout(() => { if (groupExists(pid)) retireGroup(pid); else processGroups.delete(pid); }, 2000).unref();
+}
+
+export function runScript(launcher, script) {
+  const key = keyFor(launcher.id, script.id);
+  if (running.has(key)) throw new Error('This script is already running.');
+  if (!existsSync(launcher.folder)) throw new Error('The configured project folder does not exist.');
+  logs.set(key, { output: `$ ${script.command}\n`, error: '' });
+  const child = spawn(process.execPath, [supervisorPath], { cwd: launcher.folder, detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, ...(launcher.executor === 'pnpm' || /^\s*pnpm\b/.test(script.command) ? { CI: 'true' } : {}), BUDDY_PARENT_PID: String(process.pid), BUDDY_SCRIPT_COMMAND: script.command } });
+  child.stdout.on('data', (chunk) => appendLog(key, 'output', chunk.toString()));
+  child.stderr.on('data', (chunk) => appendLog(key, 'error', chunk.toString()));
+  running.set(key, child);
+  processGroups.add(child.pid);
+  launchHistory.push({ key, groupPid: child.pid, launcher: launcher.alias, script: script.name, startedAt: new Date().toISOString(), ports: new Map() });
+  if (launchHistory.length > 200) launchHistory.splice(0, launchHistory.length - 200);
+  setTimeout(() => { void observeLauncherPorts().catch(() => {}); }, 1000).unref();
+  child.on('exit', (code) => { appendLog(key, code === 0 ? 'output' : 'error', `\nProcess exited with code ${code}.\n`); running.delete(key); retireGroup(child.pid); });
+}
+
+export function stopScript(launcherId, scriptId) {
+  const key = keyFor(launcherId, scriptId);
+  const child = running.get(key);
+  if (!child) throw new Error('This script is not running.');
+  appendLog(key, 'output', '\nStop requested.\n');
+  stoppingGroups.add(child.pid);
+  terminateGroup(child.pid, 'SIGTERM');
+  setTimeout(() => { terminateGroup(child.pid, 'SIGKILL'); stoppingGroups.delete(child.pid); processGroups.delete(child.pid); }, 1500).unref();
+  running.delete(key);
+}
+
+export function stopAllScripts(force = false) {
+  if (force) {
+    for (const pid of stoppingGroups) terminateGroup(pid, 'SIGKILL');
+    stoppingGroups.clear();
+    for (const pid of processGroups) terminateGroup(pid, 'SIGKILL');
+    processGroups.clear();
+    running.clear();
+    return;
+  }
+  for (const pid of processGroups) { stoppingGroups.add(pid); terminateGroup(pid, 'SIGTERM'); }
+  for (const [key] of running) appendLog(key, 'output', '\nWorkbench is shutting down. Stop requested.\n');
+}
+
+export async function waitForAllScripts(timeout = 3000) {
+  const deadline = Date.now() + timeout;
+  while (processGroups.size && Date.now() < deadline) {
+    for (const pid of processGroups) if (!groupExists(pid)) processGroups.delete(pid);
+    if (processGroups.size) await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return processGroups.size === 0;
+}

package/server/services/script-supervisor.js

@@ -0,0 +1,28 @@
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const parentPid = Number(process.env.BUDDY_PARENT_PID);
+const command = process.env.BUDDY_SCRIPT_COMMAND;
+const child = spawn(command, { cwd: process.cwd(), shell: true, stdio: 'inherit' });
+
+function stopGroup() {
+  if (process.platform === 'win32') { child.kill('SIGTERM'); return; }
+  try { process.kill(-process.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
+}
+
+const parentWatch = setInterval(() => {
+  try { process.kill(parentPid, 0); } catch { stopGroup(); }
+}, 500);
+
+child.on('exit', async (code) => {
+  if (process.platform === 'win32') process.exit(code || 0);
+  const groupWatch = setInterval(async () => {
+    try {
+      const { stdout } = await execFileAsync('pgrep', ['-g', String(process.pid)]);
+      const descendants = stdout.trim().split(/\s+/).filter((pid) => pid && Number(pid) !== process.pid);
+      if (descendants.length) return;
+    } catch {}
+    clearInterval(groupWatch); clearInterval(parentWatch); process.exit(code || 0);
+  }, 500);
+});

package/server.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import express from 'express';
+
+import { appendFileSync } from 'node:fs';
+import { paths } from './server/config.js';
+import { freePort } from './server/lib/free-port.js';
+import launcherRoutes from './server/routes/launchers.js';
+import pluginRoutes from './server/routes/plugins.js';
+import { stopAllScripts, waitForAllScripts } from './server/services/process-manager.js';
+import clipboardRoutes from './server/routes/clipboard.js';
+import groupTaskRoutes from './server/routes/group-tasks.js';
+import portDiagnosticsRoutes from './server/routes/port-diagnostics.js';
+import settingsRoutes from './server/routes/settings.js';
+import prReviewRoutes from './server/routes/pr-review.js';
+import { startClipboardCapture } from './server/services/clipboard-history.js';
+
+const port = Number(process.env.PORT || 3100);
+const app = express();
+app.use(express.json());
+app.use(express.static(paths.ui));
+app.use('/plugins', express.static(paths.plugins));
+app.use('/api/launchers', launcherRoutes);
+app.use('/api/plugins', pluginRoutes);
+app.use('/api/clipboard', clipboardRoutes);
+app.use('/api/group-tasks', groupTaskRoutes);
+app.use('/api/port-diagnostics', portDiagnosticsRoutes);
+app.use('/api/settings', settingsRoutes);
+app.use('/api/pr-review', prReviewRoutes);
+
+await freePort(port);
+const server = app.listen(port, () => { console.log(`Buddy Workbench: http://localhost:${port} (pid ${process.pid})`); shutdownTrace(`server started (pid=${process.pid})`); });
+startClipboardCapture();
+
+let shuttingDown = false;
+const shutdownTrace = (message) => { try { appendFileSync(paths.shutdownLog, `${new Date().toISOString()} ${message}\n`); } catch {} };
+async function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  shutdownTrace(`shutdown requested (pid=${process.pid}, exitCode=${exitCode})`);
+  console.log('Buddy Workbench: stopping launched scripts…');
+  stopAllScripts();
+  server.close();
+  const stopped = await waitForAllScripts(3000);
+  shutdownTrace(stopped ? 'all tracked process groups stopped' : 'forcing remaining process groups');
+  if (!stopped) console.log('Buddy Workbench: force stopping remaining scripts…');
+  stopAllScripts(true);
+  process.exit(exitCode);
+}
+
+process.once('SIGINT', () => { shutdownTrace('received SIGINT'); void shutdown(); });
+process.once('SIGTERM', () => { shutdownTrace('received SIGTERM'); void shutdown(); });
+process.once('SIGHUP', () => { shutdownTrace('received SIGHUP'); void shutdown(); });
+process.once('uncaughtException', (error) => { console.error(error); void shutdown(1); });
+process.once('unhandledRejection', (error) => { console.error(error); void shutdown(1); });
+process.once('exit', () => stopAllScripts(true));