esa-cli 0.0.1-beta.1

package/dist/libs/git/index.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { execSync } from 'child_process';
+import { exit } from 'process';
+export function isInstalledGit() {
+    try {
+        execSync('git --version');
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function isGitConfigured() {
+    try {
+        execSync('git config --get user.name');
+        execSync('git config --get user.email');
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function cloneRepository(url, path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            execSync(`git clone ${url} ${path}`, { stdio: 'inherit' });
+            console.log('Repository cloned successfully.');
+        }
+        catch (error) {
+            console.error('Error occurred while cloning the repository:', error);
+            exit(0);
+        }
+    });
+}
+export function installGit(path) {
+    try {
+        execSync('git init', { stdio: 'inherit', cwd: path });
+        console.log('Git has been installed successfully.');
+    }
+    catch (error) {
+        console.error('Error occurred during Git installation:', error);
+        exit(0);
+    }
+}

package/dist/libs/interface.js

@@ -0,0 +1,21 @@
+export var Environment;
+(function (Environment) {
+    Environment["Production"] = "production";
+    Environment["Staging"] = "staging";
+})(Environment || (Environment = {}));
+export var PublishType;
+(function (PublishType) {
+    PublishType["Staging"] = "staging";
+    PublishType["Production"] = "production";
+    PublishType["Canary"] = "canary";
+})(PublishType || (PublishType = {}));
+var BasicType;
+(function (BasicType) {
+    BasicType["Basic"] = "basic";
+})(BasicType || (BasicType = {}));
+var UpgradeTargetTypes;
+(function (UpgradeTargetTypes) {
+    UpgradeTargetTypes["Medium"] = "medium";
+    UpgradeTargetTypes["High"] = "high";
+    UpgradeTargetTypes["Enterprise"] = "enterprise";
+})(UpgradeTargetTypes || (UpgradeTargetTypes = {}));

package/dist/libs/logger.js

@@ -0,0 +1,149 @@
+import chalk from 'chalk';
+import { format, createLogger, transports } from 'winston';
+import Table from 'cli-table3';
+import path from 'path';
+import os from 'os';
+import ora from 'ora';
+import { fileURLToPath } from 'url';
+import t from '../i18n/index.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+class Logger {
+    constructor() {
+        const { combine, timestamp, label, printf } = format;
+        const customFormat = printf(({ level, message, label: printLabel, timestamp: printTimestamp }) => {
+            let colorizedLevel;
+            switch (level) {
+                case 'error':
+                    colorizedLevel = chalk.bgRed(' ERROR ');
+                    return `❌ ${colorizedLevel} ${chalk.red(message)}`;
+                case 'verbose':
+                    colorizedLevel = chalk.magenta(level);
+                    break;
+                case 'debug':
+                    colorizedLevel = chalk.grey(level);
+                    break;
+                case 'silly':
+                    colorizedLevel = chalk.white(level);
+                    break;
+                default:
+                    colorizedLevel = level;
+            }
+            return `${printTimestamp} [${chalk.green(printLabel)}] ${colorizedLevel}: ${message}`;
+        });
+        this.logger = createLogger({
+            level: 'info',
+            format: combine(label({ label: 'Esa' }), timestamp(), customFormat),
+            transports: [
+                new transports.Console(),
+                new transports.File({
+                    filename: path.join(os.homedir(), '.asea-logs/esa-debug.log'),
+                    level: 'error'
+                })
+            ]
+        });
+        this.spinner = ora('Loading...');
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+            // Object.freeze(Logger.instance);
+        }
+        return Logger.instance;
+    }
+    get ora() {
+        return this.spinner;
+    }
+    setLogLevel(level) {
+        this.logger.level = level;
+    }
+    log(message) {
+        console.log(message);
+    }
+    subLog(message) {
+        console.log(`\t${message}`);
+    }
+    success(message) {
+        console.log(`🎉 ${chalk.bgGreen(' SUCCESS ')} ${chalk.green(message)}`);
+    }
+    debug(message) {
+        this.logger.debug(message);
+    }
+    info(message) {
+        console.log(`💬 ${message}`);
+    }
+    ask(message) {
+        console.log(`❓ ${message}`);
+    }
+    point(message) {
+        console.log(`👉🏻 ${chalk.green(message)}`);
+    }
+    block() {
+        console.log(' ');
+    }
+    warn(message) {
+        console.log(`${chalk.bgYellow(' WARNING ')} ${chalk.yellow(message)}`);
+    }
+    error(message) {
+        this.logger.error(message);
+    }
+    subError(message) {
+        console.log(` ${chalk.red(message)}`);
+    }
+    http(message) {
+        this.logger.http(message);
+    }
+    url(message) {
+        console.log(`🔗 ${chalk.blue(message)}`);
+    }
+    verbose(message) {
+        this.logger.verbose(message);
+    }
+    silly(message) {
+        this.logger.silly(message);
+    }
+    announcement(message) {
+        // todo
+        console.log(message);
+    }
+    notInProject() {
+        const initCommand = chalk.green('esa init');
+        this.logger.error(t('common_not_edge_project', { initCommand }).d(`You are not in an esa project, Please run ${initCommand} to initialize a project, or enter an esa project.`));
+    }
+    pathEacces(localPath) {
+        this.block();
+        this.log(chalk.yellow(t('common_eacces_intro', { localPath }).d(`You do not have permission to ${localPath}, please use`)));
+        this.block();
+        this.log(chalk.green(`$ ${chalk.red('sudo')} esa <Command>`));
+        this.block();
+        this.subLog(chalk.yellow('OR'));
+        this.block();
+        this.log(chalk.green(`$ sudo chmod -R 777 ${localPath}`));
+    }
+    table(head, data) {
+        const table = new Table({
+            head
+        });
+        table.push(...data);
+        this.log(table.toString());
+        this.block();
+    }
+    tree(messages) {
+        if (messages.length === 0)
+            return;
+        if (messages.length === 1) {
+            console.log(`─ ${messages[0]}`);
+            return;
+        }
+        console.log(`╭─ ${messages[0]}`);
+        for (let i = 1; i < messages.length - 1; i++) {
+            console.log(`│`);
+            console.log(`├─ ${messages[i]}`);
+        }
+        if (messages.length > 1) {
+            console.log(`│`);
+            console.log(`╰─ ${messages[messages.length - 1]}`);
+        }
+    }
+}
+const logger = Logger.getInstance();
+export default logger;

