@taon-dev/cloud 21.0.207

package/lib-prod/start-cli.js

@@ -0,0 +1,43 @@
+//#region tnp-helpers cli template
+// import { Helpers, BaseCommandLineFeature } from 'tnp-helpers/src';
+// import { BaseProject, BaseStartConfig } from 'tnp-helpers/src'; // @backend
+// class $Version extends BaseCommandLineFeature<{}> {
+//   public _() {
+//     console.log(`Hello world from cli`);
+//     this._exit();
+//   }
+// }
+//#endregion
+/**
+ *
+ * @param argsv process.argsv
+ * @param filename needed if you want ipc communicaiton
+ */
+export async function startCli(argsv, filename) {
+    //#region @backendFunc
+    console.log('Hello from cli');
+    console.log({ argsv });
+    process.exit(0);
+    //#region start config
+    // new BaseStartConfig({
+    //   ProjectClass: BaseProject,
+    //   functionsOrClasses: [
+    //     {
+    //       classOrFnName: '$Version',
+    //       funcOrClass: $Version,
+    //     },
+    //   ],
+    //   argsv,
+    //   useStringArrForArgsFunctions: true,
+    //   shortArgsReplaceConfig: {
+    //     v: 'version',
+    //   },
+    //   callbackNotRecognizedCommand: async () => {
+    //     Helpers.error(`Command not recognized`, false, true);
+    //   },
+    // });
+    //#endregion
+    //#endregion
+}
+export default startCli;
+//# sourceMappingURL=start-cli.js.map

package/lib-prod/start-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-cli.js","sourceRoot":"","sources":[""],"names":[],"mappings":"AAAA,kCAAkC;AAClC,qEAAqE;AACrE,8EAA8E;AAE9E,sDAAsD;AACtD,iBAAiB;AACjB,2CAA2C;AAC3C,oBAAoB;AACpB,MAAM;AACN,IAAI;AACJ,YAAY;AAEZ;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,KAAe,EAAE,QAAgB;IAC9D,sBAAsB;IACtB,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAC9B,OAAO,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACvB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEhB,sBAAsB;IACtB,wBAAwB;IACxB,+BAA+B;IAC/B,0BAA0B;IAC1B,QAAQ;IACR,mCAAmC;IACnC,+BAA+B;IAC/B,SAAS;IACT,OAAO;IACP,WAAW;IACX,wCAAwC;IACxC,8BAA8B;IAC9B,oBAAoB;IACpB,OAAO;IACP,gDAAgD;IAChD,4DAA4D;IAC5D,OAAO;IACP,MAAM;IACN,YAAY;IACZ,YAAY;AACd,CAAC;AAED,eAAe,QAAQ,CAAC"}

package/lib-prod/traefik/traefik.models.d.ts

@@ -0,0 +1,20 @@
+export interface TraefikConfig {
+    http: {
+        routers: Record<string, TraefikRouter>;
+        services: Record<string, TraefikService>;
+    };
+}
+export interface TraefikRouter {
+    rule: string;
+    service: string;
+    entryPoints: string[];
+    tls?: Record<string, any> | null;
+}
+export interface TraefikService {
+    loadBalancer: {
+        servers: TraefikServer[];
+    };
+}
+export interface TraefikServer {
+    url: string;
+}

package/lib-prod/traefik/traefik.models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=traefik.models.js.map

package/lib-prod/traefik/traefik.models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traefik.models.js","sourceRoot":"","sources":[""],"names":[],"mappings":""}

package/lib-prod/traefik/traefik.provider.d.ts

