esa-cli 0.0.2-beta.1 → 0.0.2-beta.12

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

@@ -1,31 +1,115 @@
 class MockCache {
-  constructor() {
-    this.cache = new Map();
+  constructor(port) {
+    this.port = port;
   }
 
-  static async init(cacheName) {
-    const instance = await MockCache.open(cacheName);
-    return new MockCache(instance);
-  }
+  async put(reqOrUrl, response) {
+    if (arguments.length < 2) {
+      throw new TypeError(
+        `Failed to execute 'put' on 'cache': 2 arguments required, but only ${arguments.length} present.`
+      );
+    }
+    if (!reqOrUrl) {
+      throw new TypeError(
+        "Failed to execute 'put' on 'cache': 2 arguments required, but only 0 present."
+      );
+    }
+    if (!(response instanceof Response)) {
+      throw new TypeError(
+        "Failed to execute 'put' on 'cache': Argument 2 is not of type Response."
+      );
+    }
+
+    try {
+      const body = await response.clone().text();
+      const headers = {};
+      response.headers.forEach((v, k) => (headers[k] = v));
+
+      const cacheControl = response.headers.get('Cache-Control') || '';
+      const ttl = this.parseTTL(cacheControl);
 
-  static async open(cacheName) {
-    return new Map();
+      const key = this.normalizeKey(reqOrUrl);
+      const fetchRes = await fetch(
+        `http://localhost:${this.port}/mock_cache/put`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            key,
+            response: {
+              status: response.status,
+              headers,
+              body
+            },
+            ttl
+          })
+        }
+      );
+      if (!fetchRes.ok) {
+        const error = await fetchRes.json();
+        throw new Error(error.error);
+      }
+      return undefined;
+    } catch (err) {
+      throw new Error(`Cache put failed: ${err.message}`);
+    }
   }
 
-  async match(reqOrUrl) {
-    return this.cache.get(reqOrUrl) || null;
+  async get(reqOrUrl) {
+    const key = this.normalizeKey(reqOrUrl);
+    const fetchRes = await fetch(
+      `http://localhost:${this.port}/mock_cache/get`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          key
+        })
+      }
+    );
+    if (!fetchRes.ok) {
+      const error = await fetchRes.json();
+      throw new Error(error.error);
+    }
+    const res = await fetchRes.json();
+    if (res && res.success) {
+      return new Response(res.data.response.body, {
+        status: res.data.response.status,
+        headers: new Headers(res.data.response.headers)
+      });
+    } else {
+      return undefined;
+    }
   }
 
   async delete(reqOrUrl) {
-    return this.cache.delete(reqOrUrl);
+    const key = this.normalizeKey(reqOrUrl);
+    const fetchRes = await fetch(
+      `http://localhost:${this.port}/mock_cache/delete`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          key
+        })
+      }
+    );
+    if (!fetchRes.ok) {
+      const error = await fetchRes.json();
+      throw new Error(error.error);
+    }
+    const res = await fetchRes.json();
+    return res.success;
   }
 