package/dist/libs/request.js

@@ -0,0 +1,98 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fetch, { Headers } from 'node-fetch';
+class HttpRequest {
+    constructor(defaultHeaders = {
+        'Content-Type': 'application/json'
+    }, timeout = 15000, retryCount = 3) {
+        this.defaultHeaders = new Headers(defaultHeaders);
+        this.timeout = timeout;
+        this.retryCount = retryCount;
+    }
+    static getInstance(defaultHeaders, timeout, retryCount) {
+        if (!HttpRequest.instance) {
+            HttpRequest.instance = new HttpRequest(defaultHeaders, timeout, retryCount);
+            Object.freeze(HttpRequest.instance);
+        }
+        return HttpRequest.instance;
+    }
+    fetchWithTimeout(url_1) {
+        return __awaiter(this, arguments, void 0, function* (url, options = {}) {
+            const controller = new AbortController();
+            const id = setTimeout(() => controller.abort(), this.timeout);
+            options.signal = controller.signal;
+            try {
+                return yield fetch(url, options);
+            }
+            catch (error) {
+                throw new Error(`请求超时或失败: ${error.message}`);
+            }
+            finally {
+                clearTimeout(id);
+            }
+        });
+    }
+    fetchWithRetry(url_1) {
+        return __awaiter(this, arguments, void 0, function* (url, options = {}) {
+            for (let attempt = 1; attempt <= this.retryCount; attempt++) {
+                try {
+                    const response = yield this.fetchWithTimeout(url, options);
+                    if (response.ok) {
+                        return response;
+                    }
+                    throw new Error(`服务器响应错误: ${response.status} ${response.statusText}`);
+                }
+                catch (error) {
+                    if (attempt === this.retryCount) {
+                        throw error;
+                    }
+                }
+            }
+            throw new Error('达到最大重试次数');
+        });
+    }
+    get(url, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.fetchWithRetry(url, {
+                    method: 'GET',
+                    headers: headers
+                        ? new Headers(Object.assign(Object.assign({}, this.defaultHeaders), headers))
+                        : this.defaultHeaders
+                });
+                return yield response.json();
+            }
+            catch (error) {
+                console.error(`GET请求错误: ${error.message}`);
+                throw error;
+            }
+        });
+    }
+    post(url, data, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.fetchWithRetry(url, {
+                    method: 'POST',
+                    body: JSON.stringify(data),
+                    headers: headers
+                        ? new Headers(Object.assign(Object.assign({}, this.defaultHeaders), headers))
+                        : this.defaultHeaders
+                });
+                return yield response.json();
+            }
+            catch (error) {
+                console.error(`POST请求错误: ${error.message}`);
+                throw error;
+            }
+        });
+    }
+}
+const request = HttpRequest.getInstance();
+export default request;

