esa-cli 0.0.1-beta.9 → 0.0.2-beta.0

package/dist/commands/dev/ew2/server.js

@@ -0,0 +1,234 @@
+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 * as http from 'http';
+import spawn from 'cross-spawn';
+import fetch from 'node-fetch';
+import logger from '../../../libs/logger.js';
+import { getRoot } from '../../../utils/fileUtils/base.js';
+import { EW2BinPath } from '../../../utils/installEw2.js';
+import { HttpProxyAgent } from 'http-proxy-agent';
+import chalk from 'chalk';
+import t from '../../../i18n/index.js';
+import sleep from '../../../utils/sleep.js';
+const getColorForStatusCode = (statusCode, message) => {
+    if (statusCode >= 100 && statusCode < 200) {
+        return chalk.blue(`${statusCode} ${message}`);
+    }
+    else if (statusCode >= 200 && statusCode < 300) {
+        return chalk.green(`${statusCode} ${message}`);
+    }
+    else if (statusCode >= 300 && statusCode < 400) {
+        return chalk.yellow(`${statusCode} ${message}`);
+    }
+    else if (statusCode >= 400 && statusCode < 500) {
+        return chalk.red(`${statusCode} ${message}`);
+    }
+    else if (statusCode >= 500) {
+        return chalk.magenta(chalk.bold(`${statusCode} ${message}`));
+    }
+    else {
+        return `${statusCode} ${message}`;
+    }
+};
+class Ew2Server {
+    constructor(props) {
+        this.worker = null;
+        this.startingWorker = false;
+        this.workerStartTimeout = undefined;
+        this.server = null;
+        this.restarting = false;
+        this.port = 18080;
+        // @ts-ignore
+        if (global.port)
+            this.port = global.port;
+        if (props.port)
+            this.port = props.port;
+        if (props.onClose)
+            this.onClose = props.onClose;
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.startingWorker = true;
+            const result = yield this.openEdgeWorker();
+            if (!result) {
+                throw new Error('Worker start failed');
+            }
+            this.createServer();
+        });
+    }
+    openEdgeWorker() {
+        if (this.worker) {
+            return Promise.resolve();
+        }
+        const root = getRoot();
+        // @ts-ignore
+        const id = global.id || '';
+        return new Promise((resolve, reject) => {
+            var _a, _b, _c;
+            this.worker = spawn(EW2BinPath, [
+                '--config_file',
+                `${root}/.dev/config-${id}.toml`,
+                '--log_stdout',
+                '-v'
+            ], {
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            this.workerStartTimeout = setTimeout(() => {
+                reject(new Error(t('dev_worker_timeout').d('Worker start timeout')));
+                this.worker && this.worker.kill();
+            }, 60000);
+            const sendToRuntime = () => {
+                return new Promise((resolveStart) => {
+                    // @ts-ignore
+                    const ew2Port = global.ew2Port;
+                    const options = {
+                        hostname: '127.0.0.1',
+                        port: ew2Port,
+                        method: 'GET'
+                    };
+                    const req = http.get(options, (res) => {
+                        resolveStart(res.statusCode);
+                    });
+                    req.on('error', (err) => {
+                        resolveStart(null);
+                    });
+                    req.end();
+                });
+            };
+            const checkRuntimeStart = () => __awaiter(this, void 0, void 0, function* () {
+                while (this.startingWorker) {
+                    const [result] = yield Promise.all([sendToRuntime(), sleep(500)]);
+                    if (result) {
+                        this.startingWorker = false;
+                        this.clearTimeout();
+                        resolve(result);
+                    }
+                }
+            });
+            checkRuntimeStart();
+            (_a = this.worker.stdout) === null || _a === void 0 ? void 0 : _a.setEncoding('utf8');
+            (_b = this.worker.stdout) === null || _b === void 0 ? void 0 : _b.on('data', this.stdoutHandler.bind(this));
+            (_c = this.worker.stderr) === null || _c === void 0 ? void 0 : _c.on('data', this.stderrHandler.bind(this));
+            this.worker.on('close', this.closeHandler.bind(this));
+            this.worker.on('error', this.errorHandler.bind(this));
+            process.on('SIGTERM', () => {
+                this.worker && this.worker.kill();
+            });
+        });
+    }
+    clearTimeout() {
+        clearTimeout(this.workerStartTimeout);
+    }
+    createServer() {
+        this.server = http.createServer((req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const host = req.headers.host;
+                const url = req.url;
+                // @ts-ignore
+                const ew2Port = global.ew2Port;
+                // @ts-ignore
+                const localUpstream = global.localUpstream;
+                const workerRes = yield fetch(`http://${localUpstream ? localUpstream : host}${url}`, {
+                    method: 'GET',
+                    headers: {
+                        'x-er-context': 'eyJzaXRlX2lkIjogIjYyMjcxODQ0NjgwNjA4IiwgInNpdGVfbmFtZSI6ICJjb21wdXRlbHguYWxpY2RuLXRlc3QuY29tIiwgInNpdGVfcmVjb3JkIjogIm1vY2hlbi1uY2RuLmNvbXB1dGVseC5hbGljZG4tdGVzdC5jb20iLCAiYWxpdWlkIjogIjEzMjI0OTI2ODY2NjU2MDgiLCAic2NoZW1lIjoiaHR0cCIsICAiaW1hZ2VfZW5hYmxlIjogdHJ1ZX0=',
+                        'x-er-id': 'a.bA'
+                    },
+                    agent: new HttpProxyAgent(`http://127.0.0.1:${ew2Port}`)
+                });
+                const workerHeaders = Object.fromEntries(workerRes.headers.entries());
+                // 解决 gzip 兼容性问题，防止net::ERR_CONTENT_DECODING_FAILED
+                workerHeaders['content-encoding'] = 'identity';
+                if (workerRes.body) {
+                    if ((_a = workerRes.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('text/')) {
+                        const text = yield workerRes.text();
+                        // 出现换行符之类会导致 content-length 不一致
+                        workerHeaders['content-length'] =
+                            Buffer.byteLength(text).toString();
+                        res.writeHead(workerRes.status, workerHeaders);
+                        res.end(text);
+                    }
+                    else {
+                        res.writeHead(workerRes.status, workerHeaders);
+                        workerRes.body.pipe(res);
+                    }
+                    logger.log(`[ESA Dev] ${req.method} ${url} ${getColorForStatusCode(workerRes.status, workerRes.statusText)}`);
+                }
+                else {
+                    res.writeHead(500, { 'Content-Type': 'text/plain' });
+                    res.end('EW2 return null');
+                }
+            }
+            catch (err) {
+                console.log(err);
+            }
+        }));
+        this.server.listen(this.port, () => {
+            logger.log(`listening on port ${this.port}`);
+        });
+    }
+    stdoutHandler(chunk) {
+        logger.log(`${chalk.bgGreen('[Worker]')} ${chunk.toString().trim()}`);
+    }
+    stderrHandler(chunk) {
+        logger.subError(`${chalk.bgGreen('[Worker Error]')} ${chunk.toString().trim()}`);
+    }
+    errorHandler(error) {
+        logger.error(error.message ? error.message : error);
+        if (error.code && error.code === 'EACCES') {
+            logger.pathEacces(EW2BinPath);
+        }
+        this.stop();
+    }
+    closeHandler(code, signal) {
+        if (this.restarting) {
+            this.restarting = false;
+            return;
+        }
+        this.stop().then(() => {
+            logger.log(t('dev_server_closed').d('Worker server closed'));
+            logger.info('Worker server closed');
+            // @ts-ignore
+            global.port = undefined;
+            this.onClose && this.onClose();
+        });
+    }
+    runCommand(command) {
+        var _a, _b;
+        (_b = (_a = this.worker) === null || _a === void 0 ? void 0 : _a.stdin) === null || _b === void 0 ? void 0 : _b.write(command);
+    }
+    stop() {
+        return new Promise((resolve) => {
+            var _a;
+            if (!this.worker) {
+                resolve(false);
+                return;
+            }
+            const onExit = (code, signal) => {
+                this.worker = null;
+                resolve(true);
+            };
+            this.worker.on('exit', onExit);
+            this.worker.kill('SIGTERM');
+            (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
+        });
+    }
+    restart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.restarting = true;
+            yield this.stop();
+            this.start();
+            logger.log(t('dev_server_restart').d('Worker server restarted'));
+            logger.info('Worker server restarted');
+        });
+    }
+}
+export default Ew2Server;

