@faapi/faapi 6.24.0 → 6.26.0

package/dist/index.js

@@ -1662,7 +1662,7 @@ var init_atomicWrite = __esm({
 
 // src/cli/generateZodArtifacts.ts
 import path11 from "path";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 async function generateZodArtifacts(sources, options) {
   const { generateFileSource, resolversByFile, rootDir, dist } = options;
   if (sources.length === 0) return;
@@ -1696,7 +1696,7 @@ async function generateZodArtifacts(sources, options) {
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
     const helpersPath = path11.resolve(rootDir, dist, HELPERS_FILENAME);
-    if (!existsSync(helpersPath)) {
+    if (!existsSync2(helpersPath)) {
       await atomicWriteFile(helpersPath, generateHelpersFileSource());
     }
   }
@@ -2046,14 +2046,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path31) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path31}`, 404);
+  constructor(path32) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path32}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path31, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path31}`, 405);
+  constructor(method, path32, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path32}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -2079,8 +2079,16 @@ var PayloadTooLargeError = class extends FaapiError {
 };
 
 // src/task/taskWorker.ts
+import { existsSync } from "fs";
 import { Worker } from "worker_threads";
-import { pathToFileURL } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
+var workerEntryUrl;
+function resolveWorkerEntryUrl() {
+  if (workerEntryUrl) return workerEntryUrl;
+  const js = new URL("./workerEntry.js", import.meta.url);
+  workerEntryUrl = existsSync(fileURLToPath(js)) ? js : new URL("./workerEntry.ts", import.meta.url);
+  return workerEntryUrl;
+}
 var KILL_GRACE_MS = 5e3;
 var TaskCancelledError = class extends Error {
   constructor(message) {
@@ -2101,153 +2109,6 @@ function safeConfig(config) {
     return void 0;
   }
 }
-var BUILD_VIEW_SOURCE = `
-function buildRegistriesView(snapshot) {
-  var agents = new Map(((snapshot && snapshot.agents) || []).map(function (a) { return [a.name, a]; }));
-  var tools = new Map(((snapshot && snapshot.tools) || []).map(function (t) { return [t.name, t]; }));
-  var skills = new Map(((snapshot && snapshot.skills) || []).map(function (s) { return [s.name, s]; }));
-  return {
-    agent: {
-      getAgent: function (name) { return agents.get(name); },
-      getAgentEntry: function (name) { return agents.get(name); },
-      listAgents: function () { return Array.from(agents.values()); },
-      asTool: function (name) {
-        var agent = agents.get(name);
-        if (!agent) return undefined;
-        return {
-          kind: 'agent',
-          name: 'agent.' + agent.name,
-          agentName: agent.name,
-          description: agent.description,
-          metadata: agent,
-        };
-      },
-      resolveAgentTools: function (name) {
-        var agent = agents.get(name);
-        var result = new Map();
-        if (agent && agent.tools) {
-          agent.tools.forEach(function (toolName) {
-            var resolved = tools.get(toolName);
-            if (resolved) result.set(resolved.name, resolved);
-          });
-        }
-        return Array.from(result.values());
-      },
-      resolveSubAgents: function (name) {
-        var agent = agents.get(name);
-        var result = [];
-        if (agent && agent.agents) {
-          agent.agents.forEach(function (subName) {
-            var sub = agents.get(subName);
-            if (sub) result.push(sub);
-          });
-        }
-        return result;
-      },
-    },
-    tool: {
-      get: function (name) { return tools.get(name); },
-      list: function () { return Array.from(tools.values()); },
-    },
-    skill: {
-      get: function (name) { return skills.get(name); },
-      list: function () { return Array.from(skills.values()); },
-    },
-  };
-}
-`;
-var SERIALIZE_ERROR_SOURCE = `
-function serializeError(err) {
-  if (err instanceof Error) {
-    var props = {};
-    var keys = Object.keys(err);
-    for (var i = 0; i < keys.length; i++) {
-      props[keys[i]] = err[keys[i]];
-    }
-    return { name: err.name, message: err.message, stack: err.stack, props: props };
-  }
-  return { name: 'Error', message: String(err), stack: undefined, props: {} };
-}
-`;
-var BUILD_LOGGER_SOURCE = `
-var LOG_RANK = { debug: 0, info: 1, warn: 2, error: 3 };
-function createTaskLogger(level, scope, fields) {
-  function make(suffix) {
-    function write(lvl, message, callFields) {
-      if (level !== undefined && LOG_RANK[lvl] < LOG_RANK[level]) return;
-      var entry = { level: lvl, message: message, time: new Date().toISOString() };
-      var fullScope = suffix === undefined ? scope : scope === undefined ? suffix : scope + ':' + suffix;
-      if (fullScope !== undefined) entry.scope = fullScope;
-      if (fields !== undefined || callFields !== undefined) {
-        entry.fields = Object.assign({}, fields, callFields);
-      }
-      try {
-        parentPort.postMessage({ type: 'log', entry: entry });
-      } catch (_) {
-        entry.fields = { warning: 'log fields not cloneable across worker boundary, dropped' };
-        parentPort.postMessage({ type: 'log', entry: entry });
-      }
-    }
-    return {
-      debug: function (m, f) { write('debug', m, f); },
-      info: function (m, f) { write('info', m, f); },
-      warn: function (m, f) { write('warn', m, f); },
-      error: function (m, f) { write('error', m, f); },
-      child: function (cs) { return make(suffix === undefined ? cs : suffix + ':' + cs); },
-    };
-  }
-  return make(undefined);
-}
-`;
-function buildWrapperSource(moduleUrl) {
-  return `
-import { parentPort } from 'node:worker_threads';
-import * as mod from '${moduleUrl}';
-
-${BUILD_VIEW_SOURCE}
-
-${SERIALIZE_ERROR_SOURCE}
-
-${BUILD_LOGGER_SOURCE}
-
-const run = mod.run;
-if (typeof run !== 'function') {
-  parentPort.postMessage({
-    type: 'error',
-    error: { name: 'Error', message: 'Task module has no run export', stack: undefined, props: {} },
-  });
-} else {
-  let controller = null;
-  parentPort.on('message', async (msg) => {
-    if (msg?.type === 'abort') {
-      controller?.abort(new Error(msg.reason));
-      return;
-    }
-    if (msg?.type !== 'run') return;
-    controller = new AbortController();
-    const { payload, taskCtx } = msg;
-    try {
-      const registries = buildRegistriesView(msg.registries);
-      const progress = (value) => parentPort.postMessage({ type: 'progress', value });
-      const taskLog = msg.log ? createTaskLogger(msg.log.level, msg.log.scope, msg.log.fields) : undefined;
-      const result = await run(payload, { ...taskCtx, signal: controller.signal, registries, progress, log: taskLog });
-      parentPort.postMessage({ type: 'done', result });
-    } catch (err) {
-      const serialized = serializeError(err);
-      try {
-        parentPort.postMessage({ type: 'error', error: serialized });
-      } catch (_) {
-        // props \u542B\u4E0D\u53EF\u514B\u9686\u503C\uFF08\u51FD\u6570\u7B49\uFF09\u65F6\u4E22\u5F03 props\uFF0C\u4FDD\u5E95 name/message/stack
-        parentPort.postMessage({
-          type: 'error',
-          error: { name: serialized.name, message: serialized.message, stack: serialized.stack, props: {} },
-        });
-      }
-    }
-  });
-}
-`;
-}
 function reviveError(payload) {
   const err = new Error(payload?.message ?? "task worker error");
   if (payload?.name !== void 0) err.name = payload.name;
@@ -2268,13 +2129,12 @@ async function runTaskInWorker(options) {
     );
   }
   const moduleUrl = pathToFileURL(taskModulePath).href;
-  const wrapperUrl = new URL(
-    `data:text/javascript,${encodeURIComponent(buildWrapperSource(moduleUrl))}`
-  );
   return new Promise((resolve, reject) => {
     let worker;
     try {
-      worker = new Worker(wrapperUrl);
+      worker = new Worker(resolveWorkerEntryUrl(), {
+        workerData: { moduleUrl, resourcesDir: taskCtx.resourcesDir }
+      });
     } catch (err) {
       reject(err);
       return;
@@ -2997,6 +2857,7 @@ function parseNumericLiteral(raw) {
   return Number(raw.replace(/_/g, ""));
 }
 var MIN_ISOLATED_TIMEOUT_MS = 6e4;
+var MAX_ISOLATED_TIMEOUT_MS = 23 * 60 * 6e4;
 function filePathToTaskName(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
   const match = normalized.match(/(?:^|\/)tasks\/(.+)\/task\.ts$/);
@@ -3045,6 +2906,11 @@ async function scanTasks(rootDir, patterns) {
           `[faapi] Task "${name}" timeoutMs ${value} is below the minimum ${MIN_ISOLATED_TIMEOUT_MS}ms (1 minute). Declaring a timeout means this is a long-running task that needs real cancellation \u2014 tasks finishing within a minute do not need one: remove timeoutMs to run in-process (implement your own deadline with Promise.race if needed), or raise it.`
         );
       }
+      if (value > MAX_ISOLATED_TIMEOUT_MS) {
+        throw new Error(
+          `[faapi] Task "${name}" timeoutMs ${value} exceeds the maximum ${MAX_ISOLATED_TIMEOUT_MS}ms (23 hours). The pg-boss driver budgets expire_in from timeoutMs (execution budget preventing mid-run re-delivery), and pg-boss versions before 12.28 assert expire_in strictly below 24h \u2014 the 23h cap keeps every driver and pg-boss version on a single bound. Split the work into a resumable pipeline (persist progress, enqueue the next stage), or use the bullmq driver (Redis has no such cap).`
+        );
+      }
       manifest.timeoutMs = value;
     }
     if (graceMs !== void 0) manifest.graceMs = parseNumericLiteral(graceMs);
@@ -3778,7 +3644,7 @@ async function loadToolModule(filePath, functionName, rootDir) {
 }
 
 // src/loader/loadToolSchema.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 
 // src/cli/generateToolArtifacts.ts
 init_generateZodArtifacts();
@@ -4012,7 +3878,7 @@ async function loadToolSchema(tool, rootDir) {
   if (!tool.inputTypeName) return void 0;
   const schemaName = `${tool.inputTypeName}Schema`;
   const zodPath = getToolSchemaPath(tool, rootDir);
-  if (!existsSync2(zodPath)) return void 0;
+  if (!existsSync3(zodPath)) return void 0;
   try {
     const mod = await importWithCacheBust(zodPath, isDevOnDemandEnabled());
     const schema = mod[`${tool.inputTypeName}Schema`];
@@ -4320,9 +4186,53 @@ function loadEnv(rootDir) {
   }
 }
 
+// src/utils/readResource.ts
+import path18 from "path";
+import fs15 from "fs/promises";
+var ACTIVE_RESOURCES_DIR_KEY = /* @__PURE__ */ Symbol.for("faapi.resources.dir");
+function getActiveResourcesDir() {
+  return globalThis[ACTIVE_RESOURCES_DIR_KEY] ?? null;
+}
+function setActiveResourcesDir(dir) {
+  if (dir === null) {
+    delete globalThis[ACTIVE_RESOURCES_DIR_KEY];
+  } else {
+    globalThis[ACTIVE_RESOURCES_DIR_KEY] = dir;
+  }
+}
+function resolveResourceTarget(resourcesDir, relativePath) {
+  if (typeof relativePath !== "string" || relativePath === "") {
+    throw new Error("[faapi] readResource: relativePath must be a non-empty string");
+  }
+  const root = toRealPath(path18.resolve(resourcesDir));
+  const resolved = path18.resolve(root, relativePath);
+  if (!isInsideDir(resolved, root)) {
+    throw new Error(
+      `[faapi] readResource: "${relativePath}" escapes the resources directory (absolute paths and ".." are not allowed)`
+    );
+  }
+  const realTarget = toRealPath(resolved);
+  if (!isInsideDir(realTarget, root)) {
+    throw new Error(
+      `[faapi] readResource: "${relativePath}" resolves outside the resources directory via a symlink`
+    );
+  }
+  return realTarget;
+}
+async function readResource(relativePath, encoding) {
+  const resourcesDir = getActiveResourcesDir();
+  if (!resourcesDir) {
+    throw new Error(
+      "[faapi] readResource: no active app in this process \u2014 resources are bound at app startup (createAppBase); testing direct-call can pass `resourcesDir` to createTestContext to bind"
+    );
+  }
+  const target = resolveResourceTarget(resourcesDir, relativePath);
+  return encoding === void 0 ? fs15.readFile(target) : fs15.readFile(target, encoding);
+}
+
 // src/cli/createAppCore.ts
-import fs21 from "fs";
-import path27 from "path";
+import fs22 from "fs";
+import path28 from "path";
 
 // src/router/sortRoutes.ts
 function sortRoutes(routes) {
@@ -4386,7 +4296,7 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable2 } from "stream";
-import path20 from "path";
+import path21 from "path";
 
 // src/router/matchRoute.ts
 var httpIndexCache = /* @__PURE__ */ new WeakMap();
@@ -4428,25 +4338,25 @@ function getWsIndex(routes) {
   wsIndexCache.set(routes, index);
   return index;
 }
-function matchRoute(routes, method, path31) {
+function matchRoute(routes, method, path32) {
   const index = getHttpIndex(routes);
   const upper = method.toUpperCase();
-  const hit = matchByMethod(index, upper, path31);
+  const hit = matchByMethod(index, upper, path32);
   if (hit) return hit;
   if (upper === "HEAD") {
-    return matchByMethod(index, "GET", path31);
+    return matchByMethod(index, "GET", path32);
   }
   return null;
 }
-function matchByMethod(index, method, path31) {
-  const staticHit = index.static.get(`${method}|${path31}`);
+function matchByMethod(index, method, path32) {
+  const staticHit = index.static.get(`${method}|${path32}`);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   if (index.dynamics.length === 0) {
     return null;
   }
-  const pathSegments = path31.split("/").filter(Boolean);
+  const pathSegments = path32.split("/").filter(Boolean);
   for (const entry of index.dynamics) {
     const route = entry.route;
     if (route.method !== method) {
@@ -4459,31 +4369,31 @@ function matchByMethod(index, method, path31) {
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path31) {
+function matchWsRoute(wsRoutes, path32) {
   const index = getWsIndex(wsRoutes);
-  const staticHit = index.static.get(path31);
+  const staticHit = index.static.get(path32);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   for (const route of index.dynamics) {
-    const params = matchDynamicPath(route.urlPath, path31, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path32, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function findAllowedMethods(routes, path31) {
+function findAllowedMethods(routes, path32) {
   const index = getHttpIndex(routes);
   const methods = /* @__PURE__ */ new Set();
-  const staticMethods = index.methodsByStaticPath.get(path31);
+  const staticMethods = index.methodsByStaticPath.get(path32);
   if (staticMethods) {
     for (const method of staticMethods) {
       methods.add(method);
     }
   }
   if (index.dynamics.length > 0) {
-    const pathSegments = path31.split("/").filter(Boolean);
+    const pathSegments = path32.split("/").filter(Boolean);
     for (const entry of index.dynamics) {
       const params = matchSegments(
         entry.segments,
@@ -4501,10 +4411,10 @@ function findAllowedMethods(routes, path31) {
   }
   return Array.from(methods);
 }
-function matchDynamicPath(pattern, path31, paramNames, isCatchAll) {
+function matchDynamicPath(pattern, path32, paramNames, isCatchAll) {
   return matchSegments(
     pattern.split("/").filter(Boolean),
-    path31.split("/").filter(Boolean),
+    path32.split("/").filter(Boolean),
     paramNames,
     isCatchAll
   );
@@ -5643,9 +5553,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue);
-    const path31 = issue.path.map(String).join(".") || "";
+    const path32 = issue.path.map(String).join(".") || "";
     return {
-      path: path31,
+      path: path32,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -5866,16 +5776,16 @@ function etag(options = {}) {
 }
 
 // src/server/handleWsUpgrade.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path19 from "path";
+import path20 from "path";
 
 // src/cli/copyResources.ts
-import path18 from "path";
-import fs15 from "fs";
+import path19 from "path";
+import fs16 from "fs";
 var RESOURCES_OUTPUT_DIR = "resources";
 function resolveResourcesDir(rootDir, dist) {
-  return path18.resolve(rootDir, dist, RESOURCES_OUTPUT_DIR);
+  return path19.resolve(rootDir, dist, RESOURCES_OUTPUT_DIR);
 }
 
 // src/server/serverUtils.ts
@@ -6016,7 +5926,7 @@ async function loadWsHandler(filePath, ctx, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs16.existsSync(sourcePath)) {
+      if (sourcePath && fs17.existsSync(sourcePath)) {
         await ensureCompiled(sourcePath, rootDir, dist);
       }
     }
@@ -6158,7 +6068,7 @@ function attachWebSocket(options) {
     let upgraded = false;
     const finalHandler = async () => {
       const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
-      if (fs16.existsSync(schemaPath)) {
+      if (fs17.existsSync(schemaPath)) {
         if (isDevOnDemandEnabled()) {
           const devDist = getDevDist();
           if (devDist) {
@@ -6197,7 +6107,7 @@ function attachWebSocket(options) {
       }
       let handlers;
       try {
-        const absoluteFilePath = path19.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path20.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -6460,7 +6370,7 @@ function getRoutePaths(route, rootDir, dist) {
   let cached = routePathCache.get(route);
   if (!cached) {
     cached = {
-      absFilePath: path20.resolve(rootDir, route.filePath),
+      absFilePath: path21.resolve(rootDir, route.filePath),
       schemaPath: getRuntimeSchemaPath(route.filePath, dist, rootDir)
     };
     routePathCache.set(route, cached);
@@ -6680,8 +6590,8 @@ function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
 }
 
 // src/cli/generateRoutes.ts
-import fs17 from "fs";
-import path21 from "path";
+import fs18 from "fs";
+import path22 from "path";
 async function hydrateRoutes(manifest) {
   const hydrateRoute = (serialized) => ({
     method: serialized.method,
@@ -6725,18 +6635,18 @@ function createIdleTaskDriver() {
 }
 
 // src/cli/loadPlugins.ts
-import path23 from "path";
-import fs19 from "fs";
+import path24 from "path";
+import fs20 from "fs";
 import { pathToFileURL as pathToFileURL3 } from "url";
 
 // src/cli/compileConfig.ts
-import path22 from "path";
-import fs18 from "fs";
+import path23 from "path";
+import fs19 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 = path22.resolve(rootDir, dist);
+  const absDist = path23.resolve(rootDir, dist);
   await esbuild.build({
     entryPoints: [...entryPoints, ...outsideFiles],
     outdir: absDist,
@@ -6750,7 +6660,7 @@ async function compileProjectModules(entryPoints, rootDir, dist) {
     logLevel: "silent"
   });
   if (insideFiles.length > 0) {
-    const appOutbase = path22.resolve(rootDir, "src");
+    const appOutbase = path23.resolve(rootDir, "src");
     await esbuild.build({
       entryPoints: insideFiles,
       outdir: absDist,
@@ -6831,30 +6741,30 @@ async function loadPlugins(declarations, ctx, rootDir, dist) {
 var TS_EXTS = /\.(ts|tsx|mts|cts)$/;
 var JS_EXTS = /\.(js|mjs|cjs|jsx)$/;
 function resolveLocalPluginSource(specifier, baseDir) {
-  const base = path23.isAbsolute(specifier) ? specifier : path23.resolve(baseDir, specifier);
-  if ((TS_EXTS.test(base) || JS_EXTS.test(base)) && fs19.existsSync(base)) return base;
+  const base = path24.isAbsolute(specifier) ? specifier : path24.resolve(baseDir, specifier);
+  if ((TS_EXTS.test(base) || JS_EXTS.test(base)) && fs20.existsSync(base)) return base;
   for (const ext of [".ts", ".js"]) {
-    if (fs19.existsSync(base + ext)) return base + ext;
+    if (fs20.existsSync(base + ext)) return base + ext;
   }
   for (const indexExt of ["/index.ts", "/index.js"]) {
-    if (fs19.existsSync(base + indexExt)) return base + indexExt;
+    if (fs20.existsSync(base + indexExt)) return base + indexExt;
   }
   return null;
 }
 function mirrorProductPath(sourcePath, baseDir, distDir) {
-  let rel = path23.relative(baseDir, sourcePath).replace(/\\/g, "/");
+  let rel = path24.relative(baseDir, sourcePath).replace(/\\/g, "/");
   if (rel.startsWith("src/")) rel = rel.slice(4);
-  return path23.resolve(distDir, rel.replace(TS_EXTS, ".js"));
+  return path24.resolve(distDir, rel.replace(TS_EXTS, ".js"));
 }
 async function importPluginModule(specifier, baseDir, dist) {
   const isRelative = specifier.startsWith("./") || specifier.startsWith("../");
-  if (!isRelative && !path23.isAbsolute(specifier)) {
+  if (!isRelative && !path24.isAbsolute(specifier)) {
     return import(specifier);
   }
-  const distDir = dist ? path23.resolve(baseDir, dist) : null;
+  const distDir = dist ? path24.resolve(baseDir, dist) : null;
   const sourcePath = resolveLocalPluginSource(specifier, baseDir);
   const productPath = sourcePath && distDir ? mirrorProductPath(sourcePath, baseDir, distDir) : null;
-  if (productPath !== null && fs19.existsSync(productPath) && (sourcePath === null || isProductFresh(sourcePath, productPath))) {
+  if (productPath !== null && fs20.existsSync(productPath) && (sourcePath === null || isProductFresh(sourcePath, productPath))) {
     return import(pathToFileURL3(productPath).href);
   }
   if (sourcePath && TS_EXTS.test(sourcePath)) {
@@ -6863,13 +6773,13 @@ async function importPluginModule(specifier, baseDir, dist) {
         `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 = path23.relative(baseDir, sourcePath).replace(/\\/g, "/");
+    const relFromRoot = path24.relative(baseDir, sourcePath).replace(/\\/g, "/");
     if (relFromRoot.startsWith("src/")) {
       await ensureCompiled(sourcePath, baseDir, dist);
     } else {
       await compileProjectModules([sourcePath], baseDir, dist);
     }
-    if (productPath && fs19.existsSync(productPath)) {
+    if (productPath && fs20.existsSync(productPath)) {
       return import(pathToFileURL3(productPath).href);
     }
   }
@@ -6881,7 +6791,7 @@ async function importPluginModule(specifier, baseDir, dist) {
     `${specifier}/index.ts`,
     `${specifier}.js`,
     `${specifier}/index.js`
-  ].map((c) => path23.isAbsolute(c) ? c : path23.join(baseDir, c));
+  ].map((c) => path24.isAbsolute(c) ? c : path24.join(baseDir, c));
   throw new Error(
     `Cannot find local plugin "${specifier}" (resolved from ${baseDir}). Expected one of:
   ${candidates.join("\n  ")}
@@ -6906,11 +6816,11 @@ function resolveDeclaration(decl) {
 }
 
 // src/cli/manifestLoader.ts
-import fs20 from "fs";
-import path26 from "path";
+import fs21 from "fs";
+import path27 from "path";
 
 // src/cli/generateAgentArtifacts.ts
-import path24 from "path";
+import path25 from "path";
 
 // src/ast/extractAgentMetadata.ts
 import ts11 from "typescript";
@@ -7227,9 +7137,9 @@ function validateAgentList(metadata) {
 }
 async function generateAgentArtifacts(agents, rootDir, dist) {
   const metadata = [];
-  const programByFile = createPrograms(agents.map((m) => path24.resolve(rootDir, m.filePath)));
+  const programByFile = createPrograms(agents.map((m) => path25.resolve(rootDir, m.filePath)));
   for (const manifest of agents) {
-    const absPath = path24.resolve(rootDir, manifest.filePath);
+    const absPath = path25.resolve(rootDir, manifest.filePath);
     const program = programByFile.get(absPath);
     const result = extractAgentMetadata(program, absPath, {
       name: manifest.name,
@@ -7244,14 +7154,14 @@ async function generateAgentArtifacts(agents, rootDir, dist) {
   }
   validateAgentList(metadata);
   const serialized = serializeAgents(metadata, dist);
-  const agentsPath = path24.resolve(rootDir, dist, AGENTS_FILE);
+  const agentsPath = path25.resolve(rootDir, dist, AGENTS_FILE);
   await writeAgentsModule(serialized, agentsPath);
   return metadata;
 }
 
 // src/cli/generateTaskArtifacts.ts
 init_generateZodArtifacts();
-import path25 from "path";
+import path26 from "path";
 init_createProgram();
 init_atomicWrite();
 init_extractHandlerTypes();
@@ -7289,7 +7199,7 @@ function collectTaskSchemaSources(tasks, rootDir) {
   const tasksByFile = /* @__PURE__ */ new Map();
   for (const task of tasks) {
     if (!task.inputTypeName) continue;
-    const absPath = path25.resolve(rootDir, task.filePath);
+    const absPath = path26.resolve(rootDir, task.filePath);
     let list = tasksByFile.get(absPath);
     if (!list) {
       list = [];
@@ -7346,9 +7256,9 @@ function generateTaskSchemaFileSource(sources, resolveType, helpersImportPath) {
 async function generateTaskArtifacts(manifests, rootDir, dist) {
   const metadata = [];
   if (manifests.length > 0) {
-    const programByFile = createPrograms(manifests.map((m) => path25.resolve(rootDir, m.filePath)));
+    const programByFile = createPrograms(manifests.map((m) => path26.resolve(rootDir, m.filePath)));
     for (const manifest of manifests) {
-      const absPath = path25.resolve(rootDir, manifest.filePath);
+      const absPath = path26.resolve(rootDir, manifest.filePath);
       const result = extractToolMetadata(programByFile.get(absPath), absPath, "run", {
         name: manifest.name,
         filePath: manifest.filePath
@@ -7359,7 +7269,7 @@ async function generateTaskArtifacts(manifests, rootDir, dist) {
     }
   }
   const serialized = serializeTasks(manifests, dist);
-  const tasksPath = path25.resolve(rootDir, dist, TASKS_FILE);
+  const tasksPath = path26.resolve(rootDir, dist, TASKS_FILE);
   await writeTasksModule(serialized, tasksPath);
   if (metadata.length === 0) {
     return hydrateTasks(serialized);
@@ -7381,8 +7291,8 @@ async function generateTaskArtifacts(manifests, rootDir, dist) {
 var TOOLS_FILE2 = "faapi-tools.js";
 var AGENTS_FILE2 = "faapi-agents.js";
 async function loadAndHydrateTools(rootDir, dist, registries = defaultRegistries) {
-  const toolsPath = path26.resolve(rootDir, dist, TOOLS_FILE2);
-  if (!fs20.existsSync(toolsPath)) {
+  const toolsPath = path27.resolve(rootDir, dist, TOOLS_FILE2);
+  if (!fs21.existsSync(toolsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(toolsPath);
@@ -7391,8 +7301,8 @@ async function loadAndHydrateTools(rootDir, dist, registries = defaultRegistries
   return hydrated;
 }
 async function loadAndHydrateAgents(rootDir, dist, registries = defaultRegistries) {
-  const agentsPath = path26.resolve(rootDir, dist, AGENTS_FILE2);
-  if (!fs20.existsSync(agentsPath)) {
+  const agentsPath = path27.resolve(rootDir, dist, AGENTS_FILE2);
+  if (!fs21.existsSync(agentsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(agentsPath);
@@ -7407,8 +7317,8 @@ function getTaskDriverOptions(config) {
   return void 0;
 }
 async function loadAndHydrateTasks(rootDir, dist, registries = defaultRegistries) {
-  const tasksPath = path26.resolve(rootDir, dist, TASKS_FILE);
-  if (!fs20.existsSync(tasksPath)) {
+  const tasksPath = path27.resolve(rootDir, dist, TASKS_FILE);
+  if (!fs21.existsSync(tasksPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(tasksPath);
@@ -7597,11 +7507,17 @@ function logStartupSummary(routes, wsRoutes, tools, agents, taskMetas, p) {
   }
 }
 async function createAppBase(options) {
+  if (getCurrentApp()) {
+    throw new Error(
+      "[faapi] createApp: an app is already alive in this process \u2014 faapi supports a single app per process. Close it first (`await app.close()`) or run the second app in a separate process."
+    );
+  }
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
   const resourcesDir = resolveResourcesDir(rootDir, dist);
-  const routesPath = path27.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs21.existsSync(routesPath)) {
+  setActiveResourcesDir(resourcesDir);
+  const routesPath = path28.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs22.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`
     );
@@ -7766,6 +7682,7 @@ async function createAppBase(options) {
       registries.task.clear();
       registries.agentHandle.clear();
       registries.taskHandle.clear();
+      setActiveResourcesDir(null);
       if (!server.listening) {
         app.server = null;
         if (getCurrentApp() === app) setCurrentApp(null);
@@ -7819,21 +7736,21 @@ async function createAppBase(options) {
 }
 
 // src/cli/createDevApp.ts
-import path30 from "path";
+import path31 from "path";
 
 // src/router/scanRoutes.ts
 import fg3 from "fast-glob";
-import path28 from "path";
-import fs22 from "fs";
+import path29 from "path";
+import fs23 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(path31) {
-  if (!path31) return "";
-  let result = path31.replace(/\\/g, "/");
+function normalizePath(path32) {
+  if (!path32) return "";
+  let result = path32.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -7894,34 +7811,34 @@ function extractExportsFromSource(source) {
   return names;
 }
 function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
-  const routeDir = path28.dirname(routeFilePath);
-  const resolvedRoot = path28.resolve(rootDir);
+  const routeDir = path29.dirname(routeFilePath);
+  const resolvedRoot = path29.resolve(rootDir);
   const paths = [];
-  let currentDir = path28.resolve(rootDir, routeDir);
+  let currentDir = path29.resolve(rootDir, routeDir);
   while (true) {
     if (dist) {
-      const mwTsPath = path28.join(currentDir, "middlewares.ts");
-      const mwJsPath = path28.join(currentDir, "middlewares.js");
-      const absTsPath = path28.resolve(rootDir, mwTsPath);
-      const absJsPath = path28.resolve(rootDir, mwJsPath);
-      const absMwPath = fs22.existsSync(absTsPath) ? absTsPath : fs22.existsSync(absJsPath) ? absJsPath : null;
+      const mwTsPath = path29.join(currentDir, "middlewares.ts");
+      const mwJsPath = path29.join(currentDir, "middlewares.js");
+      const absTsPath = path29.resolve(rootDir, mwTsPath);
+      const absJsPath = path29.resolve(rootDir, mwJsPath);
+      const absMwPath = fs23.existsSync(absTsPath) ? absTsPath : fs23.existsSync(absJsPath) ? absJsPath : null;
       if (absMwPath) {
-        const relMwPath = path28.relative(rootDir, absMwPath);
-        const prodAbsPath = path28.resolve(rootDir, toProdFilePath(relMwPath, dist));
+        const relMwPath = path29.relative(rootDir, absMwPath);
+        const prodAbsPath = path29.resolve(rootDir, toProdFilePath(relMwPath, dist));
         paths.push(prodAbsPath);
       }
     } else {
       for (const ext of [".ts", ".js"]) {
-        const mwPath = path28.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path28.resolve(rootDir, mwPath);
-        if (fs22.existsSync(absMwPath)) {
+        const mwPath = path29.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path29.resolve(rootDir, mwPath);
+        if (fs23.existsSync(absMwPath)) {
           paths.push(absMwPath);
           break;
         }
       }
     }
     if (currentDir === resolvedRoot) break;
-    const parentDir = path28.dirname(currentDir);
+    const parentDir = path29.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -7940,7 +7857,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 = path28.resolve(rootDir, normalizedFile);
+      const absPath = path29.resolve(rootDir, normalizedFile);
       const urlPath = filePathToUrlPath(normalizedFile);
       const paramNames = extractParamNames(urlPath);
       const isDynamic = paramNames.length > 0;
@@ -7953,7 +7870,7 @@ async function scanRoutes(rootDir, patterns, dist) {
         const mwPaths = collectMiddlewarePaths(normalizedFile, rootDir);
         middlewareBundle = await loadMergedMiddlewares(mwPaths);
       }
-      const source = await fs22.promises.readFile(absPath, "utf8").catch(() => "");
+      const source = await fs23.promises.readFile(absPath, "utf8").catch(() => "");
       const exportNames = extractExportsFromSource(source);
       const methods = HTTP_METHODS.filter((m) => exportNames.has(m));
       for (const method of methods) {
@@ -7989,8 +7906,8 @@ async function scanRoutes(rootDir, patterns, dist) {
 
 // src/tools/scanTools.ts
 import fg4 from "fast-glob";
-import path29 from "path";
-import fs23 from "fs";
+import path30 from "path";
+import fs24 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*(?:\(|=)`,
@@ -8040,8 +7957,8 @@ async function scanTools(rootDir, patterns) {
     if (fileName !== "handler.ts" && fileName !== "handler.js") {
       continue;
     }
-    const absPath = path29.resolve(rootDir, normalizedFile);
-    const source = await fs23.promises.readFile(absPath, "utf8").catch(() => "");
+    const absPath = path30.resolve(rootDir, normalizedFile);
+    const source = await fs24.promises.readFile(absPath, "utf8").catch(() => "");
     const exportNames = extractToolExportsFromSource(source);
     const namespace = filePathToToolNamespace(normalizedFile);
     for (const fnName of exportNames) {
@@ -8158,7 +8075,7 @@ async function createDevApp(options) {
     if (!suppressProgramInvalidation) invalidateProgramCache();
     const tasks = await scanTasks(ctx.rootDir, TASK_PATTERNS);
     for (const task of tasks) {
-      await ensureCompiled(path30.resolve(ctx.rootDir, task.filePath), ctx.rootDir, ctx.dist);
+      await ensureCompiled(path31.resolve(ctx.rootDir, task.filePath), ctx.rootDir, ctx.dist);
     }
     await generateTaskArtifacts(tasks, ctx.rootDir, ctx.dist);
     ctx.taskQueue.invalidateModules();
@@ -8230,6 +8147,7 @@ export {
   loadToolModule,
   loadToolSchema,
   logger,
+  readResource,
   registerAgentHandleFactory,
   removeSkill,
   resolveAgentTools,