esa-cli 0.0.2-beta.9 → 1.0.0

package/dist/libs/git/index.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { execSync } from 'child_process';
-import { exit } from 'process';
+import logger from '../../libs/logger.js';
 export function isInstalledGit() {
     try {
         execSync('git --version');
@@ -30,23 +30,100 @@ export function isGitConfigured() {
 }
 export function cloneRepository(url, path) {
     return __awaiter(this, void 0, void 0, function* () {
+        if (!isInstalledGit()) {
+            logger.error('Git is not installed on your system.');
+            logger.info('Please install Git first:');
+            logger.info('  • macOS: brew install git');
+            logger.info('  • Ubuntu/Debian: sudo apt-get install git');
+            logger.info('  • Windows: Download from https://git-scm.com/');
+            logger.info('  • Or visit: https://git-scm.com/downloads');
+            return false;
+        }
         try {
             execSync(`git clone ${url} ${path}`, { stdio: 'inherit' });
-            console.log('Repository cloned successfully.');
+            logger.log('Repository cloned successfully.');
+            return true;
         }
         catch (error) {
-            console.error('Error occurred while cloning the repository:', error);
-            exit(0);
+            logger.error(`Error occurred while cloning the repository: ${error}`);
+            return false;
         }
     });
 }
-export function installGit(path) {
+export function installGit(path, debug = false, autoInstall = false) {
+    if (!isInstalledGit()) {
+        if (autoInstall) {
+            logger.info('Git not found. Attempting to auto-install...');
+            if (autoInstallGit()) {
+                logger.info('Git installed successfully! Now initializing repository...');
+            }
+            else {
+                logger.error('Failed to auto-install Git.');
+                logger.info('Please install Git manually:');
+                logger.info('  • macOS: brew install git');
+                logger.info('  • Ubuntu/Debian: sudo apt-get install git');
+                logger.info('  • Windows: Download from https://git-scm.com/');
+                logger.info('  • Or visit: https://git-scm.com/downloads');
+                return false;
+            }
+        }
+        else {
+            logger.error('Git is not installed on your system.');
+            logger.info('Please install Git first:');
+            logger.info('  • macOS: brew install git');
+            logger.info('  • Ubuntu/Debian: sudo apt-get install git');
+            logger.info('  • Windows: Download from https://git-scm.com/');
+            logger.info('  • Or visit: https://git-scm.com/downloads');
+            return false;
+        }
+    }
+    try {
+        execSync('git init', { stdio: 'ignore', cwd: path });
+        if (debug) {
+            logger.log('Git repository initialized successfully.');
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error(`Error occurred while initializing Git repository: ${error}`);
+        return false;
+    }
+}
+/**
+ * Attempt to automatically install Git on supported platforms
+ * @returns true if installation was successful, false otherwise
+ */
+export function autoInstallGit() {
     try {
-        execSync('git init', { stdio: 'inherit', cwd: path });
-        console.log('Git has been installed successfully.');
+        const platform = process.platform;
+        if (platform === 'darwin') {
+            // macOS - try using Homebrew
+            logger.info('Attempting to install Git using Homebrew...');
+            execSync('brew install git', { stdio: 'inherit' });
+            logger.success('Git installed successfully via Homebrew!');
+            return true;
+        }
+        else if (platform === 'linux') {
+            // Linux - try using apt-get (Ubuntu/Debian)
+            logger.info('Attempting to install Git using apt-get...');
+            execSync('sudo apt-get update && sudo apt-get install -y git', {
+                stdio: 'inherit'
+            });
+            logger.success('Git installed successfully via apt-get!');
+            return true;
+        }
+        else {
+            logger.warn('Auto-installation is not supported on this platform.');
+            logger.info('Please install Git manually from: https://git-scm.com/downloads');
+            return false;
+        }
     }
     catch (error) {
-        console.error('Error occurred during Git installation:', error);
-        exit(0);
+        logger.error(`Failed to auto-install Git: ${error}`);
+        logger.info('Please install Git manually:');
+        logger.info('  • macOS: brew install git');
+        logger.info('  • Ubuntu/Debian: sudo apt-get install git');
+        logger.info('  • Windows: Download from https://git-scm.com/');
+        return false;
     }
 }

package/dist/libs/interface.js

@@ -7,7 +7,6 @@ export var PublishType;
 (function (PublishType) {
     PublishType["Staging"] = "staging";
     PublishType["Production"] = "production";
-    PublishType["Canary"] = "canary";
 })(PublishType || (PublishType = {}));
 var BasicType;
 (function (BasicType) {

package/dist/libs/logger.js

@@ -1,10 +1,10 @@
+import os from 'os';
+import path from 'path';
 import chalk from 'chalk';
-import { format, createLogger } from 'winston';
-import DailyRotateFile from 'winston-daily-rotate-file';
 import Table from 'cli-table3';
-import path from 'path';
-import os from 'os';
 import ora from 'ora';
+import { format, createLogger } from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
 import t from '../i18n/index.js';
 import { getProjectConfig } from '../utils/fileUtils/index.js';
 const transport = new DailyRotateFile({
@@ -17,6 +17,7 @@ const transport = new DailyRotateFile({
 });
 class Logger {
     constructor() {
+        this.spinnerText = '';
         const { combine, timestamp, label, printf } = format;
         const customFormat = printf(({ level, message, label: printLabel, timestamp: printTimestamp }) => {
             var _a;
@@ -65,6 +66,60 @@ class Logger {
     setLogLevel(level) {
         this.logger.level = level;
     }
+    /**
+     * Start a sub-step: show a spinner with the provided message.
+     * If a spinner is already running, just update its text.
+     */
+    startSubStep(message) {
+        this.spinnerText = message;
+        this.spinner.text = message;
+        if (!this.spinner.isSpinning) {
+            this.spinner.start();
+        }
+    }
+    /**
+     * End a sub-step: stop loading and replace spinner with `├` and final message.
+     * This overwrites the previous spinner line with the provided message.
+     */
+    endSubStep(message) {
+        // console.log(chalk.gray('├') + ' ' + this.spinnerText);
+        try {
+            if (this.spinner && this.spinner.isSpinning) {
+                this.spinner.stop();
+            }
+        }
+        catch (_a) { }
+        console.log(chalk.gray(`│ `));
+        console.log(chalk.gray('├  ') + this.spinnerText);
+        console.log(chalk.gray(`│  ${message}`));
+    }
+    stopSpinner() {
+        try {
+            if (this.spinner && this.spinner.isSpinning) {
+                this.spinner.stop();
+            }
+        }
+        catch (_a) { }
+    }
+    /**
+     * Prepare terminal output just before showing an interactive prompt.
+     * - Stops any active spinner
+     * - Replaces the previous line with a clean `╰ <text>` indicator
+     */
+    prepareForPrompt(text) {
+        this.stopSpinner();
+        const content = `╰ ${text || ''}`;
+        this.replacePrevLine(content);
+    }
+    /**
+     * Consolidate interactive prompt output after completion by replacing
+     * the previous N lines with a concise summary line.
+     * Defaults to 2 lines (prompt + answer line in most cases).
+     */
+    consolidateAfterPrompt(summary, linesToReplace = 2) {
+        const content = `├ ${summary}`;
+        this.replacePrevLines(linesToReplace, content);
+    }
     log(message) {
         console.log(message);
     }
@@ -72,7 +127,7 @@ class Logger {
         console.log(`\t${message}`);
     }
     success(message) {
-        console.log(`\n🎉 ${chalk.bgGreen(' SUCCESS ')} ${chalk.green(message)}`);
+        console.log(`🎉 ${chalk.bgGreen(' SUCCESS ')} ${chalk.green(message)}`);
     }
     debug(message) {
         this.logger.debug(message);
@@ -120,14 +175,53 @@ class Logger {
         console.log(message);
     }
     notInProject() {
-        const initCommand = chalk.green('esa init');
-        this.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.`));
+        this.block();
+        this.error('Missing ESA project configuration (esa.jsonc or esa.toml)');
+        this.block();
+        this.log('If there is code to deploy, you can either:');
+        this.subLog(`- Specify an entry-point to your Routine via the command line (ex: ${chalk.green('esa-cli deploy src/index.ts')})`);
+        this.subLog('- Or create an "esa.jsonc" file (recommended):');
+        console.log('```jsonc\n' +
+            '{\n' +
+            '  "name": "my-routine",\n' +
+            '  "entry": "src/index.ts",\n' +
+            '  "dev": { "port": 18080 }\n' +
+            '}\n' +
+            '```');
+        this.subLog('- Or, if you prefer TOML, create an "esa.toml" file:');
+        console.log('```toml\n' +
+            'name = "my-routine"\n' +
+            'entry = "src/index.ts"\n' +
+            '\n' +
+            '[dev]\n' +
+            'port = 18080\n' +
+            '```\n');
+        this.log('If you are deploying a directory of static assets, you can either:');
+        this.subLog(`- Create an "esa.jsonc" file (recommended) and run ${chalk.green('esa-cli deploy -a ./dist')}`);
+        console.log('```jsonc\n' +
+            '{\n' +
+            '  "name": "my-routine",\n' +
+            '  "assets": {\n' +
+            '    "directory": "./dist"\n' +
+            '  }\n' +
+            '}\n' +
+            '```');
+        this.subLog(`- Or create an "esa.toml" file and run ${chalk.green('esa-cli deploy -a ./dist')}`);
+        console.log('```toml\n' +
+            'name = "my-routine"\n' +
+            '\n' +
+            '[assets]\n' +
+            'directory = "./dist"\n' +
+            '```\n');
+        this.log('Alternatively, initialize a new ESA project:');
+        this.log(chalk.green('$ esa-cli init my-project'));
+        this.block();
     }
     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.log(chalk.green(`$ ${chalk.red('sudo')} esa-cli <Command>`));
         this.block();
         this.subLog(chalk.yellow('OR'));
         this.block();
@@ -146,15 +240,73 @@ class Logger {
         if (messages.length === 0)
             return;
         const lines = [];
-        lines.push(`╭─ ${messages[0]}`);
+        lines.push(`╭ ${messages[0]}`);
         for (let i = 1; i < messages.length - 1; i++) {
             lines.push(`│ ${messages[i]}`);
         }
         if (messages.length > 1) {
-            lines.push(`╰─ ${messages[messages.length - 1]}`);
+            lines.push(`╰ ${messages[messages.length - 1]}`);
         }
         console.log(lines.join('\n'));
     }
+    StepHeader(title, step, total) {
+        console.log(`\n╭ ${title} ${chalk.green(`Step ${step} of ${total}`)}`);
+        console.log('│');
+    }
+    StepItem(prompt) {
+        console.log(`├ ${prompt}`);
+    }
+    StepStart(prompt) {
+        console.log(`╭ ${prompt}`);
+    }
+    StepKV(key, value) {
+        const orange = chalk.hex('#FFA500');
+        console.log(`│ ${orange(key)} ${value}`);
+    }
+    StepSpacer() {
+        console.log('│');
+    }
+    StepEnd(str) {
+        console.log(`╰ ${str || ''}`);
+    }
+    StepEndInline() {
+        try {
+            process.stdout.write('╰ ');
+        }
+        catch (_a) {
+            console.log('╰');
+        }
+    }
+    divider() {
+        console.log(chalk.yellow('--------------------------------------------------------'));
+    }
+    // Replace the previous single terminal line with new content
+    replacePrevLine(content) {
+        try {
+            // Move cursor up 1 line, clear it, carriage return, print new content
+            process.stdout.write('\x1b[1A');
+            process.stdout.write('\x1b[2K');
+            process.stdout.write('\r');
+            console.log(content);
+        }
+        catch (_a) {
+            console.log(content);
+        }
+    }
+    // Replace multiple previous lines with one consolidated line
+    replacePrevLines(linesToReplace, content) {
+        try {
+            for (let i = 0; i < linesToReplace; i++) {
+                process.stdout.write('\x1b[1A'); // move up
+                process.stdout.write('\x1b[2K'); // clear line
+            }
+            process.stdout.write('\r');
+            console.log(content);
+        }
+        catch (_a) {
+            console.log(content);
+        }
+    }
 }
 const logger = Logger.getInstance();
 export default logger;

package/dist/libs/service.js

@@ -7,10 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import ora from 'ora';
-import chain from 'lodash';
 import FormData from 'form-data';
+import chain from 'lodash';
 import fetch from 'node-fetch';
+import ora from 'ora';
 import t from '../i18n/index.js';
 import api from './api.js';
 import { Environment } from './interface.js';

package/dist/libs/templates/index.js

@@ -1,5 +1,5 @@
-import { getSummary } from '../../commands/common/constant.js';
 import chalk from 'chalk';
+import { getSummary } from '../../commands/common/constant.js';
 import logger from '../logger.js';
 export default class Template {
     constructor(path, title) {

package/dist/utils/checkAssetsExist.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import path from 'path';
+import { getProjectConfig } from './fileUtils/index.js';
+/**
+ * Check if the assets directory exists in the project config
+ * @returns {boolean} true if the assets directory exists, false otherwise
+ */
+const checkConfigAssetsExist = () => {
+    var _a;
+    const projectConfig = getProjectConfig();
+    if (!projectConfig) {
+        return false;
+    }
+    const directory = (_a = projectConfig.assets) === null || _a === void 0 ? void 0 : _a.directory;
+    if (!directory) {
+        return false;
+    }
+    return true;
+};
+export var EDGE_ROUTINE_TYPE;
+(function (EDGE_ROUTINE_TYPE) {
+    EDGE_ROUTINE_TYPE["ASSETS_ONLY"] = "assets_only";
+    EDGE_ROUTINE_TYPE["JS_ONLY"] = "js_only";
+    EDGE_ROUTINE_TYPE["JS_AND_ASSETS"] = "js_and_assets";
+    EDGE_ROUTINE_TYPE["NOT_EXIST"] = "not_exist";
+})(EDGE_ROUTINE_TYPE || (EDGE_ROUTINE_TYPE = {}));
+/**
+ * Check if a path exists and is valid
+ * @param filePath - The path to check
+ * @param isDirectory - Whether the path should be a directory
+ * @returns boolean
+ */
+const isValidPath = (filePath, isDirectory = false) => {
+    if (!filePath || typeof filePath !== 'string' || filePath.trim() === '') {
+        return false;
+    }
+    try {
+        const resolvedPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.resolve(filePath);
+        const exists = fs.existsSync(resolvedPath);
+        if (!exists) {
+            return false;
+        }
+        if (isDirectory) {
+            return fs.statSync(resolvedPath).isDirectory();
+        }
+        else {
+            return fs.statSync(resolvedPath).isFile();
+        }
+    }
+    catch (error) {
+        return false;
+    }
+};
+export const checkEdgeRoutineType = (scriptEntry, assetsDirectory, projectPath) => {
+    var _a;
+    const projectConfig = getProjectConfig(projectPath);
+    const entry = scriptEntry || (projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.entry);
+    const assets = assetsDirectory || ((_a = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.assets) === null || _a === void 0 ? void 0 : _a.directory);
+    const entryPath = path.resolve(projectPath !== null && projectPath !== void 0 ? projectPath : '', entry !== null && entry !== void 0 ? entry : '');
+    const assetsPath = path.resolve(projectPath !== null && projectPath !== void 0 ? projectPath : '', assets !== null && assets !== void 0 ? assets : '');
+    const hasAssets = isValidPath(assetsPath, true) && assets;
+    const hasEntry = isValidPath(entryPath, false) && entry;
+    // Both assets and entry exist
+    if (hasAssets && hasEntry) {
+        return EDGE_ROUTINE_TYPE.JS_AND_ASSETS;
+    }
+    // Only assets exist
+    if (hasAssets && !hasEntry) {
+        return EDGE_ROUTINE_TYPE.ASSETS_ONLY;
+    }
+    // Only entry exists
+    if (!hasAssets && hasEntry) {
+        return EDGE_ROUTINE_TYPE.JS_ONLY;
+    }
+    // Neither exists
+    return EDGE_ROUTINE_TYPE.NOT_EXIST;
+};
+export default checkConfigAssetsExist;

package/dist/utils/checkDevPort.js

@@ -7,12 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import portscanner from 'portscanner';
-import SelectItems from '../components/selectInput.js';
+import chalk from 'chalk';
 import inquirer from 'inquirer';
-import logger from '../libs/logger.js';
+import portscanner from 'portscanner';
 import t from '../i18n/index.js';
-import chalk from 'chalk';
+import logger from '../libs/logger.js';
 export const checkPort = (port) => {
     return new Promise((resolve) => {
         portscanner.checkPortStatus(port, '127.0.0.1', (error, status) => {
@@ -28,19 +27,6 @@ export const checkPort = (port) => {
         });
     });
 };
-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);
 });
@@ -76,7 +62,7 @@ const checkAndInputPort = (port, inspectPort) => __awaiter(void 0, void 0, void
             }
         }
         catch (_) {
-            const option = chalk.green('esa dev --port <port>');
+            const option = chalk.green('esa-cli dev --port <port>');
             logger.log(t('dev_port_used_advice', { option }).d(`You can use ${option} to specify another port.`));
             throw new Error('Specified port already in use.');
         }
@@ -102,7 +88,7 @@ const checkAndInputPort = (port, inspectPort) => __awaiter(void 0, void 0, void
             ])).port;
         }
         catch (_) {
-            const option = chalk.green('esa dev --inspect-port <port>');
+            const option = chalk.green('esa-cli dev --inspect-port <port>');
             logger.log(t('dev_port_used_advice', { option }).d(`You can use ${option} to specify another port.`));
             throw new Error('Inspect port already in use.');
         }

package/dist/utils/checkEntryFileExist.js

@@ -0,0 +1,10 @@
+import fs from 'fs';
+import { getProjectConfig } from './fileUtils/index.js';
+export const checkEntryFileExist = () => {
+    const projectConfig = getProjectConfig();
+    const entry = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.entry;
+    if (!entry) {
+        return true;
+    }
+    return fs.existsSync(entry);
+};

package/dist/utils/checkIsRoutineCreated.js

@@ -7,15 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import path from 'path';
-import { createEdgeRoutine } from '../commands/commit/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 { log } from '@clack/prompts';
 import chalk from 'chalk';
+import t from '../i18n/index.js';
+import { ApiService } from '../libs/apiService.js';
+import logger from '../libs/logger.js';
 export function isRoutineExist(name) {
     return __awaiter(this, void 0, void 0, function* () {
         const server = yield ApiService.getInstance();
@@ -28,29 +25,38 @@ 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);
+            logger.warn(`${t('routine_not_exist').d('Project does not exist, please create a new one. Run command:')} ${chalk.greenBright('esa-cli deploy')}`);
+            exit(1);
         }
     });
 }
-export function checkRoutineExist(name, entry) {
+/**
+ * Ensure routine exists, if not, create a new routine
+ * @param name - Routine name
+ */
+export function ensureRoutineExists(name) {
     return __awaiter(this, void 0, void 0, function* () {
-        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 res = yield createEdgeRoutine({
+        const isExist = yield isRoutineExist(name);
+        // If routine does not exist, create a new routine
+        if (!isExist) {
+            logger.startSubStep(`Creating routine ${chalk.gray(name)}`);
+            const server = yield ApiService.getInstance();
+            const createRes = yield server.createRoutine({
                 name: name,
-                code: code
+                description: '',
+                hasAssets: true
             });
-            if (res) {
-                logger.success(t('routine_create_success').d('Routine created successfully.'));
+            const isSuccess = (createRes === null || createRes === void 0 ? void 0 : createRes.data.Status) === 'OK';
+            if (isSuccess) {
+                logger.endSubStep('Routine created successfully');
             }
             else {
-                logger.error(t('routine_create_fail').d('Routine created failed.'));
+                logger.endSubStep('Routine created failed');
+                exit();
             }
         }
+        else {
+            log.step('Routine has already exists');
+        }
     });
 }