extension-develop 3.17.0 → 3.18.0

package/dist/0~dev-server.mjs

@@ -4,7 +4,9 @@ import { Writable } from "stream";
 import { rspack } from "@rspack/core";
 import { RspackDevServer } from "@rspack/dev-server";
 import { merge } from "webpack-merge";
+import { WebSocket, WebSocketServer } from "ws";
 import { createPlaywrightMetadataWriter, autoExitModeEnabled, autoExitForceKill, loadCommandConfig, extensionJsRunnerError, portInUse, devServerStartTimeout, autoExitTriggered, loadCustomConfig, loadBrowserConfig, sanitize, resolveCompanionExtensionsConfig, getSpecialFoldersDataForProjectRoot } from "./946.mjs";
+import { CONTROL_WS_PATH, clearControlToken, writeControlToken } from "./45.mjs";
 import { setupNoBrowserBannerOnFirstDone, webpackConfig, setupCompilerLifecycleHooks } from "./0~rspack-config.mjs";
 import * as __rspack_external_path from "path";
 import * as __rspack_external_crypto from "crypto";
@@ -47,65 +49,29 @@ function resolveInstanceIdOverride() {
 class PortManager {
     basePort;
     currentInstance = null;
-    constructor(_browser, _projectPath, basePort = 8080){
+    constructor(basePort = 8080){
         this.basePort = basePort;
     }
-    async allocatePorts(_browser, _projectPath, requestedPort) {
-        try {
-            const isValidRequested = 'number' == typeof requestedPort && requestedPort >= 0 && requestedPort < 65536;
-            const base = isValidRequested ? requestedPort : this.basePort;
-            const port = await findAvailablePortNear(base);
-            const webSocketPort = await findAvailablePortNear(port + 1);
-            const instanceId = resolveInstanceIdOverride() || __rspack_external_crypto.randomBytes(8).toString('hex');
-            this.currentInstance = {
-                instanceId,
-                port,
-                webSocketPort
-            };
-            return {
-                port,
-                webSocketPort,
-                instanceId
-            };
-        } catch (error) {
-            throw error;
-        }
+    async allocatePorts(requestedPort) {
+        const isValidRequested = 'number' == typeof requestedPort && requestedPort >= 0 && requestedPort < 65536;
+        const base = isValidRequested ? requestedPort : this.basePort;
+        const port = await findAvailablePortNear(base);
+        const instanceId = resolveInstanceIdOverride() || __rspack_external_crypto.randomBytes(8).toString('hex');
+        this.currentInstance = {
+            instanceId,
+            port
+        };
+        return {
+            port,
+            instanceId
+        };
     }
     getCurrentInstance() {
         return this.currentInstance;
     }
-    async updateExtensionId(extensionId) {
-        if (this.currentInstance) this.currentInstance.extensionId = extensionId;
-    }
     async terminateCurrentInstance() {
         this.currentInstance = null;
     }
-    getPortInfo(allocation) {
-        return `Port: ${allocation.port}, WebSocket: ${allocation.webSocketPort}, Instance: ${allocation.instanceId.slice(0, 8)}`;
-    }
-    async isPortInUse(port) {
-        return new Promise((resolve)=>{
-            const server = __rspack_external_net.createServer();
-            server.once('error', ()=>resolve(true));
-            server.once('listening', ()=>{
-                server.close(()=>resolve(false));
-            });
-            server.listen(port, '127.0.0.1');
-        });
-    }
-    async getRunningInstances() {
-        return this.currentInstance ? [
-            this.currentInstance
-        ] : [];
-    }
-    async getStats() {
-        return {
-            total: this.currentInstance ? 1 : 0,
-            running: this.currentInstance ? 1 : 0,
-            terminated: 0,
-            error: 0
-        };
-    }
 }
 function hasDependency(projectPath, dependency) {
     const findNearestPackageJsonDirectory = (startPath)=>{
@@ -207,9 +173,8 @@ function setupCleanupHandlers(devServer, portManager) {
         console.error('[Extension.js Runner] Uncaught exception.', error);
         await cleanup();
     });
-    process.on('unhandledRejection', async (reason, promise)=>{
+    process.on('unhandledRejection', (reason, promise)=>{
         console.error('[Extension.js Runner] Unhandled rejection.', promise, reason);
-        await cleanup();
     });
     const cancelAutoExit = setupAutoExit(process.env.EXTENSION_AUTO_EXIT_MS, process.env.EXTENSION_FORCE_KILL_MS, cleanup);
     const cancelAndCleanup = async ()=>{
@@ -218,12 +183,590 @@ function setupCleanupHandlers(devServer, portManager) {
         } catch  {}
         await cleanup();
     };
-    process.on('ERROR', cancelAndCleanup);
     process.on('SIGINT', cancelAndCleanup);
     process.on('SIGTERM', cancelAndCleanup);
     process.on('SIGHUP', cancelAndCleanup);
     return cancelAutoExit;
 }
+const DEFAULT_RING_CAPACITY = 5000;
+class LogRingBuffer {
+    capacity;
+    buf = [];
+    nextSeq = 1;
+    droppedSinceDrain = 0;
+    constructor(capacity = DEFAULT_RING_CAPACITY){
+        this.capacity = Math.max(1, Math.floor(capacity));
+    }
+    push(incoming) {
+        const event = {
+            ...incoming,
+            v: 1,
+            seq: this.nextSeq++
+        };
+        this.buf.push(event);
+        if (this.buf.length > this.capacity) {
+            this.buf.shift();
+            this.droppedSinceDrain++;
+        }
+        return event;
+    }
+    get size() {
+        return this.buf.length;
+    }
+    get bufferedFrom() {
+        return this.buf.length ? this.buf[0].seq : this.nextSeq;
+    }
+    get nextSequence() {
+        return this.nextSeq;
+    }
+    snapshot() {
+        return this.buf.slice();
+    }
+    since(seq) {
+        if (!Number.isFinite(seq)) return this.snapshot();
+        return this.buf.filter((e)=>e.seq > seq);
+    }
+    drainDropped() {
+        if (0 === this.droppedSinceDrain) return null;
+        const dropped = this.droppedSinceDrain;
+        this.droppedSinceDrain = 0;
+        return {
+            dropped,
+            reason: 'ring_overflow',
+            sinceSeq: this.bufferedFrom
+        };
+    }
+}
+const DEFAULTS = {
+    maxBytes: 8388608,
+    maxLines: 50000,
+    generations: 3,
+    flushIntervalMs: 250,
+    maxQueue: 20000
+};
+class LogsFileWriter {
+    opts;
+    queue = [];
+    bytes = 0;
+    lines = 0;
+    droppedToDisk = 0;
+    timer = null;
+    started = false;
+    constructor(options){
+        this.opts = {
+            ...DEFAULTS,
+            ...options
+        };
+    }
+    start() {
+        if (this.started) return;
+        this.started = true;
+        try {
+            __rspack_external_fs.mkdirSync(__rspack_external_path.dirname(this.opts.filePath), {
+                recursive: true
+            });
+            if (__rspack_external_fs.existsSync(this.opts.filePath)) this.rotate();
+        } catch  {}
+        this.writeHeader(null);
+        this.timer = setInterval(()=>this.flush(), this.opts.flushIntervalMs);
+        if (this.timer.unref) this.timer.unref();
+    }
+    write(event) {
+        this.enqueue(JSON.stringify(event));
+    }
+    enqueue(line) {
+        this.queue.push(line);
+        if (this.queue.length > this.opts.maxQueue) {
+            this.queue.shift();
+            this.droppedToDisk++;
+        }
+    }
+    flush() {
+        if (!this.started || 0 === this.queue.length) return void this.maybeNoteDrops();
+        const batch = this.queue;
+        this.queue = [];
+        const payload = batch.join('\n') + '\n';
+        try {
+            __rspack_external_fs.appendFileSync(this.opts.filePath, payload, 'utf-8');
+            this.bytes += Buffer.byteLength(payload);
+            this.lines += batch.length;
+        } catch  {
+            this.droppedToDisk += batch.length;
+        }
+        this.maybeNoteDrops();
+        if (this.bytes >= this.opts.maxBytes || this.lines >= this.opts.maxLines) {
+            this.rotate();
+            this.writeHeader(this.opts.runId);
+        }
+    }
+    close() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.flush();
+        this.started = false;
+    }
+    maybeNoteDrops() {
+        if (0 === this.droppedToDisk) return;
+        const dropped = this.droppedToDisk;
+        this.droppedToDisk = 0;
+        try {
+            const sentinel = JSON.stringify({
+                v: 1,
+                type: 'gap',
+                reason: 'disk_slow',
+                dropped
+            }) + '\n';
+            __rspack_external_fs.appendFileSync(this.opts.filePath, sentinel, 'utf-8');
+            this.bytes += Buffer.byteLength(sentinel);
+            this.lines += 1;
+        } catch  {}
+    }
+    writeHeader(rotatedFrom) {
+        const header = JSON.stringify({
+            v: 1,
+            type: 'header',
+            runId: this.opts.runId,
+            startedAt: new Date().toISOString(),
+            rotatedFrom
+        }) + '\n';
+        try {
+            __rspack_external_fs.writeFileSync(this.opts.filePath, header, 'utf-8');
+            this.bytes = Buffer.byteLength(header);
+            this.lines = 1;
+        } catch  {
+            this.bytes = 0;
+            this.lines = 0;
+        }
+    }
+    rotatedName(n) {
+        return this.opts.filePath.replace(/\.ndjson$/, `.${n}.ndjson`);
+    }
+    rotate() {
+        const { generations } = this.opts;
+        try {
+            const oldest = this.rotatedName(generations);
+            if (__rspack_external_fs.existsSync(oldest)) __rspack_external_fs.rmSync(oldest, {
+                force: true
+            });
+            for(let n = generations - 1; n >= 1; n--){
+                const from = this.rotatedName(n);
+                if (__rspack_external_fs.existsSync(from)) __rspack_external_fs.renameSync(from, this.rotatedName(n + 1));
+            }
+            if (__rspack_external_fs.existsSync(this.opts.filePath)) __rspack_external_fs.renameSync(this.opts.filePath, this.rotatedName(1));
+        } catch  {}
+    }
+}
+const actions_file_DEFAULTS = {
+    maxBytes: 8388608,
+    maxLines: 50000,
+    generations: 3
+};
+class ActionsFileWriter {
+    opts;
+    bytes = 0;
+    lines = 0;
+    started = false;
+    constructor(options){
+        this.opts = {
+            ...actions_file_DEFAULTS,
+            ...options
+        };
+    }
+    start() {
+        if (this.started) return;
+        this.started = true;
+        try {
+            __rspack_external_fs.mkdirSync(__rspack_external_path.dirname(this.opts.filePath), {
+                recursive: true
+            });
+            if (__rspack_external_fs.existsSync(this.opts.filePath)) this.rotate();
+        } catch  {}
+        this.bytes = 0;
+        this.lines = 0;
+    }
+    write(record) {
+        if (!this.started) this.start();
+        const line = JSON.stringify(record) + '\n';
+        try {
+            __rspack_external_fs.appendFileSync(this.opts.filePath, line, 'utf-8');
+            this.bytes += Buffer.byteLength(line);
+            this.lines += 1;
+        } catch  {
+            return;
+        }
+        if (this.bytes >= this.opts.maxBytes || this.lines >= this.opts.maxLines) {
+            this.rotate();
+            this.bytes = 0;
+            this.lines = 0;
+        }
+    }
+    close() {
+        this.started = false;
+    }
+    rotatedName(n) {
+        return this.opts.filePath.replace(/\.ndjson$/, `.${n}.ndjson`);
+    }
+    rotate() {
+        const { generations } = this.opts;
+        try {
+            const oldest = this.rotatedName(generations);
+            if (__rspack_external_fs.existsSync(oldest)) __rspack_external_fs.rmSync(oldest, {
+                force: true
+            });
+            for(let n = generations - 1; n >= 1; n--){
+                const from = this.rotatedName(n);
+                if (__rspack_external_fs.existsSync(from)) __rspack_external_fs.renameSync(from, this.rotatedName(n + 1));
+            }
+            if (__rspack_external_fs.existsSync(this.opts.filePath)) __rspack_external_fs.renameSync(this.opts.filePath, this.rotatedName(1));
+        } catch  {}
+    }
+}
+function fnv1aHex(input) {
+    let hash = 0x811c9dc5;
+    for(let i = 0; i < input.length; i++){
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+const CLOSE_BAD_INSTANCE = 4001;
+const CLOSE_BAD_HELLO = 4002;
+const CLOSE_CONTROL_UNAVAILABLE = 4003;
+const DEFAULT_CMD_TIMEOUT_MS = 5000;
+const MAX_CMD_TIMEOUT_MS = 30000;
+const CONTROL_OPS = new Set([
+    'eval',
+    'storage.get',
+    'storage.set',
+    'reload',
+    'open',
+    'tabs.query',
+    'inspect'
+]);
+class BridgeBroker {
+    instanceId;
+    runId;
+    engine;
+    ring;
+    file;
+    roles = new Map();
+    allowControl;
+    allowEval;
+    controlToken;
+    actions;
+    authorMode;
+    now;
+    setTimer;
+    clearTimer;
+    evalAllowed = new Map();
+    pending = new Map();
+    constructor(options){
+        this.instanceId = options.instanceId;
+        this.runId = options.runId;
+        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.controlToken = options.controlToken;
+        this.actions = options.actions;
+        this.authorMode = options.authorMode ?? false;
+        this.now = options.now ?? (()=>Date.now());
+        this.setTimer = options.setTimer ?? ((fn, ms)=>setTimeout(fn, ms));
+        this.clearTimer = options.clearTimer ?? ((h)=>clearTimeout(h));
+    }
+    get consumerCount() {
+        return this.countRole('consumer');
+    }
+    get producerCount() {
+        return this.countRole('producer');
+    }
+    get controllerCount() {
+        return this.countRole('controller');
+    }
+    get pendingCount() {
+        return this.pending.size;
+    }
+    onFrame(conn, frame) {
+        switch(frame.type){
+            case 'hello':
+                this.onHello(conn, frame);
+                return;
+            case 'log':
+                if ('producer' === this.roles.get(conn)) this.ingestLog(frame.event);
+                return;
+            case 'command':
+                if ('controller' === this.roles.get(conn)) this.onCommand(conn, frame);
+                return;
+            case 'result':
+                if ('producer' === this.roles.get(conn)) this.onResult(frame);
+                return;
+            default:
+                return;
+        }
+    }
+    onClose(conn) {
+        this.roles.delete(conn);
+        this.evalAllowed.delete(conn);
+        for (const [cmdId, p] of this.pending)if (p.controller === conn) {
+            this.clearTimer(p.timer);
+            this.pending.delete(cmdId);
+        }
+    }
+    ingestLog(incoming) {
+        const event = this.ring.push(incoming);
+        this.file?.write(event);
+        this.fanOut({
+            type: 'log',
+            event
+        });
+        const gap = this.ring.drainDropped();
+        if (gap) this.fanOut({
+            type: 'gap',
+            dropped: gap.dropped,
+            reason: gap.reason,
+            sinceSeq: gap.sinceSeq
+        });
+    }
+    onHello(conn, hello) {
+        if (1 !== hello.v) return void conn.close(CLOSE_BAD_HELLO, 'unsupported envelope version');
+        if (hello.instanceId !== this.instanceId) return void conn.close(CLOSE_BAD_INSTANCE, 'instanceId mismatch');
+        if ('controller' === hello.role) {
+            if (!this.allowControl) return void conn.close(CLOSE_CONTROL_UNAVAILABLE, 'control channel not available');
+            this.roles.set(conn, 'controller');
+            this.evalAllowed.set(conn, this.allowEval && !!hello.token && !!this.controlToken && hello.token === this.controlToken);
+            conn.send(this.controllerReady());
+            return;
+        }
+        if ('producer' !== hello.role && 'consumer' !== hello.role) return void conn.close(CLOSE_BAD_HELLO, 'unknown role');
+        this.roles.set(conn, hello.role);
+        if ('consumer' === hello.role) {
+            const ready = {
+                type: 'ready',
+                runId: this.runId,
+                bufferedFrom: this.ring.bufferedFrom,
+                engine: this.engine
+            };
+            conn.send(ready);
+            for (const event of this.ring.snapshot())conn.send({
+                type: 'log',
+                event
+            });
+        }
+    }
+    controllerReady() {
+        const isFirefox = 'firefox' === this.engine;
+        return {
+            type: 'ready',
+            runId: this.runId,
+            bufferedFrom: this.ring.bufferedFrom,
+            engine: this.engine,
+            capabilities: {
+                eval: this.allowEval,
+                storage: this.allowControl,
+                reload: this.allowControl,
+                open: this.allowControl ? isFirefox ? [
+                    'popup',
+                    'options'
+                ] : [
+                    'popup',
+                    'options',
+                    'sidebar'
+                ] : [],
+                deepDom: 'chromium' === this.engine
+            }
+        };
+    }
+    onCommand(controller, cmd) {
+        const principal = 'controller';
+        const isEval = 'eval' === cmd.op;
+        const exprHash = isEval && 'string' == typeof cmd.args?.expression ? fnv1aHex(cmd.args.expression) : void 0;
+        const expr = isEval && this.authorMode && 'string' == typeof cmd.args?.expression ? cmd.args.expression : void 0;
+        const deny = (name, message)=>{
+            const result = {
+                type: 'result',
+                cmdId: cmd.cmdId,
+                ok: false,
+                error: {
+                    name,
+                    message
+                }
+            };
+            controller.send(result);
+            this.audit({
+                cmdId: cmd.cmdId,
+                op: cmd.op,
+                target: cmd.target,
+                ok: false,
+                durationMs: 0,
+                principal,
+                exprHash,
+                expr,
+                errorName: name
+            });
+        };
+        if (!CONTROL_OPS.has(cmd.op)) return void deny('BadRequest', `unknown op: ${String(cmd.op)}`);
+        if (isEval && !this.evalAllowed.get(controller)) return void deny('Forbidden', 'eval requires --allow-eval and a valid session token in the hello');
+        const executor = this.firstExecutor();
+        if (!executor) return void deny('Unavailable', 'no executor connected (is the dev session running?)');
+        const timeoutMs = Math.min(Math.max(cmd.timeoutMs ?? DEFAULT_CMD_TIMEOUT_MS, 1), MAX_CMD_TIMEOUT_MS);
+        const timer = this.setTimer(()=>this.onTimeout(cmd.cmdId), timeoutMs);
+        this.pending.set(cmd.cmdId, {
+            controller,
+            op: cmd.op,
+            target: cmd.target,
+            issuedAt: this.now(),
+            timer,
+            principal,
+            exprHash,
+            expr
+        });
+        executor.send({
+            type: 'command',
+            cmdId: cmd.cmdId,
+            op: cmd.op,
+            target: cmd.target,
+            args: cmd.args,
+            timeoutMs
+        });
+    }
+    onResult(result) {
+        const p = this.pending.get(result.cmdId);
+        if (!p) return;
+        this.clearTimer(p.timer);
+        this.pending.delete(result.cmdId);
+        p.controller.send(result);
+        this.audit({
+            cmdId: result.cmdId,
+            op: p.op,
+            target: p.target,
+            ok: result.ok,
+            durationMs: result.durationMs ?? this.now() - p.issuedAt,
+            principal: p.principal,
+            exprHash: p.exprHash,
+            expr: p.expr,
+            errorName: result.ok ? void 0 : result.error?.name
+        });
+    }
+    onTimeout(cmdId) {
+        const p = this.pending.get(cmdId);
+        if (!p) return;
+        this.pending.delete(cmdId);
+        const result = {
+            type: 'result',
+            cmdId,
+            ok: false,
+            error: {
+                name: 'Timeout',
+                message: 'command timed out'
+            }
+        };
+        p.controller.send(result);
+        this.audit({
+            cmdId,
+            op: p.op,
+            target: p.target,
+            ok: false,
+            durationMs: this.now() - p.issuedAt,
+            principal: p.principal,
+            exprHash: p.exprHash,
+            expr: p.expr,
+            errorName: 'Timeout'
+        });
+    }
+    firstExecutor() {
+        for (const [conn, role] of this.roles)if ('producer' === role) return conn;
+        return null;
+    }
+    audit(record) {
+        if (!this.actions) return;
+        const line = {
+            v: 1,
+            ts: new Date(this.now()).toISOString(),
+            ...record
+        };
+        if (void 0 === line.exprHash) delete line.exprHash;
+        if (void 0 === line.expr) delete line.expr;
+        if (void 0 === line.errorName) delete line.errorName;
+        if (void 0 === line.durationMs) delete line.durationMs;
+        this.actions.write(line);
+    }
+    fanOut(frame) {
+        for (const [conn, role] of this.roles)if ('consumer' === role) try {
+            conn.send(frame);
+        } catch  {}
+    }
+    countRole(role) {
+        let n = 0;
+        for (const r of this.roles.values())if (r === role) n++;
+        return n;
+    }
+}
+const SLOW_CONSUMER_BYTES = 8388608;
+const CLOSE_SLOW_CONSUMER = 4008;
+let connSeq = 0;
+function startControlServer(options) {
+    const { broker } = options;
+    const host = options.host ?? '127.0.0.1';
+    const path = options.path ?? CONTROL_WS_PATH;
+    return new Promise((resolve, reject)=>{
+        const wss = new WebSocketServer({
+            host,
+            port: options.port ?? 0,
+            path
+        });
+        wss.on('error', reject);
+        wss.on('connection', (socket)=>{
+            const conn = {
+                id: `c${++connSeq}`,
+                send (frame) {
+                    if (socket.readyState !== WebSocket.OPEN) return;
+                    if (socket.bufferedAmount > SLOW_CONSUMER_BYTES) {
+                        try {
+                            socket.close(CLOSE_SLOW_CONSUMER, 'slow consumer');
+                        } catch  {}
+                        return;
+                    }
+                    try {
+                        socket.send(JSON.stringify(frame));
+                    } catch  {}
+                },
+                close (code, reason) {
+                    try {
+                        socket.close(code, reason);
+                    } catch  {}
+                }
+            };
+            socket.on('message', (data)=>{
+                let frame;
+                try {
+                    frame = JSON.parse(data.toString());
+                } catch  {
+                    return;
+                }
+                broker.onFrame(conn, frame);
+            });
+            socket.on('close', ()=>broker.onClose(conn));
+            socket.on('error', ()=>broker.onClose(conn));
+        });
+        wss.on('listening', ()=>{
+            const address = wss.address();
+            const port = 'object' == typeof address && address ? address.port : 0;
+            resolve({
+                port,
+                broker,
+                close: ()=>new Promise((res)=>{
+                        for (const client of wss.clients)try {
+                            client.terminate();
+                        } catch  {}
+                        wss.close(()=>res());
+                    })
+            });
+        });
+    });
+}
 function shouldWriteAssetToDisk(filePath) {
     return !/(?:^|[/\\])manifest\.json$/i.test(filePath);
 }
@@ -363,13 +906,12 @@ function installManifestDiskWriteGuard(manifestOutputPath) {
 async function dev_server_devServer(projectStructure, devOptions) {
     process.env.EXTENSION_BROWSER_LAUNCH_ENABLED = devOptions.noBrowser ? '0' : '1';
     const { manifestPath, packageJsonPath } = projectStructure;
-    __rspack_external_path.dirname(manifestPath);
     const packageJsonDir = __rspack_external_path.dirname(packageJsonPath);
     const commandConfig = await loadCommandConfig(packageJsonDir, 'dev');
     const browserConfig = await loadBrowserConfig(packageJsonDir, devOptions.browser);
-    const portManager = new PortManager(devOptions.browser, packageJsonDir, 8080);
+    const portManager = new PortManager(8080);
     const desiredPort = 'string' == typeof devOptions.port ? parseInt(devOptions.port, 10) : devOptions.port;
-    const portAllocation = await portManager.allocatePorts(devOptions.browser, packageJsonDir, desiredPort);
+    const portAllocation = await portManager.allocatePorts(desiredPort);
     const currentInstance = portManager.getCurrentInstance();
     if (!currentInstance) throw new Error('Failed to create instance');
     const port = portAllocation.port;
@@ -383,6 +925,56 @@ async function dev_server_devServer(projectStructure, devOptions) {
     process.env.EXTENSION_DEV_SERVER_HOST = devServerHost;
     process.env.EXTENSION_DEV_SERVER_PORT = String(port);
     process.env.EXTENSION_DEV_SERVER_PATH = '/ws';
+    const browserName = String(devOptions.browser || 'chromium');
+    const bridgeLogsRelPath = __rspack_external_path.join('dist', 'extension-js', browserName, 'logs.ndjson');
+    const bridgeLogFile = new LogsFileWriter({
+        filePath: __rspack_external_path.join(packageJsonDir, bridgeLogsRelPath),
+        runId: currentInstance.instanceId
+    });
+    const allowControl = Boolean(devOptions.allowControl);
+    const allowEval = Boolean(devOptions.allowEval);
+    const authorMode = Boolean(devOptions.authorMode) || 'development' === process.env.EXTENSION_AUTHOR_MODE;
+    const bridgeActionsFile = allowControl ? new ActionsFileWriter({
+        filePath: __rspack_external_path.join(packageJsonDir, 'dist', 'extension-js', browserName, 'actions.ndjson')
+    }) : void 0;
+    const bridgeControlToken = allowControl && allowEval ? writeControlToken(packageJsonDir) : void 0;
+    const bridgeBroker = new BridgeBroker({
+        instanceId: currentInstance.instanceId,
+        runId: currentInstance.instanceId,
+        engine: browserName.includes('firefox') || browserName.includes('gecko') ? 'firefox' : 'chromium',
+        ring: new LogRingBuffer(),
+        file: bridgeLogFile,
+        allowControl,
+        allowEval,
+        controlToken: bridgeControlToken,
+        actions: bridgeActionsFile,
+        authorMode
+    });
+    let bridgeControlPort = null;
+    try {
+        bridgeLogFile.start();
+        bridgeActionsFile?.start();
+        const controlServer = await startControlServer({
+            broker: bridgeBroker,
+            host: devServerHost
+        });
+        bridgeControlPort = controlServer.port;
+    } catch  {
+        try {
+            bridgeLogFile.close();
+        } catch  {}
+    }
+    process.env.EXTENSION_INSTANCE_ID = currentInstance.instanceId;
+    process.env.EXTENSION_CONTROL_PORT = null != bridgeControlPort ? String(bridgeControlPort) : '';
+    process.once('exit', ()=>{
+        try {
+            bridgeLogFile.close();
+        } catch  {}
+        try {
+            bridgeActionsFile?.close();
+        } catch  {}
+        if (bridgeControlToken) clearControlToken(packageJsonDir);
+    });
     const safeBrowserConfig = sanitize(browserConfig);
     const safeCommandConfig = sanitize(commandConfig);
     const safeDevOptions = sanitize(devOptions);
@@ -401,6 +993,9 @@ async function dev_server_devServer(projectStructure, devOptions) {
         browser: devOptions.browser,
         mode: 'development',
         instanceId: currentInstance.instanceId,
+        controlPort: bridgeControlPort,
+        controlPath: CONTROL_WS_PATH,
+        logsPath: bridgeLogsRelPath,
         port: portAllocation.port,
         output: {
             clean: false,
@@ -420,7 +1015,11 @@ async function dev_server_devServer(projectStructure, devOptions) {
         command: 'dev',
         distPath: __rspack_external_path.join(packageJsonDir, 'dist', String(devOptions.browser || 'chromium')),
         manifestPath,
-        port
+        port,
+        instanceId: currentInstance.instanceId,
+        controlPort: bridgeControlPort,
+        controlPath: CONTROL_WS_PATH,
+        logsPath: bridgeLogsRelPath
     });
     setupCompilerLifecycleHooks(compiler);
     if (devOptions.noBrowser) setupNoBrowserBannerOnFirstDone({
@@ -456,8 +1055,10 @@ async function dev_server_devServer(projectStructure, devOptions) {
                     __rspack_external_path.join(packageJsonDir, 'dist', '**/*')
                 ],
                 ignoreInitial: true,
-                usePolling: true,
-                interval: 1000
+                ...'true' === process.env.EXTENSION_WATCH_POLL ? {
+                    usePolling: true,
+                    interval: parseInt(String(process.env.EXTENSION_WATCH_POLL_INTERVAL || '1000'), 10)
+                } : {}
             }
         },
         client: false,