ezpm2gui 1.4.0 → 1.5.0

package/dist/server/routes/updates.js

@@ -0,0 +1,135 @@
+"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 = require("express");
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+// @group Utilities : Read the current installed version from package.json
+const getCurrentVersion = () => {
+    try {
+        // Try the package root (works when run from source or dist)
+        const candidates = [
+            path_1.default.resolve(__dirname, '../../../package.json'),
+            path_1.default.resolve(__dirname, '../../package.json'),
+            path_1.default.resolve(process.cwd(), 'package.json'),
+        ];
+        for (const p of candidates) {
+            if (fs_1.default.existsSync(p)) {
+                const pkg = JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+                if (pkg.name === 'ezpm2gui')
+                    return pkg.version;
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return '0.0.0';
+};
+// @group Utilities : Fetch latest version info from npm registry (no external deps)
+const fetchNpmLatest = () => new Promise((resolve, reject) => {
+    const req = https_1.default.get('https://registry.npmjs.org/ezpm2gui/latest', { headers: { Accept: 'application/json' } }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+            var _a;
+            try {
+                const json = JSON.parse(data);
+                resolve({
+                    version: json.version,
+                    description: json.description,
+                    publishedAt: (_a = json.time) === null || _a === void 0 ? void 0 : _a.modified,
+                });
+            }
+            catch {
+                reject(new Error('Failed to parse npm registry response'));
+            }
+        });
+    });
+    req.on('error', reject);
+    req.setTimeout(8000, () => { req.destroy(); reject(new Error('npm registry request timed out')); });
+});
+// @group Utilities : Compare semver strings — returns true if b is newer than a
+const isNewer = (current, latest) => {
+    const parse = (v) => v.replace(/^v/, '').split('.').map(Number);
+    const [cMaj, cMin, cPat] = parse(current);
+    const [lMaj, lMin, lPat] = parse(latest);
+    if (lMaj !== cMaj)
+        return lMaj > cMaj;
+    if (lMin !== cMin)
+        return lMin > cMin;
+    return lPat > cPat;
+};
+const router = (0, express_1.Router)();
+// @group CheckUpdate : GET /api/update/check — returns current vs latest npm version
+router.get('/check', async (_req, res) => {
+    try {
+        const currentVersion = getCurrentVersion();
+        const { version: latestVersion, publishedAt } = await fetchNpmLatest();
+        const updateAvailable = isNewer(currentVersion, latestVersion);
+        const result = {
+            currentVersion,
+            latestVersion,
+            updateAvailable,
+            publishedAt,
+        };
+        res.json({ success: true, data: result });
+    }
+    catch (err) {
+        console.error('Update check failed:', err);
+        res.status(503).json({ success: false, error: err.message || 'Failed to reach npm registry' });
+    }
+});
+// @group InstallUpdate : POST /api/update/install — installs ezpm2gui@latest globally
+// Streams progress lines as newline-delimited JSON (ndjson) so the client can read incrementally.
+router.post('/install', (req, res) => {
+    res.setHeader('Content-Type', 'application/x-ndjson');
+    res.setHeader('Transfer-Encoding', 'chunked');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.flushHeaders();
+    const send = (type, message) => {
+        res.write(JSON.stringify({ type, message }) + '\n');
+    };
+    send('log', 'Starting update — running npm install -g ezpm2gui@latest...');
+    // Use `npm` with execFile for safety — no shell injection possible
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const child = (0, child_process_1.spawn)(npmCmd, ['install', '-g', 'ezpm2gui@latest'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: false,
+    });
+    child.stdout.on('data', (chunk) => {
+        chunk.toString().split('\n').filter(Boolean).forEach((line) => send('log', line));
+    });
+    child.stderr.on('data', (chunk) => {
+        // npm writes progress to stderr — treat as log unless it's an actual error keyword
+        const text = chunk.toString();
+        const isError = /^npm (ERR|error)/i.test(text.trim());
+        text.split('\n').filter(Boolean).forEach((line) => send(isError ? 'error' : 'log', line));
+    });
+    child.on('close', (code) => {
+        if (code === 0) {
+            send('done', 'Update installed successfully. Reload the page to use the new frontend. Restart the server to apply backend changes.');
+        }
+        else {
+            send('fail', `npm exited with code ${code}. Update may have failed.`);
+        }
+        res.end();
+    });
+    child.on('error', (err) => {
+        send('fail', `Failed to run npm: ${err.message}`);
+        res.end();
+    });
+});
+// @group RestartServer : POST /api/update/restart — graceful server restart (relies on process manager to respawn)
+router.post('/restart', (_req, res) => {
+    res.json({ success: true, message: 'Server will restart in 1 second.' });
+    setTimeout(() => {
+        console.log('[ezpm2gui] Graceful restart triggered via API.');
+        process.exit(0);
+    }, 1000);
+});
+exports.default = router;

