ezpm2gui 1.6.0 → 1.9.0

package/README.md

@@ -1,5 +1,7 @@
 # EZ PM2 GUI
 
+[![Discord](https://img.shields.io/discord/1234567890?logo=discord&logoColor=white&label=Discord&color=5865F2)](https://discord.gg/ttgc2zqK7b)
+
 A modern web-based graphical user interface for the PM2 process manager, built with TypeScript, Tailwind CSS, and React.
 
 ## Screenshots
@@ -12,6 +14,14 @@ A modern web-based graphical user interface for the PM2 process manager, built w
 
 ![Process Monitor](ezpm2gui/screenshots/02-monitoring.png)
 
+**Metrics (Live)** — rolling 1-hour sparklines per process, updated every 3 seconds:
+
+![Metrics Live](ezpm2gui/screenshots/12-metrics-live.png)
+
+**Metrics (History)** — SQLite-backed CPU and memory charts with selectable time range:
+
+![Metrics History](ezpm2gui/screenshots/13-metrics-history.png)
+
 **Deploy App** — start new PM2 processes from a structured form:
 
 ![Deploy App](ezpm2gui/screenshots/04-deploy-app.png)
@@ -30,18 +40,24 @@ A modern web-based graphical user interface for the PM2 process manager, built w
 
 - **Real-time process monitoring** - Keep track of all your PM2 processes in real-time
 - **Process management** - Start, stop, restart, and delete processes with one click
+- **Sidebar quick-actions** *(v1.9.0)* - Per-process restart, start/stop, and logs buttons revealed on hover in the sidebar
 - **System metrics dashboard** - Monitor CPU, memory usage, and uptime
+- **Metrics page with live sparklines** - Per-process rolling 1-hour CPU and memory micro-graphs updated every 3s; switch to History tab for SQLite-backed long-term charts
 - **Enhanced log streaming** - View and filter logs from multiple processes simultaneously
+- **Log search highlighting** *(v1.9.0)* - Search terms are visually highlighted in the log viewer
+- **Log timestamp range filter** *(v1.9.0)* - Filter log output by start/end timestamp with snapshot mode
+- **Remote log polling** *(v1.9.0)* - Logs from remote servers fetched and displayed in real-time
 - **WebSocket for live updates** - Get instant updates without refreshing
 - **Process CPU and memory charts** - Visualize performance metrics over time
 - **Filter processes by status or name** - Quickly find the processes you need
-- **Dark/light mode** - Fully supported across all pages with Tailwind CSS
+- **Dark/light mode** - Fully supported across all pages with Tailwind CSS; preference persisted across sessions
 - **Cluster management** - Easily scale your Node.js applications
 - **Application deployment** - Deploy new applications directly from the UI
 - **Ecosystem configuration** - Create and manage your PM2 ecosystem files
 - **PM2 modules support** - Manage and configure PM2 modules
 - **Cron Jobs** - Schedule and manage automated tasks with visual cron expression builder
 - **Remote Server Management** - Connect and manage PM2 on remote servers via SSH
+- **End-to-end encrypted credentials** *(v1.9.0)* - Remote server passwords encrypted in-browser with RSA-OAEP + AES-256-GCM before transmission
 - **Advanced Monitoring Dashboard** - Real-time performance charts with health scoring
 - **Tailwind CSS UI** - Sleek, compact, and responsive design with consistent dark/light theming
 - **Fully typed with TypeScript** - Robust and maintainable codebase
@@ -55,9 +71,9 @@ Monitor all your PM2 processes in real-time with detailed information on CPU usa
 Connect to and manage PM2 processes on remote servers via secure SSH connections:
 - Add multiple remote server connections with SSH credentials
 - View and manage processes on remote servers
-- Stream logs from remote processes in real-time
+- Stream logs from remote processes in real-time with polling
 - Execute PM2 commands on remote machines
-- Encrypted credential storage for security
+- **End-to-end credential encryption** — passwords are encrypted client-side (RSA-OAEP + AES-256-GCM hybrid scheme) before transmission; the server never sees plaintext passwords in transit
 
 ### Cron Jobs
 Schedule and automate tasks using PM2's cron restart feature:
@@ -91,10 +107,13 @@ Easily scale your Node.js applications with the cluster management interface. Ad
 ### Log Streaming
 View and filter logs from multiple processes simultaneously with the enhanced log streaming interface. Features include:
 - Real-time log updates via WebSocket
+- **Search with visual highlighting** — matched terms are highlighted inline
+- **Timestamp range filter** — narrow logs to a start/end time window with snapshot mode (polling pauses while filter is active)
 - Filtering by process, log level, or content
 - Pausing and resuming log streams
 - Download logs for offline analysis
 - Floating log panel for remote process logs
+- Remote server log polling
 
 ### Ecosystem Configuration
 Generate and manage PM2 ecosystem configuration files directly from the UI. This makes it easy to set up complex application deployments and share configurations across your team.
@@ -169,7 +188,7 @@ ezpm2gui.start({
 Once started, open your browser and navigate to:
 
 ```
-http://localhost:3001
+http://localhost:3101
 ```
 
 ## Requirements
@@ -181,8 +200,23 @@ http://localhost:3001
 
 EZ PM2 GUI uses environment variables for configuration:
 
-- `PORT`: The port to run the server on (default: 3001)
-- `HOST`: The host to bind to (default: localhost)
+- `PORT`: The port to run the server on (default: `3101`)
+- `HOST`: The host to bind to (default: `localhost`)
+
+You can set these in a `.env` file at the project root (create it if it doesn't exist):
+
+```env
+# .env
+PORT=3102
+HOST=localhost
+```
+
+For the React client to connect to the correct port during a production build, also set:
+
+```env
+# src/client/.env
+REACT_APP_API_URL=http://localhost:3102
+```
 
 ## Load Balancing with PM2
 

package/dist/server/config/project-configs.json

@@ -38,9 +38,7 @@
             "workingDirectory": "project"
           }
         ],
-        "environment": {
-          "NODE_ENV": "production"
-        }
+        "environment": {}
       },
       "validation": {
         "checks": [
@@ -50,7 +48,8 @@
           },
           {
             "name": "node_modules exists after install",
-            "directory": "node_modules"
+            "directory": "node_modules",
+            "optional": true
           }
         ]
       },

package/dist/server/index.js

@@ -26,6 +26,9 @@ const pageAuth_1 = __importDefault(require("./routes/pageAuth"));
 const logStreaming_1 = require("./routes/logStreaming");
 const pm2_connection_1 = require("./utils/pm2-connection");
 const remote_connection_1 = require("./utils/remote-connection");
+const metrics_history_1 = require("./utils/metrics-history");
+const remoteMetrics_1 = __importDefault(require("./routes/remoteMetrics"));
+const remote_metrics_poller_1 = require("./utils/remote-metrics-poller");
 /**
  * Create and configure the express server
  */
@@ -38,15 +41,15 @@ function createServer() {
             origin: '*',
             methods: ['GET', 'POST']
         },
-        // Increase ping timeout to prevent false positive disconnections
-        pingTimeout: 10000, // How long to wait for a pong response (default: 5000ms)
+        // Increase ping timeout to prevent false positive disconnections in VPN/remote scenarios
+        pingTimeout: 20000, // How long to wait for a pong response (increased from 10s to 20s)
         pingInterval: 25000, // How often to send ping packets (default: 25000ms)
         // Allow reconnection attempts
         allowEIO3: true,
         // Transport configuration
         transports: ['websocket', 'polling'],
         // Upgrade timeout
-        upgradeTimeout: 10000
+        upgradeTimeout: 20000 // Increased from 10s to 20s for slow VPN connections
     });
     // Configure middleware
     app.use(express_1.default.json());
