ysk-omni 1.0.0

package/dist/services/pm2.service.js

@@ -0,0 +1,789 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM2_APP_NAME = exports.pm2Service = exports.Pm2Service = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const env_1 = require("../config/env");
+const process_mgr_1 = require("../cli/lib/process-mgr");
+const paths_1 = require("../cli/lib/paths");
+const paths_2 = require("../cli/lib/paths");
+const env_file_1 = require("../cli/lib/env-file");
+const pm2_config_1 = require("./pm2-config");
+const exception_factory_1 = require("../exceptions/exception.factory");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function omniPidFile() {
+    const home = process.env.OMNI_HOME?.trim() || (0, paths_1.getDefaultHome)();
+    const candidates = [
+        node_path_1.default.join(process.cwd(), 'ysk-omni.pid'),
+        node_path_1.default.join((0, pm2_config_1.packageRoot)(), 'ysk-omni.pid'),
+        node_path_1.default.join(home, 'ysk-omni.pid'),
+    ];
+    for (const f of candidates) {
+        if (node_fs_1.default.existsSync(f))
+            return f;
+    }
+    return candidates[0];
+}
+async function whichPm2() {
+    try {
+        const { stdout } = await execFileAsync('which', ['pm2'], {
+            timeout: 5000,
+            env: process.env,
+        });
+        const p = stdout.trim();
+        return p || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function runPm2(args) {
+    const bin = await whichPm2();
+    if (!bin) {
+        throw new Error('pm2 not found on PATH. Install: npm i -g pm2');
+    }
+    try {
+        const { stdout, stderr } = await execFileAsync(bin, args, {
+            timeout: 60_000,
+            maxBuffer: 5 * 1024 * 1024,
+            env: process.env,
+            cwd: (0, pm2_config_1.packageRoot)(),
+        });
+        return { stdout: stdout || '', stderr: stderr || '' };
+    }
+    catch (e) {
+        const err = e;
+        const msg = [err.stderr, err.stdout, err.message].filter(Boolean).join('\n');
+        throw new Error(msg || 'pm2 command failed');
+    }
+}
+/** Auto-trim when a log file exceeds this size (default 5 MiB). */
+const LOG_MAX_BYTES = 5 * 1024 * 1024;
+/** After auto-trim, keep the last N bytes. */
+const LOG_KEEP_BYTES = 512 * 1024;
+function resolveLogPath(file) {
+    if (node_path_1.default.isAbsolute(file))
+        return file;
+    return node_path_1.default.join((0, pm2_config_1.packageRoot)(), file);
+}
+function managedLogPaths() {
+    const root = (0, pm2_config_1.packageRoot)();
+    const cfg = (0, pm2_config_1.readPm2Config)();
+    const list = [
+        {
+            label: node_path_1.default.basename(cfg.error_file || 'pm2-error.log'),
+            path: resolveLogPath(cfg.error_file || 'logs/pm2-error.log'),
+        },
+        {
+            label: node_path_1.default.basename(cfg.out_file || 'pm2-out.log'),
+            path: resolveLogPath(cfg.out_file || 'logs/pm2-out.log'),
+        },
+        { label: 'ysk-omni.err.log', path: node_path_1.default.join(root, 'logs', 'ysk-omni.err.log') },
+        { label: 'ysk-omni.out.log', path: node_path_1.default.join(root, 'logs', 'ysk-omni.out.log') },
+    ];
+    // de-dupe by absolute path
+    const seen = new Set();
+    return list.filter((x) => {
+        if (seen.has(x.path))
+            return false;
+        seen.add(x.path);
+        return true;
+    });
+}
+/**
+ * If file is larger than LOG_MAX_BYTES, keep only the tail (LOG_KEEP_BYTES).
+ * Returns bytes removed (0 if no trim).
+ */
+function autoTrimLogFile(filePath) {
+    try {
+        if (!node_fs_1.default.existsSync(filePath))
+            return 0;
+        const st = node_fs_1.default.statSync(filePath);
+        if (st.size <= LOG_MAX_BYTES)
+            return 0;
+        const fd = node_fs_1.default.openSync(filePath, 'r');
+        try {
+            const keep = Math.min(LOG_KEEP_BYTES, st.size);
+            const start = st.size - keep;
+            const buf = Buffer.alloc(keep);
+            node_fs_1.default.readSync(fd, buf, 0, keep, start);
+            // Prefer starting at a newline so we don't keep a partial line
+            let slice = buf;
+            const nl = buf.indexOf(0x0a);
+            if (nl > 0 && nl < buf.length - 1) {
+                slice = buf.subarray(nl + 1);
+            }
+            const header = Buffer.from(`[log auto-trimmed ${new Date().toISOString()} — kept last ~${Math.round(slice.length / 1024)}KB of ${Math.round(st.size / 1024)}KB]\n`, 'utf8');
+            node_fs_1.default.writeFileSync(filePath, Buffer.concat([header, slice]));
+            return st.size - (header.length + slice.length);
+        }
+        finally {
+            node_fs_1.default.closeSync(fd);
+        }
+    }
+    catch {
+        return 0;
+    }
+}
+function autoTrimAllLogs() {
+    const out = [];
+    for (const f of managedLogPaths()) {
+        const removed = autoTrimLogFile(f.path);
+        if (removed > 0)
+            out.push({ path: f.path, removed });
+    }
+    return out;
+}
+function tailErrorLog(lines = 40) {
+    const cfg = (0, pm2_config_1.readPm2Config)();
+    const errPath = resolveLogPath(cfg.error_file || 'logs/pm2-error.log');
+    try {
+        autoTrimLogFile(errPath);
+        if (!node_fs_1.default.existsSync(errPath))
+            return '';
+        const raw = node_fs_1.default.readFileSync(errPath, 'utf8');
+        return raw.split('\n').slice(-lines).join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+function detectPortHolders(port) {
+    const pids = (0, process_mgr_1.findPidsOnPort)(port);
+    const omniPid = (0, process_mgr_1.readPid)(omniPidFile());
+    const omniRunning = omniPid != null && (0, process_mgr_1.isProcessRunning)(omniPid);
+    return {
+        pids,
+        omniPid: omniRunning ? omniPid : null,
+        omniRunning,
+    };
+}
+/** Free port by stopping known ysk-omni/pm2 gateway processes only (never kill strangers). */
+async function freePortForPm2(port) {
+    const notes = [];
+    const pidFile = omniPidFile();
+    const omniPid = (0, process_mgr_1.readPid)(pidFile);
+    if (omniPid && (0, process_mgr_1.isProcessRunning)(omniPid)) {
+        await (0, process_mgr_1.killPid)(omniPid);
+        (0, process_mgr_1.clearPid)(pidFile);
+        notes.push(`stopped ysk-omni pid ${omniPid}`);
+    }
+    // Try stop/delete our PM2 app if it holds the port
+    try {
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        await runPm2(['stop', cfg.name]).catch(() => undefined);
+        notes.push(`pm2 stop ${cfg.name}`);
+    }
+    catch {
+        /* ignore */
+    }
+    const holders = (0, process_mgr_1.findPidsOnPort)(port);
+    if (holders.length) {
+        notes.push(`port ${port} still held by pid(s) ${holders.join(',')}; not killing unknown processes`);
+    }
+    await new Promise((r) => setTimeout(r, 500));
+    return notes;
+}
+async function stopPm2App(appName) {
+    const notes = [];
+    try {
+        await runPm2(['stop', appName]);
+        notes.push(`pm2 stop ${appName}`);
+    }
+    catch {
+        /* not running */
+    }
+    try {
+        await runPm2(['delete', appName]);
+        notes.push(`pm2 delete ${appName}`);
+    }
+    catch {
+        /* not in list */
+    }
+    return notes;
+}
+class Pm2Service {
+    isEnabled() {
+        return env_1.env.PM2_ADMIN_ENABLED !== false;
+    }
+    getConfig() {
+        return (0, pm2_config_1.readPm2Config)();
+    }
+    saveConfig(input) {
+        const current = (0, pm2_config_1.readPm2Config)();
+        return (0, pm2_config_1.writePm2Config)((0, pm2_config_1.normalizePm2Config)(input, current));
+    }
+    /** Env files that may hold PORT for this install (project + ysk-omni home). */
+    envFilesForPort() {
+        const files = new Set();
+        const root = (0, pm2_config_1.packageRoot)();
+        files.add(node_path_1.default.join(root, '.env'));
+        files.add(node_path_1.default.join(process.cwd(), '.env'));
+        try {
+            const paths = (0, paths_1.resolveRuntimePaths)({
+                home: process.env.OMNI_HOME,
+            });
+            files.add(paths.envFile);
+        }
+        catch {
+            /* ignore */
+        }
+        return [...files];
+    }
+    /**
+     * Persist listen port to .env (and soft-update CORS_ORIGINS host:port).
+     * Takes effect after restart / runner switch.
+     */
+    updateListenPort(port) {
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            throw exception_factory_1.ExceptionFactory.validation('PORT must be an integer between 1 and 65535');
+        }
+        const previous = env_1.env.PORT;
+        const portStr = String(port);
+        const touched = [];
+        for (const file of this.envFilesForPort()) {
+            try {
+                const dir = node_path_1.default.dirname(file);
+                if (!node_fs_1.default.existsSync(dir))
+                    continue;
+                // Only write where a .env already exists, or package root
+                const isRootEnv = file === node_path_1.default.join((0, pm2_config_1.packageRoot)(), '.env');
+                if (!node_fs_1.default.existsSync(file) && !isRootEnv)
+                    continue;
+                const cur = (0, env_file_1.readEnvFile)(file);
+                const updates = { PORT: portStr };
+                if (cur.CORS_ORIGINS) {
+                    // Rewrite localhost/127.0.0.1 entries that used the old port
+                    updates.CORS_ORIGINS = cur.CORS_ORIGINS.replace(new RegExp(`(https?://(?:localhost|127\\.0\\.0\\.1)):${previous}\\b`, 'g'), `$1:${port}`);
+                    // If no localhost origins at all, ensure defaults exist for admin SPA
+                    if (!/localhost|127\.0\.0\.1/.test(updates.CORS_ORIGINS) &&
+                        !updates.CORS_ORIGINS.includes(`:${port}`)) {
+                        updates.CORS_ORIGINS = [
+                            updates.CORS_ORIGINS,
+                            `http://localhost:${port}`,
+                            `http://127.0.0.1:${port}`,
+                        ]
+                            .filter(Boolean)
+                            .join(',');
+                    }
+                }
+                else {
+                    updates.CORS_ORIGINS = `http://localhost:${port},http://127.0.0.1:${port}`;
+                }
+                (0, env_file_1.upsertEnvFile)(file, updates);
+                touched.push(file);
+            }
+            catch {
+                /* skip unwritable paths */
+            }
+        }
+        if (!touched.length) {
+            // Force write package root .env
+            const file = node_path_1.default.join((0, pm2_config_1.packageRoot)(), '.env');
+            (0, env_file_1.upsertEnvFile)(file, {
+                PORT: portStr,
+                CORS_ORIGINS: `http://localhost:${port},http://127.0.0.1:${port}`,
+            });
+            touched.push(file);
+        }
+        // Process-local so subsequent scheduleSwitch uses the new port in this request
+        process.env.PORT = portStr;
+        return {
+            port,
+            previous,
+            files: touched,
+            defaultPort: paths_2.DEFAULT_PORT,
+        };
+    }
+    resetConfig() {
+        const file = (0, pm2_config_1.pm2RuntimeConfigPath)();
+        try {
+            if (node_fs_1.default.existsSync(file))
+                node_fs_1.default.unlinkSync(file);
+        }
+        catch {
+            /* ignore */
+        }
+        return (0, pm2_config_1.defaultPm2Config)();
+    }
+    async status() {
+        const port = env_1.env.PORT;
+        const holders = detectPortHolders(port);
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        const appName = cfg.name;
+        const omniInfo = {
+            running: holders.omniRunning,
+            pid: holders.omniPid,
+            pidFile: omniPidFile(),
+        };
+        if (!this.isEnabled()) {
+            return {
+                enabled: false,
+                available: false,
+                message: 'PM2 admin disabled (PM2_ADMIN_ENABLED=false)',
+                messageKey: 'pm2.msgDisabled',
+                messageParams: {},
+                app: null,
+                appName,
+                port,
+                runner: this.inferRunner(null, holders),
+                omni: omniInfo,
+                config: cfg,
+                portHolders: holders,
+            };
+        }
+        const bin = await whichPm2();
+        if (!bin) {
+            return {
+                enabled: true,
+                available: false,
+                message: 'pm2 binary not found — run: npm install -g pm2',
+                messageKey: 'pm2.msgBinaryMissing',
+                messageParams: {},
+                app: null,
+                appName,
+                port,
+                runner: this.inferRunner(null, holders),
+                omni: omniInfo,
+                config: cfg,
+                portHolders: holders,
+            };
+        }
+        try {
+            const { stdout } = await runPm2(['jlist']);
+            const list = JSON.parse(stdout || '[]');
+            const app = list.find((p) => p.name === appName) ||
+                list.find((p) => String(p.name || '').includes('ysk-omni'));
+            if (!app) {
+                let messageKey = 'pm2.msgNotInList';
+                let messageParams = { app: appName };
+                let message = `App "${appName}" not in PM2 list — Start with PM2 or Switch to PM2.`;
+                if (holders.pids.length) {
+                    if (holders.omniRunning) {
+                        messageKey = 'pm2.msgPortGctoac';
+                        messageParams = {
+                            port,
+                            pid: holders.omniPid ?? 0,
+                        };
+                        message = `Port ${port} is served by ysk-omni (pid ${holders.omniPid}). Use “Switch to PM2” to hand over.`;
+                    }
+                    else {
+                        messageKey = 'pm2.msgPortBusy';
+                        messageParams = {
+                            port,
+                            pids: holders.pids.join(', '),
+                        };
+                        message = `Port ${port} is in use (pid ${holders.pids.join(', ')}).`;
+                    }
+                }
+                return {
+                    enabled: true,
+                    available: true,
+                    message,
+                    messageKey,
+                    messageParams,
+                    app: null,
+                    appName,
+                    port,
+                    runner: this.inferRunner(null, holders),
+                    omni: omniInfo,
+                    config: cfg,
+                    portHolders: holders,
+                    lastError: '',
+                };
+            }
+            const envPm2 = app.pm2_env;
+            const monit = app.monit;
+            const status = String(envPm2?.status ?? 'unknown');
+            const restarts = Number(envPm2?.restart_time ?? 0);
+            const pmPid = Number(envPm2?.pm_pid || app.pid || 0);
+            const errored = status === 'errored' || status === 'stopped';
+            let message = 'ok';
+            let messageKey = 'pm2.msgOk';
+            let messageParams = {};
+            if (status === 'errored') {
+                messageKey = 'pm2.msgErrored';
+                message =
+                    'PM2 process errored — check logs / config, then Restart or fix port conflicts.';
+            }
+            else if (status === 'online' &&
+                holders.omniRunning &&
+                holders.omniPid &&
+                holders.omniPid !== pmPid) {
+                messageKey = 'pm2.msgBothRunners';
+                messageParams = { pid: holders.omniPid };
+                message = `Both runners detected; ysk-omni pid ${holders.omniPid} also holds resources. Prefer one runner via Switch.`;
+            }
+            return {
+                enabled: true,
+                available: true,
+                message,
+                messageKey,
+                messageParams,
+                appName,
+                app: {
+                    name: app.name,
+                    pm_id: app.pm_id,
+                    pid: pmPid || null,
+                    status,
+                    restarts,
+                    uptime: envPm2?.pm_uptime ?? null,
+                    memory: monit?.memory ?? null,
+                    cpu: monit?.cpu ?? null,
+                    exec_mode: envPm2?.exec_mode ?? cfg.exec_mode,
+                    instances: envPm2?.instances ?? cfg.instances,
+                    max_memory_restart: envPm2?.max_memory_restart ?? cfg.max_memory_restart,
+                    watch: envPm2?.watch ?? cfg.watch,
+                    autorestart: envPm2?.autorestart ?? cfg.autorestart,
+                },
+                port,
+                runner: this.inferRunner({ status, pid: pmPid }, holders),
+                omni: omniInfo,
+                config: cfg,
+                portHolders: holders,
+                lastError: errored || restarts > 5 ? tailErrorLog(25) : '',
+            };
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            return {
+                enabled: true,
+                available: true,
+                message: errMsg,
+                messageKey: 'pm2.msgError',
+                messageParams: { error: errMsg },
+                app: null,
+                appName,
+                port,
+                runner: this.inferRunner(null, holders),
+                omni: omniInfo,
+                config: cfg,
+                portHolders: holders,
+                lastError: tailErrorLog(25),
+            };
+        }
+    }
+    inferRunner(pm2App, holders) {
+        const pm2Online = pm2App &&
+            (pm2App.status === 'online' || pm2App.status === 'launching') &&
+            pm2App.pid > 0;
+        if (pm2Online && !holders.omniRunning)
+            return 'pm2';
+        if (holders.omniRunning && !pm2Online)
+            return 'ysk-omni';
+        if (pm2Online && holders.omniRunning)
+            return 'unknown';
+        if (holders.pids.length > 0)
+            return 'unknown';
+        return 'none';
+    }
+    async start() {
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        const notes = await freePortForPm2(env_1.env.PORT);
+        try {
+            await runPm2(['delete', cfg.name]);
+        }
+        catch {
+            /* not running */
+        }
+        const eco = node_path_1.default.join((0, pm2_config_1.packageRoot)(), 'ecosystem.config.cjs');
+        const result = node_fs_1.default.existsSync(eco)
+            ? await runPm2(['start', eco])
+            : await runPm2([
+                'start',
+                node_path_1.default.join((0, pm2_config_1.packageRoot)(), 'dist', 'server.js'),
+                '--name',
+                cfg.name,
+            ]);
+        // Remember preference
+        (0, pm2_config_1.writePm2Config)({ ...cfg, preferred_runner: 'pm2' });
+        return {
+            ...result,
+            notes: notes.length
+                ? `Prepared port then started PM2: ${notes.join('; ')}`
+                : 'Started via PM2',
+        };
+    }
+    async stop() {
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        try {
+            return await runPm2(['stop', cfg.name]);
+        }
+        catch (e) {
+            await freePortForPm2(env_1.env.PORT);
+            throw e;
+        }
+    }
+    async restart() {
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        const notes = await freePortForPm2(env_1.env.PORT);
+        try {
+            const { stdout } = await runPm2(['jlist']);
+            const list = JSON.parse(stdout || '[]');
+            const app = list.find((p) => p.name === cfg.name);
+            if (!app) {
+                const started = await this.start();
+                return { ...started, notes: `${notes.join('; ')}; started fresh` };
+            }
+            if (app.pm2_env?.status === 'errored') {
+                await runPm2(['delete', cfg.name]);
+                const started = await this.start();
+                return {
+                    ...started,
+                    notes: `${notes.join('; ')}; deleted errored app and started`,
+                };
+            }
+        }
+        catch {
+            /* fall through */
+        }
+        const result = await runPm2(['restart', cfg.name]);
+        return {
+            ...result,
+            notes: notes.length ? notes.join('; ') : 'restarted',
+        };
+    }
+    async reload() {
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        return runPm2(['reload', cfg.name]);
+    }
+    /**
+     * Apply saved config: rewrite runtime json; if PM2 app is online, schedule
+     * a clean restart so the HTTP response can finish first.
+     */
+    async applyConfig(input, opts) {
+        const raw = { ...(input || {}) };
+        const bodyPort = opts?.port != null
+            ? Number(opts.port)
+            : raw.port != null
+                ? Number(raw.port)
+                : undefined;
+        delete raw.port;
+        delete raw.restart;
+        let portChange = null;
+        if (bodyPort != null &&
+            Number.isFinite(bodyPort) &&
+            bodyPort !== env_1.env.PORT) {
+            portChange = this.updateListenPort(bodyPort);
+        }
+        const saved = Object.keys(raw).length > 0
+            ? this.saveConfig(raw)
+            : (0, pm2_config_1.readPm2Config)();
+        const effectivePort = portChange?.port ??
+            (Number(process.env.PORT) || env_1.env.PORT || paths_2.DEFAULT_PORT);
+        const shouldRestart = opts?.restart !== false;
+        let scheduled = null;
+        if (shouldRestart) {
+            let pm2Online = false;
+            try {
+                const { stdout } = await runPm2(['jlist']);
+                const list = JSON.parse(stdout || '[]');
+                const app = list.find((p) => p.name === saved.name);
+                pm2Online = Boolean(app &&
+                    (app.pm2_env?.status === 'online' ||
+                        app.pm2_env?.status === 'launching' ||
+                        app.pm2_env?.status === 'errored'));
+            }
+            catch {
+                pm2Online = false;
+            }
+            if (pm2Online || portChange) {
+                const mode = pm2Online || saved.preferred_runner === 'pm2' ? 'pm2' : 'ysk-omni';
+                scheduled = this.scheduleSwitch(mode, {
+                    home: process.env.OMNI_HOME,
+                    port: effectivePort,
+                });
+            }
+        }
+        return {
+            config: saved,
+            applied: true,
+            restarted: Boolean(scheduled),
+            scheduled,
+            port: effectivePort,
+            portChange,
+            defaultPort: paths_2.DEFAULT_PORT,
+        };
+    }
+    /**
+     * Switch active runner. Schedules work so HTTP can respond first when
+     * the current process will be killed.
+     */
+    scheduleSwitch(mode, options) {
+        if (mode !== 'pm2' && mode !== 'ysk-omni') {
+            throw exception_factory_1.ExceptionFactory.validation('mode must be pm2 or ysk-omni');
+        }
+        const root = (0, pm2_config_1.packageRoot)();
+        const cli = node_path_1.default.join(root, 'dist', 'cli', 'index.js');
+        const home = options?.home || process.env.OMNI_HOME || '';
+        const port = options?.port || env_1.env.PORT || paths_2.DEFAULT_PORT;
+        const homeFlag = home ? ` --home ${JSON.stringify(home)}` : '';
+        const portFlag = ` --port ${port}`;
+        // Persist preference immediately
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        (0, pm2_config_1.writePm2Config)({ ...cfg, preferred_runner: mode });
+        let script;
+        if (mode === 'pm2') {
+            script = [
+                'sleep 1.5',
+                `node ${JSON.stringify(cli)} stop${homeFlag}${portFlag} || true`,
+                // stop may free ysk-omni; also stop pm2 cleanly then start
+                `node ${JSON.stringify(cli)} start --pm2${homeFlag}${portFlag} || true`,
+            ].join(' && ');
+        }
+        else {
+            script = [
+                'sleep 1.5',
+                // stop both then start detached ysk-omni
+                `node ${JSON.stringify(cli)} stop${homeFlag}${portFlag} || true`,
+                `node ${JSON.stringify(cli)} start${homeFlag}${portFlag} || true`,
+            ].join(' && ');
+        }
+        const child = (0, node_child_process_1.spawn)('bash', ['-lc', script], {
+            detached: true,
+            stdio: 'ignore',
+            env: process.env,
+            cwd: root,
+        });
+        child.unref();
+        return {
+            scheduled: true,
+            mode,
+            port: env_1.env.PORT,
+            /** Admin SPA localizes via this key — do not display English `message` raw */
+            messageKey: mode === 'pm2' ? 'pm2.msgSwitchPm2' : 'pm2.msgSwitchGctoac',
+            messageParams: { port: env_1.env.PORT },
+            // English fallback for CLI / non-i18n clients only
+            message: mode === 'pm2'
+                ? `Switching to PM2… gateway restarts under PM2 shortly (port ${env_1.env.PORT}).`
+                : `Switching to ysk-omni… gateway restarts as a detached process shortly (port ${env_1.env.PORT}).`,
+        };
+    }
+    /**
+     * Stop PM2 app if present (used by ysk-omni stop).
+     */
+    async stopPm2IfRunning() {
+        const cfg = (0, pm2_config_1.readPm2Config)();
+        return stopPm2App(cfg.name);
+    }
+    async logs(lines = 100) {
+        const n = Math.min(Math.max(lines, 10), 500);
+        const trimmed = autoTrimAllLogs();
+        const files = managedLogPaths();
+        const meta = [];
+        const chunks = [];
+        for (const f of files) {
+            let size = 0;
+            let exists = false;
+            try {
+                if (node_fs_1.default.existsSync(f.path)) {
+                    exists = true;
+                    size = node_fs_1.default.statSync(f.path).size;
+                    const raw = node_fs_1.default.readFileSync(f.path, 'utf8');
+                    const tail = raw.split('\n').slice(-n).join('\n');
+                    chunks.push(`===== ${f.label} (${Math.round(size / 1024)} KB) =====\n${tail || '(empty)'}`);
+                }
+            }
+            catch {
+                /* skip unreadable */
+            }
+            meta.push({ label: f.label, path: f.path, size, exists });
+        }
+        if (chunks.length) {
+            return {
+                stdout: chunks.join('\n\n'),
+                stderr: '',
+                files: meta,
+                autoTrimmed: trimmed,
+                maxBytes: LOG_MAX_BYTES,
+                keepBytes: LOG_KEEP_BYTES,
+            };
+        }
+        try {
+            const r = await runPm2([
+                'logs',
+                (0, pm2_config_1.readPm2Config)().name,
+                '--nostream',
+                '--lines',
+                String(n),
+            ]);
+            return {
+                ...r,
+                files: meta,
+                autoTrimmed: trimmed,
+                maxBytes: LOG_MAX_BYTES,
+                keepBytes: LOG_KEEP_BYTES,
+            };
+        }
+        catch (e) {
+            return {
+                stdout: '',
+                stderr: e instanceof Error ? e.message : String(e),
+                files: meta,
+                autoTrimmed: trimmed,
+                maxBytes: LOG_MAX_BYTES,
+                keepBytes: LOG_KEEP_BYTES,
+            };
+        }
+    }
+    /**
+     * Truncate managed log files (pm2-error/out + ysk-omni logs).
+     * Safe while process is running (open FD keeps writing from offset 0 after truncate on most Unix).
+     */
+    async clearLogs(opts) {
+        const which = opts?.which || 'all';
+        const cleared = [];
+        for (const f of managedLogPaths()) {
+            const isErr = f.label.includes('error') ||
+                f.label.includes('err') ||
+                f.path.includes('error') ||
+                f.path.includes('err');
+            const isOut = !isErr;
+            if (which === 'error' && !isErr)
+                continue;
+            if (which === 'out' && !isOut)
+                continue;
+            try {
+                let previousSize = 0;
+                if (node_fs_1.default.existsSync(f.path)) {
+                    previousSize = node_fs_1.default.statSync(f.path).size;
+                    node_fs_1.default.writeFileSync(f.path, `[log cleared ${new Date().toISOString()}]\n`, 'utf8');
+                }
+                else {
+                    node_fs_1.default.mkdirSync(node_path_1.default.dirname(f.path), { recursive: true });
+                    node_fs_1.default.writeFileSync(f.path, `[log cleared ${new Date().toISOString()}]\n`, 'utf8');
+                }
+                cleared.push({
+                    label: f.label,
+                    path: f.path,
+                    previousSize,
+                });
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return { cleared, maxBytes: LOG_MAX_BYTES };
+    }
+    async freeEverything(port) {
+        const p = port ?? env_1.env.PORT;
+        const notes = [...(await this.stopPm2IfRunning())];
+        const g = await (0, process_mgr_1.stopGateway)({ pidFile: omniPidFile(), port: p });
+        if (g.stoppedPid)
+            notes.push('stopped ysk-omni');
+        if (g.freedPort.length)
+            notes.push(`freed pids ${g.freedPort.join(',')}`);
+        return notes;
+    }
+}
+exports.Pm2Service = Pm2Service;
+exports.pm2Service = new Pm2Service();
+// re-export name for callers
+var pm2_config_2 = require("./pm2-config");
+Object.defineProperty(exports, "PM2_APP_NAME", { enumerable: true, get: function () { return pm2_config_2.PM2_APP_NAME_DEFAULT; } });
+//# sourceMappingURL=pm2.service.js.map