extension-develop 4.0.27 → 4.0.29-next.0

package/dist/0~dev-server.mjs

@@ -13,6 +13,7 @@ import { hasProjectDependency, findNearestProjectManifestDirSync } from "./80.mj
 import { setupNoBrowserBannerOnFirstDone, webpackConfig, resolveConnectableHost, setupCompilerLifecycleHooks } from "./0~rspack-config.mjs";
 import { ensureSessionStateInProjectGitignore, logsPath, actionsPath, controlPortFilePath, legacyControlPortFilePath, ensureSessionArtifactsIgnoreFile } from "./494.mjs";
 import { isDebug } from "./349.mjs";
+import * as __rspack_external_node_os_74b4b876 from "node:os";
 import * as __rspack_external_node_path_c5b9b54f from "node:path";
 import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
 import * as __rspack_external_node_crypto_9ba42079 from "node:crypto";
@@ -285,8 +286,8 @@ class BridgeBroker {
         this.engine = options.engine;
         this.ring = options.ring ?? new LogRingBuffer();
         this.file = options.file;
-        this.allowControl = options.allowControl ?? false;
         this.allowEval = options.allowEval ?? false;
+        this.allowControl = (options.allowControl ?? false) || this.allowEval;
         this.controlToken = options.controlToken;
         this.actions = options.actions;
         this.authorMode = options.authorMode ?? false;
@@ -907,18 +908,35 @@ function createDiscardWriteStream() {
     });
     return stream;
 }
-const guardedManifestDiskWritePaths = new Set();
+const guardedManifestDiskWritePaths = new Map();
 let isManifestDiskWriteGuardInstalled = false;
+let restoreManifestDiskWriteGuardPatches = null;
 function hasGuardedManifestDiskPath(filePath) {
     if ('string' != typeof filePath) return false;
     const resolvedPath = __rspack_external_node_path_c5b9b54f.resolve(filePath);
-    for (const guardedPath of guardedManifestDiskWritePaths)if (isSamePath(guardedPath, resolvedPath)) return true;
+    for (const guardedPath of guardedManifestDiskWritePaths.keys())if (isSamePath(guardedPath, resolvedPath)) return true;
     return false;
 }
 function suppressManifestOutputWrites(compiler, manifestOutputPath) {
     const outputFileSystem = compiler?.outputFileSystem;
-    if (!outputFileSystem || outputFileSystem.__extensionjsManifestWriteGuard) return;
-    const isManifestPath = (filePath)=>'string' == typeof filePath && isSamePath(filePath, manifestOutputPath);
+    if (!outputFileSystem) return ()=>{};
+    const resolvedManifestPath = __rspack_external_node_path_c5b9b54f.resolve(manifestOutputPath);
+    const alreadyGuardedPaths = outputFileSystem.__extensionjsGuardedManifestPaths;
+    if (alreadyGuardedPaths) {
+        alreadyGuardedPaths.add(resolvedManifestPath);
+        return ()=>{
+            alreadyGuardedPaths.delete(resolvedManifestPath);
+        };
+    }
+    const guardedPaths = new Set([
+        resolvedManifestPath
+    ]);
+    outputFileSystem.__extensionjsGuardedManifestPaths = guardedPaths;
+    const isManifestPath = (filePath)=>{
+        if ('string' != typeof filePath) return false;
+        for (const guardedPath of guardedPaths)if (isSamePath(guardedPath, filePath)) return true;
+        return false;
+    };
     if ('function' == typeof outputFileSystem.writeFile) {
         const originalWriteFile = outputFileSystem.writeFile.bind(outputFileSystem);
         outputFileSystem.writeFile = (filePath, ...args)=>{
@@ -955,12 +973,27 @@ function suppressManifestOutputWrites(compiler, manifestOutputPath) {
             return originalPromiseWriteFile(filePath, ...args);
         };
     }
-    outputFileSystem.__extensionjsManifestWriteGuard = true;
+    return ()=>{
+        guardedPaths.delete(resolvedManifestPath);
+    };
 }
 function installManifestDiskWriteGuard(manifestOutputPath) {
     const guardKey = __rspack_external_node_path_c5b9b54f.resolve(manifestOutputPath);
-    guardedManifestDiskWritePaths.add(guardKey);
-    if (isManifestDiskWriteGuardInstalled) return;
+    guardedManifestDiskWritePaths.set(guardKey, (guardedManifestDiskWritePaths.get(guardKey) || 0) + 1);
+    let uninstalled = false;
+    const uninstall = ()=>{
+        if (uninstalled) return;
+        uninstalled = true;
+        const count = guardedManifestDiskWritePaths.get(guardKey) || 0;
+        if (count <= 1) guardedManifestDiskWritePaths.delete(guardKey);
+        else guardedManifestDiskWritePaths.set(guardKey, count - 1);
+        if (0 === guardedManifestDiskWritePaths.size && restoreManifestDiskWriteGuardPatches) {
+            restoreManifestDiskWriteGuardPatches();
+            restoreManifestDiskWriteGuardPatches = null;
+            isManifestDiskWriteGuardInstalled = false;
+        }
+    };
+    if (isManifestDiskWriteGuardInstalled) return uninstall;
     const guardedFs = node_fs;
     const isManifestPath = (filePath)=>hasGuardedManifestDiskPath(filePath);
     const allowManifestRename = (fromPath, toPath)=>'string' == typeof fromPath && 'string' == typeof toPath && isManifestPath(toPath) && isManifestTempPath(fromPath);
@@ -987,14 +1020,20 @@ function installManifestDiskWriteGuard(manifestOutputPath) {
         }
         return originalCreateWriteStream(filePath, ...args);
     };
+    const writeIntentFlagMask = node_fs.constants.O_WRONLY | node_fs.constants.O_RDWR | node_fs.constants.O_APPEND | node_fs.constants.O_CREAT | node_fs.constants.O_TRUNC;
+    const isWriteIntentOpen = (flags)=>{
+        if ('string' == typeof flags) return /[wa+]/.test(flags);
+        if ('number' == typeof flags) return (flags & writeIntentFlagMask) !== 0;
+        return false;
+    };
     const originalOpen = guardedFs.open.bind(guardedFs);
     guardedFs.open = (pathLike, flags, ...args)=>{
-        const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+        const nextPath = isManifestPath(pathLike) && isWriteIntentOpen(flags) ? __rspack_external_node_os_74b4b876.devNull : pathLike;
         return originalOpen(nextPath, flags, ...args);
     };
     const originalOpenSync = guardedFs.openSync.bind(guardedFs);
     guardedFs.openSync = (pathLike, flags, ...args)=>{
-        const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+        const nextPath = isManifestPath(pathLike) && isWriteIntentOpen(flags) ? __rspack_external_node_os_74b4b876.devNull : pathLike;
         return originalOpenSync(nextPath, flags, ...args);
     };
     const originalRename = guardedFs.rename.bind(guardedFs);
@@ -1010,14 +1049,26 @@ function installManifestDiskWriteGuard(manifestOutputPath) {
         if (isManifestPath(newPath) && !allowManifestRename(oldPath, newPath)) return;
         return originalRenameSync(oldPath, newPath);
     };
+    let originalPromiseWriteFile;
     if (guardedFs.promises?.writeFile) {
-        const originalPromiseWriteFile = guardedFs.promises.writeFile.bind(guardedFs.promises);
+        originalPromiseWriteFile = guardedFs.promises.writeFile.bind(guardedFs.promises);
         guardedFs.promises.writeFile = async (filePath, ...args)=>{
             if (isManifestPath(filePath)) return;
             return originalPromiseWriteFile(filePath, ...args);
         };
     }
+    restoreManifestDiskWriteGuardPatches = ()=>{
+        guardedFs.writeFile = originalWriteFile;
+        guardedFs.writeFileSync = originalWriteFileSync;
+        guardedFs.createWriteStream = originalCreateWriteStream;
+        guardedFs.open = originalOpen;
+        guardedFs.openSync = originalOpenSync;
+        guardedFs.rename = originalRename;
+        guardedFs.renameSync = originalRenameSync;
+        if (originalPromiseWriteFile) guardedFs.promises.writeFile = originalPromiseWriteFile;
+    };
     isManifestDiskWriteGuardInstalled = true;
+    return uninstall;
 }
 async function dev_server_devServer(projectStructure, devOptions) {
     const extendedOptions = devOptions;
@@ -1056,8 +1107,8 @@ async function dev_server_devServer(projectStructure, devOptions) {
         filePath: bridgeLogsAbsPath,
         runId: sessionRunId
     });