@@ -68,6 +71,9 @@ function createServer() {
     app.use('/api/cron-jobs', cronJobs_1.default);
     app.use('/api/update', updates_1.default);
     app.use('/api/auth', pageAuth_1.default);
+    app.use('/api/remote-metrics', remoteMetrics_1.default);
+    // Start remote metrics poller (30-second interval, polls all connected servers)
+    remote_metrics_poller_1.remoteMetricsPoller.start();
     // Setup log streaming with Socket.IO
     (0, logStreaming_1.setupLogStreaming)(io); // PM2 API endpoints
     app.get('/api/processes', async (req, res) => {
@@ -137,6 +143,24 @@ function createServer() {
         };
         res.json(metrics);
     });
+    // @group MetricsHistory : Return full history for all processes
+    app.get('/api/metrics/history', (_req, res) => {
+        res.json(metrics_history_1.metricsHistory.getAll());
+    });
+    // @group MetricsHistory : Return history for a single process by pm_id
+    app.get('/api/metrics/history/:processId', (req, res) => {
+        const pm_id = parseInt(req.params.processId, 10);
+        if (isNaN(pm_id)) {
+            res.status(400).json({ error: 'Invalid processId' });
+            return;
+        }
+        const entry = metrics_history_1.metricsHistory.getOne(pm_id);
+        if (!entry) {
+            res.status(404).json({ error: 'No history found for this process' });
+            return;
+        }
+        res.json(entry);
+    });
     // @group LogHistory : Resolve log path from PM2 process descriptor
     const resolveLocalLogPath = async (id, logType) => {
         var _a, _b, _c;
@@ -355,6 +379,19 @@ function createServer() {
             res.status(500).json({ error: 'Failed to download file' });
         }
     });
