tnp-helpers 18.0.13 → 18.0.15

package/client/lib/base/base-cli-worker-config.d.ts

@@ -0,0 +1,24 @@
+// @ts-nocheck
+export declare class BaseCliWorkerConfig {
+    static from(opt: Partial<BaseCliWorkerConfig>): BaseCliWorkerConfig & Partial<BaseCliWorkerConfig>;
+    /**
+     * port taken by service
+     */
+    port: number;
+    /**
+     * unique in whole system id of service
+     */
+    serviceID: string;
+    /**
+     * pid of service process
+     */
+    pid: number;
+    /**
+     * timestamp when service was started
+     * (in other cases = null)
+     */
+    startTimestamp: number;
+    isEquals(other: BaseCliWorkerConfig): boolean;
+    get isEmpty(): boolean;
+    toString(): any;
+}

package/client/lib/base/base-cli-worker-controller.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { Taon } from 'taon/browser';
+import { BaseCliWorkerConfig } from './base-cli-worker-config';
+export declare abstract class BaseCliWorkerController<ENTITY> extends Taon.Base
+    .CrudController<ENTITY> {
+    /**
+     * service id
+     */
+    private cliWorkerServiceId;
+    baseCLiWorkerCommand_initializeMetadata(serviceId: string): Taon.Response<void>;
+    baseCLiWorkerCommand_kill(): Taon.Response<void>;
+    info(): Taon.Response<string>;
+    baseCLiWorkerCommand_isHealthy(configWorker: BaseCliWorkerConfig): Taon.Response<boolean>;
+}

package/client/lib/base/base-cli-worker.d.ts

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import type { BaseCliWorkerController } from './base-cli-worker-controller';
+import { BaseCliWorkerConfig } from './base-cli-worker-config';
+export declare abstract class BaseCliWorker {
+    /**
+     * unique id for service
+     */
+    protected readonly serviceID: string;
+    /**
+     * external command that will start service
+     */
+    protected readonly startCommand: string;
+    constructor(
+    /**
+     * unique id for service
+     */
+    serviceID: string, 
+    /**
+     * external command that will start service
+     */
+    startCommand: string);
+    protected abstract startNormallyInCurrentProcess(): any;
+    protected abstract getControllerForRemoteConnection(): Promise<BaseCliWorkerController<any>>;
+    private get pathToProcessLocalInfoJson();
+    protected get processLocalInfoObj(): BaseCliWorkerConfig;
+    startDetachedIfNeedsToBeStarted(): Promise<any>;
+    /**
+     * stop if started
+     */
+    kill(): Promise<void>;
+    /**
+     * kill detached process and start again
+     */
+    restart(): Promise<void>;
+    protected isServiceHealthy(options?: {
+        healthCheckRequestTrys?: number;
+    }): Promise<boolean>;
+    /**
+     * start if not started detached process
+     */
+    protected startDetached(): Promise<any>;
+    protected _infoScreen(): Promise<void>;
+    private saveProcessInfo;
+    protected initializeWorkerMetadata(): Promise<any>;
+    protected waitForProcessPortSavedToDisk(): Promise<void>;
+    getServicePort(): Promise<number>;
+}

package/client/lib/base/base-db.d.ts

@@ -5,6 +5,6 @@ export declare class BaseDb<DB extends object> {
     private dbName;
     private defaultDb;
     constructor(ins: BaseProjectResolver, dbName: string, defaultDb: DB);
-    get isUnsingDB(): boolean;
+    get isUsingDB(): boolean;
     get projectsDbLocation(): any;
 }

package/client/lib/base/base-git.d.ts

@@ -2,8 +2,8 @@
 import { BaseFeatureForProject } from './base-feature-for-project';
 import { CommitData, PushProcessOptions, TypeOfCommit } from '../index';
 import type { BaseProject } from './base-project';
