badmfck-api-server 5.0.2 → 5.0.5

package/dist/apiServer/deployment/Deploy.js

@@ -16,23 +16,28 @@ async function Deploy(opt) {
     const archiveName = __1.UID.sha256(opt.name.replaceAll(".", "_")) + ".tar.gz";
     console.log("Changing Config to live");
     const config = path_1.default.resolve("src", "Config.ts");
-    let configSrc = fs_1.default.readFileSync(config).toString("utf-8");
-    const schemeRe = /(\bscheme\s*:\s*Scheme\s*=\s*)local\b/g;
-    let replaced = 0;
-    const updated = configSrc.replace(schemeRe, (_match, prefix) => {
-        replaced++;
-        return prefix + "live";
-    });
-    if (replaced > 0) {
-        fs_1.default.writeFileSync(config, updated);
-        console.log(`Config: switched to live (${replaced} occurrence${replaced === 1 ? "" : "s"})`);
-    }
-    else if (/\bscheme\s*:\s*Scheme\s*=\s*live\b/.test(configSrc)) {
-        console.log("Config already in live mode — nothing to change");
+    if (!fs_1.default.existsSync(config)) {
+        console.log("Config: src/Config.ts not found — skipping scheme switch");
     }
     else {
-        console.warn("Config: no 'scheme: Scheme = local|live' pattern found in " + config +
-            " — check the file was not renamed/restructured");
+        const configSrc = fs_1.default.readFileSync(config).toString("utf-8");
+        const schemeRe = /(\bscheme\s*:\s*Scheme\s*=\s*)local\b/g;
+        let replaced = 0;
+        const updated = configSrc.replace(schemeRe, (_match, prefix) => {
+            replaced++;
+            return prefix + "live";
+        });
+        if (replaced > 0) {
+            fs_1.default.writeFileSync(config, updated);
+            console.log(`Config: switched to live (${replaced} occurrence${replaced === 1 ? "" : "s"})`);
+        }
+        else if (/\bscheme\s*:\s*Scheme\s*=\s*live\b/.test(configSrc)) {
+            console.log("Config already in live mode — nothing to change");
+        }
+        else {
+            console.warn("Config: no 'scheme: Scheme = local|live' pattern found in " + config +
+                " — check the file was not renamed/restructured");
+        }
     }
     const pkgPath = path_1.default.resolve("package.json");
     const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath).toString("utf-8"));
@@ -99,6 +104,8 @@ async function Deploy(opt) {
         }
         excludes.add(trimmed);
     };