@@ -0,0 +1,42 @@
+import { TaonCloudStatus } from '../models';
+import { TraefikServiceProvider } from './treafik-service.provider';
+export declare class TraefikProvider {
+    /**
+     * Path to traefik docker compose template files
+     */
+    private readonly pathToTraefikComposeSourceTemplateFilesCwd;
+    service: TraefikServiceProvider;
+    readonly cloudIps: string[];
+    protected taonCloudStatus: TaonCloudStatus;
+    protected reverseProxyNetworkName: string;
+    get cloudIsEnabled(): boolean;
+    get isDevMode(): boolean;
+    /**
+     * Path to traefik docker compose cwd where
+     * compose will be started
+     */
+    get pathToTraefikComposeDestCwd(): string;
+    constructor(
+    /**
+     * Path to traefik docker compose template files
+     */
+    pathToTraefikComposeSourceTemplateFilesCwd: () => string);
+    protected setEnabledMode(): void;
+    protected checkIfDockerEnabled(): Promise<boolean>;
+    protected deleteTraefikNetwork(): Promise<void>;
+    protected makeSureTraefikNetworkCreated(): Promise<void>;
+    protected selectModeExplain(): Promise<void>;
+    protected selectMode(options?: {}): Promise<TaonCloudStatus>;
+    protected checkIfTraefikIsRunning(options?: {
+        waitUntilHealthy?: boolean;
+        maxTries?: number;
+    }): Promise<boolean>;
+    protected selectCloudIps(): Promise<boolean>;
+    protected areCloudIpsValid(): Promise<boolean>;
+    initialCloudStatusCheck(): Promise<void>;
+    restartTraefik(options?: {
+        hardRestart?: boolean;
+    }): Promise<void>;
+    startTraefik(): Promise<boolean>;
+    stopTraefik(): Promise<void>;
+}

package/lib-prod/traefik/traefik.provider.js

