@open-wxa/wxa-runner-core 0.12.1 → 0.12.2

package/dist/index.mjs

@@ -98,6 +98,26 @@ var FileStore = class {
         this.write(destPath, this.read(srcPath));
         return {};
       },
+      rename: ({ oldPath, newPath }) => {
+        const source = this.normalize(oldPath);
+        const target = this.normalize(newPath);
+        const node = this.existing(oldPath);
+        this.assertNotRoot(source);
+        this.assertNotRoot(target);
+        if (source === target) return {};
+        const parent = target.slice(0, target.lastIndexOf("/")) || "/";
+        if (!this.nodes.get(parent)?.dir) throw new Error(`no such file or directory ${newPath}`);
+        if (node.dir && target.startsWith(source + "/")) throw new Error("invalid argument: directory moved into itself");
+        const destination = this.nodes.get(target);
+        if (destination) {
+          if (destination.dir !== node.dir) throw new Error(`incompatible file type ${newPath}`);
+          if (destination.dir && this.readdir(target).length) throw new Error(`directory not empty ${newPath}`);
+        }
+        const entries = [...this.nodes].filter(([key]) => key === source || node.dir && key.startsWith(source + "/"));
+        for (const [key] of entries) this.nodes.delete(key);
+        for (const [key, value] of entries) this.nodes.set(target + key.slice(source.length), value);
+        return {};
+      },
       access: ({ path: path7 }) => {
         this.existing(path7);
         return {};
@@ -225,7 +245,7 @@ import net from "net";
 import os3 from "os";
 import path6 from "path";
 import express2 from "express";
-import { WebSocket as WebSocket2, WebSocketServer } from "ws";
+import { WebSocket as WebSocket3, WebSocketServer as WebSocketServer2 } from "ws";
 import { readRegionData, resolveBaseLib, usesIsolatedContext } from "@open-wxa/wxa-runner-extractor";
 
 // src/project/AppBuilder.ts
@@ -1411,6 +1431,71 @@ async function handleProxy(req, res) {
   }
 }
 
