@open-wxa/wxa-runner-core 0.7.0 → 0.8.0

package/dist/index.js

@@ -39,9 +39,135 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/server/DevServer.ts
-var import_crypto3 = require("crypto");
+var import_crypto4 = require("crypto");
+
+// src/server/FileStore.ts
+var import_crypto = require("crypto");
+var FileStore = class {
+  /** @param roots 预先创建的目录（如用户目录）。rmdir 不能删除它们和它们的上级目录：删掉之后再写 USER_DATA_PATH 都会失败 */
+  constructor(roots = []) {
+    this.etagPrefix = (0, import_crypto.randomUUID)();
+    this.version = 0;
+    this.nodes = /* @__PURE__ */ new Map([["/", { dir: true, data: Buffer.alloc(0), mtime: Date.now(), etag: "" }]]);
+    this.roots = roots.map((root) => this.normalize(root));
+    for (const root of this.roots) this.mkdir(root, true);
+  }
+  normalize(filePath) {
+    const stripped = String(filePath || "").replace(/^[a-z]+:\/\/[^/]*/i, "");
+    const parts = [];
+    for (const part of stripped.split("/")) {
+      if (!part || part === ".") continue;
+      if (part === "..") parts.pop();
+      else parts.push(part);
+    }
+    return "/" + parts.join("/");
+  }
+  stat(filePath) {
+    return this.nodes.get(this.normalize(filePath));
+  }
+  mkdir(dirPath, recursive = false) {
+    const target = this.normalize(dirPath);
+    if (this.nodes.has(target)) throw new Error(`file already exists ${dirPath}`);
+    const parent = target.slice(0, target.lastIndexOf("/")) || "/";
+    if (!this.nodes.get(parent)?.dir) {
+      if (!recursive) throw new Error(`no such file or directory ${dirPath}`);
+      this.mkdir(parent, true);
+    }
+    this.nodes.set(target, { dir: true, data: Buffer.alloc(0), mtime: Date.now(), etag: "" });
+  }
+  write(filePath, input, append = false) {
+    const data = Buffer.from(input);
+    const target = this.normalize(filePath);
+    const parent = target.slice(0, target.lastIndexOf("/")) || "/";
+    if (!this.nodes.get(parent)?.dir) throw new Error(`no such file or directory ${filePath}`);
+    const existing = this.nodes.get(target);
+    if (existing?.dir) throw new Error(`illegal operation on a directory ${filePath}`);
+    const contents = append && existing ? Buffer.concat([existing.data, data]) : data;
+    this.nodes.set(target, { dir: false, data: contents, mtime: Date.now(), etag: `${this.etagPrefix}-${++this.version}` });
+  }
+  read(filePath) {
+    const node = this.stat(filePath);
+    if (!node) throw new Error(`no such file or directory, open ${filePath}`);
+    if (node.dir) throw new Error(`illegal operation on a directory ${filePath}`);
+    return node.data;
+  }
+  readdir(dirPath) {
+    const target = this.normalize(dirPath);
+    if (!this.nodes.get(target)?.dir) throw new Error(`no such file or directory ${dirPath}`);
+    const prefix = target === "/" ? "/" : target + "/";
+    return [...this.nodes.keys()].filter((key) => key.startsWith(prefix) && key !== target && !key.slice(prefix.length).includes("/")).map((key) => key.slice(prefix.length));
+  }
+  remove(filePath, options) {
+    const target = this.normalize(filePath);
+    const node = this.nodes.get(target);
+    if (!node) throw new Error(`no such file or directory ${filePath}`);
+    if (node.dir !== options.dir) throw new Error(options.dir ? `not a directory ${filePath}` : `operation not permitted ${filePath}`);
+    if (node.dir) {
+      const children = this.readdir(target);
+      if (children.length && !options.recursive) throw new Error(`directory not empty ${filePath}`);
+      for (const key of [...this.nodes.keys()]) if (key.startsWith(target + "/")) this.nodes.delete(key);
+    }
+    this.nodes.delete(target);
+  }
+  execute(operation, args) {
+    switch (operation) {
+      case "readFile": {
+        const data = this.read(args.filePath);
+        return args.encoding === void 0 ? { data: data.toString("base64"), binary: true } : { data: data.toString(args.encoding) };
+      }
+      case "writeFile":
+      case "appendFile": {
+        const data = Buffer.from(args.data ?? "", args.binary ? "base64" : args.encoding || "utf8");
+        this.write(args.filePath, data, operation === "appendFile");
+        return {};
+      }
+      case "copyFile":
+        this.write(args.destPath, this.read(args.srcPath));
+        return {};
+      case "access":
+        if (!this.stat(args.path)) throw new Error(`no such file or directory ${args.path}`);
+        return {};
+      case "stat": {
+        const node = this.stat(args.path);
+        if (!node) throw new Error(`no such file or directory ${args.path}`);
+        const stats = {
+          mode: node.dir ? 16877 : 33188,
+          size: node.data.length,
+          lastAccessedTime: Math.floor(node.mtime / 1e3),
+          lastModifiedTime: Math.floor(node.mtime / 1e3)
+        };
+        return { stats, ...stats };
+      }
+      case "getFileInfo":
+        return { size: this.read(args.filePath).length };
+      case "mkdir":
+        this.mkdir(args.dirPath, !!args.recursive);
+        return {};
+      case "readdir":
+        return { files: this.readdir(args.dirPath) };
+      case "unlink":
+        this.remove(args.filePath, { dir: false });
+        return {};
+      case "rmdir": {
+        const target = this.normalize(args.dirPath);
+        const prefix = target === "/" ? "/" : target + "/";
+        if (this.roots.some((root) => root === target || root.startsWith(prefix))) {
+          throw new Error(`operation not permitted ${args.dirPath}`);
+        }
+        this.remove(args.dirPath, { dir: true, recursive: !!args.recursive });
+        return {};
+      }
+      default:
+        throw new Error(`unsupported filesystem operation ${operation}`);
+    }
+  }
+};
+
+// src/server/DevServer.ts
 var import_fs4 = __toESM(require("fs"));
 var import_http = __toESM(require("http"));
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
 var import_path4 = __toESM(require("path"));
 var import_express2 = __toESM(require("express"));
 var import_ws2 = require("ws");
