badmfck-api-server 4.1.27 → 4.1.29

package/dist/apiServer/deployment/DeployerService.js

@@ -0,0 +1,543 @@
+"use strict";
+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;
+const badmfck_signal_1 = require("badmfck-signal");
+const BaseService_1 = require("../BaseService");
+const ConfigService_1 = require("./ConfigService");
+const path_1 = __importDefault(require("path"));
+const LogService_1 = require("../LogService");
+const __1 = require("../..");
+const Notifier_1 = require("./Notifier");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const Watchdog_1 = require("./Watchdog");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+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");
+class DeployerService extends BaseService_1.BaseService {
+    options;
+    notifier = null;
+    busy = new Map();
+    constructor(options) {
+        super("DeployerService");
+        this.options = options;
+    }
+    async init() {
+        super.init();
+        const cs = new ConfigService_1.ConfigService(this.options.projects_path);
+        await cs.init();
+        let notifier = null;
+        if (this.options.notifier) {
+            if (this.options.notifier.controller) {
+                notifier = this.options.notifier.controller;
+                notifier.init();
+            }
+            else {
+                if (this.options.notifier.URL && this.options.notifier.KEY) {
+                    notifier = new Notifier_1.Notifier({ URL: this.options.notifier.URL, KEY: this.options.notifier.KEY });
+                    await notifier.init();
+                }
+            }
+        }
+        if (this.options.watchdog) {
+            const wd = new Watchdog_1.Watchdog(notifier);
+            await wd.init();
+        }
+        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);
+    }
+    async proceed(data) {
+        const user = this._checkUserAuth(data.auth);
+        if (!user) {
+            (0, LogService_1.logError)("Deploy rejected: user auth failed");
+            return { error: { code: 20, message: "Unauthorized.", httpStatus: 401 } };
+        }
+        const configurations = await ConfigService_1.REQ_DEPLOYMENT_CONFIG.request();
+        let found;
+        for (let i of configurations.values()) {
+            if (i.name === data.name && this.tokensMatch(i.token, data.token)) {
+                found = i;
+                break;
+            }
+        }
+        if (!found) {
+            (0, LogService_1.logError)("Deploy rejected: wrong token and/or name");
+            return { error: { code: 12, message: "Wrong token and/or name.", httpStatus: 400 } };
+        }
+        if (this.busy.get(found.name))
+            return { error: { code: 13, message: "Deployment already in progress.", httpStatus: 400 } };
+        const realName = found.name;
+        this.busy.set(realName, true);
+        try {
+            found = structuredClone(found);
+            const file = data.files.file;
+            const safeName = (path_1.default.basename(file.name || "").replace(/[^a-zA-Z0-9._-]/g, "_")) || "upload";
+            let projectState = null;
+            let projectStatePath = null;
+            if (found.bluegreen && found.bluegreen.blue_config && found.bluegreen.green_config) {
+                projectStatePath = path_1.default.resolve(this.options.projects_path, data.name + "_state_.json");
+                if (fs_1.default.existsSync(projectStatePath)) {
+                    try {
+                        projectState = JSON.parse(fs_1.default.readFileSync(projectStatePath, "utf-8"));
+                    }
+                    catch (e) {
+                        (0, LogService_1.logError)("Failed to load project state: " + e.message);
+                    }
+                }
+                if (!projectState) {
+                    projectState = {
+                        active: "blue",
+                        lastDeployed: "blue",
+                        history: []
+                    };
+                }
+                else {
+                    projectState.lastDeployed = projectState.active === "blue" ? "green" : "blue";
+                }
+                projectState.history.push({
+                    slot: projectState.lastDeployed,
+                    action: "deploy",
+                    user: user.login,
+                    at: Date.now()
+                });
+                const subdir = projectState.lastDeployed;
+                const deployPath = path_1.default.resolve(found.destination, subdir);
+                fs_1.default.mkdirSync(deployPath, { recursive: true });
+                found.destination = deployPath;
+                if (projectState && found.bluegreen) {
+                    if (projectState.lastDeployed === "blue" && found.bluegreen.blue_config) {
+                        found.config = found.bluegreen.blue_config;
+                    }
+                    else if (projectState.lastDeployed === "green" && found.bluegreen.green_config) {
+                        found.config = found.bluegreen.green_config;
+                    }
+                }
+                found.name = data.name + "-" + projectState.lastDeployed;
+            }
+            const uploadPath = path_1.default.resolve(found.destination, __1.UID.generate() + "_" + safeName);
+            const result = await this.upload(file, uploadPath);
+            if (__1.ErrorUtils.isError(result)) {
+                if (found.email && found.email.length > 0) {
+                    for (let email of found.email) {
+                        this.notifier?.notifyEmailStatus(email, "error-copy", found.name, user.login);
+                    }
+                }
+                throw result;
+            }
+            if (found.backup) {
+                console.log("TODO: backup");
+            }
+            if (found.unpack) {
+                const unpackResult = await this.unpack(found.destination, uploadPath, found.install, found.ignoreDirectoryClean);
+                if (__1.ErrorUtils.isError(unpackResult)) {
+                    if (found.email && found.email.length > 0) {
+                        for (let email of found.email) {
+                            this.notifier?.notifyEmailStatus(email, "error-unpack", found.name, user.login);
+                        }
+                    }
+                    throw unpackResult;
+                }
+            }
+            if (found.chmod && found.chmod > 1) {
+                try {
+                    console.log("Try to execute: ", `chmod -R ${found.chmod} ${found.destination}`);
+                    (0, child_process_1.execFileSync)("chmod", ["-R", String(found.chmod), found.destination]);
+                }
+                catch (e) {
+                    (0, LogService_1.logError)("Can't execute chmod", e);
+                }
+            }
+            if (found.config) {
+                await this.applyConfig(found.destination, found.config);
+            }
+            if (found.pm2) {
+                const pm2Result = await this.runPM2(found, projectState);
+                if (__1.ErrorUtils.isError(pm2Result)) {
+                    if (found.email && found.email.length > 0) {
+                        for (let email of found.email) {
+                            this.notifier?.notifyEmailStatus(email, "error-pm2", found.name, user.login);
+                        }
+                    }
+                    throw pm2Result;
+                }
+            }
+            if (projectState && projectStatePath) {
+                const tmp = projectStatePath + ".tmp";
+                fs_1.default.writeFileSync(tmp, JSON.stringify(projectState, null, 4), "utf-8");
+                fs_1.default.renameSync(tmp, projectStatePath);
+            }
+            if (found.email && found.email.length > 0) {
+                for (let email of found.email) {
+                    this.notifier?.notifyEmailStatus(email, "done", found.name, user.login);
+                }
+            }
+            if (found.phone && found.phone.length > 0) {
+                for (let p of found.phone) {
+                    this.notifier?.notifySMSStatus(p, found.name + " deployment done", user.login);
+                }
+            }
+            if (found.liveness) {
+                const conf = found;
+                const liveness = found.liveness;
+                setTimeout(async () => {
+                    const result = await __1.Http.get(liveness);
+                    if (!result.ok) {
+                        (0, LogService_1.logError)("Liveness check failed for", conf.name);
+                        if (conf.email && conf.email.length > 0) {
+                            for (let email of conf.email) {
+                                this.notifier?.notifyEmailStatus(email, "error-liveness", conf.name, user.login);
+                            }
+                        }
+                    }
+                }, 5000);
+            }
+            return { data: true };
+        }
+        finally {
+            this.busy.set(realName, false);
+        }
+    }
+    async switchSlot(data) {
+        const user = this._checkUserAuth(data.auth);
+        if (!user) {
+            (0, LogService_1.logError)("Switch rejected: user auth failed");
+            return { error: { code: 40, message: "Unauthorized.", httpStatus: 401 } };
+        }
+        const configurations = await ConfigService_1.REQ_DEPLOYMENT_CONFIG.request();
+        let found;
+        for (const i of configurations.values()) {
+            if (i.name === data.name && this.tokensMatch(i.token, data.token)) {
+                found = i;
+                break;
+            }
+        }
+        if (!found) {
+            (0, LogService_1.logError)("Switch rejected: wrong token and/or name");
+            return { error: { code: 41, message: "Wrong token and/or name.", httpStatus: 400 } };
+        }
+        if (!found.bluegreen || !found.bluegreen.blue_config || !found.bluegreen.green_config) {
+            return { error: { code: 42, message: "Project has no blue-green configuration.", httpStatus: 400 } };
+        }
+        if (this.busy.get(found.name)) {
+            return { error: { code: 43, message: "Deployment in progress, try again shortly.", httpStatus: 409 } };
+        }
+        const realName = found.name;
+        this.busy.set(realName, true);
+        try {
+            const projectStatePath = path_1.default.resolve(this.options.projects_path, data.name + "_state_.json");
+            if (!fs_1.default.existsSync(projectStatePath)) {
+                return { error: { code: 44, message: "Project has never been deployed.", httpStatus: 400 } };
+            }
+            let projectState;
+            try {
+                projectState = JSON.parse(fs_1.default.readFileSync(projectStatePath, "utf-8"));
+            }
+            catch (e) {
+                return { error: { code: 45, message: "Corrupt state file: " + e.message, httpStatus: 500 } };
+            }
+            const target = data.scheme ?? projectState.lastDeployed;
+            if (target !== "blue" && target !== "green") {
+                return { error: { code: 46, message: "Invalid target slot.", httpStatus: 400 } };
+            }
+            if (target === projectState.active) {
+                return { error: { code: 47, message: `Slot '${target}' is already active.`, httpStatus: 400 } };
+            }
+            const previousActive = projectState.active;
+            const action = target === projectState.lastDeployed ? "switch" : "rollback";
+            projectState.active = target;
+            projectState.history.push({
+                slot: target,
+                action,
+                user: user.login,
+                at: Date.now(),
+            });
+            const tmp = projectStatePath + ".tmp";
+            fs_1.default.writeFileSync(tmp, JSON.stringify(projectState, null, 4), "utf-8");
+            fs_1.default.renameSync(tmp, projectStatePath);
+            let hookError = null;
+            const rawHook = found.bluegreen.on_switch;
+            if (Array.isArray(rawHook)) {
+                const cmd = rawHook.filter(s => typeof s === "string" && s.length > 0);
+                if (cmd.length > 0) {
+                    if (!path_1.default.isAbsolute(cmd[0])) {
+                        hookError = "on_switch command must be an absolute path, got: " + cmd[0];
+                        (0, LogService_1.logError)(hookError);
+                    }
+                    else {
+                        try {
+                            const result = await execFileAsync(cmd[0], cmd.slice(1), {
+                                timeout: 30_000,
+                                maxBuffer: 4 * 1024 * 1024,
+                                env: { PATH: process.env.PATH ?? "/usr/bin:/bin" },
+                            });
+                            if (result.stderr)
+                                (0, LogService_1.logWarn)("on_switch stderr:", result.stderr);
+                        }
+                        catch (e) {
+                            hookError = String(e?.stderr || e?.message || e);
+                            (0, LogService_1.logError)("on_switch hook failed:", hookError);
+                        }
+                    }
+                }
+            }
+            const status = hookError ? "switch-hook-failed" : action === "rollback" ? `rolled-back-to-${target}` : `switched-to-${target}`;
+            if (found.email && found.email.length > 0) {
+                for (const email of found.email) {
+                    this.notifier?.notifyEmailStatus(email, status, found.name, user.login);
+                }
+            }
+            if (found.phone && found.phone.length > 0) {
+                for (const p of found.phone) {
+                    this.notifier?.notifySMSStatus(p, `${found.name} ${action} to ${target}`, user.login);
+                }
+            }
+            return { data: { active: projectState.active, previousActive, action, hookError } };
+        }
+        finally {
+            this.busy.set(realName, false);
+        }
+    }
+    async status(data) {
+        const user = this._checkUserAuth(data.auth);
+        if (!user) {
+            return { error: { code: 50, message: "Unauthorized.", httpStatus: 401 } };
+        }
+        const configurations = await ConfigService_1.REQ_DEPLOYMENT_CONFIG.request();
+        const results = {};
+        for (const cfg of configurations.values()) {
+            if (data.name && cfg.name !== data.name)
+                continue;
+            const statePath = path_1.default.resolve(this.options.projects_path, cfg.name + "_state_.json");
+            let state = null;
+            if (fs_1.default.existsSync(statePath)) {
+                try {
+                    state = JSON.parse(fs_1.default.readFileSync(statePath, "utf-8"));
+                }
+                catch { }
+            }
+            results[cfg.name] = {
+                hasBlueGreen: !!(cfg.bluegreen && cfg.bluegreen.blue_config && cfg.bluegreen.green_config),
+                state,
+                readyToSwitch: !!(state && state.lastDeployed !== state.active),
+            };
+        }
+        return { data: results };
+    }
+    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());
+        return crypto_1.default.timingSafeEqual(ha, hb);
+    }
+    _checkUserAuth(authHeader) {
+        if (!authHeader)
+            return null;
+        const token = authHeader.split(" ").pop() ?? "";
+        if (!token)
+            return null;
+        if (!this.options.users || this.options.users.length === 0)
+            return null;
+        let matched = null;
+        for (const user of this.options.users) {
+            const expected = crypto_1.default.createHash("sha256").update(user.login + ":" + user.password).digest("hex");
+            if (this.tokensMatch(token, expected))
+                matched = user;
+        }
+        return matched;
+    }
+    async runPM2(found, projectState) {
+        let pm2attrs = projectState?.lastDeployed === "blue" ? found.bluegreen?.blue_pm2_attributes : found.bluegreen?.green_pm2_attributes;
+        const pm2Attrs = Array.isArray(pm2attrs) ? pm2attrs.filter(s => typeof s === "string" && s.length > 0) : found.pm2_attributes;
+        return new Promise((resolve) => {
+            try {
+                (0, child_process_1.execFileSync)("pm2", ["--version"]);
+                const extra = Array.isArray(pm2Attrs)
+                    ? pm2Attrs.filter(s => typeof s === "string" && s.length > 0)
+                    : [];
+                const ecoJs = path_1.default.resolve(found.destination, "ecosystem.config.js");
+                const ecoCjs = path_1.default.resolve(found.destination, "ecosystem.config.cjs");
+                const ecosystem = fs_1.default.existsSync(ecoJs) ? ecoJs
+                    : fs_1.default.existsSync(ecoCjs) ? ecoCjs
+                        : null;
+                if (ecosystem) {
+                    (0, child_process_1.execFileSync)("pm2", ["startOrReload", ecosystem, "--update-env", ...extra]);
+                    resolve(null);
+                    return;
+                }
+                const list = (0, child_process_1.execFileSync)("pm2", ["list"]).toString();
+                let running = false;
+                for (let l of list.split("\n")) {
+                    if (l.indexOf(found.name) !== -1) {
+                        running = true;
+                        break;
+                    }
+                }
+                const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(found.destination, "package.json")).toString());
+                let main = packageJson.main || "index.js";
+                if (main.startsWith("./"))
+                    main = main.substring(2);
+                if (!found.destination.endsWith("/"))
+                    main = "/" + main;
+                if (running) {
+                    try {
+                        (0, child_process_1.execFileSync)("pm2", ["delete", found.name]);
+                    }
+                    catch { }
+                }
+                (0, child_process_1.execFileSync)("pm2", ["start", found.destination + main, "--name", found.name, ...extra]);
+                resolve(null);
+            }
+            catch (e) {
+                resolve({ code: 18, message: "Can't run pm2", details: "" + e, httpStatus: 500 });
+            }
+        });
+    }
+    static SKIP_DIRS = new Set(["node_modules", ".git", "__tmp"]);
+    static TEMPLATE_EXTENSIONS = [".js", ".ts", ".json", ".env"];
+    async applyConfig(dir, config) {
+        if (Object.keys(config).length < 1)
+            return;
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                if (DeployerService.SKIP_DIRS.has(entry.name))
+                    continue;
+                const fullPath = path_1.default.join(dir, entry.name);
+                await this.applyConfig(fullPath, config);
+                continue;
+            }
+            if (entry.isFile()) {
+                const fullPath = path_1.default.join(dir, entry.name);
+                const lower = fullPath.toLowerCase();
+                if (DeployerService.TEMPLATE_EXTENSIONS.some(ext => lower.endsWith(ext)))
+                    await this.processFile(fullPath, config);
+            }
+        }
+    }
+    async processFile(filePath, config) {
+        let content = fs_1.default.readFileSync(filePath, "utf-8");
+        let hash = crypto_1.default.createHash("md5").update(content).digest("hex");
+        for (const [key, value] of Object.entries(config)) {
+            content = content.replaceAll(`_{{${key}}}_`, value);
+        }
+        let hash2 = crypto_1.default.createHash("md5").update(content).digest("hex");
+        if (hash !== hash2) {
+            console.log("Values was changed in " + filePath);
+            fs_1.default.writeFileSync(filePath, content, "utf-8");
+        }
+        const leftover = content.match(/_\{\{[A-Za-z0-9_]+\}\}_/g);
+        if (leftover && leftover.length > 0) {
+            const unique = [...new Set(leftover)];
+            (0, LogService_1.logWarn)("Unresolved template placeholders in " + filePath + ": " + unique.join(", "));
+        }
+    }
+    _isDestinationSafe(destination) {
+        try {
+            const dest = path_1.default.resolve(destination);
+            const root = path_1.default.resolve(this.options.projects_path);
+            if (!path_1.default.isAbsolute(dest))
+                return false;
+            if (dest.length < 5 || dest === "/")
+                return false;
+            if (dest === root)
+                return false;
+            if (!dest.startsWith(root + path_1.default.sep))
+                return false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async unpack(destination, uploadedFile, install, ignoreDirectoryClean) {
+        return new Promise((resolve) => {
+            if (!this._isDestinationSafe(destination)) {
+                (0, LogService_1.logError)("Refusing to unpack: destination outside projects_path", destination);
+                resolve({ code: 19, message: "Destination outside projects root", httpStatus: 500 });
+                return;
+            }
+            try {
+                const tmp = path_1.default.resolve(destination, "__tmp");
+                if (fs_1.default.existsSync(tmp))
+                    fs_1.default.rmSync(tmp, { recursive: true });
+                if (!fs_1.default.existsSync(tmp))
+                    fs_1.default.mkdirSync(tmp, { recursive: true });
+                (0, child_process_1.execFileSync)("tar", ["--no-absolute-names", "-xzf", uploadedFile, "-C", tmp]);
+            }
+            catch (e) {
+                (0, LogService_1.logError)(e);
+                try {
+                    fs_1.default.rmSync(path_1.default.resolve(uploadedFile));
+                }
+                catch (e) { }
+                resolve({ code: 14, message: "Can't unpack file", httpStatus: 500 });
+                return;
+            }
+            try {
+                fs_1.default.rmSync(path_1.default.resolve(uploadedFile));
+            }
+            catch (e) {
+                (0, LogService_1.logError)("Can't remove file", e);
+            }
+            if (install) {
+                try {
+                    (0, child_process_1.execFileSync)("npm", ["--prefix", path_1.default.resolve(destination, "__tmp"), "i", "--ignore-scripts"]);
+                }
+                catch (e) {
+                    console.error(e);
+                    (0, LogService_1.logError)(e);
+                    resolve({ code: 17, message: "Can't install", httpStatus: 500 });
+                    return;
+                }
+            }
+            if (!ignoreDirectoryClean) {
+                fs_1.default.readdirSync(destination).forEach((file) => {
+                    if (file === "__tmp")
+                        return;
+                    try {
+                        fs_1.default.rmSync(path_1.default.resolve(destination, file), { recursive: true });
+                    }
+                    catch (e) {
+                        (0, LogService_1.logError)(e);
+                    }
+                });
+            }
+            try {
+                (0, child_process_1.execFileSync)("cp", ["-rf", path_1.default.resolve(destination, "__tmp") + "/.", destination]);
+            }
+            catch (e) {
+                (0, LogService_1.logError)(e);
+                resolve({ code: 15, message: "Can't copy files", httpStatus: 500 });
+                return;
+            }
+            try {
+                fs_1.default.rmSync(path_1.default.resolve(destination, "__tmp"), { recursive: true });
+            }
+            catch (e) {
+                (0, LogService_1.logError)(e);
+                resolve({ code: 16, message: "Can't remove tmp", httpStatus: 500 });
+            }
+            resolve(null);
+        });
+    }
+    async upload(file, uploadPath) {
+        return new Promise((resolve) => {
+            file.mv(uploadPath, (err) => {
+                if (err) {
+                    resolve({ code: 13, message: "Can't upload file", httpStatus: 500, details: err });
+                    return;
+                }
+                resolve(null);
+            });
+        });
+    }
+}
+exports.DeployerService = DeployerService;

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

@@ -0,0 +1,2 @@
+export declare class NginxHelper {
+}

package/dist/apiServer/deployment/NginxHelper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NginxHelper = void 0;
+const default_conf = `
+ server {
+        server_name  paypartner.eu www.paypartner.eu apgp.paypartner.eu;
+        root         /var/www/apgp.paypartner.eu;
+        index index.html;
+
+        location /api {
+            include /etc/nginx/proxy_common.conf;
+            proxy_set_header X-Branch paypartner;
+            #paysolo api, 8096 to paypartner api
+            # 8065 -new paysolo
+            # 8095 - old paysolo
+            proxy_pass http://127.0.0.1:8065; 
+        }
+
+
+        location / {
+            try_files $uri $uri/ /index.html;
+        }
+    
+        listen 443 ssl; # managed by Certbot
+        #ssl_certificate /etc/letsencrypt/live/apgp.paypartner.eu/fullchain.pem; # managed by Certbot
+        #ssl_certificate_key /etc/letsencrypt/live/apgp.paypartner.eu/privkey.pem; # managed by Certbot
+
+        ssl_certificate /etc/letsencrypt/live/paypartner.eu/fullchain.pem;
+        ssl_certificate_key /etc/letsencrypt/live/paypartner.eu/privkey.pem;
+
+        include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
+        ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
+    }
+`;
+class NginxHelper {
+}
+exports.NginxHelper = NginxHelper;

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

@@ -0,0 +1,16 @@
+import { BaseService } from '../BaseService';
+export interface IDeploymentNotifier extends BaseService {
+    notifyEmailStatus(email: string, status: string, project: string, user: string): Promise<void>;
+    notifySMSStatus(phone: string, text: string, user: string): Promise<void>;
+}
+export declare class Notifier extends BaseService implements IDeploymentNotifier {
+    SMS_URL: string;
+    SMS_KEY: string;
+    constructor({ URL, KEY }: {
+        URL: string;
+        KEY: string;
+    });
+    init(): Promise<void>;
+    notifyEmailStatus(email: string, status: string, project: string, user: string): Promise<void>;
+    notifySMSStatus(phone: string, text: string, user: string): Promise<void>;
+}

package/dist/apiServer/deployment/Notifier.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notifier = void 0;
+const crypto_1 = require("crypto");
+const BaseService_1 = require("../BaseService");
+const __1 = require("../..");
+class Notifier extends BaseService_1.BaseService {
+    SMS_URL;
+    SMS_KEY;
+    constructor({ URL, KEY }) {
+        super("Notifier");
+        this.SMS_URL = URL;
+        this.SMS_KEY = KEY;
+    }
+    async init() {
+        super.init();
+    }
+    async notifyEmailStatus(email, status, project, user) {
+        const text = `${project} deployment <b>${status}</b> by <b>${user}</b> ${new Date().toISOString()}`;
+        const title = `Deployment: ${project} - ${status} (${user})`;
+        const token = (0, crypto_1.createHash)("sha256").update(this.SMS_KEY + email + title + text).digest("base64");
+        let response = null;
+        try {
+            response = await __1.Http.post(this.SMS_URL + "/api/mail/send", {
+                to: email,
+                text: title,
+                html: text
+            }, {
+                headers: {
+                    "authorization": token,
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    async notifySMSStatus(phone, text, user) {
+        const finalText = `${text} (by ${user})`;
+        const token = (0, crypto_1.createHash)("sha256").update(this.SMS_KEY + phone + finalText + "").digest("base64");
+        let response = null;
+        try {
+            response = await __1.Http.post(this.SMS_URL + "/api/sms", {
+                to: phone,
+                content: finalText
+            }, {
+                headers: {
+                    "authorization": token,
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+exports.Notifier = Notifier;

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

@@ -0,0 +1,14 @@
+import { BaseService } from "../BaseService";
+import { IConfig } from "./ConfigService";
+import { IDeploymentNotifier } from "./Notifier";
+export declare class Watchdog extends BaseService {
+    config: Map<string, IConfig>;
+    lastStatuses: Map<string, boolean>;
+    notifier: IDeploymentNotifier | null;
+    constructor(notifier?: IDeploymentNotifier | null);
+    applicationReady(): void;
+    setup(): Promise<void>;
+    checkReadiness(config: IConfig): Promise<void>;
+    statusPassed(config: IConfig): void;
+    statusFailed(config: IConfig): void;
+}