package/dist/libs/templates/index.js

@@ -0,0 +1,16 @@
+import { getSummary } from '../../commands/common/constant.js';
+import chalk from 'chalk';
+export default class Template {
+    constructor(path, title) {
+        this.path = path;
+        this.title = title;
+    }
+    printSummary() {
+        const list = getSummary(this.title);
+        list.forEach((summary) => {
+            const title = chalk.bold(summary.title);
+            const command = chalk.green(summary.command);
+            console.log(`${title}: ${command}`);
+        });
+    }
+}

package/dist/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "esa-cli",
+  "version": "0.0.1-beta.1",
+  "description": "A CLI for operating Alibaba Cloud ESA EdgeRoutine (Edge Functions).",
+  "main": "bin/enter.cjs",
+  "type": "module",
+  "files": [
+    "dist/"
+  ],
+  "bin": {
+    "esa": "bin/enter.cjs"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && rm -rf ./build && node ./genLocale.cjs && tsc && node ./copy.cjs",
+    "watch": "tsc --watch",
+    "eslint": "eslint src/ --ext .js,.jsx,.ts,.tsx",
+    "lint-staged": "lint-staged",
+    "prepare": "npm run build",
+    "test": "vitest",
+    "coverage": "vitest --coverage",
+    "preuninstall": "rm -rf ~/.esa/config"
+  },
+  "keywords": [
+    "cli",
+    "edge",
+    "esa",
+    "alibaba",
+    "ali"
+  ],
+  "author": "Kinice",
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/plugin-syntax-import-attributes": "^7.24.7",
+    "@types/cli-table": "^0.3.4",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.12",
+    "@types/lodash": "^4.14.202",
+    "@types/node": "^20.8.10",
+    "@types/node-fetch": "^2.6.9",
+    "@types/portscanner": "^2.1.4",
+    "@types/react": "^18.2.47",
+    "@types/yargs": "^17.0.32",
+    "@typescript-eslint/parser": "^6.9.1",
+    "eslint": "^8.52.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-react": "^7.33.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "husky": "^8.0.3",
+    "lint-staged": "^15.0.2",
+    "prettier": "^3.0.3",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rimraf": "^6.0.1",
+    "tsc-files": "^1.1.4",
+    "typescript": "^5.2.2",
+    "vitest": "^2.0.4"
+  },
+  "dependencies": {
+    "@alicloud/openapi-client": "^0.4.7",
+    "@alife/esa-cli-test": "^0.0.1-beta.1",
+    "@babel/parser": "^7.24.4",
+    "@babel/traverse": "^7.24.1",
+    "@iarna/toml": "^2.2.5",
+    "@tqman/ink-table": "^0.0.0-development",
+    "@types/inquirer": "^9.0.7",
+    "@vitest/coverage-istanbul": "^2.0.4",
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "cli-table3": "^0.6.5",
+    "cross-spawn": "^7.0.3",
+    "esbuild": "^0.21.1",
+    "esbuild-plugin-less": "^1.3.8",
+    "form-data": "^4.0.0",
+    "fs-extra": "^11.2.0",
+    "ink": "^5.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-text-input": "^6.0.0",
+    "inquirer": "^9.2.15",
+    "js-base64": "^3.7.7",
+    "node-fetch": "^3.3.2",
+    "open": "^9.1.0",
+    "ora": "^7.0.1",
+    "os-locale": "^6.0.2",
+    "portscanner": "^2.2.0",
+    "winston": "^3.11.0",
+    "yargs": "^17.7.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/aliyun/alibabacloud-esa-cli.git"
+  }
+}