@@ -481,6 +607,22 @@ function readJsonFile(file) {
   }
 }
 
+// src/runtime/networkPanel.ts
+var PROXY_PREFIX = "/__wxa__/proxy/";
+var MOCK_PREFIX = "/__wxa__/mock/";
+function fromServerPath(prefix, serverPath) {
+  if (!serverPath.startsWith(prefix)) return null;
+  const match = /^(https?)\/([^/?#]+)(.*)$/.exec(serverPath.slice(prefix.length));
+  if (!match) return null;
+  const url = `${match[1]}://${match[2]}${match[3]}`;
+  try {
+    new URL(url);
+    return url;
+  } catch {
+    return null;
+  }
+}
+
 // src/server/plugins.ts
 var import_wxa_runner_extractor2 = require("@open-wxa/wxa-runner-extractor");
 
@@ -758,7 +900,7 @@ ${pageWindow(build2, pagePath).disableScroll ? "<style>body{overflow-y:hidden}</
 }
 function workerScript(build2, baseLib) {
   const modules = build2.workerModules.map((id) => `/__wxa__/module/${encodeURI(id)}?v=${build2.version}`);
-  const prelude = `var __wxConfig = ${toJs(build2.wxConfig)};
+  const prelude = `var __wxConfig = ${toJs(build2.wxConfig)}; __wxConfig.env.USER_DATA_PATH = location.origin + "/__wxa__/usr/" + new URL(location.href).searchParams.get("session");
 importScripts('/__wxa__/runtime/worker.js');
 `;
   if (!baseLib.hasWorker) {
@@ -840,13 +982,62 @@ function vlq(value) {
   return out;
 }
 
+// src/server/forwardConsole.ts
+var MAX_LENGTH = 4e3;
+var LIMIT_PER_SECOND = 20;
+var CONTROL_CHARS = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+function printBrowserReports(socket, logger) {
+  let windowStart = 0;
+  let printed = 0;
+  let dropped = 0;
+  socket.on("message", (data) => {
+    const report = parseReport(data);
+    if (!report) return;
+    const now = Date.now();
+    if (now - windowStart >= 1e3) {
+      windowStart = now;
+      printed = 0;
+    }
+    if (printed >= LIMIT_PER_SECOND) {
+      if (dropped++ === 0) {
+        setTimeout(() => {
+          logger.warn(`[wxa-runner] \u6D4F\u89C8\u5668 1 \u79D2\u5185\u8F6C\u53D1\u7684\u62A5\u9519\u592A\u591A\uFF0C\u7701\u7565\u4E86 ${dropped} \u6761`);
+          dropped = 0;
+        }, windowStart + 1e3 - now).unref();
+      }
+      return;
+    }
+    printed++;
+    logger[report.level](`[wxa-runner] ${clean(report.text)}`);
+  });
+}
+function parseReport(data) {
+  try {
+    const report = JSON.parse(data.toString());
+    if (report?.type === "console" && (report.level === "warn" || report.level === "error") && typeof report.text === "string") return report;
+  } catch {
+  }
+  return null;
+}
+function clean(text) {
+  const printable = text.replace(CONTROL_CHARS, "");
+  return printable.length > MAX_LENGTH ? `${printable.slice(0, MAX_LENGTH)}\u2026\uFF08\u5DF2\u622A\u65AD\uFF09` : printable;
+}
+function ignoreConsoleHook(sourceMap) {
+  const map = JSON.parse(sourceMap);
+  map.x_google_ignoreList = map.sources.flatMap((source, index) => source.endsWith("consoleHook.ts") ? [index] : []);
+  return JSON.stringify(map);
+}
+
 // src/server/proxy.ts
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
 var DROPPED_REQUEST_HEADERS = /* @__PURE__ */ new Set(["host", "connection", "content-length", "transfer-encoding", "keep-alive", "upgrade", "expect"]);
 var DROPPED_RESPONSE_HEADERS = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding", "connection", "set-cookie"]);
 async function handleProxy(req, res) {
-  const target = String(req.query.url || "");
-  if (!/^https?:\/\//i.test(target)) {
-    res.status(400).set("x-wxa-proxy-error", "1").send(`invalid url "${target}"`);
+  const target = fromServerPath(PROXY_PREFIX, req.originalUrl);
+  if (!target) {
+    res.status(400).set("x-wxa-proxy-error", "1").send(`invalid url "${req.originalUrl}"`);
     return;
   }
   let requestHeaders = {};
@@ -868,31 +1059,47 @@ async function handleProxy(req, res) {
     headers["content-type"] = browserContentType;
   }
   const hasBody = !["GET", "HEAD"].includes(req.method) && Buffer.isBuffer(req.body) && req.body.length > 0;
-  let upstream;
+  const controller = new AbortController();
+  const cancel = () => controller.abort();
+  res.once("close", cancel);
   try {
-    upstream = await fetch(target, {
-      method: req.method,
-      headers,
-      body: hasBody ? req.body : void 0,
-      redirect: "follow"
+    let upstream;
+    try {
+      upstream = await fetch(target, {
+        method: req.method,
+        headers,
+        body: hasBody ? req.body : void 0,
+        redirect: "follow",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (res.destroyed || controller.signal.aborted) return;
+      const cause = error?.cause?.message;
+      res.status(502).set("x-wxa-proxy-error", "1").send(cause || error.message);
+      return;
+    }
+    const responseHeaders = {};
+    upstream.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
     });
+    const setCookies = typeof upstream.headers.getSetCookie === "function" ? upstream.headers.getSetCookie() : [];
+    res.status(upstream.status);
+    upstream.headers.forEach((value, key) => {
+      if (!DROPPED_RESPONSE_HEADERS.has(key)) res.setHeader(key, value);
+    });
+    res.setHeader("x-wxa-headers", encodeURIComponent(JSON.stringify(responseHeaders)));
+    res.setHeader("x-wxa-set-cookie", encodeURIComponent(JSON.stringify(setCookies)));
+    res.flushHeaders();
+    if (!upstream.body) {
+      res.end();
+      return;
+    }
+    await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(upstream.body), res);
   } catch (error) {
-    const cause = error?.cause?.message;
-    res.status(502).set("x-wxa-proxy-error", "1").send(cause || error.message);
-    return;
+    if (!res.destroyed) res.destroy(error);
+  } finally {
+    res.off("close", cancel);
   }
-  const responseHeaders = {};
-  upstream.headers.forEach((value, key) => {
-    responseHeaders[key] = value;
-  });
-  const setCookies = typeof upstream.headers.getSetCookie === "function" ? upstream.headers.getSetCookie() : [];
-  res.status(upstream.status);
-  upstream.headers.forEach((value, key) => {
-    if (!DROPPED_RESPONSE_HEADERS.has(key)) res.setHeader(key, value);
-  });
-  res.setHeader("x-wxa-headers", encodeURIComponent(JSON.stringify(responseHeaders)));
-  res.setHeader("x-wxa-set-cookie", encodeURIComponent(JSON.stringify(setCookies)));
-  res.send(Buffer.from(await upstream.arrayBuffer()));
 }
 
 // src/server/hmr.ts
@@ -910,8 +1117,8 @@ function planHotUpdate(files, units) {
 
 // src/server/developerTicket.ts
 var import_child_process = require("child_process");
-var import_crypto = require("crypto");
-var import_promises = require("timers/promises");
+var import_crypto2 = require("crypto");
+var import_promises2 = require("timers/promises");
 var import_ws = require("ws");
 var import_wxa_runner_extractor3 = require("@open-wxa/wxa-runner-extractor");
 var AUTO_PORT = 9420;
@@ -960,7 +1167,7 @@ async function requestTicketOnceWindowReady(port, projectPath) {
     } catch (error) {
       if (!(error instanceof WindowNotFound)) throw error;
       if (Date.now() >= deadline) throw new Error(`\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177\u91CC\u627E\u4E0D\u5230\u9879\u76EE\u7A97\u53E3\uFF0C\u8BF7\u5728\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177\u91CC\u6253\u5F00\u9879\u76EE ${projectPath}`);
-      await (0, import_promises.setTimeout)(WINDOW_RETRY_INTERVAL);
+      await (0, import_promises2.setTimeout)(WINDOW_RETRY_INTERVAL);
     }
   }
 }
@@ -1002,7 +1209,7 @@ function cliErrorMessage(stdout) {
 }
 function requestTicket(port) {
   return new Promise((resolve, reject) => {
-    const id = `wxa-runner-${(0, import_crypto.randomUUID)()}`;
+    const id = `wxa-runner-${(0, import_crypto2.randomUUID)()}`;
     const socket = new import_ws.WebSocket(`ws://127.0.0.1:${port}`);
     const settle = (finish) => {
       clearTimeout(timer);
@@ -1153,7 +1360,7 @@ function builtinSetupModule() {
 }
 
 // src/server/watcher.ts
-var import_crypto2 = require("crypto");
+var import_crypto3 = require("crypto");
 var import_fs3 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
 var import_chokidar = __toESM(require("chokidar"));
@@ -1197,7 +1404,7 @@ function updateFingerprint(fingerprints, file, event) {
   if (event !== "add" && event !== "change" || !FINGERPRINTED.test(file)) return false;
   let next;
   try {
-    next = (0, import_crypto2.createHash)("sha1").update(import_fs3.default.readFileSync(file)).digest("hex");
+    next = (0, import_crypto3.createHash)("sha1").update(import_fs3.default.readFileSync(file)).digest("hex");
   } catch {
     return false;
   }
@@ -1224,8 +1431,9 @@ var DevServer = class {
     this.sockets = null;
     this.watcher = null;
     this.address = "";
+    this.lanAccess = false;
     /** 运行时生成的临时文件（canvas 导出、拍照等），随服务器进程存在 */
-    this.tempFiles = /* @__PURE__ */ new Map();
+    this.fileSessions = /* @__PURE__ */ new Map();
     this.logger = options.logger || console;
     this.project = new MiniProgram(import_path4.default.resolve(options.projectPath));
     this.baseLib = (0, import_wxa_runner_extractor5.resolveBaseLib)({ version: options.baseLibVersion, cacheDir: options.baseLibCacheDir });
@@ -1244,9 +1452,16 @@ var DevServer = class {
     this.setupEnv = collectSetupEnv(process.env);
     this.app = this.createApp();
   }
+  /** 本机访问的地址 */
   get url() {
     return this.address;
   }
+  /** 局域网里其他设备访问的地址，每块网卡一个；只监听本机时为空 */
+  get networkUrls() {
+    if (!this.lanAccess) return [];
+    const { port } = new URL(this.address);
+    return Object.values(import_os.default.networkInterfaces()).flat().filter((net2) => net2 && net2.family === "IPv4" && !net2.internal).map((net2) => `http://${net2.address}:${port}`);
+  }
   async start() {
     try {
       const build2 = await this.builder.build();
@@ -1256,7 +1471,11 @@ var DevServer = class {
 ${error.message}`);
     }
     const server = import_http.default.createServer(this.app);
-    this.sockets = new import_ws2.WebSocketServer({ noServer: true });
+    this.sockets = new import_ws2.WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
+    this.sockets.on("connection", (socket) => {
+      socket.on("error", () => void 0);
+      if (this.options.forwardConsole) printBrowserReports(socket, this.logger);
+    });
     server.on("upgrade", (req, socket, head) => {
       if (req.url?.startsWith("/__wxa__/ws")) {
         this.sockets.handleUpgrade(req, socket, head, (ws) => this.sockets.emit("connection", ws, req));
@@ -1265,13 +1484,10 @@ ${error.message}`);
       }
     });
     const host = this.options.host || "localhost";
-    await new Promise((resolve, reject) => {
-      server.once("error", reject);
-      server.listen(this.options.port ?? 3e3, host, () => resolve());
-    });
+    const port = await listen(server, this.options.port, host, this.logger);
     this.server = server;
-    const { port } = server.address();
-    this.address = `http://${host}:${port}`;
+    this.lanAccess = LOCAL_HOST_OF_ANY_ADDRESS.has(host);
+    this.address = `http://${LOCAL_HOST_OF_ANY_ADDRESS.get(host) ?? host}:${port}`;
     if (this.options.watch !== false) this.startWatching();
     this.ticketSource?.().then(requireUsableTicket).catch((error) => this.logger.warn(`[wxa-runner] \u5F00\u53D1\u8005\u5DE5\u5177\u7684\u767B\u5F55\u6001\u6682\u4E0D\u53EF\u7528\uFF08--devtools-login\uFF09\uFF1A${error.message}`));
     return this.address;
@@ -1286,6 +1502,7 @@ ${error.message}`);
       server.closeAllConnections();
       await new Promise((resolve) => server.close(() => resolve()));
     }
+    this.fileSessions.clear();
   }
   createApp() {
     const app = (0, import_express2.default)();
@@ -1300,7 +1517,13 @@ ${error.message}`);
     });
     app.get("/__wxa__/app-info.json", async (_req, res) => {
       noStore(res);
-      const base = { appid: this.project.appid, baseLibVersion: this.baseLib.version, device: this.device, devtoolsLogin: this.devtoolsLogin };
+      const base = {
+        appid: this.project.appid,
+        baseLibVersion: this.baseLib.version,
+        device: this.device,
+        devtoolsLogin: this.devtoolsLogin,
+        forwardConsole: this.options.forwardConsole ?? false
+      };
       try {
         const build2 = await this.plugins.refresh(await this.builder.build());
         const info = { ...base, version: build2.version, wxConfig: build2.wxConfig, pages: build2.pages };
@@ -1379,7 +1602,18 @@ ${error.message}`);
     app.get("/__wxa__/page-frame.js", this.withBuild((build2, _req, res) => {
       res.type("js").send(build2.pageFrame);
     }));
-    app.use("/__wxa__/runtime", import_express2.default.static(this.runtimeDir(), { cacheControl: false }));
+    app.get("/__wxa__/runtime/frame.js.map", (_req, res, next) => {
+      const file = import_path4.default.join(this.runtimeDir(), "frame.js.map");
+      if (!import_fs4.default.existsSync(file)) return next();
+      res.type("json").send(ignoreConsoleHook(import_fs4.default.readFileSync(file, "utf8")));
+    });
+    app.use("/__wxa__/runtime", import_express2.default.static(this.runtimeDir(), {
+      cacheControl: false,
+      // Service Worker 默认只能接管自己所在目录下的页面，宿主页面在根路径
+      setHeaders: (res, file) => {
+        if (import_path4.default.basename(file) === "sw.js") res.setHeader("Service-Worker-Allowed", "/");
+      }
+    }));
     const sourceMaps = /* @__PURE__ */ new Map();
     app.get(/^\/__baselib__\/(.+\.js)\.map$/, (req, res, next) => {
       const file = import_path4.default.resolve(this.baseLib.dir, req.params[0]);
@@ -1393,16 +1627,45 @@ ${error.message}`);
         if (file.endsWith(".js")) res.setHeader("SourceMap", `${import_path4.default.basename(file)}.map`);
       }
     }));