package/dist/commands/dev/index.js

@@ -8,29 +8,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { exec } from 'child_process';
+import { isIP } from 'net';
 import chokidar from 'chokidar';
 import doProcess from './doProcess.js';
 import { getProjectConfig, generateConfigFile, getDevConf } from '../../utils/fileUtils/index.js';
 import { getRoot } from '../../utils/fileUtils/base.js';
 import SelectItems from '../../components/selectInput.js';
 import logger from '../../libs/logger.js';
-import devPack from './devPack.js';
-import WorkerServer from './server.js';
-import { preCheckRuntime } from '../../utils/installRuntime.js';
+import MockServer from './mockWorker/server.js';
+import mockPack from './mockWorker/devPack.js';
+import Ew2Server from './ew2/server.js';
+import ew2Pack from './ew2/devPack.js';
+import { preCheckDeno } from '../../utils/installDeno.js';
+import { preCheckEw2 } from '../../utils/installEw2.js';
 import debounce from '../../utils/debounce.js';
 import t from '../../i18n/index.js';
 import checkAndInputPort from '../../utils/checkDevPort.js';
+import { checkOS, Platforms } from '../../utils/checkOS.js';
 let yargsIns;
+const OS = checkOS();
+const useEw2 = OS === Platforms.AppleArm || Platforms.AppleIntel || Platforms.LinuxX86;
 const dev = {
     command: 'dev [entry]',
     describe: `💻 ${t('dev_describe').d('Start a local server for developing your routine')}`,
     builder: (yargs) => {
-        yargsIns = yargs;
-        return yargs
+        yargsIns = yargs
             .positional('entry', {
             describe: t('dev_entry_describe').d('Entry file of the Routine'),
             type: 'string',
             demandOption: false
+        })
+            .option('p', {
+            alias: 'port',
+            describe: t('dev_port_describe').d('Port to listen on'),
+            type: 'number'
+        })
+            .option('m', {
+            alias: 'minify',
+            describe: t('dev_option_minify').d('Minify code during development'),
+            type: 'boolean',
+            default: false
         })
             .option('refresh-command', {
             describe: t('dev_refresh_command_describe').d('Provide a command to be executed before the auto-refresh on save'),
@@ -40,46 +57,47 @@ const dev = {
             describe: t('dev_option_local_upstream').d('Host to act as origin in development'),
             type: 'string'
         })
-            .option('m', {
-            alias: 'minify',
-            describe: t('dev_option_minify').d('Minify code during development'),
+            .option('debug', {
+            describe: t('dev_option_debugger').d('Output debug logs'),
             type: 'boolean',
             default: false
-        })
-            .option('inspect-port', {
-            describe: t('dev_inspect_port_describe').d('Chrome inspect devTool port'),
-            type: 'number'
-        })
-            .option('p', {
-            alias: 'port',
-            describe: t('dev_port_describe').d('Port to listen on'),
-            type: 'number'
         });
+        if (!useEw2) {
+            yargsIns.option('inspect-port', {
+                describe: t('dev_inspect_port_describe').d('Chrome inspect devTool port'),
+                type: 'number'
+            });
+        }
+        return yargsIns;
     },
     handler: (argv) => __awaiter(void 0, void 0, void 0, function* () {
         let { port, inspectPort } = argv;
-        let userFileRepacking = false; // flag of user code repack not .dev file change
-        const { entry, minify, refreshCommand, localUpstream, help } = argv;
+        let userFileRepacking = false; // Indicates that user code repacking does not change the .dev file
+        const { entry, minify, refreshCommand, localUpstream, help, debug } = argv;
         if (yargsIns && help) {
             yargsIns.showHelp('log');
-            return;
+            process.exit(0);
         }
+        if (debug) {
+            logger.setLogLevel('debug');
+        }
+        // Get options and set global variables
         const projectConfig = getProjectConfig();
         if (!projectConfig) {
-            if (entry) {
-                try {
-                    yield selectToCreateConf(entry);
-                }
-                catch (_) {
-                    logger.notInProject();
-                    process.exit(1);
-                }
+            if (!entry) {
+                logger.notInProject();
+                process.exit(1);
             }
-            else {
-                return logger.notInProject();
+            try {
+                // If no config is found and an entry is provided, create a new one.
+                yield selectToCreateConf(entry);
+            }
+            catch (_) {
+                logger.notInProject();
+                process.exit(1);
             }
         }
-        else if (entry) {
+        if (entry) {
             // @ts-ignore
             global.entry = entry;
         }
@@ -95,9 +113,18 @@ const dev = {
             }
             // @ts-ignore
             global.port = port;
+            logger.debug(`Entered port: ${port}`);
         }
         if (inspectPort) {
-            inspectPort = Number(inspectPort);
+            if (Array.isArray(inspectPort)) {
+                inspectPort = Number(inspectPort[0]);
+            }
+            else {
+                inspectPort = Number(inspectPort);
+                if (isNaN(inspectPort)) {
+                    logger.warn(t('dev_import_port_invalid').d('Invalid port entered, default port will be used.'));
+                }
+            }
             // @ts-ignore
             global.inspectPort = inspectPort;
         }
@@ -105,33 +132,63 @@ const dev = {
             // @ts-ignore
             global.minify = minify;
         }
-        if (minify) {
-            // @ts-ignore
-            global.minify = minify;
-        }
         if (localUpstream) {
+            const url = localUpstream;
             // @ts-ignore
             global.localUpstream = localUpstream;
+            try {
+                const hostname = new URL(url).hostname;
+                if (isIP(hostname)) {
+                    logger.error(t('dev_ip_not_allowed', { url }).d(`Direct access to IP addresses is not allowed when setting local-upstream: ${url}`));
+                    process.exit(1);
+                }
+            }
+            catch (err) {
+                logger.error(t('dev_url_invalid', { url }).d(`Invalid URL: ${url}. Please enter a valid URL.`));
+                process.exit(1);
+            }
         }
-        const runtimeCommand = yield preCheckRuntime();
-        if (!runtimeCommand) {
-            return;
+        const checkFunc = useEw2 ? preCheckEw2 : preCheckDeno;
+        const checkResult = yield checkFunc();
+        if (!checkResult) {
+            process.exit(1);
         }
-        const speDenoPort = getDevConf('port', 'dev', 18080);
-        const speInspectPort = getDevConf('inspectPort', 'dev', 9229);
-        try {
+        if (useEw2) {
+            const speEw2Port = getDevConf('port', 'dev', 18080);
+            const result = yield checkAndInputPort(speEw2Port);
+            // @ts-ignore
+            global.port = result.port;
+        }
+        else {
+            const speDenoPort = getDevConf('port', 'dev', 18080);
+            const speInspectPort = getDevConf('inspectPort', 'dev', 9229);
             const result = yield checkAndInputPort(speDenoPort, speInspectPort);
             // @ts-ignore
-            global.port = result.denoPort;
+            global.port = result.port;
             // @ts-ignore
             global.inspectPort = result.inspectPort;
         }
+        const devPack = useEw2 ? ew2Pack : mockPack;
+        try {
+            yield devPack();
+        }
         catch (err) {
             process.exit(1);
         }
-        logger.info(`${t('dev_build_start').d('Starting build process')}...`);
-        yield devPack();
-        const worker = new WorkerServer({ command: runtimeCommand });
+        let worker;
+        if (useEw2) {
+            worker = new Ew2Server({ onClose: onWorkerClosed });
+        }
+        else {
+            worker = new MockServer({ command: checkResult });
+        }
+        try {
+            yield worker.start();
+        }
+        catch (err) {
+            console.log('Track err', err);
+            process.exit(1);
+        }
         const ignored = (path) => {
             return /(^|[\/\\])\.(?!dev($|[\/\\]))/.test(path);
         };
@@ -148,7 +205,8 @@ const dev = {
                 worker.restart();
                 return;
             }
-            logger.info(`${t('dev_repacking').d('Detected local file changes, re-packaging')}...`);
+            logger.info('Dev repack');
+            logger.log(`${t('dev_repacking').d('Detected local file changes, re-packaging')}...`);
             if (refreshCommand) {
                 try {
                     yield execRefreshCommand(refreshCommand);
@@ -159,9 +217,12 @@ const dev = {
             yield devPack();
             yield worker.restart();
         }), 500));
-        const { devElement } = doProcess(worker);
+        var { devElement, exit } = doProcess(worker);
         const { waitUntilExit } = devElement;
         yield waitUntilExit();
+        function onWorkerClosed() {
+            exit && exit();
+        }
         watcher.close();
     })
 };
@@ -216,7 +277,8 @@ function execRefreshCommand(cmd) {
 }
 function selectToCreateConf(entry) {
     return new Promise((resolve, reject) => {
-        logger.info(t('dev_create_config').d('Configuration file not found. Would you like to create one?'));
+        logger.info('Configuration file not found');
+        logger.log(t('dev_create_config').d('Configuration file not found. Would you like to create one?'));
         SelectItems({
             items: [
                 { label: 'Yes', value: 'yes' },

package/dist/commands/dev/{config → mockWorker}/devEntry.js

@@ -41,6 +41,7 @@ const dev = async () => {
       handler: async (request) => {
         const url = new URL(request.url);
         let nextRequest = request;
+        // Replace the request url with the local upstream url
         if (config.localUpstream) {
           const nextUrl = `${config.localUpstream}${url.pathname}${url.search}${url.hash}`;
           nextRequest = new Request(nextUrl, request);
@@ -49,13 +50,13 @@ const dev = async () => {
           const res = await worker.fetch(nextRequest);
           const status = res.status;
           console.log(
-            `[Esa Dev] ${request.method} ${url.pathname} ${getColorForStatusCode(status, res.statusText)}`
+            `[ESA Dev] ${request.method} ${url.pathname} ${getColorForStatusCode(status, res.statusText)}`
           );
           return res;
         } catch (err) {
           console.error(err);
           console.log(
-            `[Esa Dev] ${request.method} ${url.pathname} ${getColorForStatusCode(500, 'Internal Server Error')}`
+            `[ESA Dev] ${request.method} ${url.pathname} ${getColorForStatusCode(500, 'Internal Server Error')}`
           );
           return new Response('Internal Server Error', {
             status: 500

package/dist/commands/dev/{devPack.js → mockWorker/devPack.js}

@@ -9,20 +9,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import path from 'path';
 import fs from 'fs';
-import logger from '../../libs/logger.js';
-import devBuild from './config/devBuild.js';
-import t from '../../i18n/index.js';
-import { getDevConf } from '../../utils/fileUtils/index.js';
-import { getRoot, getDirName } from '../../utils/fileUtils/base.js';
-import { checkPort } from '../../utils/checkDevPort.js';
+import logger from '../../../libs/logger.js';
+import devBuild from '../build.js';
+import t from '../../../i18n/index.js';
+import { getDevConf } from '../../../utils/fileUtils/index.js';
+import { getRoot, getDirName } from '../../../utils/fileUtils/base.js';
+import { checkPort } from '../../../utils/checkDevPort.js';
 const generateEntry = (id, projectEntry, userRoot) => __awaiter(void 0, void 0, void 0, function* () {
     const __dirname = getDirName(import.meta.url);
     const devDir = path.resolve(userRoot, '.dev');
     const devEntry = path.resolve(devDir, `devEntry-${id}.js`);
-    const devEntryTemp = path.resolve(__dirname, './config/devEntry.js');
+    const devEntryTemp = path.resolve(__dirname, './devEntry.js');
     const devEntryTempFile = fs.readFileSync(devEntryTemp, 'utf-8');
     const mockDevDir = path.resolve(userRoot, '.dev/mock');
-    const mockDir = path.resolve(__dirname, './config/mock');
+    const mockDir = path.resolve(__dirname, './mock');
     if (!fs.existsSync(devDir)) {
         yield fs.promises.mkdir(devDir);
     }
@@ -40,10 +40,12 @@ const generateEntry = (id, projectEntry, userRoot) => __awaiter(void 0, void 0,
 const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(void 0, void 0, void 0, function* () {
     const options = {};
     const currentOptions = { entry, port, localUpstream };
+    // 支持同时跑多个 deno
     const id = new Date().getTime().toString();
     // @ts-ignore
     global.id = id;
     yield generateEntry(id, entry, userRoot);
+    // 给每一次 dev 的配置项，在一个文件中通过 id 区分
     if (fs.existsSync(configPath)) {
         const currentConfig = fs
             .readFileSync(configPath, 'utf-8')