tnp-helpers 19.0.65 → 19.0.67

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

@@ -1,6 +1,10 @@
 // @ts-nocheck
 export declare class BaseCliWorkerConfig {
     static from(opt: Partial<BaseCliWorkerConfig>): BaseCliWorkerConfig;
+    /**
+     * path to file where config is stored
+     */
+    pathToFile: string;
     /**
      * port taken by service
      */

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

@@ -1,16 +1,15 @@
 // @ts-nocheck
 import { Taon } from 'taon/browser';
 import { BaseCliWorkerConfig } from './base-cli-worker-config';
-export declare abstract class BaseCliWorkerController extends Taon.Base
-    .Controller {
+export declare abstract class BaseCliWorkerController<UPLOAD_FILE_QUERY_PARAMS = {}> extends Taon.Base.Controller<UPLOAD_FILE_QUERY_PARAMS> {
     /**
      * service id
      */
     private cliWorkerServiceId;
     private cliWorkerServiceVersion;
     baseCLiWorkerCommand_initializeMetadata(serviceId: string, serviceVersion: string): Taon.Response<void>;
-    baseCLiWorkerCommand_kill(): Taon.Response<void>;
-    info(): Taon.Response<string>;
+    baseCLiWorkerCommand_kill(dontRemoveConfigFile?: boolean): Taon.Response<void>;
+    info(): Taon.ResponseHtml;
     baseCLiWorkerCommand_isHealthy(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
     baseCLiWorkerCommand_hasUpToDateVersion(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
 }

package/browser/lib/base/classes/base-cli-worker/base-cli-worker-terminal-ui.d.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { CoreModels } from 'tnp-core/browser';
-import type { BaseCliWorker } from './base-cli-worker';
+import type { BaseCliWorker, BaseCliWorkerGuiUrlOptions } from './base-cli-worker';
 import type { BaseCliWorkerController } from './base-cli-worker-controller';
 export type BaseWorkerTerminalActionReturnType = {
     [uniqeActionName: string]: {
@@ -8,7 +8,7 @@ export type BaseWorkerTerminalActionReturnType = {
         action: () => unknown | Promise<unknown>;
     };
 };
-export declare class BaseCliWorkerTerminalUI<WORKER extends BaseCliWorker<BaseCliWorkerController, any>> {
+export declare class BaseCliWorkerTerminalUI<WORKER extends BaseCliWorker<BaseCliWorkerController<any>, any>> {
     protected worker: WORKER;
     constructor(worker: WORKER);
     protected headerText(): Promise<string>;
@@ -18,7 +18,7 @@ export declare class BaseCliWorkerTerminalUI<WORKER extends BaseCliWorker<BaseCl
      * override whole terminal header
      */
     protected header(): Promise<void>;
-    infoMessageBelowHeader(): Promise<void>;
+    infoMessageBelowHeader(options?: BaseCliWorkerGuiUrlOptions): Promise<void>;
     protected get backAction(): {
         back: {
             name: string;
@@ -34,6 +34,7 @@ export declare class BaseCliWorkerTerminalUI<WORKER extends BaseCliWorker<BaseCl
         exitIsOnlyReturn?: boolean;
         chooseAction?: boolean;
     }): BaseWorkerTerminalActionReturnType;
+    private headerDisplayed;
     infoScreen(options?: {
         exitIsOnlyReturn?: boolean;
     }): Promise<void>;

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

@@ -1,9 +1,16 @@
 // @ts-nocheck
-import { Taon } from 'taon/browser';
+import { BehaviorSubject } from 'rxjs';
+import { EndpointContext, Taon } from 'taon/browser';
 import { BaseCliWorkerConfig } from './base-cli-worker-config';
 import type { BaseCliWorkerController } from './base-cli-worker-controller';
 import { BaseCliWorkerTerminalUI } from './base-cli-worker-terminal-ui';
-export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerController, TERMINAL_UI extends BaseCliWorkerTerminalUI<any>> {
+import { BaseCliMethodOptions } from './base-cli-worker.models';
+export interface BaseCliWorkerGuiUrlOptions {
+    domain?: string;
+    port?: number | null;
+    useHttps?: boolean;
+}
+export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerController<any>, TERMINAL_UI extends BaseCliWorkerTerminalUI<any> = any> {
     /**
      * unique id for service
      */
@@ -16,16 +23,34 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      * unique id for service
      */
     readonly serviceVersion: string;
+    /**
+     * Indicates if worker is part of cloud
+     * and should use cloud ip address
+     */
+    static readonly isCloudEnable: Pick<BehaviorSubject<boolean>, 'next' | 'getValue'>;
+    /**
+     * Cloud ip address of the worker (if part of cloud)
+     */
+    static readonly cloudIp: Pick<BehaviorSubject<string | null>, 'next' | 'getValue'>;
+    private static workers;
     readonly SPECIAL_WORKER_READY_MESSAGE = "$$$ WORKER_READY $$$";
+    /**
+     * dependency workers that should be started before this worker
+     */
+    readonly dependencyWorkers: Map<string, BaseCliWorker<any, any>>;
     readonly terminalUI: TERMINAL_UI;
     readonly workerContextTemplate: ReturnType<typeof Taon.createContextTemplate>;
-    private workerMainContext;
-    getRemoteControllerFor(ipAddressOfTaonInstance: string, port?: number): Promise<REMOTE_CTRL>;
-    private workerRemoteContext;
+    /**
+     * Name of the worker context
+     */
+    get contextName(): string;
+    /**
+     * Port where worker is running
+     * (getter only accessible from host machine)
+     */
+    get port(): number | undefined;
+    getWorkerInfoGuiUrl(options?: BaseCliWorkerGuiUrlOptions): string;
     readonly controllerClass: new () => REMOTE_CTRL;
-    private contextForRemoteConnection;
-    protected get pathToProcessLocalInfoJson(): string;
-    get processLocalInfoObj(): BaseCliWorkerConfig;
     constructor(
     /**
      * unique id for service
@@ -39,43 +64,66 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      * unique id for service
      */
     serviceVersion: string);
-    /**
-     * <strong>IMPORTANT USE ONLY IN DEVELOPMENT !!!</strong>
-     * for production use startDetachedIfNeedsToBeStarted()
-     * start normally process
-     * this will crash if process already started
-     */
-    startNormallyInCurrentProcess(options?: {
-        actionBeforeTerminalUI?: () => Promise<void>;
-    }): Promise<void>;
-    getControllerForRemoteConnection(options?: {
-        calledFrom?: string;
-    }): Promise<REMOTE_CTRL>;
-    startDetachedIfNeedsToBeStarted(options?: {
-        useCurrentWindowForDetach?: boolean;
-    }): Promise<any>;
+    static getAllWorkersStartedInSystemFromCurrentCli(): BaseCliWorker<any, any>[];
+    get processLocalInfoObj(): BaseCliWorkerConfig;
+    getRemoteControllerFor<ctrl = REMOTE_CTRL>(options?: {
+        methodOptions: Partial<BaseCliMethodOptions>;
+        /**
+         * Optionally get other controller from remote context
+         */
+        controllerClass?: new () => ctrl;
+    }): Promise<ctrl>;
     /**
      * stop if started
      */
     kill(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
         dontRemoveConfigFile?: boolean;
-    }): Promise<any>;
+    }): Promise<void>;
     /**
      * kill detached process and start again
      * @param options.detached - default true
      */
     restart(options?: {
-        detached?: boolean;
-        useCurrentWindowForDetach?: boolean;
+        methodOptions?: BaseCliMethodOptions;
     }): Promise<void>;
     /**
      * only for cli start
      * @param cliParams on from cli
      */
-    cliStartProcedure(cliParams: any): Promise<any>;
-    protected preventExternalConfigChange(): any;
-    protected preventStartIfAlreadyStarted(): Promise<void>;
-    protected killWorkerWithLowerVersion(): Promise<void>;
+    cliStartProcedure(options: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<{
+        controller: REMOTE_CTRL;
+        worker: BaseCliWorker<any, any>;
+        serviceId: string;
+    }>;
+    protected getRemoteContextFor(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<EndpointContext>;
+    protected get pathToProcessLocalInfoJson(): string;
+    protected get processLocalInfoPortNotInited(): boolean;
+    protected get workerIsStarting(): boolean;
+    protected startDetachedIfNeedsToBeStarted(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    /**
+     * <strong>IMPORTANT USE ONLY IN DEVELOPMENT !!!</strong>
+     * for production use startDetachedIfNeedsToBeStarted()
+     * start normally process
+     * this will crash if process already started
+     */
+    protected startNormallyInCurrentProcess(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+        actionBeforeTerminalUI?: () => Promise<void>;
+    }): Promise<void>;
+    protected preventExternalConfigChange(): void;
+    protected preventStartIfAlreadyStarted(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    protected killWorkerWithLowerVersion(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
     /**
      * This has 2 purposes:
      * - infinite check when when detached process finished starting
@@ -83,17 +131,20 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      */
     protected isServiceHealthy(options: {
         healthCheckRequestTrys?: number;
+        methodOptions?: Partial<BaseCliMethodOptions>;
     }): Promise<boolean>;
     /**
      * start if not started detached process
      */
     protected startDetached(options?: {
-        useCurrentWindowForDetach?: boolean;
+        methodOptions?: Partial<BaseCliMethodOptions>;
     }): Promise<void>;
     private saveProcessInfo;
-    protected initializeWorkerMetadata(): Promise<any>;
-    protected waitForProcessPortSavedToDisk(options?: {
-        calledFrom?: string;
+    protected initializeWorkerMetadata(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    protected waitForProcessPortSavedToDisk(options: {
+        methodOptions: BaseCliMethodOptions;
     }): Promise<void>;
-    getServicePort(): Promise<number>;
+    protected getServicePort(): Promise<number>;
 }

package/browser/lib/base/classes/base-cli-worker/base-cli-worker.models.d.ts

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { BaseClass } from 'taon/browser';
+interface BaseCliWorkerOptionCallable {
+    /**
+     * Name of the function from which the option was called
+     */
+    calledFrom: string;
+}
+export declare class BaseCliWorkerConfigGetContextOptions {
+    /**
+     * default localhost
+     */
+    ipAddressOfTaonInstance?: string;
+    /**
+     * if null nothing is used as port (ip address will be clean)
+     */
+    port?: number | null;
+}
+/**
+ * Default mode: DETACHED_CHILD_PROCESS
+ */
+export declare enum BaseCLiWorkerStartMode {
+    CHILD_PROCESS = "child",
+    IN_CURRENT_PROCESS = "process",
+    DETACHED_WINDOW = "window"
+}
+export declare class BaseCLiWorkerStartParams {
+    /**
+     * Start mode
+     * Default mode DETACHED_CHILD_PROCESS
+     */
+    mode: BaseCLiWorkerStartMode;
+    restart?: boolean;
+    kill?: boolean;
+}
+export declare class BaseCliMethodOptions extends BaseClass<BaseCliMethodOptions> implements BaseCliWorkerOptionCallable {
+    static from(opt?: Partial<BaseCliMethodOptions>): BaseCliMethodOptions;
+    connectionOptions?: BaseCliWorkerConfigGetContextOptions;
+    cliParams?: BaseCLiWorkerStartParams;
+    /**
+     * Name of the function from which the option was called
+     */
+    calledFrom: string;
+}
+export {};

package/browser/lib/base/classes/base-cli-worker/base-cli-worker.utils.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { BaseCliWorkerConfig } from './base-cli-worker-config';
+export declare namespace BaseCliWorkerUtils {
+    const getPathToProcessLocalInfoJson: (serviceID: string) => string;
+    const getAllServicesFromOS: () => BaseCliWorkerConfig[];
+}

package/browser/lib/base/classes/base-cli-worker/index.d.ts

@@ -1,6 +1,8 @@
 // @ts-nocheck
 export * from './base-cli-worker';
+export * from './base-cli-worker.models';
 export * from './base-cli-worker-database-config';
 export * from './base-cli-worker-controller';
 export * from './base-cli-worker-config';
-export * from './base-cli-worker-terminal-ui';
+export * from './base-cli-worker-terminal-ui';
+export * from './base-cli-worker.utils';

package/browser/lib/base/classes/base-docker.d.ts

@@ -1,5 +1,6 @@
 // @ts-nocheck
-import type { ChildProcess, StdioOptions } from 'child_process';
+import type { ChildProcess } from 'child_process';
+import { UtilsDocker } from '../../utils';
 import { BaseFeatureForProject } from './base-feature-for-project';
 import { BaseProject } from './base-project';
 export declare class BaseDocker<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
@@ -7,10 +8,6 @@ export declare class BaseDocker<PROJECT extends BaseProject = any> extends BaseF
      * Updates ports in .env file based on available ports range.
      */
     updateDockerComposePorts(): Promise<void>;
-    getDockerComposeUpExecChildProcess(action: 'up' | 'down', options?: {
-        composeFileName?: string;
-        cwd?: string;
-        env?: NodeJS.ProcessEnv;
-        stdio?: StdioOptions;
-    }): ChildProcess;
+    getDockerComposeActionChildProcess(action: UtilsDocker.DockerComposeActionType, options?: UtilsDocker.DockerComposeActionOptions): ChildProcess;
+    removeAllImagesBy_Env_COMPOSE_PROJECT_NAME(): Promise<void>;
 }

package/browser/lib/base/classes/base-git.d.ts

@@ -61,6 +61,7 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     resolveLastChanges(options?: {
         tryAutomaticActionFirst?: boolean;
         projectNameAsOutputPrefix?: string;
+        questionPrefixMessage?: string;
     }): Promise<void>;
     get hasActionCommitsToMelt(): boolean;
     /**
@@ -172,6 +173,7 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     }): Promise<void>;
     validateEmailDomain(allowedEmailsEnds: string[]): Promise<void>;
     protected _afterPullProcessAction(setOrigin: 'ssh' | 'http', skipCloneGitChildren?: boolean): Promise<void>;
+    backupBranch(branchName?: string): Promise<string>;
     pushProcess(options?: PushProcessOptions): Promise<void>;
     _beforeAnyActionOnGitRoot(): void;
     protected _beforePushProcessAction(setOrigin: 'ssh' | 'http'): Promise<void>;

package/browser/lib/base/classes/base-global-command-line.d.ts

@@ -0,0 +1,265 @@
+// @ts-nocheck
+import { PushProcessOptions } from '../../index';
+import { TypeOfCommit } from '../commit-data';
+import { BaseCommandLineFeature } from './base-command-line-feature';
+import { BaseProject } from './base-project';
+import type { BaseProjectResolver } from './base-project-resolver';
+export declare class BaseGlobalCommandLine<PARAMS = any, PROJECT extends BaseProject<any, any> = BaseProject<any, any>, PROJECT_RESOLVER extends BaseProjectResolver<PROJECT> = BaseProjectResolver<PROJECT>> extends BaseCommandLineFeature<PARAMS, PROJECT, PROJECT_RESOLVER> {
+    _(): void;
+    /**
+     * TODO return argument not need for now
+     */
+    cwdIsProject(options?: {
+        requireProjectWithGitRoot?: boolean;
+    }): Promise<boolean>;
+    hosts(): any;
+    countCommits(): any;
+    removeSubmodules(): any;
+    removeSubmodule(): any;
+    setEditor(): Promise<any>;
+    upapi(): Promise<any>;
+    apiup(): Promise<any>;
+    apiUpdate(): Promise<any>;
+    cu(): Promise<any>;
+    choreUpdate(): Promise<any>;
+    colorvscode(): any;
+    /**
+     * Generate or update .vscode/settings.json file color settings
+     */
+    settingsVscode(): any;
+    refreshVscodeColors(): any;
+    protected _regenerateVscodeSettingsColors(overideBottomColor?: string): void;
+    /**
+     * quick git update push
+     */
+    update(): Promise<any>;
+    private updateProject;
+    deepUp(noExit?: boolean): Promise<any>;
+    upAll(noExit?: boolean): Promise<any>;
+    deepUpForce(noExit?: boolean): Promise<any>;
+    deepUpdateForce(noExit?: boolean): Promise<any>;
+    deepUpdate(noExit?: boolean): Promise<any>;
+    /**
+     * Push update
+     */
+    up(): Promise<any>;
+    /**
+     * Push update
+     */
+    pu(): Promise<any>;
+    develop(): Promise<any>;
+    dev(): Promise<any>;
+    repul(): Promise<any>;
+    repull(): Promise<any>;
+    pul(): Promise<any>;
+    pull(): Promise<any>;
+    pullAll(): Promise<any>;
+    pp(): Promise<any>;
+    private __resetInfo;
+    fetch(): Promise<any>;
+    reset(): Promise<any>;
+    soft(): Promise<any>;
+    rebase(): Promise<any>;
+    /**
+     * stash only staged files
+     */
+    stash(): Promise<any>;
+    /**
+     * stash all files
+     */
+    stashAll(): Promise<any>;
+    /**
+     * push force to all origins
+     */
+    pushAllForce(): Promise<void>;
+    pAllForce(): Promise<void>;
+    pAllf(): Promise<void>;
+    pAll(): Promise<void>;
+    /**
+     * push to all origins
+     */
+    pushAll(force?: boolean): Promise<void>;
+    forcePush(): Promise<void>;
+    pushForce(): Promise<void>;
+    /**
+     * Commit and push this for single repo
+     */
+    commit(options?: {
+        force?: boolean;
+        typeofCommit?: TypeOfCommit;
+        origin?: string;
+        commitMessageRequired?: boolean;
+        noExit?: boolean;
+    }): Promise<void>;
+    _preventPushPullFromNotCorrectBranch(): Promise<void>;
+    qPush(): Promise<void>;
+    quickPush(): Promise<void>;
+    repushauto(): Promise<void>;
+    rePush(skipQuesion?: boolean): Promise<void>;
+    push(options?: PushProcessOptions): Promise<void>;
+    melt(): Promise<void>;
+    meltUp(): Promise<any>;
+    meltAll(): Promise<any>;
+    private __meltCommitsFunc;
+    private meltUpdateCommits;
+    pf(): Promise<any>;
+    pRel(): Promise<any>;
+    pRelease(): Promise<any>;
+    pushRelease(): Promise<any>;
+    mPush(): Promise<any>;
+    fmPush(): Promise<any>;
+    mfPush(): Promise<any>;
+    mforcePush(): Promise<any>;
+    meltforcePush(): Promise<any>;
+    forceMeltPush(): Promise<any>;
+    meltPush(force?: boolean): Promise<any>;
+    pushFeature(): Promise<any>;
+    pushFix(): Promise<any>;
+    pfix(): any;
+    pushChore(): Promise<any>;
+    pc(): Promise<any>;
+    pushRefactor(): Promise<any>;
+    pushref(): Promise<any>;
+    pref(): Promise<any>;
+    pushStyle(): Promise<any>;
+    pstyl(): Promise<any>;
+    pstyle(): Promise<any>;
+    pushDocs(): Promise<any>;
+    pd(): Promise<any>;
+    pdocs(): Promise<any>;
+    pushTest(): Promise<any>;
+    pTest(): Promise<any>;
+    pTests(): Promise<any>;
+    pushPerf(): Promise<any>;
+    pushCi(): Promise<any>;
+    branch(): Promise<any>;
+    pushBuild(): Promise<any>;
+    SET_ORIGIN(): Promise<any>;
+    RENAME_ORIGIN(): Promise<any>;
+    LAST_TAG_HASH(): Promise<any>;
+    LAST_TAG(): Promise<any>;
+    CHECK_TAG_EXISTS(): any;
+    /**
+     * TODO move somewhere
+     */
+    lint(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    version(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    init(): Promise<any>;
+    /**
+     * init parent and first level children
+     */
+    initAll(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    struct(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    info(): Promise<any>;
+    modified(): Promise<any>;
+    refresh(): Promise<void>;
+    changes(): Promise<any>;
+    allTags(): Promise<any>;
+    removeTag(): Promise<any>;
+    BRANCH_NAME(): any;
+    REMOTES(): any;
+    SET_REMOTE_SSH(): Promise<any>;
+    SET_REMOTE_http(): Promise<any>;
+    SET_REMOTE_https(): Promise<any>;
+    protected _resolveChildFromArg(): any;
+    origin(): any;
+    remote(): any;
+    originHttp(): any;
+    originHttps(): any;
+    originssh(): any;
+    origins(): any;
+    gitConfig(): any;
+    LAST_COMMIT_HASH(): any;
+    COMMIT_MESSAGE_BY_HASH(): Promise<any>;
+    LAST_5_COMMITS(): Promise<any>;
+    updateDepsFrom(): Promise<any>;
+    isSupportedTaonTerminal(): any;
+    isRunningInWindowsCmd(): any;
+    isRunningInWindowsPowerShell(): any;
+    INSTALL_PROJECT_EXTENSIONS(): Promise<void>;
+    INSTALL_PROJECT_EXT(): Promise<void>;
+    INS_PROJ_EXT(): Promise<void>;
+    INSTALL_PROJ_EXT(): Promise<void>;
+    projdb(): Promise<any>;
+    private __filterBranchesByPattern;
+    private __selectBrach;
+    clone(): Promise<any>;
+    ghSave(): Promise<any>;
+    ghRestore(): Promise<any>;
+    ports(): Promise<any>;
+    /**
+     * tnp startCliServicePortsWorker --restart
+     */
+    startCliServicePortsWorker(): Promise<void>;
+    waitForUserAnyKey(): Promise<any>;
+    pauseTerminal(): any;
+    sleepTerminal(): any;
+    ghPagesInit(): Promise<any>;
+    isPortInUse(): Promise<any>;
+    procInfo(): any;
+    processInfo(): any;
+    lastGitTag(): any;
+    checkPort(): Promise<any>;
+    checkPorts(): Promise<any>;
+    removeSymlinksDryRun(): any;
+    selectJava(): Promise<any>;
+    selectTomcat(): Promise<any>;
+    LN(): any;
+    copy(): any;
+    simulateDomain(): Promise<any>;
+    preview(): Promise<void>;
+    /**
+     * read huge file and display only lines with specyfic words
+     */
+    shorten(): Promise<any>;
+    dumpPackagesVersions(): void;
+    zip(): Promise<any>;
+    unzip(): Promise<any>;
+    startTransmission(): Promise<any>;
+    _removeTransmission(): Promise<any>;
+    backupBranch(): Promise<any>;
+    bb(): Promise<any>;
+    countCodeLines(): Promise<any>;
+    countCode(): Promise<any>;
+    countLines(): Promise<any>;
+    isNodeVersionOk(): any;
+    pwd(): void;
+    more(): Promise<any>;
+    less(): Promise<any>;
+    /**
+     *  npm install --global bin-version-check-cli
+     *  npm i -g yt-dlp
+     *  choco install ffmpeg
+     */
+    MP3(args: any): any;
+    MP4(args: any): any;
+    gif(): void;
+    killZs(): any;
+    startZs(): any;
+    zsKill(): any;
+    zsStart(): any;
+    startZscaller(): any;
+    killZscaller(): any;
+    hasCommand(): Promise<void>;
+    hasCommandSync(): void;
+    publicIpAddress(): Promise<void>;
+    publicIp(): Promise<void>;
+    localIps(): Promise<void>;
+    isOnline(): Promise<any>;
+    configureBash(): Promise<void>;
+    configureShell(): Promise<void>;
+    confBash(): void;
+    confShell(): void;
+}

package/browser/lib/base/classes/base-node-modules.d.ts

@@ -37,6 +37,7 @@ export declare class BaseNodeModules<NPM_HELPERS extends BaseNpmHelpers = BaseNp
     get realPath(): string;
     protected preventWrongLinkDestination(dest: string): string;
     linkToProject(project: Partial<BaseProject>): any;
+    copyToProject(project: BaseProject): void;
     linkToLocation(location: string): void;
     makeSureInstalled(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<void>;
     remove(options?: {

package/browser/lib/base/classes/base-npm-helpers.d.ts

@@ -39,6 +39,7 @@ export declare class BaseNpmHelpers<PROJECT extends BaseProject = BaseProject> e
             children: boolean;
         };
         skipQuestionToUser?: boolean;
+        messagePrefix?: string;
     }): Promise<boolean>;
     /**
      * @param registry when not specified, it will use the default npm registry

package/browser/lib/base/classes/base-release-process.d.ts

@@ -38,7 +38,9 @@ export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> =
     get toBumpProjects(): PROJECT[];
     bumpNewVersionEverywhere(): Promise<any>;
     confirmNewVersion(): Promise<void>;
-    protected selectReleaseType(versionToUseResolveFn?: (releaseVersionBumpType: CoreModels.ReleaseVersionType) => string): Promise<CoreModels.ReleaseVersionType>;
+    protected selectReleaseType(versionToUseResolveFn?: (releaseVersionBumpType: CoreModels.ReleaseVersionType) => string, options?: {
+        quesitonPrefixMessage?: string;
+    }): Promise<CoreModels.ReleaseVersionType>;
     protected commitMessageInChangelogTransformFn(message: string): Promise<string>;
     getChangelogContentToAppend(askForEveryItem: boolean): Promise<string>;
     /**

package/browser/lib/base/classes/base-vscode.d.ts

@@ -38,7 +38,7 @@ export declare class BaseVscodeHelpers<PROJECT extends BaseProject = any> extend
      */
     protected stripVersion(folderName: string): string;
     get installedExtensions(): string[];
-    applyProperGlobalSettings(): Promise<void>;
+    static applyProperGlobalSettings(): Promise<void>;
     /**
      * by default left menu color and bottom status bar are the same
      */

package/browser/lib/base/classes/index.d.ts

@@ -19,4 +19,5 @@ export * from './base-quick-fixes';
 export * from './base-cli-worker';
 export * from './base-process-manager';
 export * from './base-command-line-feature';
-export * from './base-file-folders-operations';
+export * from './base-file-folders-operations';
+export * from './base-global-command-line';

package/browser/lib/base/gh-temp-code.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { BaseProject } from './classes/base-project';
+/**
+ * Class to save and restore temporary code
+ * TODO fix removing files from repo
+ */
+export declare class GhTempCode {
+    private cwd;
+    private project;
+    constructor(cwd: string, project: BaseProject);
+    private GHTEMP_CODE_REPO_PATH;
+    private get cwdRepo();
+    private get tempPathRepo();
+    init(): any;
+    save(): Promise<any>;
+    restore(): Promise<any>;
+}