badmfck-api-server 5.0.3 → 5.0.6

package/dist/apiServer/deployment/Deploy.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const __1 = require("../..");
 const crypto_1 = __importDefault(require("crypto"));
+const os_1 = __importDefault(require("os"));
 const undici_1 = require("undici");
 const resolveConfig_1 = require("./resolveConfig");
 async function Deploy(opt) {
@@ -16,23 +17,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"));
@@ -69,21 +75,33 @@ async function Deploy(opt) {
         spaMode = true;
         console.log("No ./bin found — using entire ./dist contents as distribution");
     }
+    const staged = [];
     if (Array.isArray(opt.includes)) {
-        for (const inc of opt.includes) {
-            if (typeof inc !== "string" || inc.length === 0)
+        for (const raw of opt.includes) {
+            const inc = typeof raw === "string" ? { src: raw, dest: raw } : raw;
+            if (!inc || typeof inc.src !== "string" || inc.src.length === 0)
                 continue;
-            if (inc.startsWith("-")) {
-                console.warn(`Skipping include that starts with '-': ${inc}`);
+            const src = inc.src;
+            const dest = (inc.dest && inc.dest.length > 0 ? inc.dest : src).replace(/^\.\//, "");
+            if (src.startsWith("-") || dest.startsWith("-"))
+                throw new Error(`Include path must not start with '-': ${src} -> ${dest}`);
+            if (!fs_1.default.existsSync(src))
+                throw new Error(`Include source does not exist: ${src}`);
+            if (path_1.default.isAbsolute(dest) || dest.split(/[\\/]/).includes(".."))
+                throw new Error(`Include 'dest' must be a relative path inside the slot, without '..': ${dest}`);
+            if (dest === src.replace(/^\.\//, "")) {
+                items.push(src);
                 continue;
             }
-            if (!fs_1.default.existsSync(inc)) {
-                console.warn(`Include path does not exist (tar will error): ${inc}`);
-            }
-            items.push(inc);
+            staged.push({ src, dest });
         }
     }
-    if (items.length === 0 && !spaMode) {
+    for (const s of staged) {
+        const clash = items.some(i => i.replace(/^\.\//, "") === s.dest);
+        if (clash)
+            console.warn(`Include dest "${s.dest}" collides with an already-archived path — the later entry wins on extraction`);
+    }
+    if (items.length === 0 && !spaMode && staged.length === 0) {
         throw new Error("Nothing to archive (no ./bin, no ./dist/index.html, no valid includes)");
     }
     const excludes = new Set();
@@ -99,6 +117,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/);
@@ -120,6 +140,17 @@ async function Deploy(opt) {
     else {
         tarArgs.push(...items);
     }
+    let stageDir = null;
+    if (staged.length > 0) {
+        stageDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "badmfck-deploy-"));
+        for (const { src, dest } of staged) {
+            const target = path_1.default.join(stageDir, dest);
+            fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+            fs_1.default.cpSync(path_1.default.resolve(src), target, { recursive: true });
+            console.log(`Include: ${src} -> ${dest}`);
+        }
+        tarArgs.push("-C", stageDir, ".");
+    }
     if (spaMode) {
         console.log("Archiving: contents of ./dist (recursively, at archive root)");
         if (items.length > 0)
@@ -131,7 +162,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`);
@@ -143,6 +178,16 @@ async function Deploy(opt) {
             console.error(errOut);
         process.exit(typeof err.status === "number" ? err.status : 1);
     }
+    finally {
+        if (stageDir) {
+            try {
+                fs_1.default.rmSync(stageDir, { recursive: true, force: true });
+            }
+            catch (e) {
+                console.warn(`Could not remove staging dir ${stageDir}: ${e?.message ?? e}`);
+            }
+        }
+    }
     if (!fs_1.default.existsSync(path_1.default.resolve(archiveName))) {
         console.error("ARCHIVE NOT CREATED!");
         return "";

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/deployment/resolveConfig.d.ts

@@ -4,7 +4,10 @@ export interface IDeployerConfig {
     host: string;
     username: string;
     password: string;
-    includes?: string[];
+    includes?: (string | {
+        src: string;
+        dest?: string;
+    })[];
     excludes?: string[];
     switch_host?: string;
 }

package/dist/apiServer/deployment/resolveConfig.js

@@ -14,8 +14,20 @@ function validateConfig(cfg) {
         return "not an object";
     if (!cfg.name || !cfg.token || !cfg.host || !cfg.username || !cfg.password)
         return "missing one of: name, token, host, username, password";
-    if (cfg.includes && !Array.isArray(cfg.includes))
-        return "includes must be an array";
+    if (cfg.includes) {
+        if (!Array.isArray(cfg.includes))
+            return "includes must be an array";
+        for (const inc of cfg.includes) {
+            if (typeof inc === "string")
+                continue;
+            if (!inc || typeof inc !== "object")
+                return "includes entries must be a string or { src, dest? }";
+            if (typeof inc.src !== "string" || inc.src.length === 0)
+                return "includes entry is missing a non-empty 'src'";
+            if (inc.dest !== undefined && (typeof inc.dest !== "string" || inc.dest.length === 0))
+                return `includes entry "${inc.src}" has an invalid 'dest'`;
+        }
+    }
     if (cfg.excludes && !Array.isArray(cfg.excludes))
         return "excludes must be an array";
     if (cfg.switch_host && typeof cfg.switch_host !== "string")

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>;