@@ -0,0 +1,575 @@
+//#region imports
+import { promisify } from 'util';
+import { config } from 'tnp-core/lib-prod';
+import { chalk, child_process, crossPlatformPath, path, ___NS__first, UtilsOs__NS__isDockerAvailable, UtilsOs__NS__isRunningInOsWithGraphicsCapableEnvironment, UtilsTerminal__NS__clearConsole, UtilsTerminal__NS__confirm, UtilsTerminal__NS__input, UtilsTerminal__NS__pressAnyKeyToContinueAsync, UtilsTerminal__NS__pressAnyKeyToTryAgainErrorOccurred, UtilsTerminal__NS__select, UtilsTerminal__NS__wait } from 'tnp-core/lib-prod';
+import { UtilsNetwork__NS__checkIfServerPings, UtilsNetwork__NS__getCurrentPublicIpAddress, UtilsNetwork__NS__getLocalIpAddresses, UtilsNetwork__NS__isValidIp } from 'tnp-core/lib-prod';
+import { globalSpinner, taonBasePathToGlobalDockerTemplates, } from 'tnp-core/lib-prod';
+import { BaseCliWorker, Helpers__NS__error, Helpers__NS__exists, Helpers__NS__info, Helpers__NS__logInfo, Helpers__NS__removeFileIfExists, Helpers__NS__removeFolderIfExists, Helpers__NS__taskDone, Helpers__NS__taskStarted, Helpers__NS__warn, HelpersTaon__NS__copy, UtilsDocker__NS__cleanImagesAndContainersByDockerLabel } from 'tnp-helpers/lib-prod';
+import { TaonCloudStatus } from '../models';
+// import type { TaonProjectsWorker } from '../taon.worker';
+import { TraefikServiceProvider } from './treafik-service.provider';
+//#endregion
+export class TraefikProvider {
+    pathToTraefikComposeSourceTemplateFilesCwd;
+    //#region fields & getters
+    service = new TraefikServiceProvider(this);
+    cloudIps = [];
+    taonCloudStatus = TaonCloudStatus.NOT_STARED;
+    reverseProxyNetworkName = 'traefik-net';
+    //#region fields & getters / cloud is enabled
+    get cloudIsEnabled() {
+        //#region @backendFunc
+        return (this.taonCloudStatus === TaonCloudStatus.ENABLED_NOT_SECURE ||
+            this.taonCloudStatus === TaonCloudStatus.ENABLED_SECURED);
+        //#endregion
+    }
+    //#endregion
+    //#region fields & getters / is dev mode
+    get isDevMode() {
+        //#region @backendFunc
+        return (this.taonCloudStatus === TaonCloudStatus.ENABLED_NOT_SECURE ||
+            this.taonCloudStatus === TaonCloudStatus.STARTING_NOT_SECURE_MODE ||
+            Helpers__NS__exists([
+                this.pathToTraefikComposeDestCwd,
+                `traefik-compose.local-dev.yml`,
+            ]));
+        //#endregion
+    }
+    //#endregion
+    //#region fields & getters / get path to compose dest
+    /**
+     * Path to traefik docker compose cwd where
+     * compose will be started
+     */
+    get pathToTraefikComposeDestCwd() {
+        //#region @backendFunc
+        const pathToComposeDest = crossPlatformPath([
+            taonBasePathToGlobalDockerTemplates,
+            path.basename(this.pathToTraefikComposeSourceTemplateFilesCwd()),
+        ]);
+        return pathToComposeDest;
+        //#endregion
+    }
+    //#endregion
+    //#endregion
+    constructor(
+    /**
+     * Path to traefik docker compose template files
+     */
+    pathToTraefikComposeSourceTemplateFilesCwd) {
+        this.pathToTraefikComposeSourceTemplateFilesCwd = pathToTraefikComposeSourceTemplateFilesCwd;
+    }
+    //#region protected methods
+    //#region protected methods / set enabled mode
+    setEnabledMode() {
+        if (this.isDevMode) {
+            this.taonCloudStatus = TaonCloudStatus.ENABLED_NOT_SECURE;
+        }
+        else {
+            this.taonCloudStatus = TaonCloudStatus.ENABLED_SECURED;
+        }
+        BaseCliWorker.cloudIp.next(___NS__first(this.cloudIps));
+        BaseCliWorker.isCloudEnable.next(true);
+    }
+    //#endregion
+    //#region protected methods / check if docker enabled
+    async checkIfDockerEnabled() {
+        //#region @backendFunc
+        Helpers__NS__taskStarted(`Checking if docker is enabled...`);
+        const isEnableDocker = await UtilsOs__NS__isDockerAvailable();
+        if (!isEnableDocker) {
+            Helpers__NS__error(`
+
+        Docker is not enabled, please enable docker to use cloud features
+
+        `, true, true);
+            await UtilsTerminal__NS__pressAnyKeyToContinueAsync();
+            return false;
+        }
+        Helpers__NS__taskDone(`Docker is enabled!`);
+        return true;
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / delete traefik network
+    async deleteTraefikNetwork() {
+        //#region @backendFunc
+        try {
+            child_process.execSync(`docker network rm ${this.reverseProxyNetworkName}`, { stdio: 'inherit' });
+            console.log(`🗑️  Network deleted: ${this.reverseProxyNetworkName}`);
+        }
+        catch (error) {
+            console.log(`ℹ️ Network '${this.reverseProxyNetworkName}' probably does not exist, skipping.`);
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / make sure traefik network created
+    async makeSureTraefikNetworkCreated() {
+        //#region @backendFunc
+        try {
+            child_process.execSync(`docker network create ${this.reverseProxyNetworkName}`, {
+                stdio: 'ignore',
+            });
+            console.log(`✅ Network created: ${this.reverseProxyNetworkName}`);
+        }
+        catch (error) {
+            console.log(`ℹ️ Network '${this.reverseProxyNetworkName}' probably already exists, skipping.`);
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / select mode explain
+    async selectModeExplain() {
+        //#region @backendFunc
+        UtilsTerminal__NS__clearConsole();
+        Helpers__NS__info(`Taon Cloud Modes Explanation:
+=> ${chalk.bold.yellow('DEV MODE (ENABLED_NOT_SECURE)')}:
+  In this mode, Taon Cloud is enabled without SSL/TLS encryption.
+  This mode is suitable for development and testing purposes.
+=> ${chalk.bold.green('PRODUCTION MODE (ENABLED_SECURED)')}:
+  In this mode, Taon Cloud is enabled with SSL/TLS encryption.
+  This mode is intended for production environments where security is crucial.
+    `);
+        await UtilsTerminal__NS__pressAnyKeyToContinueAsync();
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / select mode
+    async selectMode(options) {
+        //#region @backendFunc
+        options = options || {};
+        // options.skipDisabled = options.skipDisabled || false;
+        while (true) {
+            try {
+                let status;
+                const isOsWithoutGui = !UtilsOs__NS__isRunningInOsWithGraphicsCapableEnvironment();
+                const optSecure = {
+                    [TaonCloudStatus.STARTING_SECURE_MODE]: 'Enable Taon Cloud (PRODUCTION MODE)',
+                };
+                const optNotSecure = {
+                    [TaonCloudStatus.STARTING_NOT_SECURE_MODE]: 'Enable Taon Cloud (DEV MODE)',
+                };
+                const optExplain = {
+                    explain: {
+                        name: '< Explain Taon Cloud modes >',
+                    },
+                };
+                const choices = isOsWithoutGui
+                    ? {
+                        ...optSecure,
+                        ...optNotSecure,
+                        ...optExplain,
+                    }
+                    : {
+                        ...optExplain,
+                        ...optNotSecure,
+                        ...optSecure,
+                    };
+                const answer = await UtilsTerminal__NS__select({
+                    choices: choices,
+                    question: `Select Taon Cloud mode:`,
+                });
+                if (answer === 'explain') {
+                    await this.selectModeExplain();
+                    continue;
+                }
+                status = answer;
+                return status;
+            }
+            catch (error) {
+                if (!(await UtilsTerminal__NS__pressAnyKeyToTryAgainErrorOccurred(error))) {
+                    break;
+                }
+            }
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / get worker terminal actions
+    async checkIfTraefikIsRunning(options) {
+        //#region @backendFunc
+        let tries = 0;
+        options = options || {};
+        if (options.waitUntilHealthy) {
+            options.maxTries = options.maxTries || 50;
+        }
+        const execAsync = promisify(child_process.exec);
+        globalSpinner.instance.start(`Traefik health: checking...`);
+        while (true) {
+            tries++;
+            if (options.maxTries && tries > options.maxTries) {
+                globalSpinner.instance.fail(`Traefik is not running or not healthy after ${tries} tries`);
+                return false;
+            }
+            try {
+                const { stdout } = await execAsync(process.platform === 'win32'
+                    ? `docker inspect --format="{{json .State.Health.Status}}" traefik`
+                    : `docker inspect --format='{{json .State.Health.Status}}' traefik`);
+                const status = stdout.trim().replace(/"/g, '');
+                globalSpinner.instance.text = `Traefik health: ${status}`;
+                if (status === 'healthy') {
+                    globalSpinner.instance.succeed(`Traefik is ready`);
+                    await UtilsTerminal__NS__wait(1);
+                    return true;
+                }
+                if (status === 'unhealthy') {
+                    if (options.waitUntilHealthy) {
+                        globalSpinner.instance.text =
+                            'Traefik state is not healthy yet, waiting...';
+                    }
+                    else {
+                        globalSpinner.instance.fail(`Traefik state is not running or not healthy`);
+                        return false;
+                    }
+                }
+            }
+            catch (error) {
+                if (options.waitUntilHealthy) {
+                    globalSpinner.instance.text =
+                        'Traefik is not healthy yet, waiting...';
+                }
+                else {
+                    globalSpinner.instance.fail('Traefik is not running or not healthy');
+                    return false;
+                }
+            }
+            await UtilsTerminal__NS__wait(1);
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / select cloud ips
+    async selectCloudIps() {
+        //#region @backendFunc
+        //#region select ip type
+        const localIps = await UtilsNetwork__NS__getLocalIpAddresses();
+        const optPublic = {
+            usePublic: {
+                name: 'Use Public IP Address (recommended on server)',
+            },
+        };
+        const optLocal = {
+            useLocal: {
+                name: 'Use Local IP Address',
+            },
+        };
+        const isOsWithoutGui = !UtilsOs__NS__isRunningInOsWithGraphicsCapableEnvironment();
+        const choicesIpType = isOsWithoutGui
+            ? {
+                ...optPublic,
+                ...optLocal,
+            }
+            : {
+                ...optLocal,
+                ...optPublic,
+            };
+        const useIp = await UtilsTerminal__NS__select({
+            choices: choicesIpType,
+        });
+        //#endregion
+        if (useIp === 'usePublic') {
+            //#region use public ip
+            while (true) {
+                try {
+                    Helpers__NS__info(`Detecting public IP address...`);
+                    let publicIp = await UtilsNetwork__NS__getCurrentPublicIpAddress();
+                    const choicesPublicIp = {
+                        confirm: {
+                            name: `Use detected public IP: ${chalk.bold(publicIp)}`,
+                        },
+                        manual: {
+                            name: 'Enter public IP manually',
+                        },
+                        abort: {
+                            name: '< abort and go back >',
+                        },
+                    };
+                    const selectedChoice = await UtilsTerminal__NS__select({
+                        choices: choicesPublicIp,
+                        question: `Select option for public IP address:`,
+                    });
+                    if (selectedChoice === 'abort') {
+                        return false;
+                    }
+                    if (selectedChoice === 'manual') {
+                        publicIp = await UtilsTerminal__NS__input({
+                            question: `Enter public IP address to be used by Taon Cloud:`,
+                            required: true,
+                            validate: ip => {
+                                return UtilsNetwork__NS__isValidIp(ip);
+                            },
+                        });
+                    }
+                    this.cloudIps.length = 0;
+                    this.cloudIps.push(publicIp);
+                    if (!(await this.areCloudIpsValid())) {
+                        continue;
+                    }
+                    return true;
+                }
+                catch (error) {
+                    if (!(await UtilsTerminal__NS__pressAnyKeyToTryAgainErrorOccurred(error))) {
+                        return false;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+            }
+            //#endregion
+        }
+        else {
+            //#region use local ip
+            let i = 0;
+            while (true) {
+                i++;
+                try {
+                    if (i > 1) {
+                        const shouldContinue = await UtilsTerminal__NS__confirm({
+                            message: `Selecting again IP addresses. Do you want to continue?`,
+                            defaultValue: true,
+                        });
+                        if (!shouldContinue) {
+                            return false;
+                        }
+                    }
+                    const choices = [
+                        ...localIps
+                            .filter(f => f.family === 'IPv4')
+                            .map(ip => ({
+                            name: `Local IP: ${ip.address} (${ip.type})`,
+                            value: ip.address,
+                        })),
+                    ];
+                    const selected = await UtilsTerminal__NS__select({
+                        choices: choices,
+                        question: `Select IP addresses to be used by Taon Cloud:`,
+                    });
+                    this.cloudIps.length = 0;
+                    this.cloudIps.push(selected);
+                    if (!(await this.areCloudIpsValid())) {
+                        continue;
+                    }
+                    return true;
+                }
+                catch (error) {
+                    if (!(await UtilsTerminal__NS__pressAnyKeyToTryAgainErrorOccurred(error))) {
+                        break;
+                    }
+                    continue;
+                }
+            }
+            //#endregion
+        }
+        //#endregion
+    }
+    //#endregion
+    //#endregion
+    //#region public methods
+    //#region protected methods / validate ips
+    async areCloudIpsValid() {
+        //#region @backendFunc
+        for (const localIp of this.cloudIps) {
+            Helpers__NS__info(`Validating IP address (ping): ${localIp}...`);
+            if (!(await UtilsNetwork__NS__checkIfServerPings(localIp))) {
+                Helpers__NS__error(`Server with IP ${localIp} is not reachable! Please select only reachable IPs.`, true, true);
+                return false;
+            }
+        }
+        return true;
+        //#endregion
+    }
+    //#endregion
+    //#region public methods / initial cloud status check
+    async initialCloudStatusCheck() {
+        //#region @backendFunc
+        const isDockerRunning = await UtilsOs__NS__isDockerAvailable();
+        if (isDockerRunning) {
+            Helpers__NS__logInfo(`Docker is running.. checking if Traefik is enabled...`);
+        }
+        else {
+            return;
+        }
+        const ipFromYml = this.service.getIpFromYml();
+        if (!ipFromYml) {
+            console.warn(`Can find ip from traefik dynamic config yml, assuming Traefik is not configured.`);
+            Helpers__NS__info(`Shutting down Traefik if running...`);
+            await this.stopTraefik();
+            return;
+        }
+        this.cloudIps.push(ipFromYml);
+        const isTraefikRunning = await this.checkIfTraefikIsRunning();
+        if (isTraefikRunning) {
+            Helpers__NS__info(`Traefik is running with IP: ${ipFromYml}`);
+            Helpers__NS__info(`Restarting Traefik to refresh new settings...`);
+            await this.restartTraefik();
+            this.setEnabledMode();
+        }
+        else {
+            console.warn(`Traefik is not running even if configured with IP: ${ipFromYml}`);
+            Helpers__NS__info(`Shutting down Traefik if running...`);
+            await this.stopTraefik();
+            return;
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region public methods / restart traefik
+    async restartTraefik(options) {
+        //#region @backendFunc
+        options = options || {};
+        if (options.hardRestart) {
+            await this.stopTraefik();
+            await this.startTraefik();
+            return;
+        }
+        console.log(`🚀 Restarting Traefik ${this.isDevMode ? 'DEV' : 'PROD'}...`);
+        const execAsync = promisify(child_process.exec);
+        try {
+            await execAsync(`docker compose -f ` +
+                ` traefik-compose${this.isDevMode ? '.local-dev' : ''}.yml down`, {
+                cwd: this.pathToTraefikComposeDestCwd,
+            });
+            await execAsync(`docker compose -f ` +
+                ` traefik-compose${this.isDevMode ? '.local-dev' : ''}.yml up -d traefik`, {
+                cwd: this.pathToTraefikComposeDestCwd,
+            });
+        }
+        catch (error) {
+            config.frameworkName === 'tnp' && console.error(error);
+            Helpers__NS__warn('Error restarting Traefik:');
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region public methods / start traefik
+    async startTraefik() {
+        //#region @backendFunc
+        if (!(await this.checkIfDockerEnabled())) {
+            return false;
+        }
+        this.taonCloudStatus = await this.selectMode({
+            skipDisabled: true,
+        });
+        if (!(await this.selectCloudIps())) {
+            console.error('No IPs selected, cannot start Traefik');
+            this.taonCloudStatus = TaonCloudStatus.NOT_STARED;
+            return false;
+        }
+        await this.makeSureTraefikNetworkCreated();
+        console.log(`🚀 Starting Traefik ${this.isDevMode ? 'DEV' : 'PROD'}...`);
+        const execAsync = promisify(child_process.exec);
+        Helpers__NS__removeFolderIfExists(this.pathToTraefikComposeDestCwd);
+        HelpersTaon__NS__copy(this.pathToTraefikComposeSourceTemplateFilesCwd(), this.pathToTraefikComposeDestCwd, {
+            recursive: true,
+        });
+        this.service.initServiceReadme();
+        // remove not used file
+        Helpers__NS__removeFileIfExists([
+            this.pathToTraefikComposeDestCwd,
+            `traefik-compose${!this.isDevMode ? '.local-dev' : ''}.yml`,
+        ]);
+        await execAsync(`docker compose -f ` +
+            ` traefik-compose${this.isDevMode ? '.local-dev' : ''}.yml up -d traefik`, {
+            cwd: this.pathToTraefikComposeDestCwd,
+        });
+        // Wait until container health becomes healthy
+        const isTraefikRunning = await this.checkIfTraefikIsRunning({
+            waitUntilHealthy: true,
+        });
+        if (isTraefikRunning) {
+            this.setEnabledMode();
+            for (const cloudIp of this.cloudIps) {
+                const workers = BaseCliWorker.getAllWorkersStartedInSystemFromCurrentCli();
+                await this.service.registerWorkers(cloudIp, workers);
+            }
+            await this.restartTraefik();
+        }
+        else {
+            this.taonCloudStatus = TaonCloudStatus.NOT_STARED;
+        }
+        return isTraefikRunning;
+        //#endregion
+    }
+    //#endregion
+    //#region public methods / stop traefik
+    async stopTraefik() {
+        //#region @backendFunc
+        this.taonCloudStatus = TaonCloudStatus.KILLING;
+        console.log('Stopping Traefik...');
+        await this.deleteTraefikNetwork();
+        const execAsync = promisify(child_process.exec);
+        const localDevFileBasename = `traefik-compose.local-dev.yml`;
+        const prodFileBasename = `traefik-compose.yml`;
+        // Start traefik in detached mode
+        const devFileExists = Helpers__NS__exists([
+            this.pathToTraefikComposeDestCwd,
+            localDevFileBasename,
+        ]);
+        const prodFileExists = Helpers__NS__exists([
+            this.pathToTraefikComposeDestCwd,
+            prodFileBasename,
+        ]);
+        let composeDownBothFiles = devFileExists && prodFileExists;
+        if (!Helpers__NS__exists(this.pathToTraefikComposeDestCwd)) {
+            HelpersTaon__NS__copy(this.pathToTraefikComposeSourceTemplateFilesCwd(), this.pathToTraefikComposeDestCwd, {
+                recursive: true,
+            });
+            composeDownBothFiles = true;
+        }
+        const composeDownFile = async (filename) => {
+            return await execAsync(`docker compose -f ${filename} down`, {
+                cwd: this.pathToTraefikComposeDestCwd,
+            });
+        };
+        if (composeDownBothFiles) {
+            Helpers__NS__logInfo('Composing down both dev and production mode traefik...');
+            try {
+                await composeDownFile(localDevFileBasename);
+            }
+            catch (error) {
+                console.log('Error stopping Traefik dev mode');
+            }
+            try {
+                await composeDownFile(prodFileBasename);
+            }
+            catch (error) {
+                console.log('Error stopping Traefik production mode');
+            }
+        }
+        else {
+            while (true) {
+                try {
+                    if (Helpers__NS__exists([
+                        this.pathToTraefikComposeDestCwd,
+                        localDevFileBasename,
+                    ])) {
+                        Helpers__NS__logInfo('Composing down dev mode traefik...');
+                        await composeDownFile(localDevFileBasename);
+                    }
+                    if (Helpers__NS__exists([this.pathToTraefikComposeDestCwd, prodFileBasename])) {
+                        Helpers__NS__logInfo('Composing down production mode traefik...');
+                        await composeDownFile(prodFileBasename);
+                    }
+                    break;
+                }
+                catch (error) {
+                    Helpers__NS__error('Error stopping Traefik', true, true);
+                    const tryAgain = await UtilsTerminal__NS__pressAnyKeyToTryAgainErrorOccurred(error);
+                    if (!tryAgain) {
+                        break;
+                    }
+                }
+            }
+        }
+        await UtilsDocker__NS__cleanImagesAndContainersByDockerLabel('org.opencontainers.image.title', 'Traefik');
+        Helpers__NS__removeFolderIfExists(this.pathToTraefikComposeDestCwd);
+        this.taonCloudStatus = TaonCloudStatus.NOT_STARED;
+        BaseCliWorker.isCloudEnable.next(false);
+        // docker compose rm -f traefik
+        // docker compose down --remove-orphans
+        //#endregion
+    }
+}
+//# sourceMappingURL=traefik.provider.js.map