package/dist/utils/checkDevPort.js

@@ -0,0 +1,113 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import portscanner from 'portscanner';
+import SelectItems from '../components/selectInput.js';
+import inquirer from 'inquirer';
+import logger from '../libs/logger.js';
+import t from '../i18n/index.js';
+import chalk from 'chalk';
+export const checkPort = (port) => {
+    return new Promise((resolve) => {
+        portscanner.checkPortStatus(port, '127.0.0.1', (error, status) => {
+            if (error) {
+                resolve(false);
+            }
+            else if (status === 'open') {
+                resolve(false);
+            }
+            else {
+                resolve(true);
+            }
+        });
+    });
+};
+const ask = () => {
+    return new Promise((resolve) => {
+        SelectItems({
+            items: [
+                { label: 'Yes', value: 'yes' },
+                { label: 'No', value: 'no' }
+            ],
+            handleSelect: (item) => __awaiter(void 0, void 0, void 0, function* () {
+                resolve(item.value === 'yes');
+            })
+        });
+    });
+};
+const findAvailablePort = (startPort) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield portscanner.findAPortNotInUse(startPort, 65535);
+});
+const echoNewInspectTip = () => {
+    logger.point(t('dev_inspect_tip1').d('You just provided a new inspection port'));
+    logger.point(t('dev_inspect_tip2').d('You need to open chrome://inspect'));
+    logger.point(t('dev_inspect_tip3').d('Click Configure.. button behind the Discover network targets'));
+    logger.point(t('dev_inspect_tip4').d('Config your new IP address and port in Target discovery settings'));
+    logger.point(t('dev_inspect_tip5').d('Now you can use Chrome inspect with new port 😉'));
+    logger.block();
+};
+const checkAndInputPort = (denoPort, inspectPort) => __awaiter(void 0, void 0, void 0, function* () {
+    let finalDenoPort = denoPort;
+    let finalInspectPort = inspectPort;
+    const isDenoPortAvailable = yield checkPort(denoPort);
+    const stringDenoPort = denoPort.toString();
+    const stringInspectPort = inspectPort.toString();
+    if (!isDenoPortAvailable) {
+        logger.error(t('dev_port_used', { stringDenoPort }).d(`Port ${stringDenoPort} already in use.`));
+        try {
+            const availablePort = yield findAvailablePort(denoPort);
+            finalDenoPort = (yield inquirer.prompt([
+                {
+                    type: 'number',
+                    name: 'port',
+                    message: t('dev_port_ask_input').d('Input a new port:'),
+                    default: availablePort
+                }
+            ])).port;
+            const isNewDenoPortAvailable = yield checkPort(finalDenoPort);
+            if (!isNewDenoPortAvailable) {
+                logger.error(t('dev_port_invalid').d('This port is invalid.'));
+                throw new Error('Specified port already in use.');
+            }
+        }
+        catch (_) {
+            const option = chalk.green('esa dev --port <port>');
+            logger.info(t('dev_port_used_advice', { option }).d(`You can use ${option} to specify another port.`));
+            throw new Error('Specified port already in use.');
+        }
+    }
+    const isInspectPortAvailable = yield checkPort(inspectPort);
+    if (!isInspectPortAvailable) {
+        logger.error(t('dev_inspect_port_used', { stringInspectPort }).d(`Inspect port ${stringInspectPort} already in use.`));
+        try {
+            const availablePort = yield findAvailablePort(inspectPort);
+            finalInspectPort = (yield inquirer.prompt([
+                {
+                    type: 'number',
+                    name: 'port',
+                    message: t('dev_inspect_port_ask_input').d('Input a new Chrome inspect port:'),
+                    default: availablePort
+                }
+            ])).port;
+        }
+        catch (_) {
+            const option = chalk.green('esa dev --inspect-port <port>');
+            logger.info(t('dev_port_used_advice', { option }).d(`You can use ${option} to specify another port.`));
+            throw new Error('Inspect port already in use.');
+        }
+    }
+    if (finalInspectPort !== inspectPort) {
+        echoNewInspectTip();
+    }
+    return {
+        denoPort: finalDenoPort,
+        inspectPort: finalInspectPort
+    };
+});
+export default checkAndInputPort;