-export declare class BaseGit<PROJCET extends BaseProject = any> extends BaseFeatureForProject {
-    project: PROJCET;
+export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeatureForProject {
+    project: PROJECT;
     unstageAllFiles(): any;
     revertFileChanges(fileReletivePath: string): any;
     clone(url: string, destinationFolderName?: string, branchName?: string): Promise<any>;
@@ -109,7 +109,7 @@ export declare class BaseGit<PROJCET extends BaseProject = any> extends BaseFeat
      *
      * projects that are children of this project (with its own git repo)
      */
-    get gitChildren(): PROJCET[];
+    get gitChildren(): PROJECT[];
     protected setRemoteOriginType(setOrigin: 'ssh' | 'http'): Promise<void>;
     pullProcess(options?: {
         cloneChildren?: boolean;

package/client/lib/base/base-library-build.d.ts

@@ -6,10 +6,10 @@ import type { BaseProject } from './base-project';
 /**
  * Base library build for standard angular/typescript projects
  */
-export declare abstract class BaseLibraryBuild<PROJCET extends BaseProject<BaseProject, any>> extends BaseFeatureForProject {
+export declare abstract class BaseLibraryBuild<PROJECT extends BaseProject<BaseProject, any>> extends BaseFeatureForProject {
     private cache;
     private tempOrgTsConfigFile;
-    protected sortByDeps(libraries: PROJCET[]): PROJCET[];
+    protected sortByDeps(libraries: PROJECT[]): PROJECT[];
     /**
      * Use cases:
      * 1. build all libraries in normal mode
@@ -22,35 +22,35 @@ export declare abstract class BaseLibraryBuild<PROJCET extends BaseProject<BaseP
      *    (skip normal build for not selected libraries)
      */
     selectAndSaveLibraries({ selectedLibs, watch, watchBuildSupported, skipAllLibsQuestion, useLastUserConfiguration, }: {
-        selectedLibs: PROJCET[];
+        selectedLibs: PROJECT[];
         watch: boolean;
         watchBuildSupported?: boolean;
         skipAllLibsQuestion?: boolean;
         useLastUserConfiguration?: boolean;
     }): Promise<{
-        selectedLibs: PROJCET[];
+        selectedLibs: PROJECT[];
         skipRebuildingAllForWatch: boolean;
     }>;
     /**
      * angular libraries from angular.json
      */
-    get libraries(): PROJCET[];
+    get libraries(): PROJECT[];
     protected getLibraries(): any;
     /**
      * Angular library build
      */
-    buildLibraries({ watch, strategy, releaseBuild, buildType, copylink_to_node_modules, outputLineReplace, libraries, useLastUserConfiguration, }?: LibrariesBuildOptions<PROJCET> & {
+    buildLibraries({ watch, strategy, releaseBuild, buildType, copylink_to_node_modules, outputLineReplace, libraries, useLastUserConfiguration, }?: LibrariesBuildOptions<PROJECT> & {
         watch?: boolean;
     }): Promise<void>;
     protected libWatchBuildProcess({ lib, locationsForNodeModules, strategy, buildType, outputLineReplace, }: {
-        lib: PROJCET;
+        lib: PROJECT;
         locationsForNodeModules: string[];
         strategy: 'link' | 'copy';
         buildType: CoreModels.LibraryType;
         outputLineReplace?: (outputLine: string) => string;
     }): Promise<any>;
     protected libNormalBuildProcess({ lib, locationsForNodeModules, strategy, buildType, outputLineReplace, }: {
-        lib: PROJCET;
+        lib: PROJECT;
         locationsForNodeModules: string[];
         strategy: 'link' | 'copy';
         buildType: CoreModels.LibraryType;

package/client/lib/base/base-linked-projects.d.ts

@@ -2,10 +2,10 @@
 import { LinkedPorjectsConfig, LinkedProject } from '../index';
 import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
-export declare class BaseLinkedProjects<PROJCET extends BaseProject = any> extends BaseFeatureForProject {
+export declare class BaseLinkedProjects<PROJECT extends BaseProject = any> extends BaseFeatureForProject {
     private cache;
-    project: PROJCET;
-    get embeddedProject(): PROJCET;
+    project: PROJECT;
+    get embeddedProject(): PROJECT;
     get projectsDbLocation(): any;
     saveLocationToDB(): Promise<any>;
     saveAllLinkedProjectsToDB(): Promise<void>;

package/client/lib/base/base-npm-helpers.d.ts

@@ -3,9 +3,9 @@ import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
 import { PackageJson } from 'type-fest';
 import { CoreModels } from 'tnp-core/browser';
-export declare class BaseNpmHelpers<PROJCET extends BaseProject = any> extends BaseFeatureForProject {
+export declare class BaseNpmHelpers<PROJECT extends BaseProject = any> extends BaseFeatureForProject {
     private packageJSON;
-    constructor(project: PROJCET);
+    constructor(project: PROJECT);
     updateDepsFrom(locations: string[]): any;
     /**
      * if something else change package.json in this project

package/client/lib/base/base-project-resolver.d.ts

@@ -1,15 +1,14 @@
 // @ts-nocheck
-import type { BaseProject } from './base-project';
 import { ConfigDatabase } from './config-database';
 import { ProjectDatabase } from './project-database';
+import { BaseProject } from './base-project';
+import { PortsWorker } from './ports-worker';
 export declare class BaseProjectResolver<PROJECT extends Partial<BaseProject> = any> {
     protected classFn: any;
-    /**
-     * general name for project company
-     */
-    orgName: string;
+    cliToolName: string;
     configDb: ConfigDatabase;
     projectsDb: ProjectDatabase;
+    readonly portsWorker: PortsWorker;
     protected readonly NPM_PROJECT_KEY = "npm";
     protected projects: PROJECT[];
     /**
@@ -17,7 +16,7 @@ export declare class BaseProjectResolver<PROJECT extends Partial<BaseProject> =
      * This may break things that are creating new projects
      */
     protected emptyLocations: string[];
-    constructor(classFn: any);
+    constructor(classFn: any, cliToolName: string);
     get allowedTypes(): string[];
     /**
      * project from process.cwd()

package/client/lib/base/base-project.d.ts

@@ -10,7 +10,7 @@ import { BaseGit } from './base-git';
 import { BaseVscodeHelpers } from './base-vscode';
 import { BaseReleaseProcess } from './base-release-process';
 import { BaseQuickFixes } from './base-quick-fixes';
-export declare abstract class BaseProject<PROJCET extends BaseProject = BaseProject<any, any>, TYPE = BaseProjectType> {
+export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProject<any, any>, TYPE = BaseProjectType> {
     static ins: BaseProjectResolver<BaseProject<BaseProject<any, any>, CoreModels.BaseProjectType>>;
     cache: any;
     static cache: any;
@@ -19,19 +19,19 @@ export declare abstract class BaseProject<PROJCET extends BaseProject = BaseProj
     /**
      * resolve instance
      */
-    abstract readonly ins: BaseProjectResolver<PROJCET>;
+    abstract readonly ins: BaseProjectResolver<PROJECT>;
     /**
      * Unique free port for project instance
      * only available after executing *this.assignFreePort()*
      */
     readonly port: string;
-    libraryBuild: BaseLibraryBuild<BaseProject>;
-    npmHelpers: BaseNpmHelpers;
-    linkedProjects: BaseLinkedProjects;
-    vsCodeHelpers: BaseVscodeHelpers;
-    releaseProcess: BaseReleaseProcess;
-    git: BaseGit;
-    quickFixes: BaseQuickFixes;
+    libraryBuild?: BaseLibraryBuild<BaseProject>;
+    npmHelpers?: BaseNpmHelpers;
+    linkedProjects?: BaseLinkedProjects;
+    vsCodeHelpers?: BaseVscodeHelpers;
+    releaseProcess?: BaseReleaseProcess;
+    git?: BaseGit;
+    quickFixes?: BaseQuickFixes;
     private __location;
     get location(): string;
     set location(v: string);
@@ -43,7 +43,7 @@ export declare abstract class BaseProject<PROJCET extends BaseProject = BaseProj
     get isMonorepo(): boolean;
     protected orderCoreProjects(coreProjects: CoreProject[]): CoreProject[];
     get core(): CoreProject;
-    get linkedProjectsExisted(): PROJCET[];
+    get linkedProjectsExisted(): PROJECT[];
     setType(type: TYPE): void;
     typeIs(...types: TYPE[]): boolean;
     typeIsNot(...types: TYPE[]): boolean;
@@ -62,11 +62,11 @@ export declare abstract class BaseProject<PROJCET extends BaseProject = BaseProj
     /**
      * alias to getAllChildren
      */
-    get children(): PROJCET[];
-    getChildBy(nameOrBasename: string, errors?: boolean): PROJCET;
-    get parent(): PROJCET;
-    get nearestParent(): PROJCET;
-    get grandpa(): PROJCET;
+    get children(): PROJECT[];
+    getChildBy(nameOrBasename: string, errors?: boolean): PROJECT;
+    get parent(): PROJECT;
+    get nearestParent(): PROJECT;
+    get grandpa(): PROJECT;
     get allNpmPackagesNames(): string[];
     get titleBarName(): string;
     get genericName(): any;

package/client/lib/base/base-quick-fixes.d.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
-export declare class BaseQuickFixes<PROJCET extends BaseProject = any> extends BaseFeatureForProject {
-    constructor(project: PROJCET);
+export declare class BaseQuickFixes<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> extends BaseFeatureForProject {
+    constructor(project: PROJECT);
     fixSQLLiteModuleInNodeModules(): any;
 }

package/client/lib/base/base-release-process.d.ts

@@ -3,8 +3,8 @@ import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
 import { CoreModels } from 'tnp-core/browser';
 import type { ChangelogData } from '.././models';
-export declare class BaseReleaseProcess<PROJCET extends BaseProject = any> extends BaseFeatureForProject {
-    project: PROJCET;
+export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> = any> extends BaseFeatureForProject {
+    project: PROJECT;
     /**
      * Automatic release process of patch plus one version
      */
@@ -17,7 +17,7 @@ export declare class BaseReleaseProcess<PROJCET extends BaseProject = any> exten
         index: number;
     }[];
     getReleaseWords(): string[];
-    startRelease(options?: Partial<Pick<BaseReleaseProcess<PROJCET>, 'automaticRelease' | 'type' | 'newVersion'>>): Promise<void>;
+    startRelease(options?: Partial<Pick<BaseReleaseProcess<PROJECT>, 'automaticRelease' | 'type' | 'newVersion'>>): Promise<void>;
     private reinstallNodeModules;
     selectChangelogCommits(): Promise<{
         commitMessages: string;
@@ -32,7 +32,7 @@ export declare class BaseReleaseProcess<PROJCET extends BaseProject = any> exten
     private testLibraries;
     buildAllLibraries(): Promise<void>;
     resetReleaseFiles(): Promise<any>;
-    get toBumpProjects(): PROJCET[];
+    get toBumpProjects(): PROJECT[];
     bumpNewVersionEverywhere(): Promise<any>;
     confirmNewVersion(): Promise<void>;
     private selectReleaseType;

package/client/lib/base/base-vscode.d.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 import type { BaseProject } from './base-project';
 import { BaseFeatureForProject } from './base-feature-for-project';
-export declare class BaseVscodeHelpers<PROJCET extends BaseProject = any> extends BaseFeatureForProject<PROJCET> {
+export declare class BaseVscodeHelpers<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
     /**
      * settings.json relative path
      */

package/client/lib/base/core-project.d.ts

@@ -7,7 +7,7 @@ export type CoreProjectEnvironment = {
     description?: string;
     onlineLink?: string;
 };
-export type CoreCommandArgOptions<PROJECT extends BaseProject> = {
+export type CoreCommandArgOptions<PROJECT extends BaseProject<any, any>> = {
     project?: PROJECT;
     /**
      * watch mode
@@ -42,7 +42,7 @@ export type CoreCommandArgOptions<PROJECT extends BaseProject> = {
 };
 export declare class CoreProject<PROJECT extends BaseProject = BaseProject> {
     static coreProjects: CoreProject<any>[];
-    static from<Proj extends BaseProject = BaseProject>(options: Omit<CoreProject<Proj>, 'name' | 'url' | 'branch'>): CoreProject<Proj>;
+    static from<Proj extends BaseProject = BaseProject<any, any>>(options: Omit<CoreProject<Proj>, 'name' | 'url' | 'branch'>): CoreProject<Proj>;
     private constructor();
     extends?: CoreProject<any>;
     color?: string;

package/client/lib/base/ports-worker.d.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import { BaseCliWorker } from './base-cli-worker';
+import { BaseCliWorkerController } from './base-cli-worker-controller';
+export declare class PortsWorker extends BaseCliWorker {
+    protected getControllerForRemoteConnection(): Promise<BaseCliWorkerController<any>>;
+    /**
+     * start normally process
+     * this will crash if process already started
+     */
+    startNormallyInCurrentProcess(): Promise<any>;
+}

package/lib/base/base-cli-worker-config.d.ts

@@ -0,0 +1,23 @@
+export declare class BaseCliWorkerConfig {
+    static from(opt: Partial<BaseCliWorkerConfig>): BaseCliWorkerConfig & Partial<BaseCliWorkerConfig>;
+    /**
+     * port taken by service
+     */
+    port: number;
+    /**
+     * unique in whole system id of service
+     */
+    serviceID: string;
+    /**
+     * pid of service process
+     */
+    pid: number;
+    /**
+     * timestamp when service was started
+     * (in other cases = null)
+     */
+    startTimestamp: number;
+    isEquals(other: BaseCliWorkerConfig): boolean;
+    get isEmpty(): boolean;
+    toString(): any;
+}

package/lib/base/base-cli-worker-config.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCliWorkerConfig = void 0;
+var tnp_core_1 = require("tnp-core");
+//#region @backend
+var columnify = require("columnify");
+//#endregion
+//#region base worker config
+var BaseCliWorkerConfig = /** @class */ (function () {
+    function BaseCliWorkerConfig() {
+    }
+    BaseCliWorkerConfig.from = function (opt) {
+        return tnp_core_1._.merge(new BaseCliWorkerConfig(), opt);
+    };
+    BaseCliWorkerConfig.prototype.isEquals = function (other) {
+        other = BaseCliWorkerConfig.from(other);
+        return (!!this.serviceID &&
+            !!this.port &&
+            !!this.pid &&
+            this.serviceID === other.serviceID &&
+            this.port === other.port &&
+            this.pid === other.pid);
+    };
+    Object.defineProperty(BaseCliWorkerConfig.prototype, "isEmpty", {
+        get: function () {
+            return !this.serviceID && !this.port && !this.pid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseCliWorkerConfig.prototype.toString = function () {
+        //#region @backendFunc
+        return columnify({
+            // status: this.status,
+            serviceID: this.serviceID,
+            port: this.port,
+            pid: this.pid,
+        });
+        //#endregion
+    };
+    return BaseCliWorkerConfig;
+}());
+exports.BaseCliWorkerConfig = BaseCliWorkerConfig;
+//#endregion
+//# sourceMappingURL=base-cli-worker-config.js.map

package/lib/base/base-cli-worker-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-cli-worker-config.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAAA,qCAA6B;AAC7B,kBAAkB;AAClB,qCAAuC;AACvC,YAAY;AAEZ,4BAA4B;AAC5B;IAAA;IAgDA,CAAC;IA/CQ,wBAAI,GAAX,UAAY,GAAiC;QAC3C,OAAO,YAAC,CAAC,KAAK,CAAC,IAAI,mBAAmB,EAAE,EAAE,GAAG,CAAC,CAAC;IACjD,CAAC;IAmBD,sCAAQ,GAAR,UAAS,KAA0B;QACjC,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,CACL,CAAC,CAAC,IAAI,CAAC,SAAS;YAChB,CAAC,CAAC,IAAI,CAAC,IAAI;YACX,CAAC,CAAC,IAAI,CAAC,GAAG;YACV,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS;YAClC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI;YACxB,IAAI,CAAC,GAAG,KAAK,KAAK,CAAC,GAAG,CACvB,CAAC;IACJ,CAAC;IAED,sBAAI,wCAAO;aAAX;YACE,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;QACpD,CAAC;;;OAAA;IAED,sCAAQ,GAAR;QACE,sBAAsB;QACtB,OAAO,SAAS,CAAC;YACf,uBAAuB;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAC,CAAC;QACH,YAAY;IACd,CAAC;IACH,0BAAC;AAAD,CAAC,AAhDD,IAgDC;AAhDY,kDAAmB;AAiDhC,YAAY"}

package/lib/base/base-cli-worker-controller.d.ts

@@ -0,0 +1,13 @@
+import { Taon } from 'taon/src';
+import { BaseCliWorkerConfig } from './base-cli-worker-config';
+export declare abstract class BaseCliWorkerController<ENTITY> extends Taon.Base
+    .CrudController<ENTITY> {
+    /**
+     * service id
+     */
+    private cliWorkerServiceId;
+    baseCLiWorkerCommand_initializeMetadata(serviceId: string): Taon.Response<void>;
+    baseCLiWorkerCommand_kill(): Taon.Response<void>;
+    info(): Taon.Response<string>;
+    baseCLiWorkerCommand_isHealthy(configWorker: BaseCliWorkerConfig): Taon.Response<boolean>;
+}

package/lib/base/base-cli-worker-controller.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCliWorkerController = void 0;
+var tslib_1 = require("tslib");
+var taon_1 = require("taon");
+var base_cli_worker_config_1 = require("./base-cli-worker-config");
+var BaseCliWorkerController = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseCliWorkerController, _super);
+    function BaseCliWorkerController() {
+        var _this = _super.apply(this, tslib_1.__spreadArray([], tslib_1.__read(arguments), false)) || this;
+        /**
+         * service id
+         */
+        _this.cliWorkerServiceId = null;
+        return _this;
+        //#endregion
+    }
+    //#region api methods / kill
+    BaseCliWorkerController.prototype.baseCLiWorkerCommand_initializeMetadata = function (serviceId) {
+        var _this = this;
+        //#region @backendFunc
+        return function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.cliWorkerServiceId = serviceId;
+                return [2 /*return*/];
+            });
+        }); };
+        //#endregion
+    };
+    //#endregion
+    //#region api methods / kill
+    BaseCliWorkerController.prototype.baseCLiWorkerCommand_kill = function () {
+        var _this = this;
+        //#region @backendFunc
+        return function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                console.log('Killing worker...');
+                setTimeout(function () {
+                    process.exit(0);
+                }, 1000); // TODO may be change to 0
+                return [2 /*return*/];
+            });
+        }); };
+        //#endregion
+    };
+    //#endregion
+    //#region api methods / kill
+    BaseCliWorkerController.prototype.info = function () {
+        var _this = this;
+        //#region @backendFunc
+        return function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, "Service ".concat(this.cliWorkerServiceId, " is running healthy on port ").concat(this.ctx.uri.port)];
+            });
+        }); };
+        //#endregion
+    };
+    //#endregion
+    //#region api methods / info
+    BaseCliWorkerController.prototype.baseCLiWorkerCommand_isHealthy = function (configWorker) {
+        var _this = this;
+        //#region @backendFunc
+        return function (req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var currentConfig;
+            return tslib_1.__generator(this, function (_a) {
+                configWorker = base_cli_worker_config_1.BaseCliWorkerConfig.from(configWorker);
+                currentConfig = base_cli_worker_config_1.BaseCliWorkerConfig.from({
+                    pid: process.pid,
+                    serviceID: this.cliWorkerServiceId,
+                    port: Number(this.ctx.uri.port),
+                });
+                return [2 /*return*/, configWorker.isEquals(currentConfig)];
+            });
+        }); };
+        //#endregion
+    };
+    tslib_1.__decorate([
+        taon_1.Taon.Http.PUT(),
+        tslib_1.__param(0, taon_1.Taon.Http.Param.Body('serviceId')),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", [String]),
+        tslib_1.__metadata("design:returntype", Object)
+    ], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_initializeMetadata", null);
+    tslib_1.__decorate([
+        taon_1.Taon.Http.GET(),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", []),
+        tslib_1.__metadata("design:returntype", Object)
+    ], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_kill", null);
+    tslib_1.__decorate([
+        taon_1.Taon.Http.GET({
+            pathIsGlobal: true,
+        }),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", []),
+        tslib_1.__metadata("design:returntype", Object)
+    ], BaseCliWorkerController.prototype, "info", null);
+    tslib_1.__decorate([
+        taon_1.Taon.Http.POST(),
+        tslib_1.__param(0, taon_1.Taon.Http.Param.Body()),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", [base_cli_worker_config_1.BaseCliWorkerConfig]),
+        tslib_1.__metadata("design:returntype", Object)
+    ], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_isHealthy", null);
+    BaseCliWorkerController = tslib_1.__decorate([
+        taon_1.Taon.Controller({
+            className: 'BaseCliWorkerController',
+        })
+    ], BaseCliWorkerController);
+    return BaseCliWorkerController;
+}(taon_1.Taon.Base
+    .CrudController));
+exports.BaseCliWorkerController = BaseCliWorkerController;
+//# sourceMappingURL=base-cli-worker-controller.js.map

package/lib/base/base-cli-worker-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-cli-worker-controller.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;;AAAA,6BAA4B;AAC5B,mEAA+D;AAK/D;IAA8D,mDACrC;IADzB;;QAEE;;WAEG;QACK,wBAAkB,GAAW,IAAI,CAAC;;QA2D1C,YAAY;IACd,CAAC;IA1DC,4BAA4B;IAE5B,yEAAuC,GAAvC,UACqC,SAAiB;QAFtD,iBASC;QALC,sBAAsB;QACtB,OAAO;;gBACL,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;;;aACrC,CAAC;QACF,YAAY;IACd,CAAC;IACD,YAAY;IAEZ,4BAA4B;IAE5B,2DAAyB,GAAzB;QADA,iBAUC;QARC,sBAAsB;QACtB,OAAO;;gBACL,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;gBACjC,UAAU,CAAC;oBACT,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAClB,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,0BAA0B;;;aACrC,CAAC;QACF,YAAY;IACd,CAAC;IACD,YAAY;IAEZ,4BAA4B;IAI5B,sCAAI,GAAJ;QAHA,iBASC;QALC,sBAAsB;QACtB,OAAO;;gBACL,sBAAO,kBAAW,IAAI,CAAC,kBAAkB,yCAA+B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAE,EAAC;;aAC7F,CAAC;QACF,YAAY;IACd,CAAC;IACD,YAAY;IAEZ,4BAA4B;IAE5B,gEAA8B,GAA9B,UAC0B,YAAiC;QAF3D,iBAeC;QAXC,sBAAsB;QACtB,OAAO,UAAO,GAAG,EAAE,GAAG;;;gBACpB,YAAY,GAAG,4CAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAChD,aAAa,GAAG,4CAAmB,CAAC,IAAI,CAAC;oBAC7C,GAAG,EAAE,OAAO,CAAC,GAAG;oBAChB,SAAS,EAAE,IAAI,CAAC,kBAAkB;oBAClC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;iBAChC,CAAC,CAAC;gBACH,sBAAO,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAC;;aAC7C,CAAC;QACF,YAAY;IACd,CAAC;IAtDD;QADC,WAAI,CAAC,IAAI,CAAC,GAAG,EAAE;QAEb,mBAAA,WAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;;;;0FAOnC;IAKD;QADC,WAAI,CAAC,IAAI,CAAC,GAAG,EAAE;;;;4EAUf;IAOD;QAHC,WAAI,CAAC,IAAI,CAAC,GAAG,CAAC;YACb,YAAY,EAAE,IAAI;SACnB,CAAC;;;;uDAOD;IAKD;QADC,WAAI,CAAC,IAAI,CAAC,IAAI,EAAE;QAEd,mBAAA,WAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAA;;iDAAe,4CAAmB;;iFAa1D;IA/DmB,uBAAuB;QAH5C,WAAI,CAAC,UAAU,CAAC;YACf,SAAS,EAAE,yBAAyB;SACrC,CAAC;OACoB,uBAAuB,CAiE5C;IAAD,8BAAC;CAAA,AAjED,CAA8D,WAAI,CAAC,IAAI;KACpE,cAAc,GAgEhB;AAjEqB,0DAAuB"}

package/lib/base/base-cli-worker.d.ts

@@ -0,0 +1,46 @@
+import type { BaseCliWorkerController } from './base-cli-worker-controller';
+import { BaseCliWorkerConfig } from './base-cli-worker-config';
+export declare abstract class BaseCliWorker {
+    /**
+     * unique id for service
+     */
+    protected readonly serviceID: string;
+    /**
+     * external command that will start service
+     */
+    protected readonly startCommand: string;
+    constructor(
+    /**
+     * unique id for service
+     */
+    serviceID: string, 
+    /**
+     * external command that will start service
+     */
+    startCommand: string);
+    protected abstract startNormallyInCurrentProcess(): any;
+    protected abstract getControllerForRemoteConnection(): Promise<BaseCliWorkerController<any>>;
+    private get pathToProcessLocalInfoJson();
+    protected get processLocalInfoObj(): BaseCliWorkerConfig;
+    startDetachedIfNeedsToBeStarted(): Promise<void>;
+    /**
+     * stop if started
+     */
+    kill(): Promise<void>;
+    /**
+     * kill detached process and start again
+     */
+    restart(): Promise<void>;
+    protected isServiceHealthy(options?: {
+        healthCheckRequestTrys?: number;
+    }): Promise<boolean>;
+    /**
+     * start if not started detached process
+     */
+    protected startDetached(): Promise<void>;
+    protected _infoScreen(): Promise<void>;
+    private saveProcessInfo;
+    protected initializeWorkerMetadata(): Promise<void>;
+    protected waitForProcessPortSavedToDisk(): Promise<void>;
+    getServicePort(): Promise<number>;
+}