-    const allowControl = Boolean(extendedOptions.allowControl);
     const allowEval = Boolean(extendedOptions.allowEval);
+    const allowControl = Boolean(extendedOptions.allowControl) || allowEval;
     const authorMode = Boolean(extendedOptions.authorMode) || isDebug();
     const bridgeActionsFile = allowControl ? new ActionsFileWriter({
         filePath: actionsPath(packageJsonDir, browserName)
@@ -1174,8 +1225,8 @@ async function dev_server_devServer(projectStructure, devOptions) {
     const compilerConfig = merge(finalConfig, {});
     const compiler = rspack(compilerConfig);
     const manifestOutputPath = __rspack_external_node_path_c5b9b54f.join(primaryDistPath, 'manifest.json');
-    installManifestDiskWriteGuard(manifestOutputPath);
-    suppressManifestOutputWrites(compiler, manifestOutputPath);
+    const uninstallManifestGuard = installManifestDiskWriteGuard(manifestOutputPath);
+    const releaseOutputFsGuard = suppressManifestOutputWrites(compiler, manifestOutputPath);
     if (!extendedOptions.browsersPlugin && compiler?.hooks?.watchRun) {
         const changedSources = createChangedSourcesTracker(compiler);
         let isFirstBridgeCompile = true;
@@ -1278,6 +1329,17 @@ async function dev_server_devServer(projectStructure, devOptions) {
         liveReload: true
     };
     const devServer = new RspackDevServer(serverConfig, compiler);
+    if ('function' == typeof devServer.stop) {
+        const originalDevServerStop = devServer.stop.bind(devServer);
+        devServer.stop = async ()=>{
+            try {
+                await originalDevServerStop();
+            } finally{
+                uninstallManifestGuard();
+                releaseOutputFsGuard();
+            }
+        };
+    }
     const START_TIMEOUT_MS = parseInt(String(process.env.EXTENSION_START_TIMEOUT_MS || '30000'), 10);
     let startTimeout;
     try {