ezpm2gui 1.4.0 → 1.5.0

package/dist/server/index.js

@@ -4,10 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServer = createServer;
+const path_1 = __importDefault(require("path"));
+// @group Configuration : Load .env.local first (local overrides), then .env (defaults)
+// Must happen before any code reads process.env
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const dotenv = require('dotenv');
+dotenv.config({ path: path_1.default.resolve(process.cwd(), '.env.local') });
+dotenv.config({ path: path_1.default.resolve(process.cwd(), '.env') });
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
 const socket_io_1 = require("socket.io");
-const path_1 = __importDefault(require("path"));
 const pm2_1 = __importDefault(require("pm2"));
 const os_1 = __importDefault(require("os"));
 const processConfig_1 = __importDefault(require("./routes/processConfig"));
@@ -15,6 +21,7 @@ const deployApplication_1 = __importDefault(require("./routes/deployApplication"
 const modules_1 = __importDefault(require("./routes/modules"));
 const remoteConnections_1 = __importDefault(require("./routes/remoteConnections"));
 const cronJobs_1 = __importDefault(require("./routes/cronJobs"));
+const updates_1 = __importDefault(require("./routes/updates"));
 const logStreaming_1 = require("./routes/logStreaming");
 const pm2_connection_1 = require("./utils/pm2-connection");
 const remote_connection_1 = require("./utils/remote-connection");
@@ -58,6 +65,7 @@ function createServer() {
     app.use('/api/modules', modules_1.default);
     app.use('/api/remote', remoteConnections_1.default);
     app.use('/api/cron-jobs', cronJobs_1.default);
+    app.use('/api/update', updates_1.default);
     // Setup log streaming with Socket.IO
     (0, logStreaming_1.setupLogStreaming)(io); // PM2 API endpoints
     app.get('/api/processes', async (req, res) => {
@@ -127,45 +135,224 @@ function createServer() {
         };
         res.json(metrics);
     });
-    // Get process logs
+    // @group LogHistory : Resolve log path from PM2 process descriptor
+    const resolveLocalLogPath = async (id, logType) => {
+        var _a, _b, _c;
+        const processDesc = await (0, pm2_connection_1.executePM2Command)((callback) => {
+            pm2_1.default.describe(id, callback);
+        });
+        if (!processDesc || processDesc.length === 0)
+            return null;
+        return (_c = (_b = (_a = processDesc[0]) === null || _a === void 0 ? void 0 : _a.pm2_env) === null || _b === void 0 ? void 0 : _b[`pm_${logType}_log_path`]) !== null && _c !== void 0 ? _c : null;
+    };
+    // @group LogHistory : Get log lines — ?lines=N (default 200, 0 = all)
     app.get('/api/logs/:id/:type', async (req, res) => {
-        var _a, _b;
         const { id, type } = req.params;
         const logType = type === 'err' ? 'err' : 'out';
+        const lines = parseInt(req.query.lines || '200', 10);
         try {
-            const processDesc = await (0, pm2_connection_1.executePM2Command)((callback) => {
-                pm2_1.default.describe(id, callback);
-            });
-            if (!processDesc || processDesc.length === 0) {
-                res.status(404).json({ error: 'Process not found' });
+            const logPath = await resolveLocalLogPath(id, logType);
+            if (!logPath) {
+                res.status(404).json({ error: 'Process not found or log path unavailable' });
+                return;
+            }
+            const fs = require('fs');
+            if (!fs.existsSync(logPath)) {
+                res.json({ logs: [], logPath });
                 return;
             }
-            const logPath = (_b = (_a = processDesc[0]) === null || _a === void 0 ? void 0 : _a.pm2_env) === null || _b === void 0 ? void 0 : _b[`pm_${logType}_log_path`];
+            const { lines: result, total } = await streamTailLines(fs.createReadStream(logPath), lines);
+            res.json({ logs: result, logPath, totalLines: total });
+        }
+        catch (err) {
+            console.error(`Error reading log file: ${err}`);
+            res.status(500).json({ error: 'Failed to read log file' });
+        }
+    });
+    // @group LogHistory : Download full log file
+    app.get('/api/logs/:id/:type/download', async (req, res) => {
+        const { id, type } = req.params;
+        const logType = type === 'err' ? 'err' : 'out';
+        try {
+            const logPath = await resolveLocalLogPath(id, logType);
             if (!logPath) {
-                res.status(404).json({ error: `Log file for ${logType} not found` });
+                res.status(404).json({ error: 'Process not found or log path unavailable' });
                 return;
             }
             const fs = require('fs');
-            let logContent = '';
-            if (fs.existsSync(logPath)) {
-                const stats = fs.statSync(logPath);
-                const fileSize = stats.size;
-                const readSize = Math.min(fileSize, 10 * 1024); // 10KB max
-                const position = Math.max(0, fileSize - readSize);
-                const buffer = Buffer.alloc(readSize);
-                const fd = fs.openSync(logPath, 'r');
-                fs.readSync(fd, buffer, 0, readSize, position);
-                fs.closeSync(fd);
-                logContent = buffer.toString('utf8');
+            if (!fs.existsSync(logPath)) {
+                res.status(404).json({ error: 'Log file does not exist yet' });
+                return;
             }
-            const logs = logContent.split('\n').filter((line) => line.trim() !== '');
-            res.json({ logs });
+            const fileName = `${id}-${logType}.log`;
+            res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+            res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            fs.createReadStream(logPath).pipe(res);
         }
         catch (err) {
-            console.error(`Error reading log file: ${err}`);
+            console.error(`Error downloading log file: ${err}`);
+            res.status(500).json({ error: 'Failed to download log file' });
+        }
+    });
+    // @group LogHistory : List all log files (current + rotated) for a process
+    // Uses /api/log-files/:id to avoid Express matching /:id/:type with type='files'
+    app.get('/api/log-files/:id', async (req, res) => {
+        const { id } = req.params;
+        try {
+            const fs = require('fs');
+            const nodePath = require('path');
+            const [outPath, errPath] = await Promise.all([
+                resolveLocalLogPath(id, 'out'),
+                resolveLocalLogPath(id, 'err'),
+            ]);
+            if (!outPath && !errPath) {
+                res.status(404).json({ error: 'Process not found or no log paths available' });
+                return;
+            }
+            // Derive the process base name from the log path (strip -out.log suffix)
+            const baseName = outPath
+                ? nodePath.basename(outPath).replace(/-out\.log.*$/, '')
+                : nodePath.basename(errPath).replace(/-(error|err)\.log.*$/, '');
+            const logDirs = new Set();
+            if (outPath)
+                logDirs.add(nodePath.dirname(outPath));
+            if (errPath)
+                logDirs.add(nodePath.dirname(errPath));
+            const files = [];
+            for (const dir of logDirs) {
+                if (!fs.existsSync(dir))
+                    continue;
+                for (const fileName of fs.readdirSync(dir)) {
+                    if (!fileName.startsWith(baseName))
+                        continue;
+                    const filePath = nodePath.join(dir, fileName);
+                    const stat = fs.statSync(filePath);
+                    if (!stat.isFile())
+                        continue;
+                    let type = 'unknown';
+                    if (fileName.includes('-out'))
+                        type = 'out';
+                    else if (fileName.includes('-error') || fileName.includes('-err'))
+                        type = 'err';
+                    files.push({
+                        name: fileName,
+                        path: filePath,
+                        size: stat.size,
+                        modified: stat.mtime.toISOString(),
+                        type,
+                        compressed: fileName.endsWith('.gz'),
+                    });
+                }
+            }
+            files.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+            res.json({ files });
+        }
+        catch (err) {
+            console.error('Error listing log files:', err);
+            res.status(500).json({ error: 'Failed to list log files' });
+        }
+    });
+    // @group LogHistory : Security helper — block path traversal; allow any absolute log file path
+    const isAllowedLogPath = (filePath) => {
+        const nodePath = require('path');
+        const norm = nodePath.normalize(filePath);
+        // Require absolute path; reject shell-dangerous characters; require log extension
+        const SHELL_UNSAFE = /['"`;$|&<>(){}\\\n\r\0]/;
+        return (nodePath.isAbsolute(norm) &&
+            !norm.includes('..') &&
+            !SHELL_UNSAFE.test(norm) &&
+            /\.(log|gz)$/i.test(norm));
+    };
+    // @group LogHistory : Stream last N lines from a readable stream (ring buffer, no full-file load)
+    const streamTailLines = (inputStream, maxLines) => {
+        return new Promise((resolve, reject) => {
+            const rl = require('readline').createInterface({ input: inputStream, crlfDelay: Infinity });
+            const buffer = [];
+            let total = 0;
+            rl.on('line', (line) => {
+                if (line.trim() === '')
+                    return;
+                total++;
+                if (maxLines > 0) {
+                    buffer.push(line);
+                    if (buffer.length > maxLines)
+                        buffer.shift();
+                }
+                else {
+                    buffer.push(line);
+                }
+            });
+            rl.on('close', () => resolve({ lines: buffer, total }));
+            rl.on('error', reject);
+            inputStream.on('error', reject);
+        });
+    };
+    // @group LogHistory : Read a specific log file by path — ?lines=N, supports .gz
+    // Uses /api/log-file (singular, top-level) to avoid clashing with /api/logs/:id/:type
+    app.get('/api/log-file', async (req, res) => {
+        const filePath = req.query.path;
+        const lines = parseInt(req.query.lines || '200', 10);
+        if (!filePath) {
+            res.status(400).json({ error: 'path query parameter required' });
+            return;
+        }
+        if (!isAllowedLogPath(filePath)) {
+            res.status(403).json({ error: 'Access denied: path is outside PM2 log directories' });
+            return;
+        }
+        try {
+            const fs = require('fs');
+            const zlib = require('zlib');
+            if (!fs.existsSync(filePath)) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+            const inputStream = filePath.endsWith('.gz')
+                ? fs.createReadStream(filePath).pipe(zlib.createGunzip())
+                : fs.createReadStream(filePath);
+            const { lines: result, total } = await streamTailLines(inputStream, lines);
+            res.json({ logs: result, totalLines: total });
+        }
+        catch (err) {
+            console.error('Error reading log file:', err);
             res.status(500).json({ error: 'Failed to read log file' });
         }
     });
+    // @group LogHistory : Download a specific log file by path (streams .gz as-is)
+    app.get('/api/log-file/download', async (req, res) => {
+        const filePath = req.query.path;
+        if (!filePath) {
+            res.status(400).json({ error: 'path query parameter required' });
+            return;
+        }
+        if (!isAllowedLogPath(filePath)) {
+            res.status(403).json({ error: 'Access denied' });
+            return;
+        }
+        try {
+            const fs = require('fs');
+            const zlib = require('zlib');
+            const nodePath = require('path');
+            if (!fs.existsSync(filePath)) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+            // Decompress .gz server-side so the download is always plain text
+            const baseName = nodePath.basename(filePath).replace(/\.gz$/i, '');
+            res.setHeader('Content-Disposition', `attachment; filename="${baseName}"`);
+            res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            if (filePath.endsWith('.gz')) {
+                fs.createReadStream(filePath).pipe(zlib.createGunzip()).pipe(res);
+            }
+            else {
+                fs.createReadStream(filePath).pipe(res);
+            }
+        }
+        catch (err) {
+            console.error('Error downloading log file:', err);
+            res.status(500).json({ error: 'Failed to download file' });
+        }
+    });
     // WebSocket for real-time updates
     io.on('connection', (socket) => {
         console.log('Client connected');
@@ -219,7 +406,7 @@ function createServer() {
 }
 // Only start the server if this file is run directly
 if (require.main === module) {
-    const PORT = process.env.PORT || 3001;
+    const PORT = process.env.PORT || 3101;
     const HOST = process.env.HOST || 'localhost';
     const server = createServer();
     server.listen(PORT, () => {

package/dist/server/routes/deployApplication.js

@@ -11,7 +11,7 @@ const ProjectSetupService_1 = require("../services/ProjectSetupService");
 const router = (0, express_1.Router)();
 // Deploy a new application
 router.post('/', async (req, res) => {
-    const { name, script, cwd, instances, exec_mode, autorestart, watch, max_memory_restart, env, appType, autoSetup = true } = req.body;
+    const { name, script, cwd, namespace, instances, exec_mode, autorestart, watch, max_memory_restart, env, appType, autoSetup = true } = req.body;
     // Validate required fields
     if (!name || !script) {
         return res.status(400).json({ error: 'Name and script path are required' });
@@ -67,6 +67,7 @@ router.post('/', async (req, res) => {
             name,
             script,
             cwd: projectPath,
+            namespace: namespace || 'default',
             instances: parseInt(instances) || 1,
             exec_mode: exec_mode || 'fork',
             autorestart: autorestart !== undefined ? autorestart : true,
@@ -158,8 +159,8 @@ router.post('/generate-ecosystem', (req, res) => {
                     env: pm2Env.env || {}
                 };
             });
-            const ecosystemConfig = `module.exports = {
-  apps: ${JSON.stringify(apps, null, 2)}
+            const ecosystemConfig = `module.exports = {
+  apps: ${JSON.stringify(apps, null, 2)}
 };`;
             // Create the file (either at specified path or default location)
             const filePath = req.body.path || path_1.default.join(process.cwd(), 'ecosystem.config.js');
@@ -212,8 +213,8 @@ router.get('/generate-ecosystem-preview', (req, res) => {
                     env: pm2Env.env || {}
                 };
             });
-            const ecosystemConfig = `module.exports = {
-  apps: ${JSON.stringify(apps, null, 2)}
+            const ecosystemConfig = `module.exports = {
+  apps: ${JSON.stringify(apps, null, 2)}
 };`;
             pm2_1.default.disconnect();
             res.json({

package/dist/server/routes/remoteConnections.js

@@ -6,6 +6,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
 const remote_connection_1 = require("../utils/remote-connection");
 const router = express_1.default.Router();
+// @group Security : Validate remote log file paths before shell interpolation
+const SHELL_UNSAFE_CHARS = /['"`;$|&<>(){}\\\n\r\0]/;
+const MAX_LOG_LINES = 10000;
+const validateRemotePath = (filePath) => {
+    if (!filePath)
+        return false;
+    if (filePath.includes('..'))
+        return false;
+    if (SHELL_UNSAFE_CHARS.test(filePath))
+        return false;
+    if (!/\.(log|gz)$/i.test(filePath))
+        return false;
+    return true;
+};
+const safeLogLines = (raw) => {
+    const n = parseInt(raw || '200', 10);
+    if (!Number.isFinite(n) || n < 0)
+        return 200;
+    return Math.min(n, MAX_LOG_LINES);
+};
 /**
  * Connect to an existing remote server
  * POST /api/remote/:connectionId/connect
@@ -552,6 +572,246 @@ router.get('/:connectionId/logs/:processId', async (req, res) => {
         });
     }
 });
+// @group LogHistory : Helper — resolve log path for a given process on a remote connection
+const resolveRemoteLogPath = async (connection, processId, logType) => {
+    var _a, _b;
+    const processInfoResult = await connection.executePM2Command('jlist');
+    if (processInfoResult.code !== 0)
+        return { logPath: null, error: 'Failed to get PM2 process list' };
+    try {
+        let raw = processInfoResult.stdout.trim();
+        const start = raw.indexOf('[');
+        const end = raw.lastIndexOf(']') + 1;
+        if (start !== -1 && end > 0)
+            raw = raw.substring(start, end);
+        const processList = JSON.parse(raw);
+        const proc = processList.find((p) => p.pm_id === parseInt(processId, 10) || p.name === processId);
+        if (!proc)
+            return { logPath: null, error: 'Process not found' };
+        const key = logType === 'out' ? 'pm_out_log_path' : 'pm_err_log_path';
+        return { logPath: (_b = (_a = proc.pm2_env) === null || _a === void 0 ? void 0 : _a[key]) !== null && _b !== void 0 ? _b : null };
+    }
+    catch {
+        return { logPath: null, error: 'Failed to parse PM2 process list' };
+    }
+};
+/**
+ * Get log lines from a specific log type on a remote process — ?lines=N (default 200, 0 = all)
+ * GET /api/remote/:connectionId/logs/:processId/:type
+ */
+router.get('/:connectionId/logs/:processId/:type', async (req, res) => {
+    var _a;
+    try {
+        const { connectionId, processId, type } = req.params;
+        const logType = type === 'err' ? 'err' : 'out';
+        const lines = safeLogLines(req.query.lines);
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        const { logPath, error } = await resolveRemoteLogPath(connection, processId, logType);
+        if (!logPath)
+            return res.status(404).json({ success: false, error: error || 'Log path not found' });
+        // tail -n 0 = all lines; use wc -l to get total count alongside
+        const lineArg = lines === 0 ? '+1' : `-${lines}`;
+        const cmd = `{ wc -l < "${logPath}" 2>/dev/null || echo 0; } && tail -n ${lineArg} "${logPath}" 2>/dev/null`;
+        let result = await connection.executeCommand(cmd);
+        // Fallback to sudo if the file is unreadable (root-owned logs)
+        if (result.code !== 0 || !result.stdout.trim()) {
+            result = await connection.executeCommand(`{ sudo wc -l < "${logPath}" 2>/dev/null || echo 0; } && sudo tail -n ${lineArg} "${logPath}" 2>/dev/null`);
+        }
+        const outputLines = result.stdout.split('\n');
+        const totalLines = parseInt(((_a = outputLines[0]) === null || _a === void 0 ? void 0 : _a.trim()) || '0', 10);
+        const logLines = outputLines.slice(1).filter((l) => l.trim() !== '');
+        res.json({ logs: logLines, logPath, totalLines });
+    }
+    catch (error) {
+        console.error('Error fetching remote log history:', error);
+        res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+    }
+});
+/**
+ * Download full log file from a remote process via SSH
+ * GET /api/remote/:connectionId/logs/:processId/:type/download
+ */
+router.get('/:connectionId/logs/:processId/:type/download', async (req, res) => {
+    try {
+        const { connectionId, processId, type } = req.params;
+        const logType = type === 'err' ? 'err' : 'out';
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        const { logPath, error } = await resolveRemoteLogPath(connection, processId, logType);
+        if (!logPath)
+            return res.status(404).json({ success: false, error: error || 'Log path not found' });
+        const fileName = `${processId}-${logType}.log`;
+        await connection.streamFileToResponse(logPath, res, fileName);
+    }
+    catch (error) {
+        console.error('Error downloading remote log:', error);
+        if (!res.headersSent) {
+            res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+        }
+    }
+});
+/**
+ * List all log files (current + rotated) for a remote process
+ * GET /api/remote/:connectionId/log-files/:processId
+ * Uses /log-files/ prefix to avoid Express matching /:processId/:type with type='files'
+ */
+router.get('/:connectionId/log-files/:processId', async (req, res) => {
+    try {
+        const { connectionId, processId } = req.params;
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        // Resolve both log paths so we know the directory and base name
+        const { logPath: outPath } = await resolveRemoteLogPath(connection, processId, 'out');
+        const { logPath: errPath } = await resolveRemoteLogPath(connection, processId, 'err');
+        if (!outPath && !errPath) {
+            return res.status(404).json({ success: false, error: 'No log paths found for this process' });
+        }
+        // Derive log directory + base name from the out log path (or err if out missing)
+        const refPath = outPath || errPath;
+        const logDir = refPath.substring(0, refPath.lastIndexOf('/'));
+        const baseName = refPath.split('/').pop().replace(/-out\.log.*$/, '').replace(/-(error|err)\.log.*$/, '');
+        // List matching files in the log directory
+        const lsCmd = `ls -la "${logDir}" 2>/dev/null`;
+        let lsResult = await connection.executeCommand(lsCmd);
+        if (lsResult.code !== 0)
+            lsResult = await connection.executeCommand(`sudo ${lsCmd}`);
+        const files = [];
+        if (lsResult.code === 0) {
+            for (const line of lsResult.stdout.split('\n')) {
+                // ls -la line: permissions links owner group size month day time name
+                const parts = line.trim().split(/\s+/);
+                if (parts.length < 9)
+                    continue;
+                const fileName = parts.slice(8).join(' ');
+                if (!fileName.startsWith(baseName))
+                    continue;
+                const size = parseInt(parts[4], 10) || 0;
+                const month = parts[5];
+                const day = parts[6];
+                const timeOrYr = parts[7];
+                const modified = `${month} ${day} ${timeOrYr}`;
+                let type = 'unknown';
+                if (fileName.includes('-out'))
+                    type = 'out';
+                else if (fileName.includes('-error') || fileName.includes('-err'))
+                    type = 'err';
+                files.push({
+                    name: fileName,
+                    path: `${logDir}/${fileName}`,
+                    size,
+                    modified,
+                    type,
+                    compressed: fileName.endsWith('.gz'),
+                });
+            }
+        }
+        // Sort: current files first (no date suffix), then rotated newest first
+        files.sort((a, b) => {
+            const aRot = a.name.includes('__') || /\d{4}-\d{2}/.test(a.name);
+            const bRot = b.name.includes('__') || /\d{4}-\d{2}/.test(b.name);
+            if (!aRot && bRot)
+                return -1;
+            if (aRot && !bRot)
+                return 1;
+            return b.name.localeCompare(a.name);
+        });
+        res.json({ files });
+    }
+    catch (error) {
+        console.error('Error listing remote log files:', error);
+        res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+    }
+});
+/**
+ * Read a specific remote log file by path — ?lines=N, handles .gz via zcat
+ * GET /api/remote/:connectionId/log-file?path=...&lines=N
+ * Uses /log-file top-level to avoid clashing with /logs/:processId routes
+ */
+router.get('/:connectionId/log-file', async (req, res) => {
+    var _a;
+    try {
+        const { connectionId } = req.params;
+        const filePath = req.query.path;
+        const lines = safeLogLines(req.query.lines);
+        if (!filePath)
+            return res.status(400).json({ error: 'path query parameter required' });
+        // Strict path validation — blocks traversal, shell metacharacters, and non-log extensions
+        if (!validateRemotePath(filePath)) {
+            return res.status(403).json({ error: 'Access denied: invalid or unsafe log file path' });
+        }
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        const isGz = filePath.endsWith('.gz');
+        const catCmd = isGz ? `zcat "${filePath}" 2>/dev/null` : `cat "${filePath}" 2>/dev/null`;
+        const lineArg = lines === 0 ? '' : `| tail -n ${lines}`;
+        const countCmd = isGz
+            ? `zcat "${filePath}" 2>/dev/null | wc -l`
+            : `wc -l < "${filePath}" 2>/dev/null`;
+        const [contentResult, countResult] = await Promise.all([
+            connection.executeCommand(`${catCmd} ${lineArg}`).catch(() => ({ code: 1, stdout: '', stderr: '' })),
+            connection.executeCommand(countCmd).catch(() => ({ code: 1, stdout: '0', stderr: '' })),
+        ]);
+        // Fallback to sudo on permission error
+        const content = contentResult.code === 0 && contentResult.stdout.trim()
+            ? contentResult
+            : await connection.executeCommand(`sudo ${catCmd} ${lineArg}`);
+        const totalLines = parseInt(((_a = countResult.stdout) === null || _a === void 0 ? void 0 : _a.trim()) || '0', 10);
+        const logLines = (content.stdout || '').split('\n').filter((l) => l.trim() !== '');
+        res.json({ logs: logLines, totalLines });
+    }
+    catch (error) {
+        console.error('Error reading remote log file:', error);
+        res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+    }
+});
+/**
+ * Download a specific remote log file by path via SSH cat/zcat
+ * GET /api/remote/:connectionId/log-file/download?path=...
+ */
+router.get('/:connectionId/log-file/download', async (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const filePath = req.query.path;
+        if (!filePath)
+            return res.status(400).json({ error: 'path query parameter required' });
+        if (!validateRemotePath(filePath)) {
+            return res.status(403).json({ error: 'Access denied: invalid or unsafe log file path' });
+        }
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        // .gz files: stream via SFTP + local gunzip (no server-side memory buffering)
+        if (filePath.endsWith('.gz')) {
+            const gzName = filePath.split('/').pop().replace(/\.gz$/, '');
+            await connection.streamGzFileToResponse(filePath, res, gzName);
+            return;
+        }
+        // Plain files: SFTP stream
+        const fileName = filePath.split('/').pop();
+        await connection.streamFileToResponse(filePath, res, fileName);
+    }
+    catch (error) {
+        console.error('Error downloading remote log file:', error);
+        if (!res.headersSent) {
+            res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+        }
+    }
+});
 /**
  * Get list of all remote connections with their status
  * GET /api/remote/connections

package/dist/server/routes/updates.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+declare const router: Router;
+export default router;