improvements

Author: orangecoding

lib/service/deployRunner.js

@@ -352,11 +352,18 @@ export async function runDeploy(deployment, { isRedeploy }) {
     // git repository (e.g. the initial clone failed), we must fall back to a
     // fresh clone rather than attempting a pull into a non-existent or broken
     // directory.
-    const hasGitDir = await fsp.stat(path.join(deploy_path, '.git')).then(() => true).catch(() => false);
+    const hasGitDir = await fsp
+      .stat(path.join(deploy_path, '.git'))
+      .then(() => true)
+      .catch(() => false);
     if (isRedeploy && hasGitDir) {
       // Check for tracked local changes that would cause git pull --rebase to fail.
       // Untracked files (lines starting with ??) do not affect the pull and are skipped.
-      const statusOutput = await captureStep('git', ['-C', deploy_path, 'status', '--porcelain'], config.DEPLOY_BASE_DIR);
+      const statusOutput = await captureStep(
+        'git',
+        ['-C', deploy_path, 'status', '--porcelain'],
+        config.DEPLOY_BASE_DIR,
+      );
       const trackedChanges = statusOutput
         .split('\n')
         .filter((l) => l.length >= 2 && !l.startsWith('??'))
@@ -372,7 +379,13 @@ export async function runDeploy(deployment, { isRedeploy }) {
       }
 
       broadcast('clone', `Pulling ${branch} from origin...\n`, 'running');
-      await spawnStep('git', ['-C', deploy_path, 'pull', '--rebase', 'origin', branch], config.DEPLOY_BASE_DIR, id, 'clone');
+      await spawnStep(
+        'git',
+        ['-C', deploy_path, 'pull', '--rebase', 'origin', branch],
+        config.DEPLOY_BASE_DIR,
+        id,
+        'clone',
+      );
     } else {
       // Remove a leftover partial directory from a previously failed clone so
       // git does not refuse to clone into a non-empty destination.
@@ -391,14 +404,16 @@ export async function runDeploy(deployment, { isRedeploy }) {
     // 3. Install
     if (install_cmd && install_cmd !== 'skip') {
       broadcast('install', `Running ${install_cmd}...\n`, 'running');
-      const [cmd, ...args] = install_cmd.split(' ');
+      // Split on runs of whitespace so extra/leading spaces never produce empty
+      // argv entries (which a process like npm would reject).
+      const [cmd, ...args] = install_cmd.trim().split(/\s+/);
       await spawnStep(cmd, args, deploy_path, id, 'install');
     }
 
     // 4. Build
     if (build_cmd) {
       broadcast('build', `Running ${build_cmd}...\n`, 'running');
-      const [cmd, ...args] = build_cmd.split(' ');
+      const [cmd, ...args] = build_cmd.trim().split(/\s+/);
       await spawnStep(cmd, args, deploy_path, id, 'build');
     }
 
@@ -409,7 +424,11 @@ export async function runDeploy(deployment, { isRedeploy }) {
     }
 
     // 6. Start or restart
-    broadcast('start', isRedeploy ? `Restarting PM2 process ${pm2_name}...\n` : `Starting PM2 process ${pm2_name}...\n`, 'running');
+    broadcast(
+      'start',
+      isRedeploy ? `Restarting PM2 process ${pm2_name}...\n` : `Starting PM2 process ${pm2_name}...\n`,
+      'running',
+    );
 
     if (isRedeploy) {
       // Delete first so PM2 picks up updated options (env vars, interpreter
@@ -427,7 +446,10 @@ export async function runDeploy(deployment, { isRedeploy }) {
     // Verify the start script exists before handing off to PM2, so a missing
     // file produces a clear message rather than a silent PM2 failure.
     const scriptPath = path.join(pm2Opts.cwd, pm2Opts.script);
-    const scriptExists = await fsp.stat(scriptPath).then(() => true).catch(() => false);
+    const scriptExists = await fsp
+      .stat(scriptPath)
+      .then(() => true)
+      .catch(() => false);
     if (!scriptExists) {
       throw new Error(`Start script not found: ${scriptPath}`);
     }

lib/service/logBus.js

@@ -25,7 +25,25 @@ import { evaluateAndDispatch } from './alertingService.js';
 import logger from './logger.js';
 
 const pm2Connect = promisify(pm2.connect.bind(pm2));
-const pm2LaunchBus = promisify(pm2.launchBus.bind(pm2));
+
+/**
+ * Launch the PM2 event bus, resolving with both the event emitter and the
+ * underlying axon socket.
+ *
+ * `promisify` cannot be used here: it discards the second callback argument
+ * (the socket), which carries the connection lifecycle events the reconnect
+ * logging below relies on.
+ *
+ * @returns {Promise<{ bus: import('node:events').EventEmitter, busSocket: import('node:events').EventEmitter }>}
+ */
+function launchBus() {
+  return new Promise((resolve, reject) => {
+    pm2.launchBus((err, bus, busSocket) => {
+      if (err) reject(err);
+      else resolve({ bus, busSocket });
+    });
+  });
+}
 
 /** Internal event emitter -- one 'log' event per line for all processes. */
 const emitter = new EventEmitter();
@@ -47,7 +65,7 @@ export async function startLogBus() {
   try {
     // pm2.connect is idempotent -- reuses existing connection from pm2Service.
     await pm2Connect();
-    const bus = await pm2LaunchBus();
+    const { bus, busSocket } = await launchBus();
 
     /**
      * Handle a raw PM2 bus packet.
@@ -97,6 +115,20 @@ export async function startLogBus() {
       logger.warn(`[LOG_BUS] Bus error: ${err?.message ?? err}`);
     });
 
+    // The bus runs over an auto-reconnecting axon socket (retry with backoff,
+    // indefinitely). The emitter is reused across reconnects, so the listeners
+    // above keep working without re-subscribing -- re-launching the bus would
+    // open a second socket and duplicate every log line. We only surface the
+    // socket lifecycle so a daemon restart and its recovery are visible in logs.
+    if (busSocket && typeof busSocket.on === 'function') {
+      busSocket.on('reconnect attempt', () => {
+        logger.warn('[LOG_BUS] PM2 connection lost - reconnecting...');
+      });
+      busSocket.on('connect', () => {
+        logger.info('[LOG_BUS] Reconnected to the PM2 bus.');
+      });
+    }
+
     logger.info('[LOG_BUS] Started');
   } catch (err) {
     logger.warn(`[LOG_BUS] Failed to start: ${err.message}`);

lib/service/logger.js

@@ -5,11 +5,11 @@
 
 /** @type {Record<string, string>} ANSI escape codes for coloring log levels in terminal output */
 const COLORS = {
-    debug: '\x1b[36m', // cyan
-    info: '\x1b[32m',  // green
-    warn: '\x1b[33m',  // yellow
-    error: '\x1b[31m', // red
-    reset: '\x1b[0m',
+  debug: '\x1b[36m', // cyan
+  info: '\x1b[32m', // green
+  warn: '\x1b[33m', // yellow
+  error: '\x1b[31m', // red
+  reset: '\x1b[0m',
 };
 
 const env = process.env.NODE_ENV || 'development';
@@ -20,15 +20,15 @@ const useColor = process.stdout.isTTY || process.stderr.isTTY;
  * Returns a formatted timestamp string.
  * @returns {string} Timestamp in `YYYY-MM-DD HH:MM:SS` format
  */
-function ts() { 
-    const d = new Date();
-    const yyyy = d.getFullYear();
-    const mm = String(d.getMonth() + 1).padStart(2, '0');
-    const dd = String(d.getDate()).padStart(2, '0');
-    const hh = String(d.getHours()).padStart(2, '0');
-    const mi = String(d.getMinutes()).padStart(2, '0');
-    const ss = String(d.getSeconds()).padStart(2, '0');
-    return `${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss}`;
+function ts() {
+  const d = new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  const hh = String(d.getHours()).padStart(2, '0');
+  const mi = String(d.getMinutes()).padStart(2, '0');
+  const ss = String(d.getSeconds()).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss}`;
 }
 
 /**
@@ -37,9 +37,9 @@ function ts() {
  * @returns {string} Uppercased level label, optionally colorized
  */
 function lvl(level) {
-    const upper = level.toUpperCase();
-    if (!useColor) return upper;
-    return `${COLORS[level] || ''}${upper}${COLORS.reset}`;
+  const upper = level.toUpperCase();
+  if (!useColor) return upper;
+  return `${COLORS[level] || ''}${upper}${COLORS.reset}`;
 }
 
 /* eslint-disable no-console */
@@ -50,27 +50,27 @@ function lvl(level) {
  * @param {...*} args - Values to log
  */
 function log(level, ...args) {
-    if (level === 'debug' && env !== 'development') {
-        return;
-    }
+  if (level === 'debug' && env !== 'development') {
+    return;
+  }
 
-    const prefix = `[${ts()}] ${lvl(level)}:`;
-    switch (level) {
-        case 'debug':
-            console.debug(prefix, ...args);
-            break;
-        case 'info':
-            console.info(prefix, ...args);
-            break;
-        case 'warn':
-            console.warn(prefix, ...args);
-            break;
-        case 'error':
-            console.error(prefix, ...args);
-            break;
-        default:
-            console.log(prefix, ...args);
-    }
+  const prefix = `[${ts()}] ${lvl(level)}:`;
+  switch (level) {
+    case 'debug':
+      console.debug(prefix, ...args);
+      break;
+    case 'info':
+      console.info(prefix, ...args);
+      break;
+    case 'warn':
+      console.warn(prefix, ...args);
+      break;
+    case 'error':
+      console.error(prefix, ...args);
+      break;
+    default:
+      console.log(prefix, ...args);
+  }
 }
 
 /**
@@ -79,12 +79,12 @@ function log(level, ...args) {
  * @namespace logger
  */
 export default {
-    /** @param {...*} a - Values to log at debug level */
-    debug: (...a) => log('debug', ...a),
-    /** @param {...*} a - Values to log at info level */
-    info: (...a) => log('info', ...a),
-    /** @param {...*} a - Values to log at warn level */
-    warn: (...a) => log('warn', ...a),
-    /** @param {...*} a - Values to log at error level */
-    error: (...a) => log('error', ...a),
+  /** @param {...*} a - Values to log at debug level */
+  debug: (...a) => log('debug', ...a),
+  /** @param {...*} a - Values to log at info level */
+  info: (...a) => log('info', ...a),
+  /** @param {...*} a - Values to log at warn level */
+  warn: (...a) => log('warn', ...a),
+  /** @param {...*} a - Values to log at error level */
+  error: (...a) => log('error', ...a),
 };

lib/service/updateChecker.js

@@ -40,7 +40,9 @@ const { version: CURRENT_VERSION } = require(path.join(__dirname, '..', '..', 'p
  * @returns {number[]|null} Tuple of three numbers, or null if unparseable.
  */
 function parseSemver(v) {
-  const m = String(v).replace(/^v/, '').match(/^(\d+)\.(\d+)\.(\d+)/);
+  const m = String(v)
+    .replace(/^v/, '')
+    .match(/^(\d+)\.(\d+)\.(\d+)/);
   return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
 }
 

lib/storage/deploymentStorage.js

@@ -102,10 +102,7 @@ export function getDeploymentById(id) {
  * @returns {object[]}
  */
 export function getAllDeployments() {
-  return getDb()
-    .prepare('SELECT * FROM deployments ORDER BY created_at DESC')
-    .all()
-    .map(parseRow);
+  return getDb().prepare('SELECT * FROM deployments ORDER BY created_at DESC').all().map(parseRow);
 }
 
 /**
@@ -126,9 +123,7 @@ export function setDeploying(id, deploying) {
  * @param {string} id
  */
 export function updateLastDeployed(id) {
-  getDb()
-    .prepare('UPDATE deployments SET last_deployed_at = ? WHERE id = ?')
-    .run(Date.now(), id);
+  getDb().prepare('UPDATE deployments SET last_deployed_at = ? WHERE id = ?').run(Date.now(), id);
 }
 
 /**

lib/transport/router.js

@@ -837,12 +837,10 @@ router.post('/api/deployments', requireAuth, async (req, res) => {
       .json({ error: 'Invalid app name. Use alphanumeric characters, dashes, and underscores (max 64 chars).' });
   }
   if (!validateRepoUrl(repoUrl)) {
-    return res
-      .status(400)
-      .json({
-        error:
-          'Invalid repo URL. Accepted: HTTPS GitHub/GitLab URLs or SSH git URLs (e.g. git@github.com:user/repo.git).',
-      });
+    return res.status(400).json({
+      error:
+        'Invalid repo URL. Accepted: HTTPS GitHub/GitLab URLs or SSH git URLs (e.g. git@github.com:user/repo.git).',
+    });
   }
 
   let deployPath;
@@ -920,12 +918,10 @@ router.put('/api/deployments/:deploymentId', requireAuth, validateDeploymentId,
   } = req.body;
 
   if (!validateRepoUrl(repoUrl)) {
-    return res
-      .status(400)
-      .json({
-        error:
-          'Invalid repo URL. Accepted: HTTPS GitHub/GitLab URLs or SSH git URLs (e.g. git@github.com:user/repo.git).',
-      });
+    return res.status(400).json({
+      error:
+        'Invalid repo URL. Accepted: HTTPS GitHub/GitLab URLs or SSH git URLs (e.g. git@github.com:user/repo.git).',
+    });
   }
 
   try {

lib/transport/ws.js

@@ -31,13 +31,6 @@ let _wss = null;
 
 // Helpers ──────────────────────────────────────────────────────────────────
 
-/** Authenticate a WebSocket upgrade request via session cookie. */
-function authenticate(req) {
-  const cookieHeader = req.headers['cookie'] || '';
-  const cookies = parseCookies(cookieHeader);
-  return getAuthenticatedSession({ cookies });
-}
-
 /** Send a JSON message on a WebSocket if it is still open. */
 function send(ws, type, data) {
   if (ws.readyState === WebSocket.OPEN) {
@@ -128,8 +121,10 @@ async function sendProcessList(ws) {
  * Handle the single unified WebSocket stream.
  *
  * @param {import('ws').WebSocket} ws
+ * @param {Record<string, string>} cookies - Parsed request cookies, used to
+ *   re-validate the backing session for the lifetime of the connection.
  */
-function handleUnifiedStream(ws) {
+function handleUnifiedStream(ws, cookies) {
   // Per-connection selection state.
   let selectionGeneration = 0;
   let detailInterval = null;
@@ -149,8 +144,17 @@ function handleUnifiedStream(ws) {
   sendProcessList(ws);
   const processListInterval = setInterval(() => sendProcessList(ws), 3000);
 
-  // Heartbeat — keeps the connection alive through proxies / NAT.
-  const heartbeatInterval = setInterval(() => send(ws, 'heartbeat', {}), 15000);
+  // Heartbeat — keeps the connection alive through proxies / NAT, and re-checks
+  // that the backing session is still valid. A WebSocket is authenticated only
+  // once at upgrade; without this the connection would keep streaming after the
+  // session expired or was destroyed (e.g. by logout).
+  const heartbeatInterval = setInterval(() => {
+    if (!getAuthenticatedSession({ cookies })) {
+      ws.close(4001, 'session expired');
+      return;
+    }
+    send(ws, 'heartbeat', {});
+  }, 15000);
 
   /**
    * Tear down the current per-process subscriptions.
@@ -321,7 +325,8 @@ export function attachWebSocketServer(server) {
   _wss.on('close', () => clearInterval(heartbeat));
 
   server.on('upgrade', (req, socket, head) => {
-    const session = authenticate(req);
+    const cookies = parseCookies(req.headers['cookie'] || '');
+    const session = getAuthenticatedSession({ cookies });
     if (!session) {
       socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
       socket.destroy();
@@ -330,7 +335,7 @@ export function attachWebSocketServer(server) {
 
     if (req.url === STREAM_PATH) {
       _wss.handleUpgrade(req, socket, head, (ws) => {
-        handleUnifiedStream(ws);
+        handleUnifiedStream(ws, cookies);
       });
       return;
     }