@jxa13/pm2ui 1.17.0

package/server.js

@@ -0,0 +1,889 @@
+const express = require('express');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile, spawn } = require('child_process');
+const { promisify } = require('util');
+const {
+  listProcesses,
+  startProcess,
+  stopProcess,
+  restartProcess
+} = require('./Services/pm2Service');
+const { getSystemStats } = require('./Services/systemService');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+const DEFAULT_PROTECTED_PROCESS_NAMES = ['node-webui'];
+const execFileAsync = promisify(execFile);
+const reactDistPath = path.join(__dirname, 'frontend', 'dist');
+const reactIndexPath = path.join(reactDistPath, 'index.html');
+const pm2CliPath = (() => {
+  try {
+    return require.resolve('pm2/bin/pm2');
+  } catch (error) {
+    return 'pm2';
+  }
+})();
+
+app.use(express.json());
+
+function getProtectedProcessNames() {
+  const rawValue = process.env.PROTECTED_PM2_PROCESSES;
+  const names = rawValue
+    ? rawValue.split(',')
+    : DEFAULT_PROTECTED_PROCESS_NAMES;
+
+  return names
+    .map((name) => String(name || '').trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function findProcessByTarget(processes, target) {
+  const normalizedTarget = String(target || '').trim();
+  const normalizedNameTarget = normalizedTarget.toLowerCase();
+
+  return processes.find((process) => {
+    return String(process.pm_id ?? '') === normalizedTarget
+      || String(process.name || '').toLowerCase() === normalizedNameTarget;
+  });
+}
+
+async function assertProcessCanBeControlled(target, actionName) {
+  const processes = await listProcesses();
+  const process = findProcessByTarget(processes, target);
+
+  if (!process) {
+    return;
+  }
+
+  const protectedNames = getProtectedProcessNames();
+  const processName = String(process.name || '').toLowerCase();
+
+  if (protectedNames.includes(processName)) {
+    const error = new Error(`Protected process cannot be ${actionName}`);
+    error.statusCode = 403;
+    throw error;
+  }
+}
+
+function sendActionError(res, error, fallbackMessage) {
+  res.status(error.statusCode || 500).json({
+    ok: false,
+    error: error.message || fallbackMessage
+  });
+}
+
+function getFileStatus(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+
+    return {
+      exists: true,
+      path: filePath,
+      updatedAt: stats.mtime.toISOString()
+    };
+  } catch (error) {
+    return {
+      exists: false,
+      path: filePath,
+      updatedAt: null
+    };
+  }
+}
+
+function readTextFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8').trim();
+  } catch (error) {
+    return '';
+  }
+}
+
+async function getCommandOutput(command, args) {
+  try {
+    const { stdout } = await execFileAsync(command, args);
+    return String(stdout || '').trim();
+  } catch (error) {
+    return '';
+  }
+}
+
+async function getPm2RuntimeStatus(processes = []) {
+  const homeDirectory = os.homedir();
+  const pm2Home = process.env.PM2_HOME || path.join(homeDirectory, '.pm2');
+  const userName = process.env.USER || process.env.LOGNAME || '';
+  const dumpFile = getFileStatus(path.join(pm2Home, 'dump.pm2'));
+  const daemonPidFile = getFileStatus(path.join(pm2Home, 'pm2.pid'));
+  const launchAgentFile = getFileStatus(path.join(
+    homeDirectory,
+    'Library',
+    'LaunchAgents',
+    userName ? `pm2.${userName}.plist` : 'pm2.plist'
+  ));
+  const version = await getCommandOutput(pm2CliPath, ['-v']);
+  const daemonPid = daemonPidFile.exists ? readTextFile(daemonPidFile.path) : '';
+  const daemonUptime = daemonPid
+    ? await getCommandOutput('ps', ['-p', daemonPid, '-o', 'etime='])
+    : '';
+
+  return {
+    home: pm2Home,
+    version,
+    daemon: {
+      connected: true,
+      pid: daemonPid || '',
+      pidFile: daemonPidFile.path,
+      uptime: daemonUptime || '',
+      uptimeSource: daemonUptime ? 'ps etime for the PM2 daemon process' : ''
+    },
+    managedAppCount: processes.length,
+    saved: dumpFile.exists,
+    savedAt: dumpFile.updatedAt,
+    dumpFile,
+    startup: {
+      platform: process.platform,
+      configured: process.platform === 'darwin' ? launchAgentFile.exists : null,
+      checkedPath: process.platform === 'darwin' ? launchAgentFile.path : '',
+      note: process.platform === 'darwin'
+        ? 'Detected by checking the PM2 LaunchAgent plist path.'
+        : 'Startup detection is only implemented for macOS LaunchAgent installs.'
+    }
+  };
+}
+
+function parseProcessArgsInput(value) {
+  const args = [];
+  let current = '';
+  let quote = '';
+  let isEscaped = false;
+
+  for (const char of String(value || '')) {
+    if (isEscaped) {
+      current += char;
+      isEscaped = false;
+      continue;
+    }
+
+    if (char === '\\') {
+      isEscaped = true;
+      continue;
+    }
+
+    if (quote) {
+      if (char === quote) {
+        quote = '';
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (current) {
+        args.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (isEscaped) {
+    current += '\\';
+  }
+
+  if (quote) {
+    const error = new Error('Arguments contain an unmatched quote');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  if (current) {
+    args.push(current);
+  }
+
+  return args;
+}
+
+function validateOptionalPath(filePath, label) {
+  if (!filePath) {
+    return;
+  }
+
+  const parentDirectory = path.dirname(filePath);
+
+  if (!fs.existsSync(parentDirectory)) {
+    const error = new Error(`${label} parent directory does not exist`);
+    error.statusCode = 400;
+    throw error;
+  }
+}
+
+function normalizeInstances(value) {
+  const normalizedValue = String(value || '').trim().toLowerCase();
+
+  if (!normalizedValue) {
+    return '';
+  }
+
+  if (normalizedValue === 'max') {
+    return 'max';
+  }
+
+  if (!/^[1-9]\d*$/.test(normalizedValue)) {
+    const error = new Error('Instances must be a positive number or max');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  return normalizedValue;
+}
+
+function normalizePm2Args(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item));
+  }
+
+  if (value === undefined || value === null || value === '') {
+    return [];
+  }
+
+  return [String(value)];
+}
+
+function parsePm2LogText(rawText, type, target) {
+  const ansiRegex = /\u001b\[[0-9;]*m/g;
+  const prefixRegex = /^\d+\|[^|]+\|\s*/;
+  const timestampRegex = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s*/;
+
+  return String(rawText || '')
+    .split(/\r?\n/)
+    .map((line) => line.replace(ansiRegex, '').trimEnd())
+    .filter(Boolean)
+    .map((line) => {
+      const timestampMatch = line.match(timestampRegex);
+      const timestamp = timestampMatch ? timestampMatch[1] : '';
+      const afterTimestamp = line.replace(timestampRegex, '').trimStart();
+      const withoutPrefix = afterTimestamp.replace(prefixRegex, '').trim();
+      const message = withoutPrefix;
+
+      return {
+        timestamp: timestamp || new Date().toLocaleString(),
+        type,
+        processId: null,
+        appName: target,
+        message: message || withoutPrefix
+      };
+    });
+}
+
+function mapPm2Process(pm2Process) {
+  const env = pm2Process.pm2_env || {};
+  const processEnv = env.env || {};
+
+  return {
+    pmId: pm2Process.pm_id,
+    pid: pm2Process.pid,
+    name: pm2Process.name,
+    status: env.status || 'unknown',
+    cpu: pm2Process.monit?.cpu || 0,
+    memory: pm2Process.monit?.memory || 0,
+    uptime: env.pm_uptime || null,
+    startedAt: env.pm_uptime || null,
+    restartCount: env.restart_time || 0,
+    path: env.pm_exec_path || '',
+    cwd: env.pm_cwd || '',
+    interpreter: env.exec_interpreter || '',
+    execInterpreter: env.exec_interpreter || '',
+    execMode: env.exec_mode || '',
+    namespace: env.namespace || '',
+    args: normalizePm2Args(env.args),
+    nodeArgs: normalizePm2Args(env.node_args),
+    outLogPath: env.pm_out_log_path || '',
+    errorLogPath: env.pm_err_log_path || '',
+    pidPath: env.pm_pid_path || '',
+    pm2Home: env.pm2_home || process.env.PM2_HOME || path.join(os.homedir(), '.pm2'),
+    watch: Boolean(env.watch),
+    unstableRestarts: env.unstable_restarts || 0,
+    version: env.version || '',
+    nodeEnv: processEnv.NODE_ENV || env.NODE_ENV || '',
+    envName: env.env_name || processEnv.name || '',
+    nodeAppInstance: processEnv.NODE_APP_INSTANCE || env.NODE_APP_INSTANCE || '',
+    instances: env.instances ?? '',
+    autorestart: env.autorestart ?? '',
+    maxMemoryRestart: env.max_memory_restart || '',
+    createdAt: env.created_at || null
+  };
+}
+
+async function getDashboardData() {
+  const [processes, systemStats] = await Promise.all([
+    listProcesses(),
+    getSystemStats()
+  ]);
+
+  const totalPm2Cpu = processes.reduce((sum, process) => {
+    return sum + Number(process.monit?.cpu || 0);
+  }, 0);
+
+  const totalPm2MemoryBytes = processes.reduce((sum, process) => {
+    return sum + Number(process.monit?.memory || 0);
+  }, 0);
+
+  const totalSystemMemoryBytes = Number(systemStats?.memory?.total || 0);
+  const totalPm2MemoryPercent = totalSystemMemoryBytes > 0
+    ? (totalPm2MemoryBytes / totalSystemMemoryBytes) * 100
+    : 0;
+
+  return {
+    ok: true,
+    summary: {
+      total: processes.length,
+      online: processes.filter((process) => process.pm2_env?.status === 'online').length,
+      stopped: processes.filter((process) => process.pm2_env?.status === 'stopped').length,
+      errored: processes.filter((process) => process.pm2_env?.status === 'errored').length
+    },
+    system: {
+      cpu: {
+        currentLoad: systemStats?.cpu?.currentLoad || 0
+      },
+      memory: {
+        usedPercent: systemStats?.memory?.usedPercent || 0,
+        usedBytes: systemStats?.memory?.used || 0
+      }
+    },
+    pm2Usage: {
+      cpu: {
+        currentLoad: totalPm2Cpu
+      },
+      memory: {
+        usedPercent: totalPm2MemoryPercent,
+        usedBytes: totalPm2MemoryBytes
+      }
+    },
+    pm2: await getPm2RuntimeStatus(processes),
+    processes: processes.map(mapPm2Process)
+  };
+}
+
+app.get('/api/health', (req, res) => {
+  res.json({
+    ok: true,
+    app: 'Node WebUI',
+    message: 'Server is running'
+  });
+});
+
+app.get('/api/dashboard', async (req, res) => {
+  try {
+    res.json(await getDashboardData());
+  } catch (error) {
+    console.error('Dashboard API error:', error);
+    res.status(500).json({
+      ok: false,
+      error: error.message || 'Failed to load dashboard data'
+    });
+  }
+});
+
+app.get('/api/dashboard/stream', async (req, res) => {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache, no-transform');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('X-Accel-Buffering', 'no');
+  res.flushHeaders?.();
+  res.write('retry: 5000\n\n');
+
+  let isClosed = false;
+
+  async function sendDashboardEvent() {
+    if (isClosed) {
+      return;
+    }
+
+    try {
+      const data = await getDashboardData();
+      res.write(`data: ${JSON.stringify(data)}\n\n`);
+    } catch (error) {
+      console.error('Dashboard stream error:', error);
+      res.write(`event: dashboard-error\n`);
+      res.write(`data: ${JSON.stringify({ ok: false, error: error.message || 'Failed to stream dashboard data' })}\n\n`);
+    }
+  }
+
+  await sendDashboardEvent();
+  const intervalId = setInterval(sendDashboardEvent, 5000);
+
+  req.on('close', () => {
+    isClosed = true;
+    clearInterval(intervalId);
+  });
+});
+
+app.get('/api/pm2/status', async (req, res) => {
+  try {
+    const processes = await listProcesses();
+
+    res.json({
+      ok: true,
+      pm2: await getPm2RuntimeStatus(processes)
+    });
+  } catch (error) {
+    console.error('PM2 status API error:', error);
+    res.status(500).json({
+      ok: false,
+      error: error.message || 'Failed to load PM2 status'
+    });
+  }
+});
+
+app.post('/api/pm2/save', async (req, res) => {
+  try {
+    execFile(pm2CliPath, ['save'], (error, stdout, stderr) => {
+      if (error) {
+        console.error('Save PM2 state API error:', error);
+        res.status(500).json({
+          ok: false,
+          error: stderr || error.message || 'Failed to save PM2 state'
+        });
+        return;
+      }
+
+      res.json({
+        ok: true,
+        message: 'PM2 state saved',
+        output: stdout || '',
+        errors: stderr || ''
+      });
+    });
+  } catch (error) {
+    console.error('Save PM2 state API error:', error);
+    res.status(500).json({
+      ok: false,
+      error: error.message || 'Failed to save PM2 state'
+    });
+  }
+});
+
+app.post('/api/processes', async (req, res) => {
+  try {
+    const scriptPath = String(req.body?.scriptPath || '').trim();
+    const processName = String(req.body?.name || '').trim();
+    const cwd = String(req.body?.cwd || '').trim();
+    const argsInput = String(req.body?.args || '').trim();
+    const interpreter = String(req.body?.interpreter || '').trim();
+    const nodeEnv = String(req.body?.nodeEnv || '').trim();
+    const nodeArgsInput = String(req.body?.nodeArgs || '').trim();
+    const instances = normalizeInstances(req.body?.instances);
+    const maxMemoryRestart = String(req.body?.maxMemoryRestart || '').trim();
+    const watch = req.body?.watch === true || req.body?.watch === 'true';
+    const outLogPath = String(req.body?.outLogPath || '').trim();
+    const errorLogPath = String(req.body?.errorLogPath || '').trim();
+
+    if (!scriptPath) {
+      res.status(400).json({
+        ok: false,
+        error: 'Script path is required'
+      });
+      return;
+    }
+
+    if (!processName) {
+      res.status(400).json({
+        ok: false,
+        error: 'Process name is required'
+      });
+      return;
+    }
+
+    if (!cwd) {
+      res.status(400).json({
+        ok: false,
+        error: 'Working directory is required'
+      });
+      return;
+    }
+
+    if (!fs.existsSync(scriptPath)) {
+      res.status(400).json({
+        ok: false,
+        error: 'Script path does not exist'
+      });
+      return;
+    }
+
+    if (!fs.existsSync(cwd)) {
+      res.status(400).json({
+        ok: false,
+        error: 'Working directory does not exist'
+      });
+      return;
+    }
+
+    validateOptionalPath(outLogPath, 'Output log path');
+    validateOptionalPath(errorLogPath, 'Error log path');
+
+    const parsedArgs = parseProcessArgsInput(argsInput);
+    const parsedNodeArgs = parseProcessArgsInput(nodeArgsInput);
+    const pm2Args = ['start', scriptPath, '--name', processName, '--cwd', cwd];
+
+    if (interpreter) {
+      pm2Args.push('--interpreter', interpreter);
+    }
+
+    if (parsedNodeArgs.length > 0) {
+      pm2Args.push('--node-args', parsedNodeArgs.join(' '));
+    }
+
+    if (instances) {
+      pm2Args.push('--instances', instances);
+    }
+
+    if (watch) {
+      pm2Args.push('--watch');
+    }
+
+    if (maxMemoryRestart) {
+      pm2Args.push('--max-memory-restart', maxMemoryRestart);
+    }
+
+    if (outLogPath) {
+      pm2Args.push('--output', outLogPath);
+    }
+
+    if (errorLogPath) {
+      pm2Args.push('--error', errorLogPath);
+    }
+
+    if (parsedArgs.length > 0) {
+      pm2Args.push('--', ...parsedArgs);
+    }
+
+    execFile(pm2CliPath, pm2Args, {
+      env: {
+        ...process.env,
+        ...(nodeEnv ? { NODE_ENV: nodeEnv } : {})
+      }
+    }, (error, stdout, stderr) => {
+      if (error) {
+        console.error('Create process API error:', error);
+        res.status(500).json({
+          ok: false,
+          error: stderr || error.message || 'Failed to create process'
+        });
+        return;
+      }
+
+      res.json({
+        ok: true,
+        message: `Created process: ${processName}`,
+        output: stdout || '',
+        errors: stderr || ''
+      });
+    });
+  } catch (error) {
+    console.error('Create process API error:', error);
+    sendActionError(res, error, 'Failed to create process');
+  }
+});
+
+app.delete('/api/processes/:target', async (req, res) => {
+  try {
+    const target = String(req.params.target || '').trim();
+
+    if (!target) {
+      res.status(400).json({
+        ok: false,
+        error: 'PM2 target is required'
+      });
+      return;
+    }
+
+    await assertProcessCanBeControlled(target, 'deleted');
+
+    execFile(pm2CliPath, ['delete', target], (error, stdout, stderr) => {
+      if (error) {
+        console.error('Delete process API error:', error);
+        res.status(500).json({
+          ok: false,
+          error: stderr || error.message || 'Failed to delete process'
+        });
+        return;
+      }
+
+      res.json({
+        ok: true,
+        message: `Deleted process PM2 ID: ${target}`,
+        output: stdout || '',
+        errors: stderr || ''
+      });
+    });
+  } catch (error) {
+    console.error('Delete process API error:', error);
+    sendActionError(res, error, 'Failed to delete process');
+  }
+});
+
+app.post('/api/processes/:target/start', async (req, res) => {
+  try {
+    const target = String(req.params.target || '');
+    await startProcess(target);
+    res.json({
+      ok: true,
+      message: `Started process PM2 ID: ${target}`
+    });
+  } catch (error) {
+    console.error('Start process API error:', error);
+    res.status(500).json({
+      ok: false,
+      error: error.message || 'Failed to start process'
+    });
+  }
+});
+
+app.post('/api/processes/:target/stop', async (req, res) => {
+  try {
+    const target = String(req.params.target || '');
+    await assertProcessCanBeControlled(target, 'stopped');
+    await stopProcess(target);
+    res.json({
+      ok: true,
+      message: `Stopped process PM2 ID: ${target}`
+    });
+  } catch (error) {
+    console.error('Stop process API error:', error);
+    sendActionError(res, error, 'Failed to stop process');
+  }
+});
+
+app.post('/api/processes/:target/restart', async (req, res) => {
+  try {
+    const target = String(req.params.target || '');
+    await assertProcessCanBeControlled(target, 'restarted');
+    await restartProcess(target);
+    res.json({
+      ok: true,
+      message: `Restarted process PM2 ID: ${target}`
+    });
+  } catch (error) {
+    console.error('Restart process API error:', error);
+    sendActionError(res, error, 'Failed to restart process');
+  }
+});
+
+app.get('/api/processes/:target/logs', async (req, res) => {
+  try {
+    const target = String(req.params.target || '');
+    const requestedLines = Number(req.query.lines || 100);
+    const lines = Number.isFinite(requestedLines)
+      ? Math.min(Math.max(Math.trunc(requestedLines), 1), 500)
+      : 100;
+
+    execFile(pm2CliPath, ['logs', target, '--nostream', '--lines', String(lines), '--timestamp', 'YYYY-MM-DD HH:mm:ss'], {
+      maxBuffer: 1024 * 1024 * 10
+    }, (error, stdout, stderr) => {
+      if (error && !stdout && !stderr) {
+        console.error('Logs API error:', error);
+        res.status(500).json({
+          ok: false,
+          error: error.message || 'Failed to load logs'
+        });
+        return;
+      }
+
+      const entries = [
+        ...parsePm2LogText(stdout, 'stdout', target),
+        ...parsePm2LogText(stderr, 'stderr', target)
+      ];
+
+      res.json({
+        ok: true,
+        target,
+        entries
+      });
+    });
+  } catch (error) {
+    console.error('Logs API error:', error);
+    res.status(500).json({
+      ok: false,
+      error: error.message || 'Failed to load logs'
+    });
+  }
+});
+
+app.get('/api/processes/:target/logs/stream', async (req, res) => {
+  const target = String(req.params.target || '');
+
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache, no-transform');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('X-Accel-Buffering', 'no');
+  res.flushHeaders?.();
+  res.write('retry: 5000\n\n');
+
+  let isClosed = false;
+  const logProcess = spawn(pm2CliPath, ['logs', target, '--lines', '0', '--timestamp', 'YYYY-MM-DD HH:mm:ss'], {
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  const buffers = {
+    stdout: '',
+    stderr: ''
+  };
+
+  function writeEntries(rawText, type) {
+    if (isClosed) {
+      return;
+    }
+
+    const entries = parsePm2LogText(rawText, type, target);
+
+    entries.forEach((entry) => {
+      res.write(`data: ${JSON.stringify(entry)}\n\n`);
+    });
+  }
+
+  function handleChunk(type, chunk) {
+    buffers[type] += chunk.toString('utf8');
+    const lines = buffers[type].split(/\r?\n/);
+    buffers[type] = lines.pop() || '';
+    writeEntries(lines.join('\n'), type);
+  }
+
+  const heartbeatIntervalId = setInterval(() => {
+    if (isClosed) {
+      return;
+    }
+
+    res.write(`event: heartbeat\n`);
+    res.write(`data: ${JSON.stringify({ ok: true })}\n\n`);
+  }, 15000);
+
+  logProcess.stdout.on('data', (chunk) => {
+    handleChunk('stdout', chunk);
+  });
+
+  logProcess.stderr.on('data', (chunk) => {
+    handleChunk('stderr', chunk);
+  });
+
+  logProcess.on('error', (error) => {
+    console.error('Logs stream API error:', error);
+    if (isClosed) {
+      return;
+    }
+    res.write(`event: logs-error\n`);
+    res.write(`data: ${JSON.stringify({ ok: false, error: error.message || 'Failed to stream logs' })}\n\n`);
+  });
+
+  logProcess.on('close', () => {
+    writeEntries(buffers.stdout, 'stdout');
+    writeEntries(buffers.stderr, 'stderr');
+    clearInterval(heartbeatIntervalId);
+    if (!isClosed) {
+      res.end();
+    }
+  });
+
+  req.on('close', () => {
+    isClosed = true;
+    clearInterval(heartbeatIntervalId);
+    logProcess.kill();
+  });
+});
+
+app.post('/api/processes/:target/logs/clear', async (req, res) => {
+  try {
+    const target = String(req.params.target || '');
+
+    execFile(pm2CliPath, ['flush', target], (error, stdout, stderr) => {
+      if (error) {
+        console.error('Clear logs API error:', error);
+        res.status(500).json({
+          ok: false,
+          error: stderr || error.message || 'Failed to clear logs'
+        });
+        return;
+      }
+
+      res.json({
+        ok: true,
+        target,
+        message: `Cleared logs for ${target}`,
+        output: stdout || '',
+        errors: stderr || ''
+      });
+    });
+  } catch (error) {
+    console.error('Clear logs API error:', error);
+    res.status(500).json({
+      ok: false,
+      error: error.message || 'Failed to clear logs'
+    });
+  }
+});
+
+app.post('/api/open-folder', async (req, res) => {
+  try {
+    const targetPath = req.body?.path;
+
+    if (!targetPath) {
+      res.status(400).json({
+        ok: false,
+        error: 'Path is required'
+      });
+      return;
+    }
+
+    execFile('open', ['-R', targetPath], (error) => {
+      if (error) {
+        console.error('Open folder API error:', error);
+        res.status(500).json({
+          ok: false,
+          error: error.message || 'Failed to open path'
+        });
+        return;
+      }
+
+      res.json({
+        ok: true,
+        message: `Opened path: ${targetPath}`
+      });
+    });
+  } catch (error) {
+    console.error('Open folder API error:', error);
+    res.status(500).json({
+      ok: false,
+      error: error.message || 'Failed to open path'
+    });
+  }
+});
+
+if (fs.existsSync(reactIndexPath)) {
+  app.use('/react', express.static(reactDistPath));
+  app.use(express.static(reactDistPath));
+}
+
+app.use((req, res, next) => {
+  if (req.method !== 'GET' || req.path.startsWith('/api/')) {
+    next();
+    return;
+  }
+
+  if (!fs.existsSync(reactIndexPath)) {
+    res.status(503).send('Node WebUI React build is missing. Run `npm run react:build` and restart the server.');
+    return;
+  }
+
+  res.sendFile(reactIndexPath);
+});
+
+app.listen(PORT, '127.0.0.1', () => {
+  console.log(`Node WebUI running at http://127.0.0.1:${PORT}`);
+});