esa-cli 0.0.1-beta.1

package/dist/commands/dev/config/devEntry.js

@@ -0,0 +1,71 @@
+import {
+  blue,
+  green,
+  yellow,
+  red,
+  magenta,
+  bold
+} from 'https://deno.land/std@0.177.0/fmt/colors.ts';
+import worker from '$userPath';
+import Cache from './mock/cache.js';
+import EdgeKV from './mock/kv.js';
+
+const id = Deno.args[0];
+const getColorForStatusCode = (statusCode, message) => {
+  if (statusCode >= 100 && statusCode < 200) {
+    return blue(`${statusCode} ${message}`);
+  } else if (statusCode >= 200 && statusCode < 300) {
+    return green(`${statusCode} ${message}`);
+  } else if (statusCode >= 300 && statusCode < 400) {
+    return yellow(`${statusCode} ${message}`);
+  } else if (statusCode >= 400 && statusCode < 500) {
+    return red(`${statusCode} ${message}`);
+  } else if (statusCode >= 500) {
+    return magenta(bold(`${statusCode} ${message}`));
+  } else {
+    return `${statusCode} ${message}`;
+  }
+};
+const dev = async () => {
+  try {
+    const configs = (await import('./devConfig.js')).default;
+    const config = configs[id] ?? {};
+    const cacheInstance = await Cache.init('mock');
+    globalThis.cache = cacheInstance;
+    globalThis.EdgeKV = EdgeKV;
+    if (!worker || !worker.fetch) {
+      throw new Error('Invalid ER code.');
+    }
+    Deno.serve({
+      port: config.port,
+      handler: async (request) => {
+        const url = new URL(request.url);
+        let nextRequest = request;
+        if (config.localUpstream) {
+          const nextUrl = `${config.localUpstream}${url.pathname}${url.search}${url.hash}`;
+          nextRequest = new Request(nextUrl, request);
+        }
+        try {
+          const res = await worker.fetch(nextRequest);
+          const status = res.status;
+          console.log(
+            `[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')}`
+          );
+          return new Response('Internal Server Error', {
+            status: 500
+          });
+        }
+      }
+    });
+  } catch (err) {
+    console.log('\n');
+    console.error(red(err));
+  }
+};
+dev();

package/dist/commands/dev/config/mock/cache.js

@@ -0,0 +1,31 @@
+class MockCache {
+  constructor(instance) {
+    this.cache = instance;
+  }
+  static async init(cacheName) {
+    const instance = await MockCache.open(cacheName);
+    return new MockCache(instance);
+  }
+  static open(cacheName) {
+    return caches.open(cacheName);
+  }
+  static has(cacheName) {
+    return caches.has(cacheName);
+  }
+  static delete(cacheName) {
+    return caches.delete(cacheName);
+  }
+  match(reqOrUrl, options) {
+    return this.cache.match(reqOrUrl, options);
+  }
+  delete(reqOrUrl, options) {
+    return this.cache.delete(reqOrUrl, options);
+  }
+  put(reqOrUrl, response) {
+    return this.cache.put(reqOrUrl, response);
+  }
+  get(reqOrUrl, options) {
+    return this.match(reqOrUrl, options);
+  }
+}
+export default MockCache;

package/dist/commands/dev/config/mock/kv.js

@@ -0,0 +1,87 @@
+import * as path from 'https://deno.land/std/path/mod.ts';
+class EdgeKV {
+  namespace;
+  filePath;
+  allData;
+  constructor(options) {
+    this.namespace = options.namespace;
+    this.filePath = path.join(this.getRoot(), '.dev/.kv');
+    this.allData = {};
+  }
+  getRoot(root) {
+    if (typeof root === 'undefined') {
+      root = Deno.cwd();
+    }
+    if (root === '/') {
+      return Deno.cwd();
+    }
+    const file = path.join(root, 'cliconfig.toml');
+    const prev = path.resolve(root, '../');
+    try {
+      const hasToml = fs.existsSync(file);
+      if (hasToml) {
+        return root;
+      } else {
+        return this.getRoot(prev);
+      }
+    } catch (err) {
+      return this.getRoot(prev);
+    }
+  }
+  async _loadData() {
+    try {
+      const fileData = await Deno.readTextFile(this.filePath);
+      this.allData = JSON.parse(fileData);
+    } catch (error) {
+      if (!(error instanceof Deno.errors.NotFound)) {
+        console.error('Error reading KV file:', error);
+      }
+    }
+  }
+
+  async get(key, options) {
+    await this._loadData();
+    const namespaceData = this.allData[this.namespace] || {};
+    if (!(key in namespaceData)) {
+      return undefined;
+    }
+    const value = namespaceData[key];
+    const type = options?.type || 'text';
+    switch (type) {
+      case 'text':
+        return value;
+      case 'json':
+        try {
+          return JSON.parse(value);
+        } catch (error) {
+          throw new Error('Failed to parse JSON');
+        }
+      case 'arrayBuffer':
+        const encoder = new TextEncoder();
+        const uint8Array = encoder.encode(value);
+        return uint8Array.buffer;
+      default:
+        throw new Error('Invalid type option');
+    }
+  }
+  async put(key, value) {
+    const namespaceData = this.allData[this.namespace] || {};
+    namespaceData[key] = value;
+    this.allData[this.namespace] = namespaceData;
+    await this._saveData();
+  }
+  async delete(key) {
+    const namespaceData = this.allData[this.namespace] || {};
+    delete namespaceData[key];
+    this.allData[this.namespace] = namespaceData;
+    await this._saveData();
+  }
+  async _saveData() {
+    try {
+      await Deno.writeTextFile(this.filePath, JSON.stringify(this.allData));
+    } catch (error) {
+      console.error('Error writing KV file:', error);
+    }
+  }
+}
+export default EdgeKV;

