@coze-arch/cli 0.0.5-alpha.5dd55b → 0.0.5-alpha.6339fe

package/lib/cli.js

@@ -15,6 +15,7 @@ var fs$1 = require('fs/promises');
 var os = require('os');
 var jsYaml = require('js-yaml');
 var toml = require('@iarna/toml');
+var fastGlob = require('fast-glob');
 var child_process = require('child_process');
 var addFormats = require('ajv-formats');
 var Ajv = require('ajv');
@@ -1490,7 +1491,7 @@ var browserClient = createBaseClient();
 
 
 
-const log$2 = debug('slardar:transport');
+const log$6 = debug('slardar:transport');
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 const noop = () => {};
 
@@ -1510,22 +1511,22 @@ const noop = () => {};
 function makeRequest(options) {
   const { url, method, data, success = noop, fail = noop, getResponseText = noop } = options;
 
-  log$2('Making %s request to %s', method, url);
+  log$6('Making %s request to %s', method, url);
   if (data) {
-    log$2('Request data: %s', data.slice(0, 200));
+    log$6('Request data: %s', data.slice(0, 200));
   }
 
   // 检查 URL 是否有效
   if (!url || typeof url !== 'string') {
     const error = new Error(`Invalid URL: ${url}`);
-    log$2('Invalid URL provided: %o', url);
+    log$6('Invalid URL provided: %o', url);
     fail(error);
     return;
   }
 
   try {
     const urlObj = new URL(url);
-    log$2('Parsed URL - protocol: %s, hostname: %s, port: %s, path: %s',
+    log$6('Parsed URL - protocol: %s, hostname: %s, port: %s, path: %s',
       urlObj.protocol, urlObj.hostname, urlObj.port, urlObj.pathname);
 
     const isHttps = urlObj.protocol === 'https:';
@@ -1543,34 +1544,34 @@ function makeRequest(options) {
         },
       },
       res => {
-        log$2('Response callback triggered: status=%s', res.statusCode);
+        log$6('Response callback triggered: status=%s', res.statusCode);
         let responseText = '';
 
         res.on('data', chunk => {
-          log$2('Response data chunk received: %s bytes', chunk.length);
+          log$6('Response data chunk received: %s bytes', chunk.length);
           responseText += chunk.toString();
         });
 
         res.on('end', () => {
-          log$2('Response end event fired');
-          log$2('Response received: status=%s, body=%s', res.statusCode, responseText.slice(0, 200));
+          log$6('Response end event fired');
+          log$6('Response received: status=%s, body=%s', res.statusCode, responseText.slice(0, 200));
           getResponseText(responseText);
 
           try {
             if (res.statusCode && res.statusCode >= 400) {
-              log$2('Request failed with status %s: %s', res.statusCode, responseText);
+              log$6('Request failed with status %s: %s', res.statusCode, responseText);
               fail(new Error(responseText || res.statusMessage || 'Request failed'));
             } else if (responseText) {
               // eslint-disable-next-line no-restricted-syntax -- Parsing trusted Slardar API responses
               const result = JSON.parse(responseText);
-              log$2('Request succeeded');
+              log$6('Request succeeded');
               success(result);
             } else {
-              log$2('Request succeeded with empty response');
+              log$6('Request succeeded with empty response');
               success({});
             }
           } catch (e) {
-            log$2('Failed to parse response: %s', (e ).message);
+            log$6('Failed to parse response: %s', (e ).message);
             fail(e );
           }
         });
@@ -1578,12 +1579,12 @@ function makeRequest(options) {
     );
 
     req.on('error', err => {
-      log$2('Request error: %s', err.message);
+      log$6('Request error: %s', err.message);
       fail(err);
     });
 
     req.on('timeout', () => {
-      log$2('Request timeout');
+      log$6('Request timeout');
       req.destroy();
       fail(new Error('Request timeout'));
     });
@@ -1594,7 +1595,7 @@ function makeRequest(options) {
 
     req.end();
   } catch (e) {
-    log$2('Exception during request: %s', (e ).message);
+    log$6('Exception during request: %s', (e ).message);
     fail(e );
   }
 }
@@ -1605,14 +1606,14 @@ function makeRequest(options) {
 function createNodeTransport() {
   return {
     get(options) {
-      log$2('Transport GET called: %s', options.url);
+      log$6('Transport GET called: %s', options.url);
       makeRequest({
         method: 'GET',
         ...options,
       });
     },
     post({ url, data }) {
-      log$2('Transport POST called: %s', url);
+      log$6('Transport POST called: %s', url);
       makeRequest({
         method: 'POST',
         url,
@@ -1633,7 +1634,7 @@ function _nullishCoalesce$3(lhs, rhsFn) { if (lhs != null) { return lhs; } else
 
 // 创建 debug 实例
 // 使用方式: DEBUG=slardar:* your-cli-command
-const log$1 = debug('slardar:reporter');
+const log$5 = debug('slardar:reporter');
 
 /**
  * Slardar CLI Reporter
@@ -1658,12 +1659,12 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
    */
   setup(config) {
     if (this.initialized) {
-      log$1('Already initialized, skipping setup');
+      log$5('Already initialized, skipping setup');
       return;
     }
 
     try {
-      log$1('Initializing Slardar with config:', {
+      log$5('Initializing Slardar with config:', {
         bid: config.bid,
         release: config.release,
         env: config.env,
@@ -1696,7 +1697,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
 
       // 添加 send 钩子来追踪事件上报
       this.client.on('send', (ev) => {
-        log$1(
+        log$5(
           'send hook called for event: %s',
           (_optionalChain$6([ev, 'optionalAccess', _ => _.ev_type]) ) || 'unknown',
         );
@@ -1704,9 +1705,9 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
 
       this.client.start();
       this.initialized = true;
-      log$1('Slardar initialized successfully');
+      log$5('Slardar initialized successfully');
     } catch (error) {
-      log$1('Failed to initialize:', error);
+      log$5('Failed to initialize:', error);
     }
   }
 
@@ -1715,7 +1716,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
    */
    ensureInitialized() {
     if (!this.initialized) {
-      log$1('Not initialized, call setup() first');
+      log$5('Not initialized, call setup() first');
       return false;
     }
     return true;
@@ -1737,7 +1738,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
     }
 
     try {
-      log$1('Sending event:', { name, metrics, categories });
+      log$5('Sending event:', { name, metrics, categories });
 
       // 过滤掉 undefined 值以满足 Slardar 类型要求
       const cleanMetrics = metrics
@@ -1762,7 +1763,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
         categories: cleanCategories ,
       })]);
     } catch (error) {
-      log$1('Failed to send event:', error);
+      log$5('Failed to send event:', error);
     }
   }
 
@@ -1782,7 +1783,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
     }
 
     try {
-      log$1('Sending log:', { level, message, extra });
+      log$5('Sending log:', { level, message, extra });
       // 使用 sendEvent 发送日志事件
       this.sendEvent('cli_log', undefined, {
         level,
@@ -1790,7 +1791,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
         ...extra,
       });
     } catch (error) {
-      log$1('Failed to send log:', error);
+      log$5('Failed to send log:', error);
     }
   }
 
@@ -1824,7 +1825,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
         },
       };
 
-      log$1('Reporting JS error:', {
+      log$5('Reporting JS error:', {
         name: error.name,
         message: error.message.slice(0, 100),
         stack: _optionalChain$6([error, 'access', _5 => _5.stack, 'optionalAccess', _6 => _6.slice, 'call', _7 => _7(0, 200)]),
@@ -1834,9 +1835,9 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
 
       // 使用 Slardar 的 js_error 事件类型，这样会显示在 JS 错误总览页面
       this.client.report(errorEvent);
-      log$1('JS error reported successfully');
+      log$5('JS error reported successfully');
     } catch (err) {
-      log$1('Failed to report error:', err);
+      log$5('Failed to report error:', err);
     }
   }
 
@@ -1857,7 +1858,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
     if (!this.ensureInitialized()) {
       return;
     }
-    log$1('Merging context:', context);
+    log$5('Merging context:', context);
     _optionalChain$6([this, 'access', _12 => _12.client, 'access', _13 => _13.context, 'optionalAccess', _14 => _14.merge, 'call', _15 => _15(context)]);
   }
 
@@ -1894,7 +1895,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
     }
 
     try {
-      log$1('Updating config:', config);
+      log$5('Updating config:', config);
       this.client.config({
         userId: config.userId,
         release: config.release,
@@ -1902,7 +1903,7 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
         env: config.env,
       });
     } catch (error) {
-      log$1('Failed to update config:', error);
+      log$5('Failed to update config:', error);
     }
   }
 
@@ -1914,11 +1915,11 @@ class SlardarCLIReporter {constructor() { SlardarCLIReporter.prototype.__init.ca
     if (!this.ensureInitialized()) {
       return;
     }
-    log$1('Flushing Slardar data...');
+    log$5('Flushing Slardar data...');
     _optionalChain$6([this, 'access', _24 => _24.client, 'access', _25 => _25.getSender, 'optionalCall', _26 => _26(), 'optionalAccess', _27 => _27.flush, 'call', _28 => _28()]);
-    log$1('Waiting %dms for events to be sent...', waitMs);
+    log$5('Waiting %dms for events to be sent...', waitMs);
     await new Promise(resolve => setTimeout(resolve, waitMs));
-    log$1('Slardar data flushed');
+    log$5('Slardar data flushed');
   }
 
   /**
@@ -2105,7 +2106,7 @@ const EventBuilder = {
 };
 
 var name = "@coze-arch/cli";
-var version = "0.0.5-alpha.5dd55b";
+var version = "0.0.5-alpha.6339fe";
 var description = "coze coding devtools cli";
 var license = "MIT";
 var author = "fanwenjie.fe@bytedance.com";
@@ -2145,6 +2146,7 @@ var dependencies = {
 	commander: "~12.1.0",
 	debug: "^4.3.7",
 	ejs: "^3.1.10",
+	"fast-glob": "^3.3.3",
 	"js-yaml": "^4.1.0",
 	minimist: "^1.2.5",
 	shelljs: "^0.10.0"
@@ -2209,7 +2211,7 @@ function _optionalChain$4(ops) { let lastAccessLHS = undefined; let value = ops[
  * Slardar 监控初始化和上报
  */
 
-const log = debug('slardar:cli');
+const log$4 = debug('slardar:cli');
 
 /**
  * 安全执行函数包装器
@@ -2222,18 +2224,18 @@ function safeRun(
 ) {
   return ((...args) => {
     try {
-      log('Calling Slardar function: %s', name);
+      log$4('Calling Slardar function: %s', name);
       const result = fn(...args);
 
       // 如果是 Promise，处理异步错误
       if (result instanceof Promise) {
         return result
           .then(res => {
-            log('Slardar function %s completed', name);
+            log$4('Slardar function %s completed', name);
             return res;
           })
           .catch(error => {
-            log(
+            log$4(
               'Slardar function %s failed: %s',
               name,
               (error ).message,
@@ -2242,11 +2244,11 @@ function safeRun(
           });
       }
 
-      log('Slardar function %s completed', name);
+      log$4('Slardar function %s completed', name);
       return result;
     } catch (error) {
       // Slardar 上报失败不应影响 CLI 正常运行，但要记录错误
-      log('Slardar function %s failed: %s', name, (error ).message);
+      log$4('Slardar function %s failed: %s', name, (error ).message);
     }
   }) ;
 }
@@ -2810,6 +2812,76 @@ const registerCommand$4 = program => {
     });
 };
 
+// ABOUTME: Temporary paths utility for Coze CLI
+// ABOUTME: Provides centralized management of temporary directories and files
+
+
+/**
+ * Base Coze directory in user's home
+ * Used for storing CLI-related temporary files, logs, and cache
+ * Default: ~/.coze
+ */
+const COZE_HOME_DIR = '.coze';
+
+/**
+ * Logs directory name
+ * Default: .coze-logs
+ */
+const LOGS_DIR = '.coze-logs';
+
+/**
+ * Get the Coze home directory path
+ * Can be customized via COZE_HOME environment variable
+ *
+ * @returns Absolute path to Coze home directory (default: ~/.coze)
+ */
+const getCozeHome = () =>
+  process.env.COZE_HOME || path.join(os.homedir(), COZE_HOME_DIR);
+
+/**
+ * Get the logs directory path
+ * Can be customized via COZE_LOG_DIR environment variable
+ *
+ * @returns Absolute path to logs directory (default: ~/.coze-logs)
+ */
+const getCozeLogsDir = () =>
+  process.env.COZE_LOG_DIR || path.join(os.homedir(), LOGS_DIR);
+
+/**
+ * Get path for a specific file/directory within Coze home
+ *
+ * @param relativePath - Relative path within Coze home directory
+ * @returns Absolute path to the file/directory
+ *
+ * @example
+ * ```ts
+ * // Get routes file path
+ * const routesPath = getCozeFilePath('routes.json');
+ * // Returns: ~/.coze/routes.json
+ *
+ * // Get cache directory
+ * const cacheDir = getCozeFilePath('cache');
+ * // Returns: ~/.coze/cache
+ * ```
+ */
+const getCozeFilePath = (relativePath) =>
+  path.join(getCozeHome(), relativePath);
+
+/**
+ * Get path for a log file
+ *
+ * @param filename - Log file name
+ * @returns Absolute path to the log file
+ *
+ * @example
+ * ```ts
+ * const devLog = getCozeLogPath('dev.log');
+ * // Returns: ~/.coze-logs/dev.log
+ * ```
+ */
+const getCozeLogPath = (filename) =>
+  path.join(getCozeLogsDir(), filename);
+
 // ABOUTME: This file implements the update command for coze CLI
 // ABOUTME: It wraps pnpm update/install to update package dependencies with logging support
 
@@ -2820,29 +2892,22 @@ const registerCommand$4 = program => {
  */
 const LOG_FILE_NAME$1 = 'update.log';
 
-/**
- * 获取日志目录
- * 优先使用环境变量 COZE_LOG_DIR，否则使用 ~/.coze-logs
- */
-const getLogDir$1 = () =>
-  process.env.COZE_LOG_DIR || path.join(os.homedir(), '.coze-logs');
-
 /**
  * 解析日志文件路径
  * - 如果是绝对路径，直接使用
- * - 如果是相对路径，基于 getLogDir() + 相对路径
- * - 如果为空，使用 getLogDir() + LOG_FILE_NAME
+ * - 如果是相对路径，基于 logs 目录 + 相对路径
+ * - 如果为空，使用默认日志文件路径
  */
 const resolveLogFilePath$1 = (logFile) => {
   if (!logFile) {
-    return path.join(getLogDir$1(), LOG_FILE_NAME$1);
+    return getCozeLogPath(LOG_FILE_NAME$1);
   }
 
   if (path.isAbsolute(logFile)) {
     return logFile;
   }
 
-  return path.join(getLogDir$1(), logFile);
+  return getCozeLogPath(logFile);
 };
 
 /**
@@ -3016,6 +3081,7 @@ const handleUpdateError = (
 /**
  * 执行 update 命令的内部实现
  */
+// eslint-disable-next-line max-lines-per-function
 const executeUpdate = (
   packageName,
   options
@@ -3629,35 +3695,805 @@ const registerCommand$2 = program => {
     });
 };
 
-function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+// ABOUTME: Nuxt route scanner
+// ABOUTME: Scans Nuxt file-based routing structure to extract page and server routes
+
+
+
+
+const log$3 = debug('coze:route-scanner:nuxt');
+
 /**
- * 日志文件名常量
+ * Convert Nuxt file path to route path
+ * Examples:
+ * - app/pages/index.vue -> /
+ * - pages/index.vue -> /
+ * - app/pages/blog/index.vue -> /blog
+ * - pages/blog/[id].vue -> /blog/[id]
+ * - server/api/users.ts -> /api/users
+ * - server/routes/webhook.ts -> /webhook
  */
-const LOG_FILE_NAME = 'dev.log';
+const nuxtFilePathToRoute = (
+  filePath,
+  type,
+) => {
+  let route;
+
+  if (type === 'page') {
+    // Remove pages prefix (supports both app/pages/ and pages/) and .vue extension
+    route = filePath
+      .replace(/^app\/pages\//, '')
+      .replace(/^pages\//, '')
+      .replace(/\.vue$/, '')
+      .replace(/\/index$/, ''); // Remove trailing /index
+
+    // Handle index.vue at root (becomes empty string)
+    if (route === 'index') {
+      return '/';
+    }
+  } else {
+    // API routes
+    if (filePath.startsWith('server/api/')) {
+      route = `/api/${filePath
+        .replace(/^server\/api\//, '')
+        .replace(/\.(ts|js)$/, '')}`;
+    } else {
+      // server/routes
+      route = `/${filePath
+        .replace(/^server\/routes\//, '')
+        .replace(/\.(ts|js)$/, '')}`;
+    }
+  }
+
+  // Handle root route
+  if (route === '' || route === '/') {
+    return '/';
+  }
+
+  // Ensure leading slash
+  if (!route.startsWith('/')) {
+    route = `/${route}`;
+  }
+
+  return route;
+};
 
 /**
- * 获取日志目录
- * 优先使用环境变量 COZE_LOG_DIR，否则使用 ~/.coze-logs
+ * Normalize Nuxt route path to standard format
+ * Converts Nuxt dynamic segments to standard format:
+ * - [id] -> :id
+ * - [...slug] -> :slug*
  */
-const getLogDir = () =>
-  process.env.COZE_LOG_DIR || path.join(os.homedir(), '.coze-logs');
+const normalizeRoutePath$1 = (routePath) =>
+  routePath
+    .replace(/\[\.\.\.(\w+)\]/g, ':$1*') // [...slug] -> :slug*
+    .replace(/\[(\w+)\]/g, ':$1'); // [id] -> :id
+/**
+ * Extract dynamic parameter names from route path
+ */
+const extractParams$1 = (routePath) => {
+  const params = [];
+  const patterns = [
+    /\[\.\.\.(\w+)\]/g, // [...slug]
+    /\[(\w+)\]/g, // [id]
+  ];
+
+  patterns.forEach(pattern => {
+    const matches = routePath.matchAll(pattern);
+    for (const match of matches) {
+      params.push(match[1]);
+    }
+  });
+
+  return params;
+};
+
+/**
+ * Scan Nuxt routes from pages and server directories
+ *
+ * Scans for:
+ * - app/pages/**\/*.vue OR pages/**\/*.vue - Page routes (both structures supported)
+ * - server/api/**\/*.{ts,js} - API routes
+ * - server/routes/**\/*.{ts,js} - Server routes
+ *
+ * Excludes:
+ * - app/layouts/, layouts/ - Layout components (NOT routes)
+ * - app.vue, error.vue - Special files (NOT regular routes)
+ *
+ * @param cwd - Current working directory
+ * @returns List of detected routes
+ */
+const scanNuxtRoutes = async (cwd) => {
+  log$3('Scanning Nuxt routes in:', cwd);
+  const routes = [];
+
+  // Scan page routes - support both app/pages/ and pages/ directories
+  const pageFiles = await fastGlob.glob(['{app/,}pages/**/*.vue'], {
+    cwd,
+    ignore: [
+      '**/node_modules/**',
+      '**/.nuxt/**',
+      '**/dist/**',
+      '**/.output/**',
+      // Exclude layouts directory (not routes)
+      '**/layouts/**',
+      'app/layouts/**',
+      // Exclude special files
+      'app.vue',
+      'error.vue',
+    ],
+    onlyFiles: true,
+    followSymbolicLinks: false,
+  });
+
+  log$3('Found %d page files', pageFiles.length);
+
+  routes.push(
+    ...pageFiles.map(file => {
+      const routePath = nuxtFilePathToRoute(file, 'page');
+      const isDynamic = routePath.includes('[');
+      const params = extractParams$1(routePath);
+
+      return {
+        path: normalizeRoutePath$1(routePath),
+        rawPath: routePath,
+        dynamic: isDynamic,
+        params,
+        type: 'page' ,
+        file,
+        framework: 'nuxt' ,
+      };
+    }),
+  );
+
+  // Scan API routes
+  const apiFiles = await fastGlob.glob('server/api/**/*.{ts,js}', {
+    cwd,
+    ignore: ['**/node_modules/**', '**/dist/**', '**/.output/**'],
+    onlyFiles: true,
+    followSymbolicLinks: false,
+  });
+
+  log$3('Found %d API files', apiFiles.length);
+
+  routes.push(
+    ...apiFiles.map(file => {
+      const routePath = nuxtFilePathToRoute(file, 'api');
+      const isDynamic = routePath.includes('[');
+      const params = extractParams$1(routePath);
+
+      return {
+        path: normalizeRoutePath$1(routePath),
+        rawPath: routePath,
+        dynamic: isDynamic,
+        params,
+        type: 'api' ,
+        file,
+        framework: 'nuxt' ,
+      };
+    }),
+  );
+
+  // Scan server routes
+  const serverRouteFiles = await fastGlob.glob('server/routes/**/*.{ts,js}', {
+    cwd,
+    ignore: ['**/node_modules/**', '**/dist/**', '**/.output/**'],
+    onlyFiles: true,
+    followSymbolicLinks: false,
+  });
+
+  log$3('Found %d server route files', serverRouteFiles.length);
+
+  routes.push(
+    ...serverRouteFiles.map(file => {
+      const routePath = nuxtFilePathToRoute(file, 'api');
+      const isDynamic = routePath.includes('[');
+      const params = extractParams$1(routePath);
+
+      return {
+        path: normalizeRoutePath$1(routePath),
+        rawPath: routePath,
+        dynamic: isDynamic,
+        params,
+        type: 'api' ,
+        file,
+        framework: 'nuxt' ,
+      };
+    }),
+  );
+
+  log$3('Total routes found: %d', routes.length);
+  return routes;
+};
+
+// ABOUTME: Next.js route scanner
+// ABOUTME: Scans Next.js App Router file structure to extract routes
+
+
+
+
+const log$2 = debug('coze:route-scanner:nextjs');
+
+/**
+ * Convert Next.js file path to route path
+ * Examples:
+ * - src/app/page.tsx -> /
+ * - src/app/blog/page.tsx -> /blog
+ * - src/app/blog/[id]/page.tsx -> /blog/[id]
+ * - src/app/api/users/route.ts -> /api/users
+ */
+const filePathToRoute = (filePath) => {
+  // Remove src/app prefix and file extension
+  let route = filePath
+    .replace(/^src\/app/, '')
+    .replace(/\/(page|route|layout)\.(tsx?|jsx?)$/, '');
+
+  // Handle root route
+  if (route === '' || route === '/') {
+    return '/';
+  }
+
+  // Ensure leading slash
+  if (!route.startsWith('/')) {
+    route = `/${route}`;
+  }
+
+  return route;
+};
+
+/**
+ * Normalize route path to standard format
+ * Converts Next.js dynamic segments to standard format:
+ * - [id] -> :id
+ * - [...slug] -> :slug*
+ * - [[...slug]] -> :slug*?
+ */
+const normalizeRoutePath = (routePath) =>
+  routePath
+    .replace(/\[\[\.\.\.(\w+)\]\]/g, ':$1*?') // [[...slug]] -> :slug*?
+    .replace(/\[\.\.\.(\w+)\]/g, ':$1*') // [...slug] -> :slug*
+    .replace(/\[(\w+)\]/g, ':$1'); // [id] -> :id
+/**
+ * Extract dynamic parameter names from route path
+ * Note: Uses Set to avoid duplicates when patterns overlap (e.g., [[...slug]])
+ */
+const extractParams = (routePath) => {
+  const paramsSet = new Set();
+  const patterns = [
+    /\[\[\.\.\.(\w+)\]\]/g, // [[...slug]]
+    /\[\.\.\.(\w+)\]/g, // [...slug]
+    /\[(\w+)\]/g, // [id]
+  ];
+
+  patterns.forEach(pattern => {
+    const matches = routePath.matchAll(pattern);
+    for (const match of matches) {
+      paramsSet.add(match[1]);
+    }
+  });
+
+  return Array.from(paramsSet);
+};
+
+/**
+ * Determine route type based on file name
+ */
+const getRouteType = (filePath) => {
+  if (filePath.includes('/route.')) {
+    return 'api';
+  }
+  return 'page';
+};
+
+/**
+ * Scan Next.js routes from src/app directory
+ *
+ * Scans for:
+ * - page.tsx/jsx/ts/js - Page routes
+ * - route.ts/js - API routes
+ *
+ * Note: layout.tsx, loading.tsx, error.tsx are NOT routes, they are UI components
+ *
+ * @param cwd - Current working directory
+ * @returns List of detected routes
+ */
+const scanNextjsRoutes = async (cwd) => {
+  log$2('Scanning Next.js routes in:', cwd);
+
+  // Scan for page and route files only (NOT layout, loading, error, etc.)
+  const files = await fastGlob.glob('src/app/**/{page,route}.{tsx,ts,jsx,js}', {
+    cwd,
+    ignore: [
+      '**/node_modules/**',
+      '**/.next/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/.turbo/**',
+    ],
+    onlyFiles: true,
+    followSymbolicLinks: false,
+  });
+
+  log$2('Found %d files', files.length);
+
+  return files.map(file => {
+    log$2('Processing file:', file);
+    const routePath = filePathToRoute(file);
+    const isDynamic = routePath.includes('[');
+    const params = extractParams(routePath);
+
+    return {
+      path: normalizeRoutePath(routePath),
+      rawPath: routePath,
+      dynamic: isDynamic,
+      params,
+      type: getRouteType(file),
+      file,
+      framework: 'nextjs',
+    };
+  });
+};
+
+// ABOUTME: Route manifest file writer
+// ABOUTME: Writes route data to JSON file with proper formatting and directory creation
+
+
+
+
+/**
+ * Calculate route statistics
+ */
+const calculateStats = (routes) => {
+  const dynamic = routes.filter(r => r.dynamic).length;
+  const staticCount = routes.length - dynamic;
+
+  return {
+    total: routes.length,
+    dynamic,
+    static: staticCount,
+  };
+};
+
+/**
+ * Resolve output file path
+ * - Relative path: resolve based on cwd
+ * - Absolute path: use as-is
+ */
+const resolveOutputPath = (cwd, outputPath) =>
+  path.isAbsolute(outputPath) ? outputPath : path.join(cwd, outputPath);
+
+/**
+ * Ensure parent directory exists
+ * Handles edge cases like existing files with same name
+ */
+const ensureDir$1 = (filePath) => {
+  const dir = path.dirname(filePath);
+
+  // If directory already exists, verify it's actually a directory
+  if (fs.existsSync(dir)) {
+    const stats = fs.statSync(dir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path exists but is not a directory: ${dir}`);
+    }
+    return; // Directory exists and is valid
+  }
+
+  // Create directory with recursive option (equivalent to mkdir -p)
+  fs.mkdirSync(dir, { recursive: true });
+};
+
+// JSON.stringify indent size
+const JSON_INDENT = 2;
+
+/**
+ * Write route manifest to JSON file
+ *
+ * @param cwd - Current working directory (not used when outputPath is absolute)
+ * @param routes - List of routes to write
+ * @param templateType - Framework type
+ * @param outputPath - Output file path (absolute or relative to cwd)
+ */
+const writeRoutesFile = (
+  cwd,
+  routes,
+  templateType,
+  outputPath,
+) => {
+  try {
+    const resolvedPath = resolveOutputPath(cwd, outputPath);
+
+    // Ensure parent directory exists
+    ensureDir$1(resolvedPath);
+
+    // Build manifest
+    const manifest = {
+      framework: templateType,
+      generatedAt: new Date().toISOString(),
+      routes,
+      stats: calculateStats(routes),
+    };
+
+    // Write to file with pretty formatting
+    fs.writeFileSync(
+      resolvedPath,
+      JSON.stringify(manifest, null, JSON_INDENT),
+      'utf-8',
+    );
+  } catch (error) {
+    // Wrap error with context for better debugging
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to write routes file: ${errorMessage}`);
+  }
+};
+
+/**
+ * Get the absolute path of the output file
+ * Useful for logging and testing
+ */
+const getOutputFilePath = (cwd, outputPath) =>
+  resolveOutputPath(cwd, outputPath);
+
+// ABOUTME: Template type detection logic
+// ABOUTME: Detects framework type by checking config files and package.json dependencies
+
+
+
+
+const log$1 = debug('coze:route-scanner:detect');
+
+/**
+ * Check if any of the specified files exist
+ */
+const hasFile = (cwd, ...files) =>
+  files.some(file => fs.existsSync(path.join(cwd, file)));
+
+/**
+ * Detect template type by checking config files and package.json dependencies
+ *
+ * Detection rules (priority order):
+ * 1. Next.js (highest) - has `next` dependency + next.config.{js,mjs,ts}
+ * 2. Nuxt - has `nuxt` dependency + nuxt.config.{ts,js,mjs}
+ * 3. Vite (lowest) - has `vite` + `express` dependencies + vite.config.{ts,js,mjs}
+ *
+ * @param cwd - Current working directory
+ * @returns Template type or null if detection fails
+ */
+const detectTemplate = (cwd) => {
+  log$1('Detecting template type in:', cwd);
+
+  const pkgPath = path.join(cwd, 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    log$1('package.json not found');
+    return null;
+  }
+
+  try {
+    const pkgContent = fs.readFileSync(pkgPath, 'utf-8');
+    // eslint-disable-next-line no-restricted-syntax
+    const pkg = JSON.parse(pkgContent) 
+
+
+;
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    log$1('Dependencies found:', Object.keys(deps).join(', '));
+
+    // 1. Next.js - highest priority
+    const hasNextDep = !!deps.next;
+    const hasNextConfig = hasFile(
+      cwd,
+      'next.config.js',
+      'next.config.mjs',
+      'next.config.ts',
+    );
+    log$1('Next.js check - dependency:', hasNextDep, 'config:', hasNextConfig);
+
+    if (hasNextDep && hasNextConfig) {
+      log$1('✓ Detected: nextjs');
+      return 'nextjs';
+    }
+
+    // 2. Nuxt - second priority
+    const hasNuxtDep = !!deps.nuxt;
+    const hasNuxtConfig = hasFile(
+      cwd,
+      'nuxt.config.ts',
+      'nuxt.config.js',
+      'nuxt.config.mjs',
+    );
+    log$1('Nuxt check - dependency:', hasNuxtDep, 'config:', hasNuxtConfig);
+
+    if (hasNuxtDep && hasNuxtConfig) {
+      log$1('✓ Detected: nuxt');
+      return 'nuxt';
+    }
+
+    // 3. Vite - lowest priority (requires both vite and express)
+    const hasViteDep = !!deps.vite;
+    const hasExpressDep = !!deps.express;
+    const hasViteConfig = hasFile(
+      cwd,
+      'vite.config.ts',
+      'vite.config.js',
+      'vite.config.mjs',
+    );
+    log$1(
+      'Vite check - vite dep:',
+      hasViteDep,
+      'express dep:',
+      hasExpressDep,
+      'config:',
+      hasViteConfig,
+    );
+
+    if (hasViteDep && hasExpressDep && hasViteConfig) {
+      log$1('✓ Detected: vite');
+      return 'vite';
+    }
+
+    log$1('✗ No template detected');
+    return null;
+  } catch (error) {
+    // Invalid package.json or other errors
+    log$1('Error during detection:', error);
+    return null;
+  }
+};
+
+// ABOUTME: Route scanner main entry point
+// ABOUTME: Orchestrates template detection, route scanning, and polling-based updates
+
+
+const log = debug('coze:route-scanner:main');
+
+// Polling interval in milliseconds (500ms to balance responsiveness and performance)
+const POLLING_INTERVAL_MS = 500;
+
+// Store polling interval for cleanup
+let pollingInterval = null;
+let previousRoutesHash = null;
+
+/**
+ * Scan routes based on template type
+ */
+const scanRoutes = async (
+  cwd,
+  templateType,
+) => {
+  switch (templateType) {
+    case 'nextjs':
+      return scanNextjsRoutes(cwd);
+    case 'nuxt':
+      return scanNuxtRoutes(cwd);
+    case 'vite':
+      return [];
+    default:
+      return [];
+  }
+};
+
+/**
+ * Generate a simple hash for routes to detect changes
+ */
+const hashRoutes = (routes) =>
+  routes
+    .map(r => `${r.file}:${r.type}`)
+    .sort()
+    .join('|');
+
+/**
+ * Detect and validate template type
+ * @returns Template type or null if invalid/unsupported
+ */
+const detectAndValidateTemplate = (cwd) => {
+  log('Detecting template type');
+  const templateType = detectTemplate(cwd);
+
+  if (!templateType) {
+    log('No template type detected');
+    logger.warn('Unable to detect template type, skipping route scanning');
+    return null;
+  }
+
+  log('Template detected:', templateType);
+
+  if (templateType === 'vite') {
+    log('Skipping Vite template - not supported');
+    return null;
+  }
+
+  return templateType;
+};
+
+/**
+ * Perform initial route scan and write to file
+ */
+const performInitialScan = async (
+  cwd,
+  templateType,
+  outputPath,
+) => {
+  log('Starting route scanning');
+  log('Performing initial scan');
+  const routes = await scanRoutes(cwd, templateType);
+  log('Initial scan found %d routes', routes.length);
+
+  log('Writing routes to file:', outputPath);
+  writeRoutesFile(cwd, routes, templateType, outputPath);
+
+  const outputFilePath = getOutputFilePath(cwd, outputPath);
+  log('Routes written to: %s (%d routes)', outputFilePath, routes.length);
+
+  return routes;
+};
+
+/**
+ * Setup polling interval to detect route changes
+ */
+const setupPolling = (
+  cwd,
+  templateType,
+  outputPath,
+  initialRoutes,
+) => {
+  previousRoutesHash = hashRoutes(initialRoutes);
+  log('Starting periodic route scanning (every 500ms)');
+  log('About to call setInterval...');
+
+  pollingInterval = setInterval(async () => {
+    try {
+      log('Polling cycle started...');
+      const updatedRoutes = await scanRoutes(cwd, templateType);
+      const newHash = hashRoutes(updatedRoutes);
+      log('Scanned %d routes, hash: %s vs %s', updatedRoutes.length, newHash, previousRoutesHash);
+
+      if (newHash !== previousRoutesHash) {
+        log('Routes changed, updating file');
+        writeRoutesFile(cwd, updatedRoutes, templateType, outputPath);
+        previousRoutesHash = newHash;
+        log('Routes updated (%d routes)', updatedRoutes.length);
+        logger.info(`🔄 Routes updated (${updatedRoutes.length} routes)`);
+      }
+    } catch (pollingError) {
+      log('Polling error:', pollingError);
+    }
+  }, POLLING_INTERVAL_MS);
+
+  log('setInterval called, returned interval ID:', pollingInterval);
+  log('pollingInterval type:', typeof pollingInterval);
+  log('Route polling started (checking every %dms)', POLLING_INTERVAL_MS);
+
+  // Test if interval is actually working by logging after 1 second
+  setTimeout(() => {
+    log('setTimeout test fired after 1 second - event loop is working');
+  }, 1000);
+};
+
+/**
+ * Register cleanup handlers for process termination signals
+ * Note: Do NOT listen to 'exit' event because the CLI parent process
+ * exits normally after spawning the dev server child process
+ */
+const registerCleanupHandlers = () => {
+  const cleanup = () => {
+    if (pollingInterval) {
+      log('Cleaning up polling interval on process termination');
+      clearInterval(pollingInterval);
+      pollingInterval = null;
+      previousRoutesHash = null;
+    }
+  };
+
+  // Only handle termination signals, not normal exit
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+};
+
+/**
+ * Clean up existing polling interval
+ */
+const cleanupExistingInterval = () => {
+  if (pollingInterval) {
+    log('Clearing existing polling interval before starting new one');
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+    previousRoutesHash = null;
+  }
+};
+
+/**
+ * Start route scanning and polling
+ *
+ * Workflow:
+ * 1. Detect template type (Next.js/Nuxt/Vite)
+ * 2. If Vite, skip scanning (too simple, not worth resources)
+ * 3. Perform initial route scan
+ * 4. Write routes to JSON file
+ * 5. Start periodic polling (every 500ms) to detect route changes
+ *
+ * Note: Uses polling instead of file watching to avoid EMFILE errors
+ *
+ * @param cwd - Current working directory
+ * @param options - Scanning options (output path, etc.)
+ */
+const startRouteScanning = async (
+  cwd,
+  options = {},
+) => {
+  cleanupExistingInterval();
+
+  try {
+    log('startRouteScanning called with cwd:', cwd, 'options:', options);
+    // Default output to ~/.coze/routes.json (user home), can be overridden via options or env var
+    // Using user home avoids conflict with project .coze config file
+    const defaultOutputPath =
+      process.env.COZE_ROUTES_OUTPUT || getCozeFilePath('routes.json');
+    const { outputPath = defaultOutputPath } = options;
+
+    // Step 1: Detect and validate template
+    const templateType = detectAndValidateTemplate(cwd);
+    if (!templateType) {
+      return;
+    }
+
+    // Step 2: Perform initial scan
+    const routes = await performInitialScan(cwd, templateType, outputPath);
+
+    // Step 3: Check if polling is enabled
+    const enablePolling = process.env.COZE_ROUTES_WATCH !== 'false';
+    if (!enablePolling) {
+      log('Route polling disabled via COZE_ROUTES_WATCH=false');
+      return;
+    }
+
+    // Step 4: Setup polling and cleanup handlers
+    log('About to call setupPolling...');
+    setupPolling(cwd, templateType, outputPath, routes);
+    log('setupPolling completed');
+
+    log('About to call registerCleanupHandlers...');
+    registerCleanupHandlers();
+    log('registerCleanupHandlers completed');
+
+    log('startRouteScanning function about to return');
+  } catch (error) {
+    log('ERROR CAUGHT in startRouteScanning:', error);
+    cleanupExistingInterval();
+
+    // Silently handle all errors - route scanning should never break dev server
+    log('Route scanning error:', error);
+    logger.warn(
+      '⚠️  Route scanning skipped due to error (dev server continues normally)',
+    );
+
+    if (process.env.DEBUG) {
+      logger.warn(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+
+function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+/**
+ * 日志文件名常量
+ */
+const LOG_FILE_NAME = 'dev.log';
 
 /**
  * 解析日志文件路径
  * - 如果是绝对路径，直接使用
- * - 如果是相对路径，基于 getLogDir() + 相对路径
- * - 如果为空，使用 getLogDir() + LOG_FILE_NAME
+ * - 如果是相对路径，基于 logs 目录 + 相对路径
+ * - 如果为空，使用默认日志文件路径
  */
 const resolveLogFilePath = (logFile) => {
   if (!logFile) {
-    return path.join(getLogDir(), LOG_FILE_NAME);
+    return getCozeLogPath(LOG_FILE_NAME);
   }
 
   if (path.isAbsolute(logFile)) {
     return logFile;
   }
 
-  return path.join(getLogDir(), logFile);
+  return getCozeLogPath(logFile);
 };
 
 /**
@@ -3703,15 +4539,21 @@ const executeRun = async (
       logger.info('');
     }
 
-    // 2. 加载 .coze 配置
+    // 2. 启动路由扫描（仅在 dev 模式）
+    // Note: startRouteScanning handles all errors internally and never throws
+    if (commandName === 'dev') {
+      await startRouteScanning(process.cwd());
+    }
+
+    // 3. 加载 .coze 配置
     const config = await loadCozeConfig();
     const commandArgs = getCommandConfig(config, commandName);
 
-    // 3. 准备日志
+    // 4. 准备日志
     const logFilePath = resolveLogFilePath(options.logFile);
     const logStream = createLogStream(logFilePath);
 
-    // 4. 执行命令
+    // 5. 执行命令
     const commandString = commandArgs.join(' ');
 
     logger.info(`Executing: ${commandString}`);
@@ -3738,72 +4580,76 @@ const executeRun = async (
       logStream.write(data);
     })]);
 
-    childProcess.on('close', (code, signal) => {
-      logStream.end();
+    // Wait for child process to complete
+    await new Promise((resolve, reject) => {
+      childProcess.on('close', (code, signal) => {
+        logStream.end();
+
+        if (code !== 0) {
+          const errorMessage = `Command exited with code ${_nullishCoalesce$1(code, () => ( 'unknown'))}${signal ? ` and signal ${signal}` : ''}`;
+          logger.error(errorMessage);
+          logger.error(`Check log file for details: ${logFilePath}`);
+
+          // 上报命令失败
+          reportError(new Error(errorMessage), {
+            command: commandName,
+            exitCode: String(_nullishCoalesce$1(code, () => ( 'unknown'))),
+            signal: _nullishCoalesce$1(signal, () => ( 'none')),
+            logFile: logFilePath,
+          });
+          reportCommandComplete(commandName, false, Date.now() - cmdStartTime, {
+            args: JSON.stringify(options),
+            errorCode: _nullishCoalesce$1(code, () => ( 1)),
+            errorMessage,
+          });
+          flushSlardar()
+            .then(() => {
+              process.exit(code || 1);
+            })
+            .catch(() => {
+              // Catch any errors in the promise chain to prevent unhandled rejections
+              process.exit(code || 1);
+            });
+        } else {
+          logger.success('Command completed successfully');
+          logger.info(`Log file: ${logFilePath}`);
+
+          // 上报命令成功
+          reportCommandComplete(commandName, true, Date.now() - cmdStartTime, {
+            args: JSON.stringify(options),
+          });
+          // flush 由 main 函数统一处理
+          resolve();
+        }
+      });
 
-      if (code !== 0) {
-        const errorMessage = `Command exited with code ${_nullishCoalesce$1(code, () => ( 'unknown'))}${signal ? ` and signal ${signal}` : ''}`;
-        logger.error(errorMessage);
-        logger.error(`Check log file for details: ${logFilePath}`);
+      childProcess.on('error', (error) => {
+        logger.error('Failed to execute command:');
+        logger.error(`Error: ${error.message}`);
+        if (error.stack) {
+          logger.error(`Stack trace:\n${error.stack}`);
+        }
+        logStream.end();
 
-        // 上报命令失败
-        reportError(new Error(errorMessage), {
+        // 上报错误
+        reportError(error, {
           command: commandName,
-          exitCode: String(_nullishCoalesce$1(code, () => ( 'unknown'))),
-          signal: _nullishCoalesce$1(signal, () => ( 'none')),
-          logFile: logFilePath,
+          type: 'child_process_error',
         });
         reportCommandComplete(commandName, false, Date.now() - cmdStartTime, {
           args: JSON.stringify(options),
-          errorCode: _nullishCoalesce$1(code, () => ( 1)),
-          errorMessage,
+          errorCode: 1,
+          errorMessage: error.message,
         });
         flushSlardar()
           .then(() => {
-            process.exit(code || 1);
+            process.exit(1);
           })
           .catch(() => {
             // Catch any errors in the promise chain to prevent unhandled rejections
-            process.exit(code || 1);
+            process.exit(1);
           });
-      } else {
-        logger.success('Command completed successfully');
-        logger.info(`Log file: ${logFilePath}`);
-
-        // 上报命令成功
-        reportCommandComplete(commandName, true, Date.now() - cmdStartTime, {
-          args: JSON.stringify(options),
-        });
-        // flush 由 main 函数统一处理
-      }
-    });
-
-    childProcess.on('error', (error) => {
-      logger.error('Failed to execute command:');
-      logger.error(`Error: ${error.message}`);
-      if (error.stack) {
-        logger.error(`Stack trace:\n${error.stack}`);
-      }
-      logStream.end();
-
-      // 上报错误
-      reportError(error, {
-        command: commandName,
-        type: 'child_process_error',
       });
-      reportCommandComplete(commandName, false, Date.now() - cmdStartTime, {
-        args: JSON.stringify(options),
-        errorCode: 1,
-        errorMessage: error.message,
-      });
-      flushSlardar()
-        .then(() => {
-          process.exit(1);
-        })
-        .catch(() => {
-          // Catch any errors in the promise chain to prevent unhandled rejections
-          process.exit(1);
-        });
     });
   } catch (error) {
     const err = error instanceof Error ? error : new Error(String(error));