+    addExclude("._*", "built-in");
+    addExclude(".DS_Store", "built-in");
     const ignoreFile = path_1.default.resolve(".deployignore");
     if (fs_1.default.existsSync(ignoreFile)) {
         const lines = fs_1.default.readFileSync(ignoreFile, "utf-8").split(/\r?\n/);
@@ -131,7 +138,11 @@ async function Deploy(opt) {
     if (excludeArgs.length > 0)
         console.log("Excluding:", Array.from(excludes).join(", "));
     try {
-        (0, child_process_1.execFileSync)("tar", tarArgs, { encoding: "utf-8", stdio: "inherit" });
+        (0, child_process_1.execFileSync)("tar", tarArgs, {
+            encoding: "utf-8",
+            stdio: "inherit",
+            env: { ...process.env, COPYFILE_DISABLE: "1" },
+        });
     }
     catch (err) {
         console.error(`\ntar failed while creating ${archiveName}\n`);

package/dist/apiServer/deployment/Deployer.d.ts

@@ -6,4 +6,5 @@ export declare class Deployer extends BaseEndpoint {
     file(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
     switchSlot(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
     status(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
+    slot(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
 }

package/dist/apiServer/deployment/Deployer.js

@@ -41,6 +41,19 @@ class Deployer extends BaseEndpoint_1.BaseEndpoint {
                     name: "",
                     $__name_optional: true
                 }
+            },
+            {
+                ignoreInterceptor: true,
+                ignoreHttpLogging: true,
+                endpoint: "slot",
+                handler: this.slot,
+                validationModel: {
+                    name: "",
+                    token: "",
+                    slot: "",
+                    $__slot_values: ["blue", "green"],
+                    $__slot_optional: true
+                }
             }
         ]);
     }
@@ -56,5 +69,8 @@ class Deployer extends BaseEndpoint_1.BaseEndpoint {
     async status(req) {
         return await DeployerService_1.REQ_DEPLOYMENT_STATUS.request({ ...req.data, auth: req.headers.authorization });
     }
+    async slot(req) {
+        return await DeployerService_1.REQ_DEPLOYMENT_SLOT.request({ name: req.data.name, token: req.data.token, slot: req.data.slot });
+    }
 }
 exports.Deployer = Deployer;

package/dist/apiServer/deployment/DeployerService.d.ts

@@ -17,11 +17,15 @@ declare const _TSetup: {
         readonly KEY: "";
     };
     readonly $__notifier_optional: true;
+    readonly status_url: "";
+    readonly $__status_url_optional: true;
 };
 export type TDeployerSetup = ValidationModel<typeof _TSetup>;
 export interface IDeployerServiceOptions {
     projects_path: string;
     setup_path: string;
+    selfPort?: number;
+    selfBaseEndPoint?: string;
 }
 export declare const REQ_DEPLOYMENT_PROCEED: Req<{
     auth: string;
@@ -41,7 +45,14 @@ export declare const REQ_DEPLOYMENT_STATUS: Req<{
     auth?: string;
     name?: string;
 }, any>;
+export declare const REQ_DEPLOYMENT_SLOT: Req<{
+    name: string;
+    token: string;
+    slot?: "blue" | "green";
+}, any>;
 export declare class DeployerService extends BaseService {
+    private static MAX_HISTORY;
+    private static _trimHistory;
     options: IDeployerServiceOptions;
     setup: TDeployerSetup | null;
     notifier: IDeploymentNotifier | null;
@@ -117,6 +128,29 @@ export declare class DeployerService extends BaseService {
             readyToSwitch: boolean;
         }>;
     }>;
+    slotState(data: {
+        name: string;
+        token: string;
+        slot?: "blue" | "green";
+    }): Promise<{
+        error: {
+            code: number;
+            message: string;
+            httpStatus: number;
+        };
+    } | {
+        data: {
+            project: string;
+            active: "blue" | "green";
+            lastDeployed: "blue" | "green";
+            readyToSwitch: boolean;
+            slot: "blue" | "green" | null;
+            isActive: boolean | null;
+            checkedAt: number;
+        };
+    }>;
+    private _statusUrl;
+    private _writeBlueGreenFiles;
     tokensMatch(a: string | undefined, b: string | undefined): boolean;
     private _checkUserAuth;
     private static _extractPort;

package/dist/apiServer/deployment/DeployerService.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeployerService = exports.REQ_DEPLOYMENT_STATUS = exports.REQ_DEPLOYMENT_SWITCH = exports.REQ_DEPLOYMENT_PROCEED = void 0;
+exports.DeployerService = exports.REQ_DEPLOYMENT_SLOT = exports.REQ_DEPLOYMENT_STATUS = exports.REQ_DEPLOYMENT_SWITCH = exports.REQ_DEPLOYMENT_PROCEED = void 0;
 const badmfck_signal_1 = require("badmfck-signal");
 const BaseService_1 = require("../BaseService");
 const ConfigService_1 = require("./ConfigService");
@@ -16,6 +16,7 @@ const fs_1 = __importDefault(require("fs"));
 const crypto_1 = __importDefault(require("crypto"));
 const Watchdog_1 = require("./Watchdog");
 const NginxHelper_1 = require("./NginxHelper");
+const BlueGreenState_1 = require("./BlueGreenState");
 const _TSetup = {
     users: [{
             login: "",
@@ -27,12 +28,21 @@ const _TSetup = {
         URL: "",
         KEY: "",
     },
-    $__notifier_optional: true
+    $__notifier_optional: true,
+    status_url: "",
+    $__status_url_optional: true
 };
 exports.REQ_DEPLOYMENT_PROCEED = new badmfck_signal_1.Req(undefined, "REQ_DEPLOYER_SERVICE");
 exports.REQ_DEPLOYMENT_SWITCH = new badmfck_signal_1.Req(undefined, "REQ_DEPLOYER_SWITCH");
 exports.REQ_DEPLOYMENT_STATUS = new badmfck_signal_1.Req(undefined, "REQ_DEPLOYER_STATUS");
+exports.REQ_DEPLOYMENT_SLOT = new badmfck_signal_1.Req(undefined, "REQ_DEPLOYER_SLOT");
 class DeployerService extends BaseService_1.BaseService {
+    static MAX_HISTORY = 200;
+    static _trimHistory(state) {
+        const h = state.history;
+        if (Array.isArray(h) && h.length > DeployerService.MAX_HISTORY)
+            h.splice(0, h.length - DeployerService.MAX_HISTORY);
+    }
     options;
     setup = null;
     notifier = null;
@@ -65,6 +75,7 @@ class DeployerService extends BaseService_1.BaseService {
         exports.REQ_DEPLOYMENT_PROCEED.listener = async (data) => this.proceed(data);
         exports.REQ_DEPLOYMENT_SWITCH.listener = async (data) => this.switchSlot(data);
         exports.REQ_DEPLOYMENT_STATUS.listener = async (data) => this.status(data);
+        exports.REQ_DEPLOYMENT_SLOT.listener = async (data) => this.slotState(data);
     }
     async _loadSetup() {
         const setupFile = path_1.default.resolve(this.options.setup_path, "setup.json");
@@ -176,12 +187,15 @@ class DeployerService extends BaseService_1.BaseService {
                 else {
                     projectState.lastDeployed = projectState.active === "blue" ? "green" : "blue";
                 }
+                if (!projectState.statusToken)
+                    projectState.statusToken = crypto_1.default.randomBytes(32).toString("hex");
                 projectState.history.push({
                     slot: projectState.lastDeployed,
                     action: "deploy",
                     user: user.login,
                     at: Date.now()
                 });
+                DeployerService._trimHistory(projectState);
                 const subdir = projectState.lastDeployed;
                 const deployPath = path_1.default.resolve(found.destination, subdir);
                 fs_1.default.mkdirSync(deployPath, { recursive: true });
@@ -233,6 +247,9 @@ class DeployerService extends BaseService_1.BaseService {
             if (found.config) {
                 await this.applyConfig(found.destination, found.config);
             }
+            if (projectState && projectStatePath) {
+                this._writeBlueGreenFiles(data.name, projectState, path_1.default.dirname(found.destination));
+            }
             if (found.pm2) {
                 const pm2Result = await this.runPM2(found, projectState);
                 if (__1.ErrorUtils.isError(pm2Result)) {
@@ -359,6 +376,7 @@ class DeployerService extends BaseService_1.BaseService {
                 user: user.login,
                 at: Date.now(),
             });
+            DeployerService._trimHistory(projectState);
             const tmp = projectStatePath + ".tmp";
             fs_1.default.writeFileSync(tmp, JSON.stringify(projectState, null, 4), "utf-8");
             fs_1.default.renameSync(tmp, projectStatePath);
@@ -418,6 +436,64 @@ class DeployerService extends BaseService_1.BaseService {
         }
         return { data: results };
     }
+    async slotState(data) {
+        const deny = { error: { code: 53, message: "Invalid project or status token.", httpStatus: 401 } };
+        if (!data || typeof data.name !== "string" || typeof data.token !== "string" || !/^[A-Za-z0-9._-]+$/.test(data.name))
+            return deny;
+        let state = null;
+        try {
+            const statePath = path_1.default.resolve(this.options.projects_path, data.name + "_state_.json");
+            if (fs_1.default.existsSync(statePath))
+                state = JSON.parse(fs_1.default.readFileSync(statePath, "utf-8"));
+        }
+        catch {
+            state = null;
+        }
+        const tokenOk = this.tokensMatch(data.token, state?.statusToken || crypto_1.default.randomBytes(32).toString("hex"));
+        if (!state || !state.statusToken || !tokenOk)
+            return deny;
+        const slot = data.slot === "blue" || data.slot === "green" ? data.slot : null;
+        return { data: {
+                project: data.name,
+                active: state.active ?? null,
+                lastDeployed: state.lastDeployed ?? null,
+                readyToSwitch: !!(state.lastDeployed && state.lastDeployed !== state.active),
+                slot,
+                isActive: slot ? slot === state.active : null,
+                checkedAt: Date.now(),
+            } };
+    }
+    _statusUrl() {
+        const override = this.setup?.status_url;
+        if (typeof override === "string" && override.length > 0)
+            return override;
+        let base = this.options.selfBaseEndPoint ?? "/api/";
+        if (!base.startsWith("/"))
+            base = "/" + base;
+        if (!base.endsWith("/"))
+            base += "/";
+        return `http://127.0.0.1:${this.options.selfPort ?? 8080}${base}pckg/slot`;
+    }
+    _writeBlueGreenFiles(project, state, projectRoot) {
+        if (!state.statusToken)
+            return;
+        const statusUrl = this._statusUrl();
+        for (const slot of ["blue", "green"]) {
+            const dir = path_1.default.resolve(projectRoot, slot);
+            if (!fs_1.default.existsSync(dir))
+                continue;
+            const file = path_1.default.resolve(dir, BlueGreenState_1.BLUEGREEN_FILE);
+            const payload = { version: 1, project, slot, statusUrl, token: state.statusToken, writtenAt: Date.now() };
+            try {
+                const tmp = file + ".tmp";
+                fs_1.default.writeFileSync(tmp, JSON.stringify(payload, null, 2), { encoding: "utf-8", mode: 0o600 });
+                fs_1.default.renameSync(tmp, file);
+            }
+            catch (e) {
+                (0, LogService_1.logWarn)(`Cannot write ${BlueGreenState_1.BLUEGREEN_FILE} for ${project}/${slot}: ${e?.message ?? e}`);
+            }
+        }
+    }
     tokensMatch(a, b) {
         const ha = new Uint8Array(crypto_1.default.createHash("sha256").update(String(a ?? "")).digest());
         const hb = new Uint8Array(crypto_1.default.createHash("sha256").update(String(b ?? "")).digest());

package/dist/apiServer/deployment/Status.d.ts

@@ -0,0 +1,2 @@
+import { IDeployerConfig } from "./resolveConfig";
+export declare function Status(opt?: IDeployerConfig | string | null): Promise<string | null>;

package/dist/apiServer/deployment/Status.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = Status;
+const crypto_1 = __importDefault(require("crypto"));
+const __1 = require("../..");
+const resolveConfig_1 = require("./resolveConfig");
+async function Status(opt) {
+    opt = await (0, resolveConfig_1.resolveConfig)(opt);
+    let statusUrl;
+    if (/\/add\/?$/.test(opt.host))
+        statusUrl = opt.host.replace(/\/add\/?$/, "/status");
+    else if (opt.switch_host && /\/switch\/?$/.test(opt.switch_host))
+        statusUrl = opt.switch_host.replace(/\/switch\/?$/, "/status");
+    else
+        throw new Error(`Cannot derive status URL from host "${opt.host}" — make sure "host" ends with /add.`);
+    const authToken = crypto_1.default.createHash("sha256").update(opt.username + ":" + opt.password).digest("hex");
+    const response = await __1.Http.post(statusUrl, { name: opt.name }, {
+        headers: { authorization: `Bearer ${authToken}` },
+        timeoutMs: 15 * 1000,
+        retry: { enabled: false },
+    });
+    const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+    const c = (code, t) => useColor ? `\x1b[${code}m${t}\x1b[0m` : t;
+    const red = (t) => c("31", t), green = (t) => c("32", t), yellow = (t) => c("33", t);
+    const blue = (t) => c("34", t), dim = (t) => c("2", t), bold = (t) => c("1", t);
+    const slotColor = (s) => s === "blue" ? blue(bold("BLUE")) : s === "green" ? green(bold("GREEN")) : dim("—");
+    const line = dim("─".repeat(60));
+    console.log("");
+    if (!response.ok) {
+        console.error(red(bold("✗ STATUS FAILED — transport error")));
+        console.error(line);
+        console.error(`  ${dim("host:  ")} ${statusUrl}`);
+        console.error(`  ${dim("status:")} ${response.status !== undefined ? `HTTP ${response.status}` : "network error (no response)"}`);
+        if (response.error !== undefined) {
+            const t = typeof response.error === "string" ? response.error : JSON.stringify(response.error);
+            console.error(`  ${dim("error: ")} ${t.length > 400 ? t.slice(0, 400) + "…" : t}`);
+        }
+        console.error(line);
+        process.exit(1);
+    }
+    const body = response.data;
+    const appError = __1.ErrorUtils.isError(body?.error) ? body.error : __1.ErrorUtils.isError(body?.data) ? body.data : null;
+    if (appError) {
+        console.error(red(bold("✗ STATUS REJECTED BY SERVER")));
+        console.error(line);
+        console.error(`  ${dim("code:   ")} ${appError.code}`);
+        console.error(`  ${dim("message:")} ${appError.message}`);
+        console.error(line);
+        process.exit(1);
+    }
+    const entry = body?.data?.[opt.name];
+    if (!entry) {
+        console.error(red(bold(`✗ Project "${opt.name}" is not configured on the deployer`)));
+        process.exit(1);
+    }
+    const state = entry.state;
+    console.log(`${bold("●")} ${bold(opt.name)}`);
+    console.log(line);
+    if (!entry.hasBlueGreen) {
+        console.log(`  ${dim("mode:        ")} single slot ${dim("(no blue-green configured)")}`);
+    }
+    else if (!state) {
+        console.log(`  ${dim("mode:        ")} blue-green`);
+        console.log(`  ${dim("state:       ")} ${yellow("never deployed")}`);
+    }
+    else {
+        console.log(`  ${dim("active:      ")} ${slotColor(state.active)}`);
+        console.log(`  ${dim("lastDeployed:")} ${slotColor(state.lastDeployed)}`);
+        if (entry.readyToSwitch)
+            console.log(`  ${yellow("⚠ " + state.lastDeployed + " is deployed but NOT switched")} ${dim("→ badmfck activate")}`);
+        const last = Array.isArray(state.history) && state.history.length ? state.history[state.history.length - 1] : null;
+        if (last) {
+            const d = new Date(last.at);
+            const pad = (n) => String(n).padStart(2, "0");
+            const when = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+            console.log(`  ${dim("last action: ")} ${last.action} ${last.slot} ${dim("by")} ${last.user} ${dim("·")} ${when}`);
+        }
+    }
+    console.log(line);
+    console.log("");
+    return state?.active ?? null;
+}

package/dist/apiServer/deployment/cli.js

@@ -3,10 +3,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const Deploy_1 = require("./Deploy");
 const Activate_1 = require("./Activate");
+const Status_1 = require("./Status");
 function usage() {
     console.error("Usage:");
     console.error("  badmfck deploy [config.json]                 — build + upload the current project");
     console.error("  badmfck activate [config.json] [blue|green]  — switch blue-green slot (omit slot for lastDeployed)");
+    console.error("  badmfck status [config.json]                 — show active / last deployed slot");
     console.error("");
     console.error("Config path is optional (auto-discovers deploy/ folder → deploy.json when omitted).");
     console.error("Via npm, prefix args with --   e.g.  npm run deploy -- deploy/custom.json");
@@ -51,6 +53,15 @@ async function main() {
             await (0, Activate_1.Activate)(config, scheme);
             break;
         }
+        case "status": {
+            const { scheme, config } = parseArgs(rest);
+            if (scheme) {
+                console.error(`"status" does not take a slot argument ("${scheme}").`);
+                process.exit(1);
+            }
+            await (0, Status_1.Status)(config);
+            break;
+        }
         default:
             if (command)
                 console.error(`Unknown command: ${command}\n`);

package/dist/apiServer/http/Http.js

@@ -7,6 +7,7 @@ exports.Http = void 0;
 const undici_1 = require("undici");
 const node_diagnostics_channel_1 = __importDefault(require("node:diagnostics_channel"));
 const MonitorService_1 = require("../MonitorService");
+const LogService_1 = require("../LogService");
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
@@ -138,7 +139,14 @@ class Http {
         return json.length > 500 ? json.slice(0, 500) + `...(total ${json.length})` : json;
     }
     static _pushOutgoingLog(item) {
-        const entry = { id: this._nextOutgoingLogID++, ...item };
+        const entry = {
+            id: this._nextOutgoingLogID++,
+            ...item,
+            url: typeof item.url === "string" ? LogService_1.LogService.sanitize(item.url) : item.url,
+            request: typeof item.request === "string" ? LogService_1.LogService.sanitize(item.request) : LogService_1.LogService.sanitizeDeep(item.request),
+            response: typeof item.response === "string" ? LogService_1.LogService.sanitize(item.response) : LogService_1.LogService.sanitizeDeep(item.response),
+            error: typeof item.error === "string" ? LogService_1.LogService.sanitize(item.error) : item.error,
+        };
         this._outgoingLog.push(entry);
         if (this._outgoingLog.length > this._outgoingLogLimit)
             this._outgoingLog.shift();

package/dist/apiServer/monitor/LogFiles.d.ts

@@ -0,0 +1,34 @@
+export declare const LOG_SOURCES: readonly ["process-out", "process-err", "nginx-access", "nginx-error"];
+export type TLogSourceId = typeof LOG_SOURCES[number];
+export interface ILogFilesOptions {
+    processOut?: string;
+    processErr?: string;
+    nginxAccess?: string;
+    nginxError?: string;
+}
+export interface ILogTailRequest {
+    lines?: number;
+    since?: number;
+    filter?: string;
+}
+export interface ILogTailResult {
+    source: TLogSourceId;
+    path: string;
+    size: number;
+    cursor: number;
+    rotated: boolean;
+    truncated: boolean;
+    lines: string[];
+}
+export declare function listLogSources(opts?: ILogFilesOptions): Promise<{
+    id: "nginx-access" | "nginx-error" | "process-err" | "process-out";
+    label: string;
+    path: string | null;
+    configured: boolean;
+    exists: boolean;
+    readable: boolean;
+    size: number | null;
+    modifiedAt: number | null;
+    reason: string | null;
+}[]>;
+export declare function tailLog(id: TLogSourceId, opts: ILogFilesOptions | undefined, req?: ILogTailRequest): Promise<ILogTailResult>;

package/dist/apiServer/monitor/LogFiles.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_SOURCES = void 0;
+exports.listLogSources = listLogSources;
+exports.tailLog = tailLog;
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const LogService_1 = require("../LogService");
+exports.LOG_SOURCES = ["process-out", "process-err", "nginx-access", "nginx-error"];
+const LABELS = {
+    "process-out": "Process stdout (pm2 out log)",
+    "process-err": "Process stderr (pm2 error log)",
+    "nginx-access": "nginx access log",
+    "nginx-error": "nginx error log",
+};
+const MAX_WINDOW = 512 * 1024;
+const MAX_LINE = 4000;
+const MAX_LINES = 2000;
+function resolvePaths(opts) {
+    const usable = (p) => (p && p !== "/dev/null" ? p : null);
+    return {
+        "process-out": usable(opts?.processOut) ?? usable(process.env.pm_out_log_path),
+        "process-err": usable(opts?.processErr) ?? usable(process.env.pm_err_log_path),
+        "nginx-access": usable(opts?.nginxAccess),
+        "nginx-error": usable(opts?.nginxError),
+    };
+}
+const ANSI = /\x1b\[[0-9;]*[A-Za-z]/g;
+function cleanLine(raw) {
+    const line = LogService_1.LogService.sanitize(raw.replace(/\r$/, "").replace(ANSI, ""));
+    return line.length > MAX_LINE ? line.slice(0, MAX_LINE) + `…(${line.length} chars)` : line;
+}
+async function listLogSources(opts) {
+    const paths = resolvePaths(opts);
+    return Promise.all(exports.LOG_SOURCES.map(async (id) => {
+        const path = paths[id];
+        const base = { id, label: LABELS[id], path, configured: !!path, exists: false, readable: false,
+            size: null, modifiedAt: null, reason: null };
+        if (!path)
+            return { ...base, reason: id.startsWith("process") ? "not running under pm2 and no path configured" : "path not configured (options.logFiles)" };
+        try {
+            const st = await promises_1.default.stat(path);
+            base.exists = true;
+            base.size = st.size;
+            base.modifiedAt = st.mtimeMs;
+            await promises_1.default.access(path, fs_1.constants.R_OK);
+            base.readable = true;
+        }
+        catch (e) {
+            base.reason = e?.code === "ENOENT" ? "file not found"
+                : e?.code === "EACCES" ? "permission denied for the node process user"
+                    : String(e?.message ?? e);
+        }
+        return base;
+    }));
+}
+async function tailLog(id, opts, req = {}) {
+    const path = resolvePaths(opts)[id];
+    if (!path)
+        throw new Error(`log source "${id}" is not configured`);
+    const wantLines = Math.min(MAX_LINES, Math.max(1, Math.floor(req.lines ?? 200)));
+    const fh = await promises_1.default.open(path, "r");
+    try {
+        const { size } = await fh.stat();
+        const since = typeof req.since === "number" && Number.isFinite(req.since) ? Math.floor(req.since) : undefined;
+        let start;
+        let rotated = false, truncated = false, onBoundary = false;
+        if (since !== undefined && since >= 0 && since <= size) {
+            start = since;
+            onBoundary = true;
+            if (size - start > MAX_WINDOW) {
+                start = size - MAX_WINDOW;
+                truncated = true;
+                onBoundary = false;
+            }
+        }
+        else {
+            rotated = since !== undefined && since > size;
+            start = Math.max(0, size - MAX_WINDOW);
+            onBoundary = start === 0;
+        }
+        const buf = Buffer.alloc(size - start);
+        if (buf.length > 0)
+            await fh.read(buf, 0, buf.length, start);
+        const lastNl = buf.lastIndexOf(0x0a);
+        const firstNl = buf.indexOf(0x0a);
+        let begin = onBoundary ? 0 : (firstNl >= 0 ? firstNl + 1 : buf.length);
+        const end = lastNl >= 0 ? lastNl + 1 : 0;
+        if (begin > end)
+            begin = end;
+        const text = buf.subarray(begin, end).toString("utf-8");
+        let lines = text.length ? text.split("\n") : [];
+        if (lines.length && lines[lines.length - 1] === "")
+            lines.pop();
+        lines = lines.map(cleanLine);
+        const filter = typeof req.filter === "string" ? req.filter.trim().toLowerCase() : "";
+        if (filter)
+            lines = lines.filter(l => l.toLowerCase().includes(filter));
+        if (lines.length > wantLines)
+            lines = lines.slice(-wantLines);
+        return { source: id, path, size, cursor: start + end, rotated, truncated, lines };
+    }
+    finally {
+        await fh.close();
+    }
+}

package/dist/apiServer/monitor/Monitor.d.ts

@@ -34,6 +34,8 @@ export declare class Monitor extends BaseEndpoint {
     httpstats(req: HTTPRequestVO): Promise<TransferPacketVO>;
     inventory(req: HTTPRequestVO): Promise<TransferPacketVO>;
     metrics(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    logfiles(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    logtail(req: HTTPRequestVO): Promise<TransferPacketVO>;
     metricsWeeks(req: HTTPRequestVO): Promise<TransferPacketVO>;
     metricsWeek(req: HTTPRequestVO): Promise<TransferPacketVO>;
     connections(req: HTTPRequestVO): Promise<TransferPacketVO>;

package/dist/apiServer/monitor/Monitor.js

@@ -18,6 +18,7 @@ const MonitorService_1 = require("../MonitorService");
 const DBService_1 = require("../DBService");
 const SystemInfo_1 = require("./SystemInfo");
 const ProcessMonitor_1 = require("./ProcessMonitor");
+const LogFiles_1 = require("./LogFiles");
 exports.S_MONITOR_REGISTRATE_ACTION = new badmfck_signal_1.Signal();
 exports.S_MONITOR_RESTART_REQUESTED = new badmfck_signal_1.Signal();
 const logMap = {
@@ -56,6 +57,17 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
                     range: "",
                     $__range_values: ["week", "day", "hour"]
                 } },
+            { ignoreInterceptor: true, endpoint: "logfiles", handler: this.logfiles },
+            { ignoreInterceptor: true, endpoint: "logtail", handler: this.logtail, validationModel: {
+                    source: "",
+                    $__source_values: [...LogFiles_1.LOG_SOURCES],
+                    lines: 0,
+                    $__lines_optional: true,
+                    since: 0,
+                    $__since_optional: true,
+                    filter: "",
+                    $__filter_optional: true
+                } },
             { ignoreInterceptor: true, endpoint: "metricsWeeks", handler: this.metricsWeeks },
             { ignoreInterceptor: true, endpoint: "metricsWeek", handler: this.metricsWeek, validationModel: {
                     weekKey: ""
@@ -205,6 +217,27 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
         const result = await MonitorService_1.REQ_STAT.request(req.data);
         return { data: result };
     }
+    async logfiles(req) {
+        await this.checkAuthentication(req);
+        return { data: await (0, LogFiles_1.listLogSources)(this.apiServiceOptions.logFiles) };
+    }
+    async logtail(req) {
+        await this.checkAuthentication(req);
+        const num = (v) => (v === undefined || v === null || v === "" ? undefined : Number(v));
+        try {
+            return { data: await (0, LogFiles_1.tailLog)(req.data.source, this.apiServiceOptions.logFiles, {
+                    lines: num(req.data.lines),
+                    since: num(req.data.since),
+                    filter: req.data.filter,
+                }) };
+        }
+        catch (e) {
+            const details = e?.code === "ENOENT" ? "log file not found"
+                : e?.code === "EACCES" ? "permission denied: the node process user can't read this file (nginx logs are usually root:adm 0640 — add the user to the adm group or point access_log to a readable file)"
+                    : String(e?.message ?? e);
+            throw { ...DefaultErrors_1.default.BAD_REQUEST, details };
+        }
+    }
     async metricsWeeks(req) {
         await this.checkAuthentication(req);
         return { data: await MonitorService_1.REQ_STAT_WEEKS.request() };

package/dist/apiServer/monitor/index.html

@@ -463,4 +463,4 @@ const m3={background:"#a7a7a7",backgroundSelected:"#66bb6a",toggle:"#FFFFFF"},g3
 	<body>
 		<div id="root"></div>
 	</body>
-</html>
+</html>