package/dist/commands/dev/devPack.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 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, getRoot, getDirName } from '../../utils/fileUtils/index.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 devEntryTempFile = fs.readFileSync(devEntryTemp, 'utf-8');
+    const mockDevDir = path.resolve(userRoot, '.dev/mock');
+    const mockDir = path.resolve(__dirname, './config/mock');
+    if (!fs.existsSync(devDir)) {
+        yield fs.promises.mkdir(devDir);
+    }
+    if (!fs.existsSync(mockDevDir)) {
+        yield fs.promises.mkdir(mockDevDir);
+    }
+    const entries = yield fs.promises.readdir(mockDir);
+    for (const file of entries) {
+        const srcPath = path.resolve(mockDir, file);
+        const destPath = path.resolve(mockDevDir, file);
+        yield fs.promises.copyFile(srcPath, destPath);
+    }
+    return fs.promises.writeFile(devEntry, devEntryTempFile.replace(/'\$userPath'/g, `'${projectEntry}'`));
+});
+const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(void 0, void 0, void 0, function* () {
+    const options = {};
+    const currentOptions = { entry, port, localUpstream };
+    const id = new Date().getTime().toString();
+    // @ts-ignore
+    global.id = id;
+    yield generateEntry(id, entry, userRoot);
+    if (fs.existsSync(configPath)) {
+        const currentConfig = fs
+            .readFileSync(configPath, 'utf-8')
+            .replace('export default ', '');
+        const currentConfigObj = JSON.parse(currentConfig);
+        const cIds = Object.keys(currentConfigObj);
+        if (cIds[0] && /^\d+$/.test(cIds[0])) {
+            for (let cid of cIds) {
+                const useful = yield checkPort(currentConfigObj[cid].port);
+                if (useful) {
+                    const unusedEntry = path.resolve(userRoot, `.dev/index-${cid}.js`);
+                    const unusedTemp = path.resolve(userRoot, `.dev/devEntry-${cid}.js`);
+                    if (fs.existsSync(unusedEntry)) {
+                        fs.rmSync(unusedEntry);
+                    }
+                    if (fs.existsSync(unusedTemp)) {
+                        fs.rmSync(unusedTemp);
+                    }
+                }
+                else {
+                    options[cid] = currentConfigObj[cid];
+                }
+            }
+        }
+    }
+    return fs.promises.writeFile(configPath, `export default ${JSON.stringify(Object.assign(options, { [id]: currentOptions }))}`);
+});
+const devPack = () => __awaiter(void 0, void 0, void 0, function* () {
+    logger.ora.start('Processing...\n');
+    const userRoot = getRoot();
+    const configPath = path.resolve(userRoot, 'esa.toml');
+    let port, minify, localUpstream, entry;
+    let projectEntry = path.resolve(userRoot, 'src/index.js');
+    if (fs.existsSync(configPath)) {
+        port = getDevConf('port', 'dev', 18080);
+        minify = getDevConf('minify', 'dev', false);
+        localUpstream = getDevConf('localUpstream', 'dev', '');
+        entry = getDevConf('entry', '', '');
+        if (entry) {
+            projectEntry = path.resolve(userRoot, entry);
+        }
+    }
+    else {
+        logger.notInProject();
+        process.exit(0);
+    }
+    return prepare(path.resolve(userRoot, '.dev/devConfig.js'), projectEntry, port, localUpstream, userRoot)
+        .then(() => {
+        logger.ora.succeed(t('dev_pack_config_success').d('Config created successfully'));
+        return devBuild({
+            minify
+        });
+    })
+        .then(() => {
+        logger.ora.succeed(t('dev_pack_success').d('Build finished successfully'));
+        logger.ora.stop();
+        logger.block();
+    })
+        .catch((err) => {
+        logger.ora.fail('Build Failed');
+        logger.error(`${t('common_error_occurred').d('An error occurred')}: ${err}`);
+        if (err.toString().includes('EACCES')) {
+            logger.pathEacces(getDirName(import.meta.url));
+        }
+        process.exit(1);
+    });
+});
+export default devPack;