+    // @group MetricsHistory : Server-level polling — records PM2 process metrics into the history store
+    // This runs once regardless of how many clients are connected so the ring buffer fills consistently.
+    const historyPollInterval = setInterval(async () => {
+        try {
+            const processList = await (0, pm2_connection_1.executePM2Command)((callback) => {
+                pm2_1.default.list(callback);
+            });
+            metrics_history_1.metricsHistory.record(processList);
+        }
+        catch {
+            // silent — best-effort recording; don't crash the server
+        }
+    }, 3000);
     // WebSocket for real-time updates
     io.on('connection', (socket) => {
         console.log('Client connected');
@@ -403,15 +440,17 @@ function createServer() {
             res.status(404).send('File not found. Please check server configuration.');
         }
     });
+    // Clean up history poll on server close
+    server.on('close', () => clearInterval(historyPollInterval));
     // Return the server instance
     return server;
 }
 // Only start the server if this file is run directly
 if (require.main === module) {
-    const PORT = process.env.PORT || 3101;
+    const PORT = parseInt(process.env.PORT || '3101', 10);
     const HOST = process.env.HOST || 'localhost';
     const server = createServer();
-    server.listen(PORT, () => {
+    server.listen(PORT, HOST, () => {
         console.log(`Server running on http://${HOST}:${PORT}`);
     });
     // Handle shutdown gracefully

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'
         });

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);
         });
     });
 };
@@ -67,8 +74,19 @@ const getRemoteLogStream = async (io, connectionId, processId) => {
         return activeRemoteStreams[streamKey];
     }
     const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
-    if (!connection || !connection.isConnected()) {
-        throw new Error('Connection not found or not connected');
+    if (!connection) {
+        throw new Error('Connection not found');
+    }
+    // Ensure connection is active before starting log stream
+    if (!connection.isConnected()) {
+        console.log(`Connection ${connectionId} not active, attempting to connect...`);
+        try {
+            await connection.connect();
+            console.log(`Successfully connected to ${connectionId} for log streaming`);
+        }
+        catch (error) {
+            throw new Error(`Failed to connect: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
     }
     // Get process info using the multi-path fallback so pm2 is found regardless of PATH
     console.log(`Getting process info for: ${processId}`);
@@ -178,9 +196,24 @@ const getRemoteLogStream = async (io, connectionId, processId) => {
                 processName,
                 error: error.message
             });
+            // Clean up on error
+            if (activeRemoteStreams[streamKey]) {
+                delete activeRemoteStreams[streamKey];
+            }
         });
         logStream.on('close', (code) => {
             console.log(`PM2 logs stream closed for ${processName} with code:`, code);
+            // Notify clients that the stream has closed
+            io.to(streamKey).emit('remote-log-closed', {
+                connectionId,
+                processId,
+                processName,
+                code
+            });
+            // Clean up the stream reference
+            if (activeRemoteStreams[streamKey]) {
+                delete activeRemoteStreams[streamKey];
+            }
         });
         streams.combined = logStream;
     }
@@ -267,10 +300,15 @@ const setupLogStreaming = (io) => {
                 const streams = activeRemoteStreams[streamKey];
                 if (streams) {
                     console.log(`Stopping remote log streams: ${streamKey}`);
-                    if (streams.stdout && streams.stdout.kill) {
+                    // Kill the log stream properly
+                    if (streams.combined && typeof streams.combined.kill === 'function') {
+                        streams.combined.kill();
+                    }
+                    // Also handle legacy stdout/stderr streams if they exist
+                    if (streams.stdout && typeof streams.stdout.kill === 'function') {
                         streams.stdout.kill();
                     }
-                    if (streams.stderr && streams.stderr.kill) {
+                    if (streams.stderr && typeof streams.stderr.kill === 'function') {
                         streams.stderr.kill();
                     }
                     delete activeRemoteStreams[streamKey];

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.js

@@ -96,14 +96,14 @@ router.post('/verify', (req, res) => {
     const config = loadAuthConfig();
     if (!config) {
         // No password set — treat as unlocked
-        return res.json({ success: true });
+        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 });
+    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) => {
@@ -153,7 +153,7 @@ router.post('/pin/verify', (req, res) => {
     if (!match) {
         return res.status(401).json({ success: false, error: 'Incorrect PIN' });
     }
-    res.json({ success: true });
+    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) => {