-    app.all("/__wxa__/proxy", import_express2.default.raw({ type: () => true, limit: "100mb" }), handleProxy);
-    app.post("/__wxa__/tmp", import_express2.default.raw({ type: () => true, limit: "100mb" }), (req, res) => {
+    app.use(PROXY_PREFIX, import_express2.default.raw({ type: () => true, limit: "100mb" }), handleProxy);
+    app.use(MOCK_PREFIX, (_req, res) => {
+      res.status(503).type("text").send("\u8FD9\u4E2A\u8BF7\u6C42\u5DF2\u88AB\u62E6\u622A\u89C4\u5219\u62E6\u4E0B\uFF0C\u8FD9\u91CC\u53EA\u7528\u4E8E\u5728 Network \u9762\u677F\u91CC\u663E\u793A\u5B83\u3002Service Worker \u6CA1\u6709\u751F\u6548\uFF08\u5982 DevTools \u52FE\u9009\u4E86 Bypass for network\uFF09\uFF0C\u770B\u4E0D\u5230\u62E6\u622A\u89C4\u5219\u7ED9\u51FA\u7684\u54CD\u5E94");
+    });
+    const sessionFiles = (session) => {
+      if (!/^[a-z0-9-]{1,80}$/i.test(session)) return null;
+      let files = this.fileSessions.get(session);
+      if (!files) {
+        files = new FileStore([`/__wxa__/usr/${session}`, `/__wxa__/tmp/${session}`]);
+        this.fileSessions.set(session, files);
+      }
+      return files;
+    };
+    app.post("/__wxa__/fs/:session", import_express2.default.json({ limit: "150mb" }), (req, res) => {
+      const files = sessionFiles(req.params.session);
+      if (!files) {
+        res.status(400).json({ error: `invalid filesystem session ${req.params.session}` });
+        return;
+      }
+      try {
+        res.json({ result: files.execute(req.body.operation, req.body.args || {}) });
+      } catch (error) {
+        res.json({ error: error.message });
+      }
+    });
+    app.post("/__wxa__/tmp/:session", import_express2.default.raw({ type: () => true, limit: "100mb" }), (req, res) => {
       const type = String(req.query.type || "png");
       if (!/^[a-z0-9]+$/i.test(type)) {
         res.status(400).type("text").send(`\u975E\u6CD5\u7684\u6587\u4EF6\u7C7B\u578B ${type}`);
         return;
       }
-      const name = `${(0, import_crypto3.randomUUID)()}.${type}`;
-      this.tempFiles.set(name, Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0));
-      res.json({ url: `${req.protocol}://${req.get("host")}/__wxa__/tmp/${name}` });
+      const files = sessionFiles(req.params.session);
+      if (!files) {
+        res.status(400).type("text").send(`\u975E\u6CD5\u7684\u4F1A\u8BDD\u6807\u8BC6 ${req.params.session}`);
+        return;
+      }
+      const filePath = `/__wxa__/tmp/${req.params.session}/${(0, import_crypto4.randomUUID)()}.${type}`;
+      files.write(filePath, Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0));
+      res.json({ url: `${req.protocol}://${req.get("host")}${filePath}` });
     });
     app.get("/__wxa__/region/:kind", (req, res) => {
       const kind = req.params.kind;
@@ -1413,14 +1676,16 @@ ${error.message}`);
       }
       res.type("text/plain; charset=utf-8").set("Cache-Control", "public, max-age=86400").send(data);
     });
-    app.get("/__wxa__/tmp/:name", (req, res) => {
-      const data = this.tempFiles.get(req.params.name);
-      if (!data) {
+    app.get("/__wxa__/:kind(usr|tmp)/:session/*", (req, res) => {
+      const files = this.fileSessions.get(req.params.session);
+      const node = files?.stat(`/__wxa__/${req.params.kind}/${req.params.session}/` + req.params[0]);
+      if (!node || node.dir) {
         res.status(404).end();
         return;
       }
-      res.type(import_path4.default.extname(req.params.name));
-      res.setHeader("ETag", `"${req.params.name}"`);
+      const data = node.data;
+      res.type(import_path4.default.extname(req.params[0]));
+      res.setHeader("ETag", `"${node.etag}"`);
       res.setHeader("Accept-Ranges", "bytes");
       const ranges = req.range(data.length);
       if (ranges === -1) {
@@ -1436,8 +1701,15 @@ ${error.message}`);
       }
       res.send(data);
     });