package/dist/commands/dev/doProcess.js

@@ -0,0 +1,73 @@
+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 React, { useEffect } from 'react';
+import { Box, Text, useApp, useInput, render } from 'ink';
+import chalk from 'chalk';
+import logger from '../../libs/logger.js';
+import openInBrowser from '../../utils/openInBrowser.js';
+import { getDevOpenBrowserUrl } from '../../utils/fileUtils/index.js';
+import t from '../../i18n/index.js';
+const InteractionBox = ({ worker }) => {
+    const { exit } = useApp();
+    const inspectLink = chalk.underline.blue('chrome://inspect/#devices');
+    const remoteTarget = chalk.blue('Remote Target');
+    const inspect = chalk.blue('inspect');
+    /* eslint-disable no-unused-vars */
+    useInput((input) => __awaiter(void 0, void 0, void 0, function* () {
+        switch (input.toLowerCase()) {
+            case 'c':
+                console.clear();
+                logger.block();
+                break;
+            case 'b': {
+                yield openInBrowser(getDevOpenBrowserUrl());
+                break;
+            }
+            case 'd': {
+                logger.log(t('dev_input_inspect_tip1', { inspectLink }).d(`👉 Please visit ${inspectLink} in the Chrome browser`));
+                logger.log(t('dev_input_inspect_tip2', { inspect, remoteTarget }).d(`👉 See your debugger under ${remoteTarget} and click the ${inspect} button`));
+                break;
+            }
+            case 'x':
+                exit();
+                break;
+            default:
+                break;
+        }
+    }));
+    useEffect(() => {
+        return () => {
+            if (worker) {
+                worker.stop();
+            }
+        };
+    }, []);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { borderStyle: "classic", paddingLeft: 1, paddingRight: 1 },
+            React.createElement(Text, { bold: true }, "[b]"),
+            React.createElement(Text, null, " open a browser, "),
+            React.createElement(React.Fragment, null,
+                React.createElement(Text, { bold: true }, "[d]"),
+                React.createElement(Text, null, " open Devtools, ")),
+            React.createElement(Text, { bold: true }, "[c]"),
+            React.createElement(Text, null, " clear console, "),
+            React.createElement(Text, { bold: true }, "[x]"),
+            React.createElement(Text, null, " to exit"))));
+};
+const doProcess = (worker) => {
+    const devElement = render(React.createElement(InteractionBox, { worker: worker }));
+    return {
+        devElement,
+        exit: () => {
+            devElement.unmount();
+        }
+    };
+};
+export default doProcess;

package/dist/commands/dev/index.js