+// src/server/socketProxy.ts
+import { WebSocket, WebSocketServer } from "ws";
+function mirrorClose(to, code, reason) {
+  if (code === 1005) to.close();
+  else if (code === 1006 || code === 1015) to.terminate();
+  else to.close(code, reason);
+}
+function createSocketProxy() {
+  const server = new WebSocketServer({
+    noServer: true,
+    // 不能让其他网站借本地开发服务器建立任意带凭据的连接。
+    verifyClient: ({ origin, req }) => origin === `http://${req.headers.host}`
+  });
+  server.on("connection", (client) => {
+    let upstream;
+    const timer = setTimeout(() => client.close(1008, "Missing socket request"), 1e4);
+    timer.unref();
+    client.on("error", () => void 0);
+    client.once("message", (data, binary) => {
+      clearTimeout(timer);
+      try {
+        if (binary || data.toString().length > 64 * 1024) throw new Error("Invalid socket request");
+        const { url, header: header2, protocols, timeout } = JSON.parse(data.toString());
+        const target = new URL(url);
+        if (!["ws:", "wss:"].includes(target.protocol) || target.username || target.password) throw new Error("Invalid socket URL");
+        upstream = new WebSocket(target, protocols || [], {
+          headers: header2 || {},
+          handshakeTimeout: typeof timeout === "number" && timeout > 0 ? timeout : 6e4
+        });
+      } catch {
+        client.close(1008, "Invalid socket request");
+        return;
+      }
+      const socket = upstream;
+      let header = {};
+      socket.on("upgrade", (response) => {
+        header = response.headers;
+      });
+      socket.on("open", () => {
+        if (client.readyState !== WebSocket.OPEN) {
+          socket.close();
+          return;
+        }
+        client.send(JSON.stringify({ ready: true, header }));
+      });
+      socket.on("message", (message, isBinary) => {
+        if (client.readyState === WebSocket.OPEN) client.send(message, { binary: isBinary });
+      });
+      client.on("message", (message, isBinary) => {
+        if (socket.readyState === WebSocket.OPEN) socket.send(message, { binary: isBinary });
+      });
+      socket.on("error", () => client.terminate());
+      socket.on("close", (code, reason) => {
+        if (client.readyState === WebSocket.OPEN) mirrorClose(client, code, reason);
+      });
+    });
+    client.on("close", (code, reason) => {
+      clearTimeout(timer);
+      if (upstream?.readyState === WebSocket.OPEN) mirrorClose(upstream, code, reason);
+      else if (upstream) upstream.terminate();
+    });
+  });
+  return server;
+}
+
 // src/server/hmr.ts
 var STYLE_FILE = /\.(wxss|less|scss|sass|css)$/;
 function planHotUpdate(files, units) {
@@ -1429,7 +1514,7 @@ function planHotUpdate(files, units) {
 import { execFile } from "child_process";
 import { randomUUID } from "crypto";
 import { setTimeout as sleep } from "timers/promises";
-import { WebSocket } from "ws";
+import { WebSocket as WebSocket2 } from "ws";
 import { findDeveloperTicket, findElectronDevtoolsCli, TICKET_ENV } from "@open-wxa/wxa-runner-extractor";
 var AUTO_PORT = 9420;
 var CLI_TIMEOUT = 6e4;
@@ -1520,7 +1605,7 @@ function cliErrorMessage(stdout) {
 function requestTicket(port) {
   return new Promise((resolve, reject) => {
     const id = `wxa-runner-${randomUUID()}`;
-    const socket = new WebSocket(`ws://127.0.0.1:${port}`);
+    const socket = new WebSocket2(`ws://127.0.0.1:${port}`);
     const settle = (finish) => {
       clearTimeout(timer);
       socket.removeAllListeners().on("error", () => void 0).terminate();
@@ -1906,6 +1991,7 @@ var DevServer = class {
   constructor(options) {
     this.options = options;
     this.server = null;
+    this.socketProxy = null;
     this.sockets = null;
     this.watcher = null;
     this.address = "";
@@ -1959,12 +2045,17 @@ var DevServer = class {
 ${error.message}`);
     }
     const server = http.createServer(this.app);
-    this.sockets = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
+    this.sockets = new WebSocketServer2({ noServer: true, maxPayload: 64 * 1024 });
     this.sockets.on("connection", (socket) => {
       socket.on("error", () => void 0);
       if (this.options.forwardConsole) printBrowserReports(socket, this.logger);
     });
+    this.socketProxy = createSocketProxy();
     server.on("upgrade", (req, socket, head) => {
+      if (req.url === "/__wxa__/socket") {
+        this.socketProxy.handleUpgrade(req, socket, head, (ws) => this.socketProxy.emit("connection", ws, req));
+        return;
+      }
       if (req.url?.startsWith("/__wxa__/ws")) {
         this.sockets.handleUpgrade(req, socket, head, (ws) => this.sockets.emit("connection", ws, req));
       } else {
@@ -1984,6 +2075,8 @@ ${error.message}`);
     await this.watcher?.close();
     this.sockets?.clients.forEach((client) => client.terminate());
     this.sockets?.close();
+    this.socketProxy?.clients.forEach((client) => client.terminate());
+    this.socketProxy?.close();
     const server = this.server;
     this.server = null;
     if (server) {
@@ -2014,6 +2107,7 @@ ${error.message}`);
         baseLibVersion: this.baseLib.version,
         device: this.device,
         devtoolsLogin: this.devtoolsLogin,
+        socketProxy: true,
         forwardConsole: this.options.forwardConsole ?? false,
         webViewWindow: this.options.webViewWindow ?? false
       };
@@ -2239,7 +2333,7 @@ ${message}`);
   broadcast(message) {
     const data = JSON.stringify(message);
     this.sockets?.clients.forEach((client) => {
-      if (client.readyState === WebSocket2.OPEN) client.send(data);
+      if (client.readyState === WebSocket3.OPEN) client.send(data);
     });
   }
 };