package/dist/server/utils/remote-connection.d.ts

@@ -54,6 +54,24 @@ export declare class RemoteConnection extends EventEmitter {
      * @param forceSudo Whether to force using sudo for this specific command
      */
     executeCommand(command: string, forceSudo?: boolean): Promise<CommandResult>;
+    /**
+     * Stream a remote file directly into an HTTP response without buffering.
+     *
+     * Strategy (tried in order):
+     *   1. SFTP createReadStream  — best; handles large files, uses file-transfer protocol
+     *   2. exec `cat <file>`      — current SSH user, direct pipe to response
+     *   3. exec `sudo -S cat`     — password-based sudo (when password auth is configured)
+     *   4. exec `sudo cat`        — NOPASSWD sudo (key-based auth where sudo needs no password)
+     */
+    private static readonly SHELL_UNSAFE;
+    private static validateRemotePath;
+    streamFileToResponse(remotePath: string, res: import('express').Response, fileName: string): Promise<void>;
+    /**
+     * Stream a remote .gz file to an HTTP response, decompressing it on the fly.
+     * Uses SFTP + local zlib.createGunzip() pipeline — no server-side buffering.
+     * Falls back to exec `zcat` if SFTP is unavailable.
+     */
+    streamGzFileToResponse(remotePath: string, res: import('express').Response, fileName: string): Promise<void>;
     /**
      * Check if PM2 is installed on the remote server
      * Uses multiple detection methods for better reliability

package/dist/server/utils/remote-connection.js

@@ -171,6 +171,170 @@ class RemoteConnection extends events_1.EventEmitter {
             });
         });
     }
+    static validateRemotePath(remotePath) {
+        if (!remotePath)
+            return false;
+        if (remotePath.includes('..'))
+            return false;
+        if (RemoteConnection.SHELL_UNSAFE.test(remotePath))
+            return false;
+        if (!/\.(log|gz)$/i.test(remotePath))
+            return false;
+        return true;
+    }
+    async streamFileToResponse(remotePath, res, fileName) {
+        // Validate path before any shell interpolation (fallback methods 2-4 use exec)
+        if (!RemoteConnection.validateRemotePath(remotePath)) {
+            if (!res.headersSent)
+                res.status(400).json({ success: false, error: 'Invalid log file path' });
+            return;
+        }
+        const setHeaders = () => {
+            if (!res.headersSent) {
+                res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            }
+        };
+        const escapeRemotePathForShell = (value) => {
+            if (/[\0\n\r]/.test(value)) {
+                throw new Error('Invalid remote path');
+            }
+            return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+        };
+        let escapedRemotePath;
+        try {
+            escapedRemotePath = escapeRemotePathForShell(remotePath);
+        }
+        catch {
+            if (!res.headersSent) {
+                res.status(400).json({ success: false, error: 'Invalid remote path' });
+            }
+            return;
+        }
+        // @group StreamFileToResponse : Helper — pipe an exec channel stdout to response
+        const pipeExec = (cmd, sudoPassword) => new Promise((resolve) => {
+            this.client.exec(cmd, (err, channel) => {
+                if (err) {
+                    resolve('error');
+                    return;
+                }
+                if (sudoPassword) {
+                    channel.stdin.write(sudoPassword + '\n');
+                }
+                channel.stdin.end();
+                let hasData = false;
+                channel.on('data', (chunk) => {
+                    if (!hasData) {
+                        setHeaders();
+                        hasData = true;
+                    }
+                    res.write(chunk);
+                });
+                channel.on('close', (code) => {
+                    if (hasData) {
+                        res.end();
+                        resolve('ok');
+                    }
+                    else
+                        resolve(code === 0 ? 'empty' : 'error');
+                });
+                channel.on('error', () => resolve('error'));
+                channel.stderr.resume(); // Discard stderr so it doesn't block the channel
+            });
+        });
+        // ── 1. SFTP (preferred — real streaming, no exec overhead) ──────────
+        const sftpOk = await new Promise((resolve) => {
+            this.client.sftp((err, sftp) => {
+                if (err) {
+                    resolve(false);
+                    return;
+                }
+                const stream = sftp.createReadStream(remotePath);
+                let hasData = false;
+                stream.on('data', (chunk) => {
+                    if (!hasData) {
+                        setHeaders();
+                        hasData = true;
+                    }
+                    res.write(chunk);
+                });
+                stream.on('end', () => { if (hasData) {
+                    res.end();
+                    resolve(true);
+                }
+                else
+                    resolve(false); });
+                stream.on('error', () => resolve(false));
+            });
+        });
+        if (sftpOk)
+            return;
+        // ── 2. Plain cat ─────────────────────────────────────────────────────
+        if (await pipeExec(`cat -- ${escapedRemotePath}`) === 'ok')
+            return;
+        // ── 3. sudo -S cat (password auth) ───────────────────────────────────
+        if (this.config.password) {
+            if (await pipeExec(`sudo -S cat -- ${escapedRemotePath}`, this.config.password) === 'ok')
+                return;
+        }
+        // ── 4. sudo cat without -S (NOPASSWD / key-based auth) ───────────────
+        if (await pipeExec(`sudo cat -- ${escapedRemotePath}`) === 'ok')
+            return;
+        // All attempts failed
+        if (!res.headersSent) {
+            res.status(403).json({ success: false, error: 'Cannot read log file — check file permissions or sudo configuration' });
+        }
+    }
+    /**
+     * Stream a remote .gz file to an HTTP response, decompressing it on the fly.
+     * Uses SFTP + local zlib.createGunzip() pipeline — no server-side buffering.
+     * Falls back to exec `zcat` if SFTP is unavailable.
+     */
+    async streamGzFileToResponse(remotePath, res, fileName) {
+        if (!RemoteConnection.validateRemotePath(remotePath)) {
+            if (!res.headersSent)
+                res.status(400).json({ success: false, error: 'Invalid log file path' });
+            return;
+        }
+        const zlib = require('zlib');
+        const setHeaders = () => {
+            if (!res.headersSent) {
+                res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            }
+        };
+        // ── SFTP + local gunzip (preferred — no exec, streaming, no buffering) ──
+        const sftpOk = await new Promise((resolve) => {
+            this.client.sftp((err, sftp) => {
+                if (err) {
+                    resolve(false);
+                    return;
+                }
+                const inputStream = sftp.createReadStream(remotePath);
+                const gunzip = zlib.createGunzip();
+                setHeaders();
+                inputStream.pipe(gunzip).pipe(res);
+                gunzip.on('finish', () => resolve(true));
+                gunzip.on('error', () => { inputStream.destroy(); resolve(false); });
+                inputStream.on('error', () => resolve(false));
+            });
+        });
+        if (sftpOk)
+            return;
+        // ── Fallback: exec zcat and buffer (path already validated) ──────────
+        if (!res.headersSent) {
+            const result = await this.executeCommand(`zcat -- "${remotePath}" 2>/dev/null`);
+            const decompressed = result.stdout ||
+                (await this.executeCommand(`sudo zcat -- "${remotePath}" 2>/dev/null`)).stdout;
+            if (decompressed) {
+                setHeaders();
+                res.send(decompressed);
+            }
+            else if (!res.headersSent) {
+                res.status(500).json({ success: false, error: 'Could not decompress file' });
+            }
+        }
+    }
     /**
      * Check if PM2 is installed on the remote server
      * Uses multiple detection methods for better reliability
@@ -317,15 +481,47 @@ class RemoteConnection extends events_1.EventEmitter {
         }
         try {
             const processList = JSON.parse(cleanedOutput);
-            return processList.map((proc) => ({
-                name: proc.name,
-                pm_id: proc.pm_id,
-                status: proc.pm2_env ? proc.pm2_env.status : 'unknown',
-                cpu: proc.monit ? (proc.monit.cpu || 0).toFixed(1) : '0.0',
-                memory: proc.monit ? this.formatMemory(proc.monit.memory) : '0 B',
-                uptime: proc.pm2_env ? this.formatUptime(proc.pm2_env.pm_uptime) : 'N/A',
-                restarts: proc.pm2_env ? (proc.pm2_env.restart_time || 0) : 0
-            }));
+            // Return the full PM2 process shape (pm2_env + monit) so all frontend
+            // components work without modification when viewing a remote server.
+            return processList.map((proc) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+                return ({
+                    pid: proc.pid || 0,
+                    pm_id: proc.pm_id || 0,
+                    name: proc.name || '',
+                    monit: {
+                        cpu: proc.monit ? (proc.monit.cpu || 0) : 0,
+                        memory: proc.monit ? (proc.monit.memory || 0) : 0,
+                    },
+                    pm2_env: {
+                        // identity
+                        pm_id: proc.pm_id || 0,
+                        name: proc.name || '',
+                        namespace: ((_a = proc.pm2_env) === null || _a === void 0 ? void 0 : _a.namespace) || 'default',
+                        version: ((_b = proc.pm2_env) === null || _b === void 0 ? void 0 : _b.version) || '',
+                        versioning: ((_c = proc.pm2_env) === null || _c === void 0 ? void 0 : _c.versioning) || null,
+                        // timing
+                        pm_uptime: ((_d = proc.pm2_env) === null || _d === void 0 ? void 0 : _d.pm_uptime) || 0,
+                        created_at: ((_e = proc.pm2_env) === null || _e === void 0 ? void 0 : _e.created_at) || 0,
+                        // paths
+                        pm_cwd: ((_f = proc.pm2_env) === null || _f === void 0 ? void 0 : _f.pm_cwd) || '',
+                        pm_exec_path: ((_g = proc.pm2_env) === null || _g === void 0 ? void 0 : _g.pm_exec_path) || '',
+                        pm_out_log_path: ((_h = proc.pm2_env) === null || _h === void 0 ? void 0 : _h.pm_out_log_path) || '',
+                        pm_err_log_path: ((_j = proc.pm2_env) === null || _j === void 0 ? void 0 : _j.pm_err_log_path) || '',
+                        // runtime
+                        exec_interpreter: ((_k = proc.pm2_env) === null || _k === void 0 ? void 0 : _k.exec_interpreter) || 'node',
+                        exec_mode: ((_l = proc.pm2_env) === null || _l === void 0 ? void 0 : _l.exec_mode) || 'fork',
+                        instances: ((_m = proc.pm2_env) === null || _m === void 0 ? void 0 : _m.instances) || 1,
+                        node_args: ((_o = proc.pm2_env) === null || _o === void 0 ? void 0 : _o.node_args) || [],
+                        status: ((_p = proc.pm2_env) === null || _p === void 0 ? void 0 : _p.status) || 'unknown',
+                        restart_time: ((_q = proc.pm2_env) === null || _q === void 0 ? void 0 : _q.restart_time) || 0,
+                        unstable_restarts: ((_r = proc.pm2_env) === null || _r === void 0 ? void 0 : _r.unstable_restarts) || 0,
+                        autorestart: (_t = (_s = proc.pm2_env) === null || _s === void 0 ? void 0 : _s.autorestart) !== null && _t !== void 0 ? _t : true,
+                        watch: ((_u = proc.pm2_env) === null || _u === void 0 ? void 0 : _u.watch) || false,
+                        env: ((_v = proc.pm2_env) === null || _v === void 0 ? void 0 : _v.env) || {},
+                    },
+                });
+            });
         }
         catch (error) {
             console.error('Error parsing PM2 process list:', error);
@@ -567,6 +763,17 @@ class RemoteConnection extends events_1.EventEmitter {
     }
 }
 exports.RemoteConnection = RemoteConnection;
+/**
+ * Stream a remote file directly into an HTTP response without buffering.
+ *
+ * Strategy (tried in order):
+ *   1. SFTP createReadStream  — best; handles large files, uses file-transfer protocol
+ *   2. exec `cat <file>`      — current SSH user, direct pipe to response
+ *   3. exec `sudo -S cat`     — password-based sudo (when password auth is configured)
+ *   4. exec `sudo cat`        — NOPASSWD sudo (key-based auth where sudo needs no password)
+ */
+// @group Security : Shell metacharacter allowlist for remote file paths
+RemoteConnection.SHELL_UNSAFE = /['"`$|&;<>(){}\\\n\r\0]/;
 /**
  * Ordered list of command builders tried when resolving the pm2 binary.
  * The index of the first successful builder is cached so that subsequent

package/package.json

@@ -1,71 +1,73 @@
-{
-  "name": "ezpm2gui",
-  "version": "1.4.0",
-  "main": "dist/server/index.js",
-  "bin": {
-    "ezpm2gui": "bin/ezpm2gui.js",
-    "ezpm2gui-generate-ecosystem": "bin/generate-ecosystem.js"
-  },
-  "scripts": {
-    "start": "node dist/server/index.js",
-    "dev": "concurrently \"npm run dev:server\" \"npm run dev:client\"",
-    "dev:server": "nodemon --exec ts-node src/server/index.ts",
-    "dev:client": "cd src/client && npm start",
-    "build": "node scripts/build.js",
-    "build:server": "tsc",
-    "build:client": "cd src/client && npm run build",
-    "build:bin": "tsc --project tsconfig.bin.json",
-    "prepare": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "postinstall": "node scripts/postinstall.js"
-  },
-  "keywords": [
-    "pm2",
-    "gui",
-    "monitor",
-    "process-manager",
-    "dashboard"
-  ],
-  "author": "Chandan Bhagat",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/thechandanbhagat/ezpm2gui.git"
-  },
-  "description": "A modern web-based GUI for PM2 process manager",
-  "files": [
-    "dist/",
-    "bin/",
-    "src/client/build/",
-    "scripts/postinstall.js"
-  ],
-  "dependencies": {
-    "@tailwindcss/postcss": "^4.1.14",
-    "@types/node-cron": "^3.0.11",
-    "axios": "^1.9.0",
-    "chart.js": "^4.4.9",
-    "cron-parser": "^5.4.0",
-    "express": "^4.18.3",
-    "node-cron": "^4.2.1",
-    "pm2": "^6.0.5",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
-    "react-scripts": "^5.0.1",
-    "socket.io": "^4.8.1",
-    "ssh2": "^1.16.0",
-    "uuid": "^11.0.5"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.21",
-    "@types/node": "^22.15.17",
-    "@types/react": "^19.1.4",
-    "@types/react-dom": "^19.1.5",
-    "@types/socket.io": "^3.0.2",
-    "@types/ssh2": "^1.15.5",
-    "@types/uuid": "^10.0.0",
-    "concurrently": "^9.1.2",
-    "nodemon": "^3.1.10",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
-  }
-}
+{
+  "name": "ezpm2gui",
+  "version": "1.5.0",
+  "main": "dist/server/index.js",
+  "bin": {
+    "ezpm2gui": "bin/ezpm2gui.js",
+    "ezpm2gui-generate-ecosystem": "bin/generate-ecosystem.js"
+  },
+  "scripts": {
+    "start": "node dist/server/index.js",
+    "dev": "concurrently --kill-others-on-fail --names \"server,client\" --prefix-colors \"cyan,green\" \"npm run dev:server\" \"npm run dev:client\"",
+    "dev:server": "nodemon --exec ts-node src/server/index.ts",
+    "dev:client": "cd src/client && npm run dev",
+    "build": "node scripts/build.js",
+    "build:server": "tsc",
+    "build:client": "cd src/client && npm run build",
+    "build:bin": "tsc --project tsconfig.bin.json",
+    "prepare": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "pm2",
+    "gui",
+    "monitor",
+    "process-manager",
+    "dashboard"
+  ],
+  "author": "Chandan Bhagat",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thechandanbhagat/ezpm2gui.git"
+  },
+  "description": "A modern web-based GUI for PM2 process manager",
+  "files": [
+    "dist/",
+    "bin/",
+    "src/client/build/",
+    "scripts/postinstall.js"
+  ],
+  "dependencies": {
+    "@tailwindcss/postcss": "^4.1.14",
+    "@types/node-cron": "^3.0.11",
+    "axios": "^1.9.0",
+    "dotenv": "^16.5.0",
+    "chart.js": "^4.4.9",
+    "cron-parser": "^5.4.0",
+    "express": "^4.18.3",
+    "node-cron": "^4.2.1",
+    "pm2": "^6.0.5",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-scripts": "^5.0.1",
+    "socket.io": "^4.8.1",
+    "ssh2": "^1.16.0",
+    "uuid": "^11.0.5"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.15.17",
+    "@types/react": "^19.1.4",
+    "@types/react-dom": "^19.1.5",
+    "@types/socket.io": "^3.0.2",
+    "@types/ssh2": "^1.15.5",
+    "@types/uuid": "^10.0.0",
+    "concurrently": "^9.1.2",
+    "cross-env": "^10.1.0",
+    "nodemon": "^3.1.10",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}

package/scripts/postinstall.js

@@ -1,36 +1,36 @@
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-console.log('Running postinstall script...');
-
-const isGlobalInstall = process.env.npm_config_global === 'true';
-if (isGlobalInstall) {
-  console.log('Global installation detected, skipping client dependencies.');
-  process.exit(0);
-}
-
-// Check if we're in a development environment
-const clientDir = path.join(__dirname, '..', 'src', 'client');
-const clientNodeModules = path.join(clientDir, 'node_modules');
-const packageJsonPath = path.join(clientDir, 'package.json');
-
-if (fs.existsSync(packageJsonPath) && !fs.existsSync(clientNodeModules)) {
-  console.log('Installing client dependencies...');
-  try {
-    // Change to client directory
-    process.chdir(clientDir);
-    
-    // Install dependencies
-    execSync('npm install', { stdio: 'inherit' });
-    
-    console.log('Client dependencies installed successfully.');
-  } catch (error) {
-    console.error('Error installing client dependencies:', error.message);
-    console.error('Please run "cd src/client && npm install" manually.');
-  }
-} else {
-  console.log('Client dependencies already installed or client package.json not found.');
-}
-
-console.log('Postinstall completed.');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('Running postinstall script...');
+
+const isGlobalInstall = process.env.npm_config_global === 'true';
+if (isGlobalInstall) {
+  console.log('Global installation detected, skipping client dependencies.');
+  process.exit(0);
+}
+
+// Check if we're in a development environment
+const clientDir = path.join(__dirname, '..', 'src', 'client');
+const clientNodeModules = path.join(clientDir, 'node_modules');
+const packageJsonPath = path.join(clientDir, 'package.json');
+
+if (fs.existsSync(packageJsonPath) && !fs.existsSync(clientNodeModules)) {
+  console.log('Installing client dependencies...');
+  try {
+    // Change to client directory
+    process.chdir(clientDir);
+    
+    // Install dependencies
+    execSync('npm install', { stdio: 'inherit' });
+    
+    console.log('Client dependencies installed successfully.');
+  } catch (error) {
+    console.error('Error installing client dependencies:', error.message);
+    console.error('Please run "cd src/client && npm install" manually.');
+  }
+} else {
+  console.log('Client dependencies already installed or client package.json not found.');
+}
+
+console.log('Postinstall completed.');

package/src/client/build/asset-manifest.json

@@ -1,13 +1,13 @@
 {
   "files": {
-    "main.css": "/static/css/main.c506cba5.css",
-    "main.js": "/static/js/main.5278cddd.js",
+    "main.css": "/static/css/main.2d095544.css",
+    "main.js": "/static/js/main.17e17668.js",
     "index.html": "/index.html",
-    "main.c506cba5.css.map": "/static/css/main.c506cba5.css.map",
-    "main.5278cddd.js.map": "/static/js/main.5278cddd.js.map"
+    "main.2d095544.css.map": "/static/css/main.2d095544.css.map",
+    "main.17e17668.js.map": "/static/js/main.17e17668.js.map"
   },
   "entrypoints": [
-    "static/css/main.c506cba5.css",
-    "static/js/main.5278cddd.js"
+    "static/css/main.2d095544.css",
+    "static/js/main.17e17668.js"
   ]
 }

package/src/client/build/favicon.ico

@@ -1,2 +1,2 @@
-<!-- Simple favicon content - binary content approximated with HTML comment -->
-<!-- This is a placeholder and should be replaced with a proper ICO file -->
+<!-- Simple favicon content - binary content approximated with HTML comment -->
+<!-- This is a placeholder and should be replaced with a proper ICO file -->