ezpm2gui 1.5.0 → 1.8.0

package/dist/server/routes/deployApplication.js

@@ -9,60 +9,69 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const ProjectSetupService_1 = require("../services/ProjectSetupService");
 const router = (0, express_1.Router)();
-// Deploy a new application
+// Deploy a new application (SSE streaming)
 router.post('/', async (req, res) => {
     const { name, script, cwd, namespace, instances, exec_mode, autorestart, watch, max_memory_restart, env, appType, autoSetup = true } = req.body;
-    // Validate required fields
+    // Validate required fields before starting SSE
     if (!name || !script) {
         return res.status(400).json({ error: 'Name and script path are required' });
     }
-    // Validate script path exists
     if (!fs_1.default.existsSync(script)) {
         return res.status(400).json({ error: `Script file not found: ${script}` });
     }
+    // Switch to SSE
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+    const send = (type, data) => {
+        if (!res.writableEnded) {
+            res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
+        }
+    };
+    const log = (message) => send('log', { message });
+    const done = (success, extra = {}) => {
+        send('done', { success, ...extra });
+        res.end();
+    };
     try {
         const projectPath = cwd || path_1.default.dirname(script);
-        let setupResult = null;
         let finalEnv = env || {};
         let interpreterPath = '';
-        // Auto-detect project type if not provided
+        let setupResult = null;
+        // Auto-detect project type
         let detectedType = appType;
         if (!detectedType) {
             detectedType = ProjectSetupService_1.projectSetupService.detectProjectType(projectPath);
             if (detectedType) {
-                console.log(`Auto-detected project type: ${detectedType}`);
+                log(`Auto-detected project type: ${detectedType}`);
             }
         }
-        // Run project setup if auto-setup is enabled and project type is detected
+        // Run project setup
         if (autoSetup && detectedType && ['node', 'python', 'dotnet'].includes(detectedType)) {
-            console.log(`Running setup for ${detectedType} project...`);
+            log(`Running ${detectedType} project setup...`);
             try {
-                setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, detectedType);
+                setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, detectedType, log);
                 if (!setupResult.success) {
-                    return res.status(500).json({
+                    return done(false, {
                         error: 'Project setup failed',
                         details: setupResult.errors,
-                        warnings: setupResult.warnings,
-                        steps: setupResult.steps
+                        warnings: setupResult.warnings
                     });
                 }
-                // Merge environment variables from setup
                 finalEnv = { ...setupResult.environment, ...finalEnv };
-                // Set interpreter path for Python projects
                 if (setupResult.interpreterPath) {
                     interpreterPath = setupResult.interpreterPath;
                 }
-                console.log('Project setup completed successfully');
             }
             catch (setupError) {
-                console.error('Setup error:', setupError);
-                return res.status(500).json({
+                return done(false, {
                     error: 'Project setup failed',
                     details: setupError instanceof Error ? setupError.message : 'Unknown setup error'
                 });
             }
         }
-        // Create deployment configuration
+        // Build PM2 config
         const appConfig = {
             name,
             script,
@@ -75,45 +84,38 @@ router.post('/', async (req, res) => {
             max_memory_restart: max_memory_restart || '150M',
             env: finalEnv
         };
-        // Set interpreter for Python projects
         if (detectedType === 'python' && interpreterPath) {
             appConfig.interpreter = interpreterPath;
         }
         else if (detectedType === 'dotnet') {
             appConfig.interpreter = 'dotnet';
-            // For .NET projects, update script to point to the published DLL if available
             const publishedDll = path_1.default.join(projectPath, 'publish', `${path_1.default.basename(projectPath)}.dll`);
             if (fs_1.default.existsSync(publishedDll)) {
                 appConfig.script = publishedDll;
             }
         }
-        pm2_1.default.connect((err) => {
-            if (err) {
-                console.error(err);
-                return res.status(500).json({ error: 'Failed to connect to PM2' });
-            }
-            pm2_1.default.start(appConfig, (err) => {
-                pm2_1.default.disconnect();
-                if (err) {
-                    console.error('PM2 start error:', err);
-                    return res.status(500).json({
-                        error: `Failed to deploy application: ${err.message || 'Unknown error'}`
-                    });
-                }
-                res.json({
-                    success: true,
-                    message: `Application ${name} deployed successfully`,
-                    setupResult: setupResult ? {
-                        steps: setupResult.steps,
-                        warnings: setupResult.warnings
-                    } : null
+        log(`Starting PM2 process: ${name}`);
+        await new Promise((resolve, reject) => {
+            pm2_1.default.connect((err) => {
+                if (err)
+                    return reject(err);
+                pm2_1.default.start(appConfig, (startErr) => {
+                    pm2_1.default.disconnect();
+                    if (startErr)
+                        return reject(startErr);
+                    resolve();
                 });
             });
         });
+        log(`Process "${name}" started successfully.`);
+        done(true, {
+            message: `Application ${name} deployed successfully`,
+            setupResult: setupResult ? { steps: setupResult.steps, warnings: setupResult.warnings } : null
+        });
     }
     catch (error) {
         console.error('Deployment error:', error);
-        return res.status(500).json({
+        done(false, {
             error: 'Deployment failed',
             details: error instanceof Error ? error.message : 'Unknown error'
         });
@@ -159,8 +161,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');
@@ -213,8 +215,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/logStreaming.js

@@ -7,7 +7,6 @@ exports.setupLogStreaming = void 0;
 const express_1 = require("express");
 const pm2_1 = __importDefault(require("pm2"));
 const fs_1 = __importDefault(require("fs"));
-const child_process_1 = require("child_process");
 const remote_connection_1 = require("../utils/remote-connection");
 const router = (0, express_1.Router)();
 // This variable will hold references to active log streams
@@ -18,7 +17,7 @@ const getLogStream = (io, processId, logType) => {
     const streamKey = `${processId}-${logType}`;
     // If stream already exists, return it
     if (activeStreams[streamKey]) {
-        return activeStreams[streamKey];
+        return Promise.resolve(activeStreams[streamKey]);
     }
     return new Promise((resolve, reject) => {
         pm2_1.default.describe(processId, (err, processDesc) => {
@@ -32,30 +31,38 @@ const getLogStream = (io, processId, logType) => {
                 reject(new Error(`Log file not found: ${logPath}`));
                 return;
             }
-            // Create a tail process to stream the log file
-            const tail = (0, child_process_1.spawn)('tail', ['-f', logPath]);
-            // Setup event handlers
-            tail.stdout.on('data', (data) => {
-                const lines = data.toString().split('\n').filter((line) => line.trim() !== '');
-                lines.forEach((line) => {
-                    // Emit only to clients subscribed to this specific log stream
-                    io.to(streamKey).emit('log-line', {
-                        processId,
-                        logType,
-                        line
+            // Cross-platform tail using fs.watch — no Unix `tail` binary needed
+            let position = fs_1.default.statSync(logPath).size; // start at EOF, don't replay history
+            const watcher = fs_1.default.watch(logPath, (eventType) => {
+                if (eventType !== 'change')
+                    return;
+                try {
+                    const stat = fs_1.default.statSync(logPath);
+                    // Handle log rotation / truncation
+                    if (stat.size < position)
+                        position = 0;
+                    if (stat.size === position)
+                        return;
+                    const length = stat.size - position;
+                    const buffer = Buffer.alloc(length);
+                    const fd = fs_1.default.openSync(logPath, 'r');
+                    fs_1.default.readSync(fd, buffer, 0, length, position);
+                    fs_1.default.closeSync(fd);
+                    position = stat.size;
+                    const lines = buffer.toString('utf8').split('\n').filter((l) => l.trim() !== '');
+                    lines.forEach((line) => {
+                        io.to(streamKey).emit('log-line', { processId, logType, line });
                     });
-                });
-            });
-            tail.stderr.on('data', (data) => {
-                console.error(`Tail error: ${data}`);
-            });
-            tail.on('close', (code) => {
-                console.log(`Tail process exited with code ${code}`);
-                delete activeStreams[streamKey];
+                }
+                catch (e) {
+                    console.error('Error reading log file:', e);
+                }
             });
-            // Store the tail process
-            activeStreams[streamKey] = tail;
-            resolve(tail);
+            watcher.on('error', (e) => console.error(`Watcher error for ${streamKey}:`, e));
+            // Expose a kill() so existing cleanup code works unchanged
+            const streamObj = { kill: () => { watcher.close(); delete activeStreams[streamKey]; } };
+            activeStreams[streamKey] = streamObj;
+            resolve(streamObj);
         });
     });
 };

package/dist/server/routes/modules.js

@@ -5,6 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
 const pm2_1 = __importDefault(require("pm2"));
 const pm2_connection_1 = require("../utils/pm2-connection");
 const router = (0, express_1.Router)();
@@ -123,4 +126,56 @@ router.delete('/:moduleName', async (req, res) => {
         });
     }
 });
+// @group Utilities : Resolve ~/.pm2/module_conf.json path
+const moduleConfPath = () => path_1.default.join(os_1.default.homedir(), '.pm2', 'module_conf.json');
+// @group APIEndpoints : Get config for a specific installed module
+router.get('/:moduleName/config', (req, res) => {
+    var _a;
+    const { moduleName } = req.params;
+    if (!/^[@a-zA-Z0-9/_\-.]+$/.test(moduleName)) {
+        return res.status(400).json({ error: 'Invalid module name' });
+    }
+    const confFile = moduleConfPath();
+    if (!fs_1.default.existsSync(confFile)) {
+        return res.json({ config: {} });
+    }
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(confFile, 'utf8'));
+        // PM2 stores module config under the module name key
+        const config = (_a = raw[moduleName]) !== null && _a !== void 0 ? _a : {};
+        res.json({ config });
+    }
+    catch {
+        res.status(500).json({ error: 'Failed to read module configuration' });
+    }
+});
+// @group APIEndpoints : Set one or more config keys for an installed module
+router.put('/:moduleName/config', async (req, res) => {
+    const { moduleName } = req.params;
+    const { config } = req.body;
+    if (!/^[@a-zA-Z0-9/_\-.]+$/.test(moduleName)) {
+        return res.status(400).json({ error: 'Invalid module name' });
+    }
+    if (!config || typeof config !== 'object') {
+        return res.status(400).json({ error: 'config object is required' });
+    }
+    // Validate all keys — no shell metacharacters
+    for (const key of Object.keys(config)) {
+        if (!/^[a-zA-Z0-9_\-.]+$/.test(key)) {
+            return res.status(400).json({ error: `Invalid config key: ${key}` });
+        }
+    }
+    try {
+        // Run pm2 set for each key sequentially
+        for (const [key, value] of Object.entries(config)) {
+            // Wrap value in quotes to handle spaces; strip any embedded quotes first
+            const safeValue = String(value).replace(/"/g, '');
+            await runPM2CLI(`set ${moduleName}:${key} "${safeValue}"`);
+        }
+        res.json({ success: true, message: `Configuration updated for ${moduleName}` });
+    }
+    catch (error) {
+        res.status(500).json({ error: 'Failed to update configuration', details: error.message });
+    }
+});
 exports.default = router;

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

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

package/dist/server/routes/pageAuth.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// @group Configuration : Path to the stored auth config file
+const AUTH_FILE = path_1.default.join(__dirname, '../config/auth.json');
+// @group Utilities : Load auth config — returns null when no password is set
+function loadAuthConfig() {
+    try {
+        if (!fs_1.default.existsSync(AUTH_FILE))
+            return null;
+        const raw = fs_1.default.readFileSync(AUTH_FILE, 'utf8').trim();
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// @group Utilities : Persist auth config to disk
+function saveAuthConfig(config) {
+    const dir = path_1.default.dirname(AUTH_FILE);
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(AUTH_FILE, JSON.stringify(config), 'utf8');
+}
+// @group Utilities : Hash a plaintext password with PBKDF2 + salt
+function hashPassword(password, salt) {
+    return crypto_1.default.pbkdf2Sync(password, salt, 100000, 64, 'sha512').toString('hex');
+}
+// @group Router : Express router for password-protection endpoints
+const router = express_1.default.Router();
+// @group Endpoints : GET /api/auth/status — is a password/PIN configured?
+router.get('/status', (_req, res) => {
+    var _a;
+    const config = loadAuthConfig();
+    res.json({
+        passwordSet: config !== null,
+        pinSet: !!(config === null || config === void 0 ? void 0 : config.pinHash),
+        autoLockMinutes: (_a = config === null || config === void 0 ? void 0 : config.autoLockMinutes) !== null && _a !== void 0 ? _a : 0,
+    });
+});
+// @group Endpoints : PATCH /api/auth/settings — update non-password settings (e.g. autoLockMinutes)
+router.patch('/settings', (req, res) => {
+    var _a;
+    const { autoLockMinutes } = req.body;
+    const config = loadAuthConfig();
+    if (!config) {
+        return res.status(400).json({ success: false, error: 'No password set — configure a password first' });
+    }
+    const minutes = typeof autoLockMinutes === 'number' && autoLockMinutes >= 0 ? Math.floor(autoLockMinutes) : (_a = config.autoLockMinutes) !== null && _a !== void 0 ? _a : 0;
+    saveAuthConfig({ ...config, autoLockMinutes: minutes });
+    res.json({ success: true, autoLockMinutes: minutes });
+});
+// @group Endpoints : POST /api/auth/set — set or change the password
+router.post('/set', (req, res) => {
+    var _a;
+    const { password, currentPassword } = req.body;
+    if (!password || typeof password !== 'string' || password.length < 4) {
+        return res.status(400).json({ success: false, error: 'Password must be at least 4 characters' });
+    }
+    const existing = loadAuthConfig();
+    // If a password is already set, require the current one before changing
+    if (existing) {
+        if (!currentPassword) {
+            return res.status(401).json({ success: false, error: 'Current password required to change password' });
+        }
+        const currentHash = hashPassword(currentPassword, existing.salt);
+        if (!crypto_1.default.timingSafeEqual(Buffer.from(currentHash, 'hex'), Buffer.from(existing.hash, 'hex'))) {
+            return res.status(401).json({ success: false, error: 'Current password is incorrect' });
+        }
+    }
+    const salt = crypto_1.default.randomBytes(32).toString('hex');
+    const hash = hashPassword(password, salt);
+    // Preserve PIN and autoLock settings when changing password
+    saveAuthConfig({
+        hash,
+        salt,
+        autoLockMinutes: (_a = existing === null || existing === void 0 ? void 0 : existing.autoLockMinutes) !== null && _a !== void 0 ? _a : 0,
+        ...((existing === null || existing === void 0 ? void 0 : existing.pinHash) ? { pinHash: existing.pinHash, pinSalt: existing.pinSalt } : {}),
+    });
+    res.json({ success: true });
+});
+// @group Endpoints : POST /api/auth/verify — verify a password attempt
+router.post('/verify', (req, res) => {
+    const { password } = req.body;
+    if (!password || typeof password !== 'string') {
+        return res.status(400).json({ success: false, error: 'Password is required' });
+    }
+    const config = loadAuthConfig();
+    if (!config) {
+        // No password set — treat as unlocked
+        return res.json({ success: true, token: crypto_1.default.randomBytes(32).toString('hex') });
+    }
+    const hash = hashPassword(password, config.salt);
+    const match = crypto_1.default.timingSafeEqual(Buffer.from(hash, 'hex'), Buffer.from(config.hash, 'hex'));
+    if (!match) {
+        return res.status(401).json({ success: false, error: 'Incorrect password' });
+    }
+    res.json({ success: true, token: crypto_1.default.randomBytes(32).toString('hex') });
+});
+// @group Endpoints : DELETE /api/auth/remove — remove the password (requires current password)
+router.delete('/remove', (req, res) => {
+    const { password } = req.body;
+    const config = loadAuthConfig();
+    if (!config) {
+        return res.json({ success: true }); // nothing to remove
+    }
+    if (!password || typeof password !== 'string') {
+        return res.status(400).json({ success: false, error: 'Current password required' });
+    }
+    const hash = hashPassword(password, config.salt);
+    const match = crypto_1.default.timingSafeEqual(Buffer.from(hash, 'hex'), Buffer.from(config.hash, 'hex'));
+    if (!match) {
+        return res.status(401).json({ success: false, error: 'Incorrect password' });
+    }
+    fs_1.default.unlinkSync(AUTH_FILE);
+    res.json({ success: true });
+});
+// @group Endpoints : POST /api/auth/pin/set — set or change the PIN (4-digit)
+router.post('/pin/set', (req, res) => {
+    const { pin } = req.body;
+    if (!pin || !/^\d{4}$/.test(pin)) {
+        return res.status(400).json({ success: false, error: 'PIN must be exactly 4 digits' });
+    }
+    const config = loadAuthConfig();
+    if (!config) {
+        return res.status(400).json({ success: false, error: 'Set a password first before adding a PIN' });
+    }
+    const pinSalt = crypto_1.default.randomBytes(32).toString('hex');
+    const pinHash = hashPassword(pin, pinSalt);
+    saveAuthConfig({ ...config, pinHash, pinSalt });
+    res.json({ success: true });
+});
+// @group Endpoints : POST /api/auth/pin/verify — verify a PIN attempt
+router.post('/pin/verify', (req, res) => {
+    const { pin } = req.body;
+    if (!pin || typeof pin !== 'string') {
+        return res.status(400).json({ success: false, error: 'PIN is required' });
+    }
+    const config = loadAuthConfig();
+    if (!(config === null || config === void 0 ? void 0 : config.pinHash) || !(config === null || config === void 0 ? void 0 : config.pinSalt)) {
+        return res.status(400).json({ success: false, error: 'No PIN configured' });
+    }
+    const hash = hashPassword(pin, config.pinSalt);
+    const match = crypto_1.default.timingSafeEqual(Buffer.from(hash, 'hex'), Buffer.from(config.pinHash, 'hex'));
+    if (!match) {
+        return res.status(401).json({ success: false, error: 'Incorrect PIN' });
+    }
+    res.json({ success: true, token: crypto_1.default.randomBytes(32).toString('hex') });
+});
+// @group Endpoints : DELETE /api/auth/pin/remove — remove PIN (requires current password)
+router.delete('/pin/remove', (req, res) => {
+    const { password } = req.body;
+    const config = loadAuthConfig();
+    if (!config) {
+        return res.json({ success: true }); // nothing to remove
+    }
+    if (!password || typeof password !== 'string') {
+        return res.status(400).json({ success: false, error: 'Current password required to remove PIN' });
+    }
+    const hash = hashPassword(password, config.salt);
+    const match = crypto_1.default.timingSafeEqual(Buffer.from(hash, 'hex'), Buffer.from(config.hash, 'hex'));
+    if (!match) {
+        return res.status(401).json({ success: false, error: 'Incorrect password' });
+    }
+    const { pinHash: _ph, pinSalt: _ps, ...rest } = config;
+    saveAuthConfig(rest);
+    res.json({ success: true });
+});
+exports.default = router;

package/dist/server/routes/remoteConnections.js

@@ -819,15 +819,19 @@ router.get('/:connectionId/log-file/download', async (req, res) => {
 router.get('/connections', async (req, res) => {
     try {
         const connections = remote_connection_1.remoteConnectionManager.getAllConnections();
-        const connectionsList = Array.from(connections.entries()).map(([id, conn]) => ({
-            id,
-            name: conn.name || `${conn.username}@${conn.host}`,
-            host: conn.host,
-            port: conn.port,
-            username: conn.username,
-            connected: conn.isConnected(),
-            isPM2Installed: conn.isPM2Installed
-        }));
+        const connectionsList = Array.from(connections.entries()).map(([id, conn]) => {
+            const connected = conn.isConnected();
+            return {
+                id,
+                name: conn.name || `${conn.username}@${conn.host}`,
+                host: conn.host,
+                port: conn.port,
+                username: conn.username,
+                connected,
+                isPM2Installed: conn.isPM2Installed,
+                status: connected ? 'connected' : 'disconnected',
+            };
+        });
         res.json(connectionsList);
     }
     catch (error) {

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

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

package/dist/server/routes/remoteMetrics.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const remote_metrics_db_1 = require("../utils/remote-metrics-db");
+const router = express_1.default.Router();
+// @group Constants : Default and maximum query bounds
+const DEFAULT_RANGE_MS = 3600000; // 1 hour
+const MAX_RANGE_MS = 7 * 24 * 3600000; // 7 days
+const MAX_POINTS = 500;
+// @group Utilities : Parse and clamp a query-string integer
+const parseIntParam = (raw, fallback, min, max) => {
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.max(min, Math.min(max, n));
+};
+/**
+ * List all remote connections that have recorded metrics
+ * GET /api/remote-metrics/connections
+ */
+router.get('/connections', (_req, res) => {
+    try {
+        const connections = remote_metrics_db_1.remoteMetricsDB.getConnectionsWithData();
+        res.json({ success: true, connections });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+/**
+ * List all process names recorded for a connection
+ * GET /api/remote-metrics/:connectionId/processes
+ */
+router.get('/:connectionId/processes', (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const names = remote_metrics_db_1.remoteMetricsDB.getProcessNames(connectionId);
+        res.json({ success: true, processes: names });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+/**
+ * Latest snapshot (most recent metric point per process) for a connection
+ * GET /api/remote-metrics/:connectionId/snapshot
+ */
+router.get('/:connectionId/snapshot', (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const snapshot = remote_metrics_db_1.remoteMetricsDB.getLatestSnapshot(connectionId);
+        res.json({ success: true, snapshot });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+/**
+ * Time-series metrics for one process on a connection
+ * GET /api/remote-metrics/:connectionId/:processName
+ *   ?from=<unix-ms>  (default: now - 1h)
+ *   ?to=<unix-ms>    (default: now)
+ *   ?maxPoints=<n>   (default: 500, max: 1000)
+ */
+router.get('/:connectionId/:processName', (req, res) => {
+    try {
+        const { connectionId, processName } = req.params;
+        const now = Date.now();
+        const to = parseIntParam(req.query.to, now, 0, now + 60000);
+        const from = parseIntParam(req.query.from, to - DEFAULT_RANGE_MS, 0, now);
+        // Clamp range to max window
+        const clampedFrom = Math.max(from, to - MAX_RANGE_MS);
+        const maxPoints = parseIntParam(req.query.maxPoints, MAX_POINTS, 50, 1000);
+        const metrics = remote_metrics_db_1.remoteMetricsDB.getMetrics(connectionId, processName, clampedFrom, to, maxPoints);
+        res.json({ success: true, metrics });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+exports.default = router;

package/dist/server/services/ProjectSetupService.d.ts

@@ -62,7 +62,7 @@ export declare class ProjectSetupService {
     private ensureLogDirectory;
     private log;
     detectProjectType(projectPath: string): string | null;
-    setupProject(projectPath: string, projectType: string): Promise<SetupResult>;
+    setupProject(projectPath: string, projectType: string, onLog?: (msg: string) => void): Promise<SetupResult>;
     private shouldSkipStep;
     private executeStep;
     private validateSetup;