-  async put(reqOrUrl, response) {
-    this.cache.set(reqOrUrl, response);
+  normalizeKey(input) {
+    const url = input instanceof Request ? input.url : input;
+    return url.replace(/^https:/i, 'http:');
   }
 
-  async get(reqOrUrl) {
-    return this.match(reqOrUrl);
+  parseTTL(cacheControl) {
+    const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+    return maxAgeMatch ? parseInt(maxAgeMatch[1]) : 3600;
   }
 }
 

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

@@ -1,44 +1,165 @@
 class EdgeKV {
+  static port = 0;
+  JS_RESPONSE_BUFFER_THRESHOLD = 64 * 1024;
   constructor(options) {
+    if (!options || (!options.namespace && !options.namespaceId)) {
+      throw new TypeError(
+        'The argument to `EdgeKV` must be an object with a `namespace` or `namespaceId` field'
+      );
+    }
     this.namespace = options.namespace;
-    this.allData = {};
   }
 
-  async get(key, options) {
-    const namespaceData = this.allData[this.namespace] || {};
-    if (!(key in namespaceData)) {
+  async put(key, value) {
+    if (arguments.length < 2) {
+      throw new TypeError(
+        `Failed to execute 'put' on 'EdgeKV': 2 arguments required, but only ${arguments.length} present.`
+      );
+    }
+    if (!key) {
+      throw new TypeError(
+        "Failed to execute 'put' on 'EdgeKV': 2 arguments required, but only 0 present."
+      );
+    }
+    if (typeof key !== 'string') {
+      throw new TypeError(
+        `Failed to execute 'put' on 'EdgeKV': 1th argument must be a string.`
+      );
+    }
+
+    try {
+      let body;
+      if (typeof value === 'string') {
+        if (value.length > this.JS_RESPONSE_BUFFER_THRESHOLD) {
+          const encoder = new TextEncoder();
+          const encodedValue = encoder.encode(value);
+
+          body = new ReadableStream({
+            start(controller) {
+              controller.enqueue(encodedValue);
+              controller.close();
+            }
+          });
+        } else {
+          body = value;
+        }
+      } else if (value instanceof Response) {
+        const resBody = await value.clone().text();
+        const headers = {};
+        value.headers.forEach((v, k) => (headers[k] = v));
+        body = JSON.stringify({
+          body: resBody,
+          headers,
+          status: value.status
+        });
+      } else if (
+        value instanceof ReadableStream ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value)
+      ) {
+        body = value;
+      } else {
+        throw new TypeError(
+          `Failed to execute 'put' on 'EdgeKV': 2nd argument should be one of string/Response/ArrayBuffer/ArrayBufferView/ReadableStream`
+        );
+      }
+
+      const fetchRes = await fetch(
+        `http://localhost:${EdgeKV.port}/mock_kv/put?key=${key}&namespace=${this.namespace}`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body
+        }
+      );
+      if (!fetchRes.ok) {
+        const error = await fetchRes.json();
+        throw new Error(error.error);
+      }
       return undefined;
+    } catch (err) {
+      throw new Error(`Cache put failed: ${err.message}`);
+    }
+  }
+
+  async get(key, options) {
+    const isTypeValid = (ty) =>
+      typeof ty === 'string' &&
+      (ty === 'text' ||
+        ty === 'json' ||
+        ty === 'stream' ||
+        ty === 'arrayBuffer');
+
+    if (options && !isTypeValid(options?.type)) {
+      throw new TypeError(
+        "EdgeKV.get: 2nd optional argument must be an object with a 'type' field. The 'type' field specifies the format of the return value and must be a string of 'text', 'json', 'stream' or 'arrayBuffer'"
+      );
     }
-    const value = namespaceData[key];
     const type = options?.type || 'text';
+    const fetchRes = await fetch(
+      `http://localhost:${EdgeKV.port}/mock_kv/get?key=${key}&namespace=${this.namespace}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      }
+    );
+    // 判断是否存在key
+    let isGetFailed = false;
+    fetchRes.headers.forEach((v, k) => {
+      if (k === 'kv-get-empty') {
+        isGetFailed = true;
+      }
+    });
+    if (isGetFailed) {
+      return undefined;
+    }
     switch (type) {
       case 'text':
-        return value;
+        return fetchRes.text();
       case 'json':
         try {
-          return JSON.parse(value);
+          const value = await fetchRes.text();
+          const userObject = JSON.parse(value);
+          return userObject;
         } catch (error) {
-          throw new Error('Failed to parse JSON');
+          throw new TypeError(`Invalid JSON: ${err.message}`);
         }
       case 'arrayBuffer':
-        const encoder = new TextEncoder();
-        const uint8Array = encoder.encode(value);
-        return uint8Array.buffer;
+        try {
+          const buffer = await fetchRes.arrayBuffer();
+          return buffer;
+        } catch (error) {
+          throw new TypeError(
+            `Failed to read the response body into an ArrayBuffer: ${error.message}`
+          );
+        }
+      case 'stream':
+        const value = await fetchRes.text();
+        return new ReadableStream({
+          start(controller) {
+            controller.enqueue(new TextEncoder().encode(value));
+            controller.close();
+          }
+        });
       default:
-        throw new Error('Invalid type option');
+        throw new Error(`Unsupported type: ${type}`);
     }
   }
 
-  async put(key, value) {
-    const namespaceData = this.allData[this.namespace] || {};
-    namespaceData[key] = value;
-    this.allData[this.namespace] = namespaceData;
-  }
-
   async delete(key) {
-    const namespaceData = this.allData[this.namespace] || {};
-    delete namespaceData[key];
-    this.allData[this.namespace] = namespaceData;
+    const fetchRes = await fetch(
+      `http://localhost:${EdgeKV.port}/mock_kv/delete?key=${key}&namespace=${this.namespace}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      }
+    );
+    if (!fetchRes.ok) {
+      const error = await fetchRes.json();
+      throw new Error(error.error);
+    }
+    const res = await fetchRes.json();
+    return res.success;
   }
 }
 

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

@@ -15,6 +15,8 @@ import { getRoot } from '../../../utils/fileUtils/base.js';
 import { EW2BinPath } from '../../../utils/installEw2.js';
 import { HttpProxyAgent } from 'http-proxy-agent';
 import chalk from 'chalk';
+import CacheService from './cacheService.js';
+import EdgeKV from './kvService.js';
 import t from '../../../i18n/index.js';
 import sleep from '../../../utils/sleep.js';
 const getColorForStatusCode = (statusCode, message) => {
@@ -40,6 +42,8 @@ const getColorForStatusCode = (statusCode, message) => {
 class Ew2Server {
     constructor(props) {
         this.worker = null;
+        this.cache = null;
+        this.kv = null;
         this.startingWorker = false;
         this.workerStartTimeout = undefined;
         this.server = null;
@@ -57,6 +61,8 @@ class Ew2Server {
         return __awaiter(this, void 0, void 0, function* () {
             this.startingWorker = true;
             const result = yield this.openEdgeWorker();
+            this.cache = new CacheService();
+            this.kv = new EdgeKV();
             if (!result) {
                 throw new Error('Worker start failed');
             }
@@ -128,38 +134,62 @@ class Ew2Server {
     }
     createServer() {
         this.server = http.createServer((req, res) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c;
+            if (req.url === '/favicon.ico') {
+                res.writeHead(204, {
+                    'Content-Type': 'image/x-icon',
+                    'Content-Length': 0
+                });
+                return res.end();
+            }
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.includes('/mock_cache')) {
+                const cacheResult = yield this.handleCache(req);
+                return res.end(JSON.stringify(cacheResult));
+            }
+            if ((_b = req.url) === null || _b === void 0 ? void 0 : _b.includes('/mock_kv')) {
+                const kvResult = yield this.handleKV(req);
+                if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.includes('/get')) {
+                    if (kvResult.success) {
+                        return res.end(kvResult.value);
+                    }
+                    else {
+                        res.setHeader('Kv-Get-Empty', 'true');
+                        return res.end();
+                    }
+                }
+                else {
+                    return res.end(JSON.stringify(kvResult));
+                }
+            }
             try {
                 const host = req.headers.host;
                 const url = req.url;
+                const method = req.method;
+                const headers = Object.entries(req.headers).reduce((acc, [key, value]) => {
+                    if (Array.isArray(value)) {
+                        acc[key] = value.join(', ');
+                    }
+                    else {
+                        acc[key] = value;
+                    }
+                    return acc;
+                }, {});
                 // @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'
-                    },
+                    method,
+                    headers: Object.assign(Object.assign({}, headers), { 'x-er-context': 'eyJzaXRlX2lkIjogIjYyMjcxODQ0NjgwNjA4IiwgInNpdGVfbmFtZSI6ICJjb21wdXRlbHguYWxpY2RuLXRlc3QuY29tIiwgInNpdGVfcmVjb3JkIjogIm1vY2hlbi1uY2RuLmNvbXB1dGVseC5hbGljZG4tdGVzdC5jb20iLCAiYWxpdWlkIjogIjEzMjI0OTI2ODY2NjU2MDgiLCAic2NoZW1lIjoiaHR0cCIsICAiaW1hZ2VfZW5hYmxlIjogdHJ1ZX0=', 'x-er-id': 'a.bA' }),
+                    body: req.method === 'GET' ? undefined : req,
                     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);
-                    }
+                    res.writeHead(workerRes.status, workerHeaders);
+                    workerRes.body.pipe(res);
                     logger.log(`[ESA Dev] ${req.method} ${url} ${getColorForStatusCode(workerRes.status, workerRes.statusText)}`);
                 }
                 else {
@@ -175,6 +205,65 @@ class Ew2Server {
             logger.log(`listening on port ${this.port}`);
         });
     }
+    handleCache(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const body = yield this.parseCacheBody(req);
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.includes('/put')) {
+                (_b = this.cache) === null || _b === void 0 ? void 0 : _b.put(body.key, body);
+                return { success: true };
+            }
+            if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.includes('/get')) {
+                const res = (_d = this.cache) === null || _d === void 0 ? void 0 : _d.get(body.key);
+                if (!res) {
+                    return { success: false, key: body.key };
+                }
+                return { success: true, key: body.key, data: res === null || res === void 0 ? void 0 : res.serializedResponse };
+            }
+            if ((_e = req.url) === null || _e === void 0 ? void 0 : _e.includes('/delete')) {
+                const res = (_f = this.cache) === null || _f === void 0 ? void 0 : _f.delete(body.key);
+                return { success: !!res };
+            }
+            return { success: false };
+        });
+    }
+    handleKV(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const url = new URL(req.url, 'http://localhost');
+            const key = url.searchParams.get('key');
+            const namespace = url.searchParams.get('namespace');
+            const body = yield this.parseKVBody(req);
+            if (!key || !namespace) {
+                return {
+                    success: false
+                };
+            }
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.includes('/put')) {
+                (_b = this.kv) === null || _b === void 0 ? void 0 : _b.put(key, body, namespace);
+                return {
+                    success: true
+                };
+            }
+            if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.includes('/get')) {
+                const res = (_d = this.kv) === null || _d === void 0 ? void 0 : _d.get(key, namespace);
+                const params = { success: true, value: res };
+                if (!res) {
+                    params.success = false;
+                }
+                return params;
+            }
+            if ((_e = req.url) === null || _e === void 0 ? void 0 : _e.includes('/delete')) {
+                const res = (_f = this.kv) === null || _f === void 0 ? void 0 : _f.delete(key, namespace);
+                return {
+                    success: res
+                };
+            }
+            return {
+                success: false
+            };
+        });
+    }
     stdoutHandler(chunk) {
         logger.log(`${chalk.bgGreen('[Worker]')} ${chunk.toString().trim()}`);
     }
