@faapi/faapi 4.0.0 → 4.2.0

package/dist/index.d.ts

@@ -120,8 +120,23 @@ interface Http2Options {
 
 /**
  * 生命周期钩子
+ *
+ * 执行时序:onBoot(.listen 调用前)→ server.listen → listen 回调内 onReady → 运行期 onError → 关闭时 onClose
  */
 interface LifecycleHooks {
+    /**
+     * 服务器 listen 之前调用(启动校验钩子)
+     *
+     * 时机:`app.listen()` 内、`server.listen` 调用之前——server 已创建但未监听
+     * (`server.listening === false`),路由/tool/agent 清单已水合、插件已加载。
+     *
+     * 适合启动校验(环境变量、下游依赖可达性)、DB 迁移等**失败即不该暴露端口**的逻辑:
+     * 钩子抛错 → `listen()` 以原始错误 reject,`server.listen` 不会被调用,端口不暴露。
+     *
+     * 与 onReady 的差异:onReady 在 listen 回调内执行,失败时端口已开,
+     * 存在"接受连接但不服务"的窗口——启动校验请用 onBoot,资源初始化用 onReady。
+     */
+    onBoot?: (ctx: LifecycleContext) => Promise<void> | void;
     /** 服务器启动后调用（适合初始化数据库连接等） */
     onReady?: (ctx: LifecycleContext) => Promise<void> | void;
     /** 服务器关闭时调用（适合清理资源、优雅关闭） */
@@ -149,7 +164,7 @@ interface LifecycleContext {
     rootDir: string;
     /** 当前路由清单 */
     routes: RouteManifest;
-    /** 服务器实例 */
+    /** 服务器实例（onBoot 钩子触发时已创建但未监听，`listening === false`） */
     server: node_http.Server;
     /** app 级注册表——skill 等运行时动态注册路径（`registries.skill.upsert(...)`） */
     registries: AppRegistries;

package/dist/index.js

@@ -2036,6 +2036,15 @@ function toStrippedProdImportPath(sourceFile, rootDir) {
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
+function toProdImportFromImporter(importer, rootDir, relFromDist) {
+  const importerRel = path5.relative(toRealPath(path5.resolve(rootDir)), toRealPath(importer)).split(path5.sep).join("/");
+  const importerProdDir = path5.posix.dirname(toProdExtension(importerRel));
+  if (importerProdDir === ".") return relFromDist;
+  const target = relFromDist.replace(/^\.\//, "");
+  let rel = path5.posix.relative(importerProdDir, target);
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return rel;
+}
 var PROD_EXTS = [".js", ".mjs", ".cjs"];
 var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 var INDEX_EXTS = [
@@ -2093,9 +2102,10 @@ function createAliasPlugin(config, options) {
               }
               if (appDirAbs && importerOutsideAppDir && isInsideDir(resolved, appDirAbs)) {
                 modified = true;
-                return `${prefix}${quote}${toStrippedProdImportPath(
-                  resolved,
-                  options.rootDir
+                return `${prefix}${quote}${toProdImportFromImporter(
+                  importer,
+                  options.rootDir,
+                  toStrippedProdImportPath(resolved, options.rootDir)
                 )}${quote}`;
               }
               modified = true;
@@ -2110,9 +2120,10 @@ function createAliasPlugin(config, options) {
               if (fs4.existsSync(file)) {
                 modified = true;
                 if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
-                  return `${prefix}${quote}${toStrippedProdImportPath(
-                    file,
-                    options.rootDir
+                  return `${prefix}${quote}${toProdImportFromImporter(
+                    importer,
+                    options.rootDir,
+                    toStrippedProdImportPath(file, options.rootDir)
                   )}${quote}`;
                 }
                 return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
@@ -2123,9 +2134,10 @@ function createAliasPlugin(config, options) {
               if (fs4.existsSync(file)) {
                 modified = true;
                 if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
-                  return `${prefix}${quote}${toStrippedProdImportPath(
-                    file,
-                    options.rootDir
+                  return `${prefix}${quote}${toProdImportFromImporter(
+                    importer,
+                    options.rootDir,
+                    toStrippedProdImportPath(file, options.rootDir)
                   )}${quote}`;
                 }
                 return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
@@ -3096,14 +3108,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path23) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path23}`, 404);
+  constructor(path24) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path24}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path23, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path23}`, 405);
+  constructor(method, path24, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path24}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -3129,8 +3141,8 @@ var PayloadTooLargeError = class extends FaapiError {
 };
 
 // src/cli/createAppCore.ts
-import fs15 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 import { PassThrough, Readable as Readable3 } from "stream";
 
 // src/router/sortRoutes.ts
@@ -3225,18 +3237,18 @@ function getWsIndex(routes) {
   wsIndexCache.set(routes, index);
   return index;
 }
-function matchRoute(routes, method, path23) {
+function matchRoute(routes, method, path24) {
   const index = getHttpIndex(routes);
   const upper = method.toUpperCase();
-  const hit = matchByMethod(index, upper, path23);
+  const hit = matchByMethod(index, upper, path24);
   if (hit) return hit;
   if (upper === "HEAD") {
-    return matchByMethod(index, "GET", path23);
+    return matchByMethod(index, "GET", path24);
   }
   return null;
 }
-function matchByMethod(index, method, path23) {
-  const staticHit = index.static.get(`${method}|${path23}`);
+function matchByMethod(index, method, path24) {
+  const staticHit = index.static.get(`${method}|${path24}`);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
@@ -3245,31 +3257,31 @@ function matchByMethod(index, method, path23) {
     if (route.method !== method) {
       continue;
     }
-    const params = matchSegments(entry.segments, path23, route.paramNames, route.isCatchAll);
+    const params = matchSegments(entry.segments, path24, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path23) {
+function matchWsRoute(wsRoutes, path24) {
   const index = getWsIndex(wsRoutes);
-  const staticHit = index.static.get(path23);
+  const staticHit = index.static.get(path24);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   for (const route of index.dynamics) {
-    const params = matchDynamicPath(route.urlPath, path23, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path24, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function findAllowedMethods(routes, path23) {
+function findAllowedMethods(routes, path24) {
   const index = getHttpIndex(routes);
   const methods = /* @__PURE__ */ new Set();
-  const staticMethods = index.methodsByStaticPath.get(path23);
+  const staticMethods = index.methodsByStaticPath.get(path24);
   if (staticMethods) {
     for (const method of staticMethods) {
       methods.add(method);
@@ -3278,7 +3290,7 @@ function findAllowedMethods(routes, path23) {
   for (const entry of index.dynamics) {
     const params = matchSegments(
       entry.segments,
-      path23,
+      path24,
       entry.route.paramNames,
       entry.route.isCatchAll
     );
@@ -3291,11 +3303,11 @@ function findAllowedMethods(routes, path23) {
   }
   return Array.from(methods);
 }
-function matchDynamicPath(pattern, path23, paramNames, isCatchAll) {
-  return matchSegments(pattern.split("/").filter(Boolean), path23, paramNames, isCatchAll);
+function matchDynamicPath(pattern, path24, paramNames, isCatchAll) {
+  return matchSegments(pattern.split("/").filter(Boolean), path24, paramNames, isCatchAll);
 }
-function matchSegments(patternSegments, path23, paramNames, isCatchAll) {
-  const pathSegments = path23.split("/").filter(Boolean);
+function matchSegments(patternSegments, path24, paramNames, isCatchAll) {
+  const pathSegments = path24.split("/").filter(Boolean);
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -4183,9 +4195,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue);
-    const path23 = issue.path.map(String).join(".") || "";
+    const path24 = issue.path.map(String).join(".") || "";
     return {
-      path: path23,
+      path: path24,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -4725,7 +4737,7 @@ function attachWebSocket(options) {
 // src/server/createServer.ts
 init_generateSchemaFiles();
 var DEFAULT_BODY_LIMIT = 10 * 1024 * 1024;
-function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
+function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT, requestSignal) {
   const forwardedProto = req.headers["x-forwarded-proto"];
   const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
   const host = req.headers.host ?? "localhost";
@@ -4733,7 +4745,10 @@ function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
   const headers = nodeHttpToWebHeaders(req);
   const method = req.method ?? "GET";
   if (method === "GET" || method === "HEAD") {
-    return { request: new Request(url.toString(), { method, headers }), url };
+    return {
+      request: new Request(url.toString(), { method, headers, signal: requestSignal }),
+      url
+    };
   }
   const contentLength = req.headers["content-length"];
   if (contentLength !== void 0) {
@@ -4749,7 +4764,8 @@ function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
       method,
       headers,
       body: limitedStream,
-      duplex: "half"
+      duplex: "half",
+      signal: requestSignal
     }),
     url
   };
@@ -4888,8 +4904,8 @@ function createServer(options) {
   });
   return { server, routesRef };
 }
-function prepareRequest(req, config, bodyLimit, trustedProxy, registries) {
-  const { request, url } = toWebRequest(req, bodyLimit);
+function prepareRequest(req, config, bodyLimit, trustedProxy, registries, requestSignal) {
+  const { request, url } = toWebRequest(req, bodyLimit, requestSignal);
   const method = request.method.toUpperCase();
   const urlPath = url.pathname;
   const ctx = createContextFromUrl(
@@ -4975,8 +4991,19 @@ async function sendErrorResponse(err, meta, res, onError, ctx) {
 async function handleRequest(routes, rootDir, dist, req, res, outerMiddlewares, onError, config, globalInjectors, bodyLimit, trustedProxy, registries) {
   let meta = { headers: {}, setCookies: [] };
   let ctx;
+  const abortController = new AbortController();
+  res.on("close", () => {
+    if (!res.writableEnded) abortController.abort();
+  });
   try {
-    const prepared = prepareRequest(req, config, bodyLimit, trustedProxy, registries);
+    const prepared = prepareRequest(
+      req,
+      config,
+      bodyLimit,
+      trustedProxy,
+      registries,
+      abortController.signal
+    );
     ctx = prepared.ctx;
     meta = prepared.meta;
     const { request, url, method, urlPath } = prepared;
@@ -5271,9 +5298,50 @@ async function generateAgentArtifacts(agents, rootDir, dist) {
 }
 
 // src/cli/loadPlugins.ts
-import path18 from "path";
+import path19 from "path";
+import fs16 from "fs";
 import { pathToFileURL as pathToFileURL2 } from "url";
-async function loadPlugins(declarations, ctx, rootDir) {
+
+// src/cli/compileConfig.ts
+import path18 from "path";
+import fs15 from "fs";
+async function compileProjectModules(entryPoints, rootDir, dist) {
+  const { insideFiles, outsideFiles } = await collectRelativeImports(entryPoints, rootDir);
+  const esbuild = await import("esbuild");
+  const aliasPlugins = buildAliasPlugins(rootDir);
+  const absDist = path18.resolve(rootDir, dist);
+  await esbuild.build({
+    entryPoints: [...entryPoints, ...outsideFiles],
+    outdir: absDist,
+    outbase: rootDir,
+    bundle: false,
+    platform: "node",
+    format: "esm",
+    sourcemap: true,
+    packages: "external",
+    plugins: aliasPlugins,
+    logLevel: "silent"
+  });
+  if (insideFiles.length > 0) {
+    const appOutbase = path18.resolve(rootDir, "src");
+    await esbuild.build({
+      entryPoints: insideFiles,
+      outdir: absDist,
+      outbase: appOutbase,
+      bundle: false,
+      platform: "node",
+      format: "esm",
+      sourcemap: true,
+      packages: "external",
+      plugins: aliasPlugins,
+      logLevel: "silent"
+    });
+  }
+  return { insideFiles, outsideFiles };
+}
+
+// src/cli/loadPlugins.ts
+async function loadPlugins(declarations, ctx, rootDir, dist) {
   const handlerWrappers = [];
   const upgradeWrappers = [];
   const failures = [];
@@ -5310,7 +5378,7 @@ async function loadPlugins(declarations, ctx, rootDir) {
     }
     loaded.add(specifier);
     try {
-      const mod = await import(resolveSpecifier(specifier, rootDir));
+      const mod = await importPluginModule(specifier, rootDir ?? process.cwd(), dist);
       const plugin = mod.default ?? mod;
       if (typeof plugin.setup !== "function") {
         failures.push({ specifier, reason: "plugin has no setup function" });
@@ -5333,15 +5401,72 @@ async function loadPlugins(declarations, ctx, rootDir) {
   }
   return { handlerWrappers, upgradeWrappers, failures };
 }
-function resolveSpecifier(specifier, rootDir) {
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const base = rootDir ?? process.cwd();
-    return pathToFileURL2(path18.resolve(base, specifier)).href;
+var TS_EXTS = /\.(ts|tsx|mts|cts)$/;
+var JS_EXTS = /\.(js|mjs|cjs|jsx)$/;
+function resolveLocalPluginSource(specifier, baseDir) {
+  const base = path19.isAbsolute(specifier) ? specifier : path19.resolve(baseDir, specifier);
+  if ((TS_EXTS.test(base) || JS_EXTS.test(base)) && fs16.existsSync(base)) return base;
+  for (const ext of [".ts", ".js"]) {
+    if (fs16.existsSync(base + ext)) return base + ext;
   }
-  if (path18.isAbsolute(specifier)) {
-    return pathToFileURL2(specifier).href;
+  for (const indexExt of ["/index.ts", "/index.js"]) {
+    if (fs16.existsSync(base + indexExt)) return base + indexExt;
   }
-  return specifier;
+  return null;
+}
+function mirrorProductPath(sourcePath, baseDir, distDir) {
+  let rel = path19.relative(baseDir, sourcePath).replace(/\\/g, "/");
+  if (rel.startsWith("src/")) rel = rel.slice(4);
+  return path19.resolve(distDir, rel.replace(TS_EXTS, ".js"));
+}
+function isSourceNewer(sourcePath, productPath) {
+  try {
+    return fs16.statSync(sourcePath).mtimeMs > fs16.statSync(productPath).mtimeMs;
+  } catch {
+    return true;
+  }
+}
+async function importPluginModule(specifier, baseDir, dist) {
+  const isRelative = specifier.startsWith("./") || specifier.startsWith("../");
+  if (!isRelative && !path19.isAbsolute(specifier)) {
+    return import(specifier);
+  }
+  const distDir = dist ? path19.resolve(baseDir, dist) : null;
+  const sourcePath = resolveLocalPluginSource(specifier, baseDir);
+  const productPath = sourcePath && distDir ? mirrorProductPath(sourcePath, baseDir, distDir) : null;
+  if (productPath !== null && fs16.existsSync(productPath) && (sourcePath === null || !isSourceNewer(sourcePath, productPath))) {
+    return import(pathToFileURL2(productPath).href);
+  }
+  if (sourcePath && TS_EXTS.test(sourcePath)) {
+    if (!isDevOnDemandEnabled() || !distDir) {
+      throw new Error(
+        `Local plugin "${specifier}" has no up-to-date build artifact (dist is stale or missing). Run "faapi build" first, or use "faapi dev" for on-demand compilation.`
+      );
+    }
+    const relFromRoot = path19.relative(baseDir, sourcePath).replace(/\\/g, "/");
+    if (relFromRoot.startsWith("src/")) {
+      await ensureCompiled(sourcePath, baseDir, dist);
+    } else {
+      await compileProjectModules([sourcePath], baseDir, dist);
+    }
+    if (productPath && fs16.existsSync(productPath)) {
+      return import(pathToFileURL2(productPath).href);
+    }
+  }
+  if (sourcePath && JS_EXTS.test(sourcePath)) {
+    return import(pathToFileURL2(sourcePath).href);
+  }
+  const candidates = [
+    `${specifier}.ts`,
+    `${specifier}/index.ts`,
+    `${specifier}.js`,
+    `${specifier}/index.js`
+  ].map((c) => path19.isAbsolute(c) ? c : path19.join(baseDir, c));
+  throw new Error(
+    `Cannot find local plugin "${specifier}" (resolved from ${baseDir}). Expected one of:
+  ${candidates.join("\n  ")}
+Create the plugin file (export default { name, setup(ctx) {...} }) or fix the path.`
+  );
 }
 function resolveDeclaration(decl) {
   if (typeof decl === "string") {
@@ -5367,8 +5492,8 @@ var ROUTES_FILE = "faapi-routes.js";
 var TOOLS_FILE2 = "faapi-tools.js";
 var AGENTS_FILE2 = "faapi-agents.js";
 async function loadAndHydrateTools(rootDir, dist, registries = defaultRegistries) {
-  const toolsPath = path19.resolve(rootDir, dist, TOOLS_FILE2);
-  if (!fs15.existsSync(toolsPath)) {
+  const toolsPath = path20.resolve(rootDir, dist, TOOLS_FILE2);
+  if (!fs17.existsSync(toolsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(toolsPath);
@@ -5377,8 +5502,8 @@ async function loadAndHydrateTools(rootDir, dist, registries = defaultRegistries
   return hydrated;
 }
 async function loadAndHydrateAgents(rootDir, dist, registries = defaultRegistries) {
-  const agentsPath = path19.resolve(rootDir, dist, AGENTS_FILE2);
-  if (!fs15.existsSync(agentsPath)) {
+  const agentsPath = path20.resolve(rootDir, dist, AGENTS_FILE2);
+  if (!fs17.existsSync(agentsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(agentsPath);
@@ -5445,8 +5570,8 @@ function isFaapiConfigKey(key) {
 async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
-  const routesPath = path19.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs15.existsSync(routesPath)) {
+  const routesPath = path20.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs17.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -5498,7 +5623,8 @@ async function createAppBase(options) {
       server,
       config: pluginConfig
     },
-    rootDir
+    rootDir,
+    dist
   );
   applyPluginWrappers(server, handlerWrappers, upgradeWrappers);
   let closed = false;
@@ -5511,6 +5637,16 @@ async function createAppBase(options) {
     async listen(listenPort) {
       const envPort = process.env.PORT ? Number(process.env.PORT) : void 0;
       const actualPort = listenPort ?? options?.port ?? envPort ?? DEFAULT_PORT;
+      if (config?.lifecycle?.onBoot) {
+        try {
+          await config.lifecycle.onBoot({ rootDir, routes: sorted, server, registries });
+          console.log("- onBoot hook executed");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`[faapi] onBoot hook failed: ${message}`);
+          throw err;
+        }
+      }
       return new Promise((resolve, reject) => {
         const onListenError = (err) => {
           if (err.code === "EADDRINUSE") {
@@ -5693,17 +5829,17 @@ async function createAppBase(options) {
 
 // src/router/scanRoutes.ts
 import fg2 from "fast-glob";
-import path20 from "path";
-import fs16 from "fs";
+import path21 from "path";
+import fs18 from "fs";
 
 // src/router/constants.ts
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var HTTP_METHOD_SET = new Set(HTTP_METHODS);
 
 // src/utils/normalizePath.ts
-function normalizePath(path23) {
-  if (!path23) return "";
-  let result = path23.replace(/\\/g, "/");
+function normalizePath(path24) {
+  if (!path24) return "";
+  let result = path24.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -5764,34 +5900,34 @@ function extractExportsFromSource(source) {
   return names;
 }
 function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
-  const routeDir = path20.dirname(routeFilePath);
-  const resolvedRoot = path20.resolve(rootDir);
+  const routeDir = path21.dirname(routeFilePath);
+  const resolvedRoot = path21.resolve(rootDir);
   const paths = [];
-  let currentDir = path20.resolve(rootDir, routeDir);
+  let currentDir = path21.resolve(rootDir, routeDir);
   while (true) {
     if (dist) {
-      const mwTsPath = path20.join(currentDir, "middlewares.ts");
-      const mwJsPath = path20.join(currentDir, "middlewares.js");
-      const absTsPath = path20.resolve(rootDir, mwTsPath);
-      const absJsPath = path20.resolve(rootDir, mwJsPath);
-      const absMwPath = fs16.existsSync(absTsPath) ? absTsPath : fs16.existsSync(absJsPath) ? absJsPath : null;
+      const mwTsPath = path21.join(currentDir, "middlewares.ts");
+      const mwJsPath = path21.join(currentDir, "middlewares.js");
+      const absTsPath = path21.resolve(rootDir, mwTsPath);
+      const absJsPath = path21.resolve(rootDir, mwJsPath);
+      const absMwPath = fs18.existsSync(absTsPath) ? absTsPath : fs18.existsSync(absJsPath) ? absJsPath : null;
       if (absMwPath) {
-        const relMwPath = path20.relative(rootDir, absMwPath);
-        const prodAbsPath = path20.resolve(rootDir, toProdFilePath(relMwPath, dist));
+        const relMwPath = path21.relative(rootDir, absMwPath);
+        const prodAbsPath = path21.resolve(rootDir, toProdFilePath(relMwPath, dist));
         paths.push(prodAbsPath);
       }
     } else {
       for (const ext of [".ts", ".js"]) {
-        const mwPath = path20.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path20.resolve(rootDir, mwPath);
-        if (fs16.existsSync(absMwPath)) {
+        const mwPath = path21.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path21.resolve(rootDir, mwPath);
+        if (fs18.existsSync(absMwPath)) {
           paths.push(absMwPath);
           break;
         }
       }
     }
     if (currentDir === resolvedRoot) break;
-    const parentDir = path20.dirname(currentDir);
+    const parentDir = path21.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -5810,7 +5946,7 @@ async function scanRoutes(rootDir, patterns, dist) {
     const normalizedFile = file.replace(/\\/g, "/");
     const fileName = normalizedFile.split("/").pop();
     if (fileName === "handler.ts" || fileName === "handler.js") {
-      const absPath = path20.resolve(rootDir, normalizedFile);
+      const absPath = path21.resolve(rootDir, normalizedFile);
       const urlPath = filePathToUrlPath(normalizedFile);
       const paramNames = extractParamNames(urlPath);
       const isDynamic = paramNames.length > 0;
@@ -5823,7 +5959,7 @@ async function scanRoutes(rootDir, patterns, dist) {
         const mwPaths = collectMiddlewarePaths(normalizedFile, rootDir);
         middlewareBundle = await loadMergedMiddlewares(mwPaths);
       }
-      const source = await fs16.promises.readFile(absPath, "utf8").catch(() => "");
+      const source = await fs18.promises.readFile(absPath, "utf8").catch(() => "");
       const exportNames = extractExportsFromSource(source);
       const methods = HTTP_METHODS.filter((m) => exportNames.has(m));
       for (const method of methods) {
@@ -5859,8 +5995,8 @@ async function scanRoutes(rootDir, patterns, dist) {
 
 // src/tools/scanTools.ts
 import fg3 from "fast-glob";
-import path21 from "path";
-import fs17 from "fs";
+import path22 from "path";
+import fs19 from "fs";
 var TOOL_PATTERNS = ["src/tools/**/*.ts"];
 var TOOL_EXPORT_RE = new RegExp(
   String.raw`export\s+(?:async\s+)?(?:function\s+|const\s+)([A-Za-z_$][\w$]*)\s*(?:\(|=)`,
@@ -5910,8 +6046,8 @@ async function scanTools(rootDir, patterns) {
     if (fileName !== "handler.ts" && fileName !== "handler.js") {
       continue;
     }
-    const absPath = path21.resolve(rootDir, normalizedFile);
-    const source = await fs17.promises.readFile(absPath, "utf8").catch(() => "");
+    const absPath = path22.resolve(rootDir, normalizedFile);
+    const source = await fs19.promises.readFile(absPath, "utf8").catch(() => "");
     const exportNames = extractToolExportsFromSource(source);
     const namespace = filePathToToolNamespace(normalizedFile);
     for (const fnName of exportNames) {
@@ -5935,8 +6071,8 @@ async function scanTools(rootDir, patterns) {
 
 // src/agents/scanAgents.ts
 import fg4 from "fast-glob";
-import path22 from "path";
-import fs18 from "fs";
+import path23 from "path";
+import fs20 from "fs";
 var DEFAULT_AGENT_PATTERNS = ["src/agents/*/handler.ts"];
 var RUN_EXPORT_RE = /export\s+(?:async\s+)?(?:function\s+|const\s+)run\b/;
 function extractAgentNameFromPath(filePath) {
@@ -5968,8 +6104,8 @@ async function scanAgents(rootDir, patterns) {
     if (fileName !== "handler.ts" && fileName !== "handler.js") {
       continue;
     }
-    const absPath = path22.resolve(rootDir, normalizedFile);
-    const source = await fs18.promises.readFile(absPath, "utf8").catch(() => "");
+    const absPath = path23.resolve(rootDir, normalizedFile);
+    const source = await fs20.promises.readFile(absPath, "utf8").catch(() => "");
     const { hasRun } = detectAgentExports(source);
     const name = extractAgentNameFromPath(normalizedFile);
     const prevFile = seen.get(name);