@@ -0,0 +1,240 @@
+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 { exec } from 'child_process';
+import chokidar from 'chokidar';
+import doProcess from './doProcess.js';
+import { getProjectConfig, getRoot, generateConfigFile, getDevConf } from '../../utils/fileUtils/index.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 debounce from '../../utils/debounce.js';
+import t from '../../i18n/index.js';
+import checkAndInputPort from '../../utils/checkDevPort.js';
+let yargsIns;
+const dev = {
+    command: 'dev [entry]',
+    describe: `💻 ${t('dev_describe').d('Start a local server for developing your routine')}`,
+    builder: (yargs) => {
+        yargsIns = yargs;
+        return yargs
+            .positional('entry', {
+            describe: t('dev_entry_describe').d('Entry file of the Routine'),
+            type: 'string',
+            demandOption: false
+        })
+            .option('refresh-command', {
+            describe: t('dev_refresh_command_describe').d('Provide a command to be executed before the auto-refresh on save'),
+            type: 'string'
+        })
+            .option('local-upstream', {
+            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'),
+            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'
+        });
+    },
+    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;
+        if (yargsIns && help) {
+            yargsIns.showHelp('log');
+            return;
+        }
+        const projectConfig = getProjectConfig();
+        if (!projectConfig) {
+            if (entry) {
+                try {
+                    yield selectToCreateConf(entry);
+                }
+                catch (_) {
+                    logger.notInProject();
+                    process.exit(1);
+                }
+            }
+            else {
+                return logger.notInProject();
+            }
+        }
+        else if (entry) {
+            // @ts-ignore
+            global.entry = entry;
+        }
+        if (port) {
+            if (Array.isArray(port)) {
+                port = Number(port[0]);
+            }
+            else {
+                port = Number(port);
+                if (isNaN(port)) {
+                    logger.warn(t('dev_import_port_invalid').d('Invalid port entered, default port will be used.'));
+                }
+            }
+            // @ts-ignore
+            global.port = port;
+        }
+        if (inspectPort) {
+            inspectPort = Number(inspectPort);
+            // @ts-ignore
+            global.inspectPort = inspectPort;
+        }
+        if (minify) {
+            // @ts-ignore
+            global.minify = minify;
+        }
+        if (minify) {
+            // @ts-ignore
+            global.minify = minify;
+        }
+        if (localUpstream) {
+            // @ts-ignore
+            global.localUpstream = localUpstream;
+        }
+        const runtimeCommand = yield preCheckRuntime();
+        if (!runtimeCommand) {
+            return;
+        }
+        const speDenoPort = getDevConf('port', 'dev', 18080);
+        const speInspectPort = getDevConf('inspectPort', 'dev', 9229);
+        try {
+            const result = yield checkAndInputPort(speDenoPort, speInspectPort);
+            // @ts-ignore
+            global.port = result.denoPort;
+            // @ts-ignore
+            global.inspectPort = result.inspectPort;
+        }
+        catch (err) {
+            process.exit(1);
+        }
+        logger.info(`${t('dev_build_start').d('Starting build process')}...`);
+        yield devPack();
+        const worker = new WorkerServer({ command: runtimeCommand });
+        const ignored = (path) => {
+            return /(^|[\/\\])\.(?!dev($|[\/\\]))/.test(path);
+        };
+        const watcher = chokidar.watch([`${getRoot()}/src`, `${getRoot()}/.dev`], {
+            ignored,
+            persistent: true
+        });
+        watcher.on('change', debounce((path) => __awaiter(void 0, void 0, void 0, function* () {
+            if (path.includes('.dev')) {
+                if (userFileRepacking) {
+                    userFileRepacking = false;
+                    return;
+                }
+                worker.restart();
+                return;
+            }
+            logger.info(`${t('dev_repacking').d('Detected local file changes, re-packaging')}...`);
+            if (refreshCommand) {
+                try {
+                    yield execRefreshCommand(refreshCommand);
+                }
+                catch (err) { }
+            }
+            userFileRepacking = true;
+            yield devPack();
+            yield worker.restart();
+        }), 500));
+        const { devElement } = doProcess(worker);
+        const { waitUntilExit } = devElement;
+        yield waitUntilExit();
+        watcher.close();
+    })
+};
+function execCommand(cmd) {
+    return new Promise((resolve, reject) => {
+        exec(cmd, (error, stdout, stderr) => {
+            logger.log(stdout);
+            if (error) {
+                reject({ error, stderr });
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        });
+    });
+}
+function isSafeCommand(cmd) {
+    const dangerousPatterns = [
+        /[`;]/,
+        /\|\|/,
+        /&&/,
+        />|<|>>|<<|&/,
+        /\$(?=.*\()|=/
+    ];
+    return !dangerousPatterns.some((pattern) => pattern.test(cmd));
+}
+function execRefreshCommand(cmd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (isSafeCommand(cmd)) {
+            logger.ora.start(`${t('dev_refresh_exec_start').d('Trying to execute command:')} ${cmd}`);
+            try {
+                const { stderr } = yield execCommand(cmd);
+                logger.ora.succeed(`${t('dev_refresh_exec_success').d('Command executed successfully.')}`);
+                if (stderr) {
+                    logger.ora.fail();
+                    logger.error(`Errors: ${stderr}`);
+                }
+            }
+            catch (err) {
+                logger.ora.fail();
+                logger.error(`${t('dev_refresh_exec_fail').d('Command execution failed:')} ${err.error.message}`);
+                if (err.stderr) {
+                    logger.error(`Errors: ${err.stderr}`);
+                }
+                logger.warn('Jumped it.');
+            }
+        }
+        else {
+            logger.error(t('dev_refresh_exec_unsafe').d('Command execution failed: Invalid command'));
+        }
+    });
+}
+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?'));
+        SelectItems({
+            items: [
+                { label: 'Yes', value: 'yes' },
+                { label: 'No', value: 'no' }
+            ],
+            handleSelect: (item) => __awaiter(this, void 0, void 0, function* () {
+                if (item.value === 'yes') {
+                    yield generateConfigFile(undefined, {
+                        dev: {
+                            entry
+                        }
+                    });
+                    resolve(true);
+                }
+                else {
+                    reject(false);
+                }
+            })
+        });
+    });
+}
+export default dev;