@@ -201,6 +290,48 @@ class Ew2Server {
             this.onClose && this.onClose();
         });
     }
+    parseCacheBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let totalLength = 0;
+            req.on('data', (chunk) => {
+                chunks.push(chunk);
+                totalLength += chunk.length;
+            });
+            req.on('end', () => {
+                try {
+                    const buffer = Buffer.concat(chunks, totalLength);
+                    const rawBody = buffer.toString('utf8');
+                    resolve(rawBody ? JSON.parse(rawBody) : {});
+                }
+                catch (err) {
+                    reject(new Error(`Invalid JSON: ${err.message}`));
+                }
+            });
+            req.on('error', reject);
+        });
+    }
+    parseKVBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let totalLength = 0;
+            req.on('data', (chunk) => {
+                chunks.push(chunk);
+                totalLength += chunk.length;
+            });
+            req.on('end', () => {
+                try {
+                    const buffer = Buffer.concat(chunks, totalLength);
+                    const rawBody = buffer.toString();
+                    resolve(rawBody);
+                }
+                catch (err) {
+                    reject(new Error(`Invalid JSON: ${err.message}`));
+                }
+            });
+            req.on('error', reject);
+        });
+    }
     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);
@@ -221,10 +352,12 @@ class Ew2Server {
             (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
         });
     }