package/dist/utils/checkIsRoutineCreated.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from 'path';
+import { createEdgeRoutine } from '../commands/commit/index.js';
+import { displaySelectSpec } from '../commands/deploy/index.js';
+import { ApiService } from '../libs/apiService.js';
+import { readEdgeRoutineFile } from './fileUtils/index.js';
+import logger from '../libs/logger.js';
+import t from '../i18n/index.js';
+import prodBuild from '../commands/commit/prodBuild.js';
+import { exit } from 'process';
+import chalk from 'chalk';
+export function isRoutineExist(name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const server = yield ApiService.getInstance();
+        const req = { Name: name };
+        const response = yield server.getRoutine(req, false);
+        return !!response;
+    });
+}
+export function validRoutine(name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isCreatedRoutine = yield isRoutineExist(name);
+        if (!isCreatedRoutine) {
+            logger.warn(`${t('routine_not_exist').d('Routine does not exist, please create a new one. Run command:')} ${chalk.greenBright('esa deploy')}`);
+            exit(0);
+        }
+    });
+}
+export function checkRoutineExist(name, entry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const isCreatedRoutine = yield isRoutineExist(name);
+        if (!isCreatedRoutine) {
+            logger.log(t('first_deploy').d('This is the first time to deploy, we will create a new routine for you.'));
+            const entryFile = path.resolve(entry !== null && entry !== void 0 ? entry : '', 'src/index.js');
+            yield prodBuild(false, entryFile, entry);
+            const code = readEdgeRoutineFile(entry) || '';
+            const server = yield ApiService.getInstance();
+            const specList = yield server.listRoutineSpecs();
+            const spec = yield displaySelectSpec((_a = specList === null || specList === void 0 ? void 0 : specList.data.Specs) !== null && _a !== void 0 ? _a : []);
+            yield createEdgeRoutine({
+                name: name,
+                specName: spec,
+                code: code
+            });
+        }
+    });
+}

package/dist/utils/checkVersion.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { promises as fs } from 'fs';
+import { getDirName } from '../utils/fileUtils/index.js';
+import path from 'path';
+export function handleCheckVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const __dirname = getDirName(import.meta.url);
+        const packageJsonPath = path.join(__dirname, '..', 'package.json');
+        try {
+            const jsonString = yield fs.readFile(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(jsonString);
+            console.log(`v${packageJson.version}`);
+        }
+        catch (error) {
+            console.error('Error reading version', error);
+        }
+    });
+}

package/dist/utils/debounce.js

@@ -0,0 +1,18 @@
+export default function debounce(func, wait, immediate = false) {
+    let timeoutId = null;
+    return (...args) => {
+        const later = () => {
+            timeoutId = null;
+            if (!immediate)
+                func(...args);
+        };
+        const shouldCallNow = immediate && timeoutId === null;
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(later, wait);
+        if (shouldCallNow) {
+            func(...args);
+        }
+    };
+}