-    app.delete("/__wxa__/tmp/:name", (req, res) => {
-      res.status(this.tempFiles.delete(req.params.name) ? 204 : 404).end();
+    app.delete("/__wxa__/tmp/:session/*", (req, res) => {
+      try {
+        const files = this.fileSessions.get(req.params.session);
+        if (!files) throw new Error("file not exist");
+        files.remove(`/__wxa__/tmp/${req.params.session}/` + req.params[0], { dir: false });
+        res.status(204).end();
+      } catch {
+        res.status(404).end();
+      }
     });
     if (this.ticketSource) app.use("/__wxa__/api", devtoolsLoginRouter(this.project.appid, this.ticketSource));
     app.use("/__wxa__/webview", import_express2.default.static(root));
@@ -1526,6 +1798,38 @@ ${message}`);
     });
   }
 };
+var DEFAULT_PORT = 3e3;
+var LOCAL_HOST_OF_ANY_ADDRESS = /* @__PURE__ */ new Map([["0.0.0.0", "127.0.0.1"], ["::", "localhost"]]);
+async function listen(server, port, host, logger) {
+  for (let candidate = port ?? DEFAULT_PORT; ; candidate++) {
+    const taken = LOCAL_HOST_OF_ANY_ADDRESS.has(host) && await takenOnLoopback(candidate) || !await bind(server, candidate, host);
+    if (!taken) {
+      const actual = server.address().port;
+      if (port === void 0 && actual !== DEFAULT_PORT) logger.warn(`[wxa-runner] \u7AEF\u53E3 ${DEFAULT_PORT} \u5DF2\u88AB\u5360\u7528\uFF0C\u6539\u7528 ${actual}`);
+      return actual;
+    }
+    if (port !== void 0) throw new Error(`\u7AEF\u53E3 ${port} \u5DF2\u88AB\u5360\u7528\uFF1A\u5148\u5173\u95ED\u5360\u7528\u5B83\u7684\u8FDB\u7A0B\uFF0C\u6216\u7528 --port \u6362\u4E00\u4E2A\u7AEF\u53E3`);
+  }
+}
+function bind(server, port, host) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => error.code === "EADDRINUSE" ? resolve(false) : reject(error);
+    server.once("error", onError);
+    server.listen(port, host, () => {
+      server.off("error", onError);
+      resolve(true);
+    });
+  });
+}
+async function takenOnLoopback(port) {
+  for (const address of ["127.0.0.1", "::1"]) {
+    const probe = import_net.default.createServer();
+    const free = await bind(probe, port, address).catch(() => true);
+    if (!free) return true;
+    await new Promise((resolve) => probe.close(resolve));
+  }
+  return false;
+}
 function resolveSetupFile(option, projectPath) {
   if (option === false) return null;
   if (!option) return findSetupFile(projectPath);