-    restart() {
+    restart(devPack) {
         return __awaiter(this, void 0, void 0, function* () {
             this.restarting = true;
+            console.clear();
             yield this.stop();
+            yield devPack();
             this.start();
             logger.log(t('dev_server_restart').d('Worker server restarted'));
             logger.info('Worker server restarted');

package/dist/commands/dev/index.js

@@ -27,7 +27,8 @@ 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 EW2OS = [Platforms.AppleArm, Platforms.AppleIntel, Platforms.LinuxX86];
+const useEw2 = EW2OS.includes(OS);
 const dev = {
     command: 'dev [entry]',
     describe: `💻 ${t('dev_describe').d('Start a local server for developing your routine')}`,
@@ -202,7 +203,7 @@ const dev = {
                     userFileRepacking = false;
                     return;
                 }
-                worker.restart();
+                worker.restart(devPack);
                 return;
             }
             logger.info('Dev repack');
@@ -214,8 +215,7 @@ const dev = {
                 catch (err) { }
             }
             userFileRepacking = true;
-            yield devPack();
-            yield worker.restart();
+            yield worker.restart(devPack);
         }), 500));
         var { devElement, exit } = doProcess(worker);
         const { waitUntilExit } = devElement;

package/dist/commands/dev/mockWorker/devPack.js

