auto-deploy-sh 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025 yotomum_ml
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# Auto-deploy-sh
+
+English|[简体中文](README_zh_CN.md)
+
+Cloud service deployment is a crucial aspect of project engineering development and an important way to reach more users with applications. Currently, there are various methods for running projects on the cloud, among which **containerized deployment** has become the mainstream method for delivering cloud-native applications. The technology stack represented by **Docker + Kubernetes** can effectively address core issues such as **environment consistency, resource utilization, and portability** in the software development and deployment process ([Docker Official Documentation](https://docs.docker.com/)).
+
+In enterprise-level development, project deployment often relies on tools such as GitLab to establish a comprehensive **CI/CD** (Continuous Integration/Continuous Delivery) workflow. However, for individual developers or small teams, setting up and maintaining a complete CI/CD system is not only complex but also costly, making it difficult to implement quickly.
+
+So, how can individuals or small teams efficiently deploy projects? A common practice nowadays is to directly integrate Docker for deployment through an IDE (such as IntelliJ IDEA). However, this approach typically relies on **paid IDE versions**, requires cumbersome local configuration, and demands the installation of Docker CLI in the development environment, imposing certain technical thresholds and hardware and software requirements on users.
+
+This project aims to **reduce the deployment threshold**, achieve an automated Docker deployment process with **minimal configuration and minimal dependencies**, and help developers quickly deploy applications to cloud servers without requiring complex environments.
+
+## Explanation of configuration file attributes
+
+The configuration file name is fixed as `deploy-config.json` and stored in the root directory. Since it contains private information, if added manually, please add it to `.gitignore`.
+If the file is absent, the `CLI` will guide the addition process and update the content of `.gitignore` under the added location, requiring no additional operations.
+
+```javaScript
+{
+  input: 'Remote server IP or domain name',
+  port: 'SSH port',
+  user： 'Username',
+  password: 'password',
+  beforLaunch：[ // Preparation operations before project release
+    'npm run build'
+  ],
+  dockerBuildFiles: [ 
+    // The files involved in the construction, relative to the path where the script runs (usually the root directory of the project)
+    'Dockerfile',
+    'dist'
+  ],
+  imageTag: '镜像标识', // Format: [Warehouse Address/] [Username/Project Name]: [Label]
+  containerName: '容器名', // Unique identifier of Docker running instance
+  BindPorts: '端口映射' // Format: `<Host Port>:<Container Port>`
+}
+```
+
+## Package release
+
+### Partial configuration of the project
+
+Download: `npm install auto-deploy-sh -D `
+Run:
+
+```json
+// package.json configuration
+"scripts": {
+  "deploy": "auto-deploy-sh"
+}
+// Run
+npm run deploy
+```
+
+### 全局配置
+
+Download: `npm install auto-deploy-sh -g`
+Run in the root directory of the project that needs to be deployed: `auto-deploy-sh`
+

package/dist/bin/config.d.ts

@@ -0,0 +1 @@
+export declare function createConfig(rootPath: string): Promise<void>;

package/dist/bin/config.js

@@ -0,0 +1,69 @@
+import { fs, inquirer } from "./utils/index.js";
+import path from 'path';
+const configMethod = {
+    host: {
+        type: 'input',
+        message: '远程服务器 IP 或域名: ',
+    },
+    port: {
+        type: 'number',
+        message: 'SSH 端口: ',
+    },
+    user: {
+        type: 'input',
+        message: '用户名: ',
+    },
+    password: {
+        type: 'input',
+        message: '密码: ',
+    },
+    beforLaunch: {
+        type: 'input',
+        message: '项目发布前的前置命令(befor launch) 多个以 , 隔开: ',
+        handleFn: (value) => value.split(','),
+    },
+    dockerBuildFiles: {
+        type: 'input',
+        message: 'docker构建所需的文件相对根目录的路径(多个 , 隔开): ',
+        handleFn: (value) => value.split(','),
+    },
+    imageTag: {
+        type: 'input',
+        message: 'Image tag: ',
+    },
+    containerName: {
+        type: 'input',
+        message: 'Container name: ',
+    },
+    BindPorts: {
+        type: 'input',
+        message: 'Bind Ports(such as 8080:8080): ',
+    },
+};
+export async function createConfig(rootPath) {
+    const config = {};
+    const keys = Object.keys(configMethod);
+    for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        const fn = Object.hasOwn(configMethod[key], 'handleFn')
+            ? configMethod[key].handleFn
+            : (value) => {
+                if (typeof value === 'string')
+                    return value.trim();
+                else
+                    return value;
+            };
+        const value = (await inquirer.invoke(configMethod[key]));
+        config[key] = fn(value);
+    }
+    await fs.writeFileSync(path.resolve(rootPath, 'deploy-config.json'), JSON.stringify(config, null, 2));
+    const gitIgnorePath = path.resolve(rootPath, '.gitignore');
+    let contain = '';
+    if (await fs.exist(gitIgnorePath)) {
+        contain = (await fs.readDirOrFile(gitIgnorePath));
+    }
+    if (contain.includes('deploy-config.json'))
+        return;
+    contain += '\ndeploy-config.json\n';
+    fs.writeFileSync(gitIgnorePath, contain);
+}

package/dist/bin/deploy.d.ts

@@ -0,0 +1,31 @@
+import type { sshConfig } from './type/types';
+import type { Options } from 'execa';
+import type { NodeSSH } from 'node-ssh';
+export declare class Deploy {
+    config: sshConfig;
+    context: string;
+    uploadFileName: string;
+    remotePath: string;
+    REMOTEAPPPATH: string;
+    constructor(config: sshConfig, context: string);
+    runCommon(_options: {
+        command: string;
+        context?: string;
+        options?: Options;
+        args?: string[];
+    }, std: {
+        startMsg: string;
+        succMsg: string;
+        errMsg: string;
+    }): Promise<void>;
+    preBeforeRelease(): Promise<void>;
+    compressFiles(): Promise<void>;
+    uploadSSH(ssh: NodeSSH): Promise<void>;
+    execCommand(ssh: NodeSSH, std: {
+        startMsg: string;
+        succMsg: string;
+        errMsg?: string;
+    }, command: string): Promise<void>;
+    dockcerImageBuild(ssh: NodeSSH): Promise<void>;
+    clear(ssh: NodeSSH): Promise<void>;
+}

package/dist/bin/deploy.js

@@ -0,0 +1,232 @@
+import { log, ora, run, fs, exit, chalk } from "./utils/index.js";
+import path from 'path';
+import archiver from 'archiver';
+export class Deploy {
+    config;
+    context;
+    uploadFileName;
+    remotePath;
+    REMOTEAPPPATH = '/tmp/www/app';
+    constructor(config, context) {
+        this.config = config;
+        this.context = context;
+        this.uploadFileName = `${this.config.containerName}.tar.gz`;
+        this.remotePath = `/tmp/${this.uploadFileName}`;
+    }
+    async runCommon(_options, std) {
+        ora.start(std.startMsg);
+        const { command, options, args } = _options;
+        try {
+            const { stdout, stderr, failed, signal, exitCode } = await run(command, this.context, options, args);
+            const isFailure = failed || signal || exitCode !== 0;
+            if (isFailure) {
+                throw new Error(`${stderr}\nexecution ${command} failed`);
+            }
+            ora.stop('succeed', std.succMsg);
+            if (stdout) {
+                log.info(stdout);
+            }
+            if (stderr) {
+                log.warn(stderr);
+            }
+        }
+        catch (err) {
+            ora.stop('fail', std.errMsg);
+            log.error(err.message ?? '');
+            throw err;
+        }
+    }
+    async preBeforeRelease() {
+        if (this.config.beforLaunch) {
+            if (Array.isArray(this.config.beforLaunch)) {
+                for (let i = 0; i < this.config.beforLaunch.length; ++i) {
+                    const command = this.config.beforLaunch[i];
+                    command &&
+                        (await this.runCommon({ command, options: { reject: false } }, {
+                            startMsg: `start execution ${command}....`,
+                            succMsg: `success execution ${command}`,
+                            errMsg: `error execution ${command}`,
+                        }));
+                }
+            }
+            else {
+                log.error(`beforLaunch should be an array, but the type you set is ${typeof this.config.beforLaunch}`);
+                throw new Error();
+            }
+        }
+    }
+    async compressFiles() {
+        const files = [];
+        if (this.config.dockerBuildFiles && this.config.dockerBuildFiles.length > 0) {
+            let dockerfileFlag = false, dockerignoreFlag = false;
+            for (let i = 0; i < this.config.dockerBuildFiles.length; ++i) {
+                const file = this.config.dockerBuildFiles[i];
+                if (/\bDockerfile\b/.test(file)) {
+                    dockerfileFlag = true;
+                }
+                if (/\bDockerfile\b/.test(file)) {
+                    dockerignoreFlag = true;
+                }
+                if (dockerfileFlag && dockerignoreFlag)
+                    break;
+            }
+            if (!dockerfileFlag) {
+                this.config.dockerBuildFiles.push('Dockerfile');
+            }
+            if (!dockerignoreFlag && fs._.existsSync(path.resolve(this.context, '.dockerignore'))) {
+                this.config.dockerBuildFiles.push('.dockerignore');
+            }
+            this.config.dockerBuildFiles.forEach(async (file) => {
+                const fullPath = path.resolve(this.context, file);
+                if (fs._.existsSync(fullPath)) {
+                    files.push(fullPath);
+                }
+                else {
+                    log.error(`The file name is ${file}, and the file does not exist`);
+                    throw new Error();
+                }
+            });
+        }
+        else {
+            log.error(`The file to build the image cannot be empty. Please check whether dockerBuildFiles is set correctly`);
+            throw new Error();
+        }
+        const output = fs.createWriteStream(path.resolve(this.context, this.uploadFileName));
+        const archive = archiver('tar', { gzip: true, gzipOptions: { level: 9 } });
+        archive.pipe(output);
+        const waitForArchiveEnd = new Promise((resolve, rejects) => {
+            archive.on('error', function (err) {
+                log.error(`Error in compressed file`);
+                rejects(new Error(err.message));
+            });
+            archive.on('end', () => {
+                log.done(`✔ Success in compressed file`);
+                resolve('');
+            });
+        });
+        const fileNames = [];
+        for (const file of files) {
+            const fileName = path.basename(file);
+            fileNames.push(fileName);
+            if (await fs.isDirectory(file)) {
+                archive.directory(file, fileName);
+            }
+            else {
+                archive.file(file, { name: fileName });
+            }
+        }
+        await archive.finalize();
+        await waitForArchiveEnd;
+    }
+    async uploadSSH(ssh) {
+        await this.compressFiles();
+        const uploadPath = path.resolve(this.context, this.uploadFileName);
+        if (await fs.exist(uploadPath)) {
+            const state = await fs.getFileStat(uploadPath);
+            const localSize = state.size;
+            await ora.start('📤 开始上传...', async () => {
+                await ssh.putFile(uploadPath, this.remotePath);
+            }, status => {
+                if (status)
+                    return `文件上传完成`;
+                else {
+                    exit(1);
+                    return chalk.error(`exit code: 1`);
+                }
+            });
+            const exists = await ssh.execCommand(`test -f "${this.remotePath}" && echo "yes" || echo "no"`);
+            if (exists.stdout.trim() !== 'yes') {
+                log.error('文件上传检测失败');
+                throw new Error();
+            }
+            const sizeResult = await ssh.execCommand(`stat -c %s "${this.remotePath}"`);
+            const remoteSize = parseInt(sizeResult.stdout.trim(), 10);
+            if (isNaN(remoteSize)) {
+                log.error('无法获取远程文件大小');
+                throw new Error();
+            }
+            if (remoteSize !== localSize && remoteSize < localSize - 10) {
+                log.error(`文件大小不匹配: 本地=${localSize}, 远程=${remoteSize}`);
+                throw new Error();
+            }
+        }
+        else {
+            log.error(`The file to be uploaded is not found.`);
+            throw new Error();
+        }
+    }
+    async execCommand(ssh, std, command) {
+        if (!command || !std.startMsg || !std.succMsg || !ssh)
+            throw new Error();
+        ora.start(std.startMsg);
+        const { stderr, code } = await ssh.execCommand(command);
+        if (code !== 0 || (stderr && code !== 0)) {
+            ora.stop('fail', stderr);
+            throw new Error();
+        }
+        ora.stop('succeed', std.succMsg);
+        stderr && log.info(stderr);
+    }
+    async dockcerImageBuild(ssh) {
+        await this.uploadSSH(ssh);
+        try {
+            const REMOTEAPPPATH = this.REMOTEAPPPATH;
+            const CONTAINER_NAME = this.config.containerName;
+            const REMOTE_PATH = this.remotePath;
+            const IMAGE_TAG = this.config.imageTag;
+            const TARGET_DIR = `./${CONTAINER_NAME}`;
+            await this.execCommand(ssh, {
+                startMsg: 'Start decompress project....',
+                succMsg: 'Decompress project completed.',
+            }, `
+          if ! cd "${REMOTEAPPPATH}" &>/dev/null; then
+            mkdir -p "${REMOTEAPPPATH}";
+            cd "${REMOTEAPPPATH}";
+          fi
+          mkdir -p "${TARGET_DIR}"
+
+          if [ ! -f "${REMOTE_PATH}" ]; then
+            echo "❌ 错误：压缩包不存在: ${REMOTE_PATH}";
+            exit 1
+          fi
+          tar -xzf "${REMOTE_PATH}" -C "${TARGET_DIR}";
+      `);
+            await this.execCommand(ssh, {
+                startMsg: `🐳 构建镜像: ${IMAGE_TAG}...`,
+                succMsg: `🐳 构建镜像: ${IMAGE_TAG}成功.`,
+            }, `
+        cd "${REMOTEAPPPATH}"
+        docker build -t ${IMAGE_TAG} ${TARGET_DIR}
+      `);
+            await this.execCommand(ssh, {
+                startMsg: `🔄 停止并清理旧容器: ${CONTAINER_NAME}...`,
+                succMsg: `旧容器已经清理成功.`,
+            }, `
+        if docker inspect "${CONTAINER_NAME}" >/dev/null 2>&1; then
+          docker stop "${CONTAINER_NAME}";
+          docker rm "${CONTAINER_NAME}";
+        else
+          echo "ℹ️  容器 ${CONTAINER_NAME} 不存在，跳过清理";
+        fi
+      `);
+            await this.execCommand(ssh, {
+                startMsg: `🐳 启动容器: ${CONTAINER_NAME}...`,
+                succMsg: `🐳 启动容器成功.`,
+            }, `
+        docker run -d --name ${CONTAINER_NAME} -p ${this.config.BindPorts} ${IMAGE_TAG}
+      `);
+            log.done('✔ 部署完成');
+        }
+        catch {
+            log.error('✖ 部署失败');
+        }
+        finally {
+            await this.clear(ssh);
+        }
+    }
+    async clear(ssh) {
+        await ssh.execCommand(`rm -f ${this.remotePath}`);
+        await ssh.execCommand(`rm -rf ${this.REMOTEAPPPATH}/${this.config.containerName}`);
+        await ssh.execCommand(`docker image prune -f`);
+    }
+}

package/dist/bin/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import path from 'path';
+import { NodeSSH } from 'node-ssh';
+import { log, ora, exit, chalk, fs } from "./utils/index.js";
+import { Deploy } from "./deploy.js";
+import { createConfig } from "./config.js";
+const ssh = new NodeSSH();
+const CONFIG_FILE = 'deploy-config.json';
+const CONFIG_FILE_PATH = path.resolve(process.cwd(), `./${CONFIG_FILE}`);
+async function deploySSH() {
+    if (await fs.exist(CONFIG_FILE_PATH)) {
+        let config = JSON.parse((await fs.readDirOrFile(CONFIG_FILE_PATH, { encoding: 'utf-8' })));
+        if (!config.BindPorts.includes(':')) {
+            log.error('Config BindPorts do not meet the standard');
+            exit(1);
+        }
+        await ora.start('conneting ssh...', async () => await ssh.connect({
+            host: config.host,
+            port: config.port,
+            username: config.user,
+            password: config.password,
+        }), status => {
+            if (status)
+                return `SSH连接成功！`;
+            else {
+                log.error('SSH连接失败！');
+                exit(1);
+                return chalk.error(`exit code: 1`);
+            }
+        });
+        const deploy = new Deploy(config, process.cwd());
+        try {
+            await deploy.preBeforeRelease();
+            await deploy.dockcerImageBuild(ssh);
+        }
+        catch {
+            exit(1);
+        }
+        finally {
+            fs.removeSync(path.resolve(process.cwd(), deploy.uploadFileName));
+            ssh.dispose();
+        }
+    }
+    else {
+        log.error(`⚠️ 在根目录下未找到配置文件 ${CONFIG_FILE}，将引导创建... `);
+        await createConfig(process.cwd());
+        deploySSH();
+    }
+}
+deploySSH();

package/dist/bin/type/inquirer.d.ts

@@ -0,0 +1,47 @@
+export declare const inquirerTypes: {
+    readonly INPUT: "input";
+    readonly SELECT: "select";
+    readonly CHECKBOX: "checkbox";
+    readonly CONFIRM: "confirm";
+    readonly NUMBER: "number";
+};
+export type inquirerType = (typeof inquirerTypes)[keyof typeof inquirerTypes];
+export type Choice<Value> = {
+    value: Value;
+    name?: string;
+    description?: string;
+    short?: string;
+    disabled?: boolean | string;
+};
+type theme = {
+    prefix?: string | {
+        idle: string;
+        done: string;
+    };
+    spinner?: {
+        interval: number;
+        frames: string[];
+    };
+    style?: {
+        answer?: (_text: string) => string;
+        message?: (_text: string, _status: 'idle' | 'done' | 'loading') => string;
+        error?: (_text: string) => string;
+        defaultAnswer?: (_text: string) => string;
+        [key: string]: any;
+    };
+    icon?: {
+        checked?: string;
+        unchecked?: string;
+        cursor?: string;
+    };
+    helpMode?: 'always' | 'never' | 'auto';
+};
+export interface inquirerOptions<T = any> {
+    type: inquirerType;
+    message: string;
+    default?: string | boolean | T;
+    choices?: readonly (Choice<T> | string | any)[];
+    theme?: theme;
+    [key: string]: any;
+}
+export {};

package/dist/bin/type/inquirer.js

@@ -0,0 +1,7 @@
+export const inquirerTypes = {
+    INPUT: 'input',
+    SELECT: 'select',
+    CHECKBOX: 'checkbox',
+    CONFIRM: 'confirm',
+    NUMBER: 'number',
+};

package/dist/bin/type/types.d.ts

@@ -0,0 +1,32 @@
+export type Error = NodeJS.ErrnoException | null;
+export type sshConfig = {
+    host: string;
+    port: number | string;
+    user: string;
+    password: string;
+    beforLaunch: string[];
+    dockerBuildFiles: string[];
+    imageTag: string;
+    containerName: string;
+    BindPorts: string;
+};
+export type fileData = string | NodeJS.ArrayBufferView;
+import type { promises } from 'fs';
+interface StreamOptions {
+    flags?: string | undefined;
+    encoding?: BufferEncoding | undefined;
+    fd?: number | promises.FileHandle | undefined;
+    mode?: number | undefined;
+    autoClose?: boolean | undefined;
+    emitClose?: boolean | undefined;
+    start?: number | undefined;
+    signal?: AbortSignal | null | undefined;
+    highWaterMark?: number | undefined;
+}
+interface streamOptions extends StreamOptions {
+    fs?: any | null | undefined;
+    end?: number | undefined;
+    flush?: boolean | undefined;
+}
+export type ReadStreamOptions = BufferEncoding | streamOptions;
+export {};

package/dist/bin/type/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bin/utils/chalk.d.ts

@@ -0,0 +1,9 @@
+export declare const chalk: {
+    _: import("chalk").ChalkInstance;
+    warn: import("chalk").ChalkInstance;
+    error: import("chalk").ChalkInstance;
+    info: import("chalk").ChalkInstance;
+    done: import("chalk").ChalkInstance;
+    primary: import("chalk").ChalkInstance;
+    stress: import("chalk").ChalkInstance;
+};

package/dist/bin/utils/chalk.js

@@ -0,0 +1,10 @@
+import _chalk from 'chalk';
+export const chalk = {
+    _: _chalk,
+    warn: _chalk.yellow,
+    error: _chalk.hex('#F56C6C'),
+    info: _chalk.hex('#F2F6FC'),
+    done: _chalk.hex('#67C23A'),
+    primary: _chalk.hex('#409EFF'),
+    stress: _chalk.hex('#d3fac1'),
+};

package/dist/bin/utils/fse.d.ts

@@ -0,0 +1,20 @@
+import _fs from 'fs-extra';
+import type { Error, fileData, ReadStreamOptions } from '../type/types.ts';
+import type { PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions } from 'fs';
+export declare class fs {
+    static _: typeof _fs;
+    static exist(path: string, callbak?: (_err: Error, _exists: boolean) => void | Promise<boolean>): Promise<boolean>;
+    static getFileStat(path: string): Promise<_fs.Stats>;
+    static isDirectory(path: string): Promise<Boolean>;
+    static removeSync(path: string): void;
+    static remove(path: string, callbak?: (_err: Error, _status: boolean) => Promise<boolean>): Promise<boolean>;
+    static writeFileSync(file: PathOrFileDescriptor, data: fileData, options?: WriteFileOptions): Promise<void>;
+    static mkdirSync(path: string, options?: MakeDirectoryOptions): string | undefined;
+    static readDirOrFile(path: string, options?: {
+        encoding?: BufferEncoding | null | undefined;
+        flag?: string | null;
+        signal?: any;
+    }, callbak?: (_err: Error, _data: Buffer | Buffer[] | string | string[]) => void): Promise<string | string[] | Buffer<ArrayBufferLike> | Buffer<ArrayBufferLike>[]>;
+    static createReadStream(path: string, options?: ReadStreamOptions): Promise<_fs.ReadStream>;
+    static createWriteStream(path: string, options?: ReadStreamOptions): _fs.WriteStream;
+}

package/dist/bin/utils/fse.js

@@ -0,0 +1,117 @@
+import _fs from 'fs-extra';
+import { log } from "./logger.js";
+import _path from 'path';
+export class fs {
+    static _ = _fs;
+    static async exist(path, callbak) {
+        const _callbak = (err, exists) => {
+            if (callbak) {
+                callbak(err, exists);
+            }
+            else if (err) {
+                log.error(`${err}`);
+                return Promise.reject(false);
+            }
+            return Promise.resolve(exists);
+        };
+        let _exists = false, _err = null;
+        await _fs.pathExists(path).then((exists) => (_exists = exists), (err) => (_err = err));
+        return _callbak(_err, _exists);
+    }
+    static async getFileStat(path) {
+        const exist = await fs.exist(path);
+        if (!exist) {
+            log.error(`The file does not exist in ${path}`);
+            return Promise.reject(null);
+        }
+        return Promise.resolve(_fs.statSync(path));
+    }
+    static async isDirectory(path) {
+        const stat = await fs.getFileStat(path);
+        return Promise.resolve(stat?.isDirectory() ?? false);
+    }
+    static removeSync(path) {
+        _fs.removeSync(path);
+    }
+    static async remove(path, callbak) {
+        const _callbak = (err, status) => {
+            if (callbak) {
+                callbak(err, status);
+            }
+            else if (err) {
+                log.error(`${err}`);
+                return Promise.reject(err);
+            }
+            return Promise.resolve(status);
+        };
+        let status = false, err = null;
+        const exist = await fs.exist(path);
+        if (!exist) {
+            status = true;
+        }
+        else {
+            await _fs.remove(path).then(() => (status = true), _err => {
+                status = false;
+                err = _err;
+            });
+        }
+        return _callbak(err, status);
+    }
+    static async writeFileSync(file, data, options) {
+        _fs.writeFileSync(file, data, options);
+    }
+    static mkdirSync(path, options) {
+        const _options = Object.assign({
+            recursive: true,
+        }, options);
+        return _fs.mkdirSync(path, _options);
+    }
+    static async readDirOrFile(path, options, callbak) {
+        let _options = Object.assign({
+            encoding: 'utf8',
+            flag: 'r',
+        }, options);
+        const _callbak = (err, data) => {
+            if (callbak) {
+                callbak(err, data);
+            }
+            else if (err) {
+                log.error(`${err}`);
+                return Promise.reject(err);
+            }
+            return Promise.resolve(data);
+        };
+        let _err = null, _data = Buffer.from('');
+        const isDirectory = (await fs.getFileStat(path))?.isDirectory();
+        try {
+            if (isDirectory) {
+                _data = await _fs.readdir(path, _options);
+            }
+            else {
+                _data = await _fs.readFile(path, _options);
+            }
+        }
+        catch (err) {
+            _err = err;
+        }
+        return _callbak(_err, _data);
+    }
+    static async createReadStream(path, options) {
+        const exist = await fs.exist(path);
+        if (!exist) {
+            log.error(`The file does not exist in ${path}`);
+            return Promise.reject(`The file does not exist in ${path}`);
+        }
+        return Promise.resolve(_fs.createReadStream(path, options).on('error', err => log.error(`${err}`)));
+    }
+    static createWriteStream(path, options) {
+        const dir = _path.dirname(path);
+        try {
+            fs.mkdirSync(dir);
+        }
+        catch (err) {
+            log.error(`${err}`);
+        }
+        return _fs.createWriteStream(path, options).on('error', err => log.error(`${err}`));
+    }
+}

package/dist/bin/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './logger.ts';
+export * from './chalk.ts';
+export * from './ora.ts';
+export * from './process.ts';
+export * from './fse.ts';
+export * from './inquirer.ts';

package/dist/bin/utils/index.js

@@ -0,0 +1,6 @@
+export * from "./logger.js";
+export * from "./chalk.js";
+export * from "./ora.js";
+export * from "./process.js";
+export * from "./fse.js";
+export * from "./inquirer.js";

package/dist/bin/utils/inquirer.d.ts

@@ -0,0 +1,11 @@
+import type { inquirerOptions } from '../type/inquirer.ts';
+export declare class inquirer {
+    static enumMethod: {
+        readonly INPUT: "input";
+        readonly SELECT: "select";
+        readonly CHECKBOX: "checkbox";
+        readonly CONFIRM: "confirm";
+    };
+    private static _enumMethod;
+    static invoke(options: inquirerOptions): any;
+}

package/dist/bin/utils/inquirer.js

@@ -0,0 +1,61 @@
+import { input, select, checkbox, confirm, number } from '@inquirer/prompts';
+import { chalk } from "./chalk.js";
+export class inquirer {
+    static enumMethod = {
+        INPUT: 'input',
+        SELECT: 'select',
+        CHECKBOX: 'checkbox',
+        CONFIRM: 'confirm',
+    };
+    static _enumMethod = {
+        input: input,
+        select: select,
+        checkbox: checkbox,
+        confirm: confirm,
+        number: number,
+    };
+    static invoke(options) {
+        const { type, ...args } = options;
+        switch (type) {
+            case 'checkbox':
+                args.message += ` Select by ${chalk.stress('Space bar check/cancel')}. Submit by ${chalk.stress('Enter')}`;
+                args.theme = {
+                    style: {
+                        description: (des) => chalk.stress(des),
+                    },
+                    icon: {
+                        unchecked: '○',
+                    },
+                    ...options.theme,
+                };
+                break;
+            case 'confirm':
+                args.theme = {
+                    prefix: chalk.warn('✔'),
+                    style: {
+                        answer: (text) => chalk.done(text),
+                        error: (text) => chalk.error(text),
+                    },
+                };
+                break;
+            case 'select':
+                if (!args.theme || !args.theme.spinner) {
+                    args.theme = {
+                        spinner: {
+                            interval: 80,
+                            frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+                        },
+                        ...args.theme,
+                        style: {
+                            description: (des) => chalk.stress(des),
+                            ...options.theme?.style,
+                        },
+                    };
+                }
+                break;
+            default:
+                break;
+        }
+        return inquirer._enumMethod[type](args);
+    }
+}

package/dist/bin/utils/logger.d.ts

@@ -0,0 +1,10 @@
+declare class LogClass {
+    log(msg: string, label?: string): void;
+    warn(msg: string, label?: string): void;
+    error(msg: string, label?: string): void;
+    info(msg: string, label?: string): void;
+    done(msg: string, label?: string): void;
+    primary(msg: string, label?: string): void;
+}
+export declare const log: LogClass;
+export {};

package/dist/bin/utils/logger.js

@@ -0,0 +1,46 @@
+import { chalk } from "./chalk.js";
+function format(msg, label = '') {
+    return label
+        ? `[${label}]:${msg
+            .split('\n')
+            .map((line, i) => line.padStart((i !== 0 ? label.length : 0) + line.length + 1))
+            .join('\n')}`
+        : msg;
+}
+class LogClass {
+    log(msg, label = '') {
+        console.log(format(msg, label));
+    }
+    warn(msg, label = '') {
+        if (!label) {
+            label = 'Warning';
+            msg.startsWith('Warning:') && (msg = msg.replace('Warning:', '').trimStart());
+        }
+        console.warn(chalk.warn(format(msg, label)));
+    }
+    error(msg, label = '') {
+        if (!label) {
+            label = 'Error';
+            msg.startsWith('Error:') && (msg = msg.replace('Error:', '').trimStart());
+        }
+        console.error(chalk.error(format(msg, label)));
+    }
+    info(msg, label = '') {
+        if (!label) {
+            label = 'Info';
+            msg.startsWith('Info:') && (msg = msg.replace('Info:', '').trimStart());
+        }
+        console.error(chalk.info(format(msg, label)));
+    }
+    done(msg, label = '') {
+        if (!label) {
+            label = 'Done';
+            msg.startsWith('Done:') && (msg = msg.replace('Done:', '').trimStart());
+        }
+        console.log(chalk.done(format(msg, label)));
+    }
+    primary(msg, label = '') {
+        console.log(chalk.primary(format(msg, label)));
+    }
+}
+export const log = new LogClass();

package/dist/bin/utils/ora.d.ts

@@ -0,0 +1,12 @@
+import _ora from 'ora';
+import type { Ora, Options, PersistOptions } from 'ora';
+import type { Error } from '../type/types.ts';
+export declare class ora {
+    private static spinner?;
+    static _: typeof _ora;
+    static start(options: string | Options, fn?: Function, callbak?: (_status: boolean, _err?: Error | any) => string): Promise<void>;
+    static text(text: string): void;
+    static stop(type?: 'info' | 'warn' | 'fail' | 'succeed', text?: string): void;
+    static stopAndPersist(options?: PersistOptions): void;
+    static hasSpinner(): Ora | null | undefined;
+}

package/dist/bin/utils/ora.js

@@ -0,0 +1,73 @@
+import _ora from 'ora';
+import { chalk } from "./chalk.js";
+export class ora {
+    static spinner;
+    static _ = _ora;
+    static async start(options, fn, callbak) {
+        let _options = {
+            spinner: 'dots',
+            color: 'blue',
+            text: '...',
+        };
+        const isText = typeof options == 'string';
+        if (isText) {
+            _options['text'] = options;
+        }
+        else {
+            _options = {
+                ..._options,
+                ...options,
+            };
+        }
+        if (ora.spinner)
+            ora.spinner?.stop();
+        ora.spinner = _ora(_options);
+        ora.spinner.start();
+        if (fn) {
+            let _err = null;
+            let status = false;
+            try {
+                if (fn.constructor.name === 'AsyncFunction') {
+                    await fn().then(() => (status = true), () => (status = false));
+                }
+                else {
+                    fn();
+                    status = true;
+                }
+            }
+            catch (err) {
+                _err = err;
+                status = false;
+            }
+            finally {
+                if (status) {
+                    ora.stop('succeed', callbak ? callbak(status) : chalk.done(`Succeed ${isText ? options : 'done'}`));
+                }
+                else {
+                    ora.stop('fail', callbak ? callbak(status, _err) : chalk.error(`Error: ${_err}`));
+                }
+            }
+        }
+    }
+    static text(text) {
+        ora.spinner && (ora.spinner.text = text);
+    }
+    static stop(type, text) {
+        if (!type)
+            ora.spinner?.stop();
+        else
+            ora.spinner && ora.spinner[type](text);
+        ora.spinner = null;
+    }
+    static stopAndPersist(options) {
+        ora.spinner &&
+            ora.spinner.stopAndPersist({
+                symbol: chalk.done('✔'),
+                ...options,
+            });
+        ora.spinner = null;
+    }
+    static hasSpinner() {
+        return ora.spinner;
+    }
+}

package/dist/bin/utils/process.d.ts

@@ -0,0 +1,42 @@
+import type { Options } from 'execa';
+export declare function exit(code: number): void;
+export declare function run(command: string, context?: string, options?: Options, args?: string[]): Promise<never> | import("execa").ResultPromise<{
+    preferLocal?: boolean;
+    localDir?: string | URL;
+    node?: boolean;
+    nodeOptions?: readonly string[];
+    nodePath?: string | URL;
+    shell?: boolean | string | URL;
+    cwd: string | URL;
+    env?: Readonly<Partial<Record<string, string>>>;
+    extendEnv?: boolean;
+    input?: string | Uint8Array | import("stream").Readable;
+    inputFile?: string | URL;
+    stdin?: import("execa/types/stdio/type").StdinOptionCommon<false>;
+    stdout?: import("execa/types/stdio/type").StdoutStderrOptionCommon<false>;
+    stderr?: import("execa/types/stdio/type").StdoutStderrOptionCommon<false>;
+    stdio?: import("execa/types/stdio/type").StdioOptionsProperty<false>;
+    all?: boolean;
+    encoding?: import("execa/types/arguments/encoding-option").EncodingOption;
+    lines?: import("execa/types/arguments/specific").FdGenericOption<boolean>;
+    stripFinalNewline?: import("execa/types/arguments/specific").FdGenericOption<boolean>;
+    maxBuffer?: import("execa/types/arguments/specific").FdGenericOption<number>;
+    buffer?: import("execa/types/arguments/specific").FdGenericOption<boolean>;
+    ipc?: boolean;
+    serialization?: "json" | "advanced";
+    ipcInput?: import("execa").Message;
+    verbose?: import("execa/types/verbose").VerboseOption;
+    reject?: boolean;
+    timeout?: number;
+    cancelSignal?: AbortSignal;
+    gracefulCancel?: boolean;
+    forceKillAfterDelay?: number | boolean;
+    killSignal?: keyof import("os").SignalConstants | number;
+    detached?: boolean;
+    cleanup?: boolean;
+    uid?: number;
+    gid?: number;
+    argv0?: string;
+    windowsHide?: boolean;
+    windowsVerbatimArguments?: boolean;
+}>;

package/dist/bin/utils/process.js

@@ -0,0 +1,31 @@
+import { log } from "./logger.js";
+import { execa } from 'execa';
+export function exit(code) {
+    try {
+        if (code > 0) {
+            process.exit(code);
+        }
+        else {
+            throw Error('The code for process exit must be greater than zero');
+        }
+    }
+    catch (err) {
+        log.error(`${err}`);
+    }
+}
+export function run(command, context, options, args) {
+    if (command === '' || !command) {
+        log.error('command cannot be empty');
+        return Promise.reject();
+    }
+    const _context = context ?? process.cwd();
+    let cmd = command;
+    if (!args) {
+        const parts = command.trim().split(/\s+/);
+        cmd = parts[0];
+        if (parts.length > 1) {
+            args = parts.slice(1);
+        }
+    }
+    return execa(cmd, args, { cwd: _context, ...options });
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "auto-deploy-sh",
+  "version": "1.0.0",
+  "description": "Automated Docker deployment tool",
+  "bin": {
+    "auto-deploy-sh": "./dist/bin/index.js"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/bin/index.js",
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.bulid.json",
+    "clean": "rimraf dist build",
+    "deploy": "node ./ts-node bin/index.ts",
+    "lint:eslint": "eslint --cache --ext .ts,.vue,.js,.jsx,.tsx,.json",
+    "lint:eslint:fix": "eslint --cache --ext .ts,.vue,.js,.jsx,.tsx,.json --fix",
+    "prepare": "husky",
+    "prepack": "npm run build",
+    "postbuild": "node ./postbuild.js"
+  },
+  "keywords": [
+    "Automated",
+    "Lower deployment threshold",
+    "deployment",
+    "Minimalist configuration"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yotomum-ml/auto-deploy-sh.git"
+  },
+  "author": "yotomum_ml",
+  "license": "ISC",
+  "lint-staged": {
+    "*.{js,ts,jsx,tsx,vue,css,json}": [
+      "eslint"
+    ],
+    "*.md": [
+      "prettier --check"
+    ]
+  },
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chalk": "^5.6.2",
+    "execa": "^9.6.0",
+    "fs-extra": "^11.3.1",
+    "inquirer": "^12.9.6",
+    "node-ssh": "^13.2.1",
+    "ora": "^8.2.0",
+    "readline-sync": "^1.4.10",
+    "ssh2": "^1.17.0",
+    "ts-node": "^10.9.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/css": "^0.8.1",
+    "@eslint/js": "^9.29.0",
+    "@eslint/json": "^0.12.0",
+    "@stylistic/eslint-plugin": "^4.4.1",
+    "@types/archiver": "^6.0.3",
+    "@types/fs-extra": "^11.0.4",
+    "auto-deploy-sh": "file:auto-deploy-sh-1.0.0.tgz",
+    "eslint": "^9.27.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.4.1",
+    "eslint-plugin-vue": "^10.2.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.5.2",
+    "node-notifier": "^10.0.1",
+    "rimraf": "^5.0.10",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1"
+  }
+}