@@ -35,7 +35,7 @@ const generateEntry = (id, projectEntry, userRoot) => __awaiter(void 0, void 0,
         const destPath = path.resolve(mockDevDir, file);
         yield fs.promises.copyFile(srcPath, destPath);
     }
-    return fs.promises.writeFile(devEntry, devEntryTempFile.replace(/'\$userPath'/g, `'${projectEntry}'`));
+    return fs.promises.writeFile(devEntry, devEntryTempFile.replace(/'\$userPath'/g, `'${projectEntry.replace(/\\/g, '/')}'`));
 });
 const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(void 0, void 0, void 0, function* () {
     const options = {};
@@ -51,22 +51,24 @@ const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(
             .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);
+        const currentIds = Object.keys(currentConfigObj);
+        if (currentIds[0] && /^\d+$/.test(currentIds[0])) {
+            for (let currentId of currentIds) {
+                const unused = yield checkPort(currentConfigObj[currentId].port);
+                if (unused) {
+                    const devDir = path.resolve(userRoot, '.dev');
+                    const files = fs.readdirSync(devDir);
+                    const filesToDelete = files.filter((file) => file.includes(currentId));
+                    for (const file of filesToDelete) {
+                        fs.rmSync(path.resolve(devDir, file), {
+                            force: true,
+                            recursive: true,
+                            maxRetries: 5
+                        });
                     }
                 }
                 else {
-                    options[cid] = currentConfigObj[cid];
+                    options[currentId] = currentConfigObj[currentId];
                 }
             }
         }

package/dist/commands/domain/add.js

@@ -14,7 +14,7 @@ import logger from '../../libs/logger.js';
 import { validRoutine } from '../../utils/checkIsRoutineCreated.js';
 const addDomain = {
     command: 'add <domain>',
-    describe: `📥 ${t('domain_add_describe').d('Bind a domain to a routine')}`,
+    describe: `🔗 ${t('domain_add_describe').d('Bind a domain to a routine')}`,
     builder: (yargs) => {
         return yargs
             .positional('domain', {

package/dist/commands/domain/delete.js

@@ -31,7 +31,7 @@ const deleteDomain = {
 export default deleteDomain;
 export function handleDeleteDomain(argv) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a;
         if (!checkDirectory()) {
             return;
         }
@@ -44,10 +44,10 @@ export function handleDeleteDomain(argv) {
         yield validRoutine(projectConfig.name);
         const server = yield ApiService.getInstance();
         const req = { Name: projectConfig.name || '' };
-        const routineDetail = yield server.getRoutine(req);
-        if (!routineDetail)
+        const listRoutineRelatedRecordRes = yield server.listRoutineRelatedRecords(req);
+        if (!listRoutineRelatedRecordRes)
             return;
-        const relatedRecords = (_b = (_a = routineDetail.data) === null || _a === void 0 ? void 0 : _a.RelatedRecords) !== null && _b !== void 0 ? _b : [];
+        const relatedRecords = ((_a = listRoutineRelatedRecordRes.data) === null || _a === void 0 ? void 0 : _a.RelatedRecords) || [];
         const relatedDomain = argv.domain;
         const matchedSite = relatedRecords.find((item) => {
             return String(item.RecordName) === relatedDomain;

package/dist/commands/domain/index.js

@@ -5,7 +5,7 @@ import t from '../../i18n/index.js';
 let yargsIns;
 const domainCommand = {
     command: 'domain [script]',
-    describe: `🚀 ${t('domain_describe').d('Manage the domain names bound to your routine')}`,
+    describe: `🔗 ${t('domain_describe').d('Manage the domain names bound to your routine')}`,
     builder: (yargs) => {
         yargsIns = yargs;
         return yargs