@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/dev/browser-logs/file-logger.js

@@ -86,6 +86,9 @@ class FileLogger {
     getLogQueue() {
         return this.logQueue;
     }
+    isEnabled() {
+        return this.mcpServerEnabled && this.isInitialized;
+    }
     flush() {
         if (this.logQueue.length === 0) {
             return;
@@ -127,10 +130,7 @@ class FileLogger {
     }
     log(source, level, message) {
         // Don't log anything if mcpServer is disabled
-        if (!this.mcpServerEnabled) {
-            return;
-        }
-        if (!this.isInitialized) {
+        if (!this.isEnabled()) {
             return;
         }
         const logEntry = {

package/dist/node_modules/next/dist/server/dev/browser-logs/receive-logs.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    handleClientFileLogs: null,
     handleLog: null,
     receiveBrowserLogsTurbopack: null,
     receiveBrowserLogsWebpack: null,
@@ -17,9 +16,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    handleClientFileLogs: function() {
-        return handleClientFileLogs;
-    },
     handleLog: function() {
         return handleLog;
     },
@@ -36,11 +32,11 @@ _export(exports, {
         return stripFormatSpecifiers;
     }
 });
+const _safestablestringify = require("next/dist/compiled/safe-stable-stringify");
 const _picocolors = require("../../../lib/picocolors");
 const _util = /*#__PURE__*/ _interop_require_default(require("util"));
 const _sourcemap = require("./source-map");
 const _forwardlogsshared = require("../../../next-devtools/shared/forward-logs-shared");
-const _console = require("../../../client/lib/console");
 const _filelogger = require("./file-logger");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -57,19 +53,6 @@ function restoreUndefined(x) {
     }
     return x;
 }
-function cleanConsoleArgsForFileLogging(args) {
-    /**
-   * Use formatConsoleArgs to strip out background and color format specifiers
-   * and keep only the original string content for file logging
-   */ try {
-        return (0, _console.formatConsoleArgs)(args);
-    } catch  {
-        // Fallback to simple string conversion if formatting fails
-        return args.map((arg)=>typeof arg === 'string' ? arg : _util.default.inspect(arg, {
-                depth: 2
-            })).join(' ');
-    }
-}
 const methods = [
     'log',
     'info',
@@ -103,7 +86,7 @@ const forwardConsole = {
                     })))
         ]))
 };
-async function deserializeArgData(arg) {
+function deserializeArgData(arg) {
     try {
         // we want undefined to be represented as it would be in the browser from the user's perspective (otherwise it would be stripped away/shown as null)
         if (arg === _forwardlogsshared.UNDEFINED_MARKER) {
@@ -204,18 +187,24 @@ function stripFormatSpecifiers(args) {
     }
     return result;
 }
-async function prepareFormattedErrorArgs(entry, ctx, distDir) {
-    const mapped = await (0, _sourcemap.getSourceMappedStackFrames)(entry.stack, ctx, distDir);
-    return [
-        colorError(mapped, {
-            prefix: entry.prefix
-        })
-    ];
+const safeStringify = (0, _safestablestringify.configure)({
+    maximumDepth: 5,
+    maximumBreadth: 100
+});
+function formatFileLogValue(arg) {
+    if (typeof arg === 'string') return arg;
+    if (typeof arg === 'number' || typeof arg === 'boolean') return String(arg);
+    if (arg === null) return 'null';
+    if (arg === undefined) return 'undefined';
+    return safeStringify(arg) ?? String(arg);
+}
+function formatConsoleArgsForFileLogging(args) {
+    return stripFormatSpecifiers(args).map(formatFileLogValue).join(' ');
 }
 async function prepareConsoleArgs(entry, ctx, distDir) {
     const deserialized = await Promise.all(entry.args.map(async (arg)=>{
         if (arg.kind === 'arg') {
-            const data = await deserializeArgData(arg.data);
+            const data = deserializeArgData(arg.data);
             if (entry.method === 'warn' && typeof data === 'string') {
                 return (0, _picocolors.yellow)(data);
             }
@@ -224,23 +213,36 @@ async function prepareConsoleArgs(entry, ctx, distDir) {
         if (!arg.stack) return (0, _picocolors.red)(arg.prefix);
         const mapped = await (0, _sourcemap.getSourceMappedStackFrames)(arg.stack, ctx, distDir);
         return colorError(mapped, {
-            prefix: arg.prefix,
-            applyColor: false
+            prefix: arg.prefix
         });
     }));
     return processConsoleFormatStrings(deserialized);
 }
 async function prepareConsoleErrorArgs(entry, ctx, distDir) {
-    const deserialized = await Promise.all(entry.args.map(async (arg)=>{
+    const pairs = await Promise.all(entry.args.map(async (arg)=>{
         if (arg.kind === 'arg') {
-            if (arg.isRejectionMessage) return (0, _picocolors.red)(arg.data);
-            return deserializeArgData(arg.data);
+            const data = deserializeArgData(arg.data);
+            return {
+                terminal: arg.isRejectionMessage ? (0, _picocolors.red)(arg.data) : data,
+                fileLog: data
+            };
+        }
+        if (!arg.stack) {
+            return {
+                terminal: (0, _picocolors.red)(arg.prefix),
+                fileLog: arg.prefix
+            };
         }
-        if (!arg.stack) return (0, _picocolors.red)(arg.prefix);
         const mapped = await (0, _sourcemap.getSourceMappedStackFrames)(arg.stack, ctx, distDir);
-        return colorError(mapped, {
-            prefix: arg.prefix
-        });
+        return {
+            terminal: colorError(mapped, {
+                prefix: arg.prefix
+            }),
+            fileLog: colorError(mapped, {
+                prefix: arg.prefix,
+                applyColor: false
+            })
+        };
     }));
     const mappedStack = await (0, _sourcemap.getSourceMappedStackFrames)(entry.consoleErrorStack, ctx, distDir);
     /**
@@ -248,21 +250,37 @@ async function prepareConsoleErrorArgs(entry, ctx, distDir) {
    * - it will look overwhelming to see 2 stacks and 2 code blocks
    * - the user already knows where the console.error is at because we append the location
    */ const location = (0, _sourcemap.getConsoleLocation)(mappedStack);
-    if (entry.args.some((a)=>a.kind === 'formatted-error-arg')) {
-        const result = stripFormatSpecifiers(deserialized);
+    const hasFormattedErrorArg = entry.args.some((a)=>a.kind === 'formatted-error-arg');
+    if (hasFormattedErrorArg) {
+        const terminal = stripFormatSpecifiers(pairs.map((p)=>p.terminal));
+        const fileLog = stripFormatSpecifiers(pairs.map((p)=>p.fileLog));
         if (location) {
-            result.push((0, _picocolors.dim)(`(${location})`));
+            terminal.push((0, _picocolors.dim)(`(${location})`));
+            fileLog.push(`(${location})`);
         }
-        return result;
+        return {
+            terminal,
+            fileLog
+        };
     }
-    const result = [
-        ...processConsoleFormatStrings(deserialized),
+    const terminal = [
+        ...processConsoleFormatStrings(pairs.map((p)=>p.terminal)),
         colorError(mappedStack)
     ];
+    const fileLog = [
+        ...processConsoleFormatStrings(pairs.map((p)=>p.fileLog)),
+        colorError(mappedStack, {
+            applyColor: false
+        })
+    ];
     if (location) {
-        result.push((0, _picocolors.dim)(`(${location})`));
+        terminal.push((0, _picocolors.dim)(`(${location})`));
+        fileLog.push(`(${location})`);
     }
-    return result;
+    return {
+        terminal,
+        fileLog
+    };
 }
 async function handleTable(entry, browserPrefix, ctx, distDir) {
     const deserializedArgs = await Promise.all(entry.args.map(async (arg)=>{
@@ -335,7 +353,7 @@ async function handleDir(entry, browserPrefix, ctx, distDir) {
     }
     consoleMethod(browserPrefix, ...loggableEntry);
 }
-async function handleDefaultConsole(entry, browserPrefix, ctx, distDir, config, isServerLog) {
+async function handleDefaultConsole(entry, browserPrefix, ctx, distDir, config) {
     const consoleArgs = await prepareConsoleArgs(entry, ctx, distDir);
     const withStackEntry = await (0, _sourcemap.withLocation)({
         original: consoleArgs,
@@ -343,16 +361,6 @@ async function handleDefaultConsole(entry, browserPrefix, ctx, distDir, config,
     }, ctx, distDir, config);
     const consoleMethod = forwardConsole[entry.method] || forwardConsole.log;
     consoleMethod(browserPrefix, ...withStackEntry);
-    // Process enqueued logs and write to file
-    // Log to file with correct source based on context
-    const fileLogger = (0, _filelogger.getFileLogger)();
-    // Use cleaned console args to strip out background and color format specifiers
-    const message = cleanConsoleArgsForFileLogging(consoleArgs);
-    if (isServerLog) {
-        fileLogger.logServer(entry.method.toUpperCase(), message);
-    } else {
-        fileLogger.logBrowser(entry.method.toUpperCase(), message);
-    }
 }
 // Log levels from most severe to least severe
 // Lower index = more severe
@@ -396,16 +404,38 @@ function shouldShowEntry(entry, config) {
     }
     return false;
 }
+function deserializeForFileLog(a) {
+    if (a.kind === 'arg') {
+        return deserializeArgData(a.data);
+    }
+    // formatted-error-arg
+    return a.prefix ?? '';
+}
 async function handleLog(entries, ctx, distDir, config) {
     // Determine the source based on the context
     const isServerLog = ctx.isServer || ctx.isEdgeServer;
     const browserPrefix = isServerLog ? (0, _picocolors.cyan)('[server]') : (0, _picocolors.cyan)('[browser]');
     const fileLogger = (0, _filelogger.getFileLogger)();
+    const shouldWriteFileLogs = fileLogger.isEnabled();
     for (const entry of entries){
-        // Filter entries based on config mode
-        if (!shouldShowEntry(entry, config)) {
+        const shouldShow = shouldShowEntry(entry, config);
+        if (!shouldWriteFileLogs && !shouldShow) {
             continue;
         }
+        // Console entries: write file log from raw args (no source mapping needed)
+        if (shouldWriteFileLogs && entry.kind === 'console') {
+            try {
+                const message = formatConsoleArgsForFileLogging(entry.args.map(deserializeForFileLog));
+                if (isServerLog) {
+                    fileLogger.logServer(entry.method.toUpperCase(), message);
+                } else {
+                    fileLogger.logBrowser(entry.method.toUpperCase(), message);
+                }
+            } catch  {
+            // noop
+            }
+        }
+        if (!shouldShow && entry.kind === 'console') continue;
         try {
             switch(entry.kind){
                 case 'console':
@@ -451,7 +481,7 @@ async function handleLog(entries, ctx, distDir, config) {
                             case 'error':
                             case 'warn':
                                 {
-                                    await handleDefaultConsole(entry, browserPrefix, ctx, distDir, config, isServerLog);
+                                    await handleDefaultConsole(entry, browserPrefix, ctx, distDir, config);
                                     break;
                                 }
                             default:
@@ -464,54 +494,82 @@ async function handleLog(entries, ctx, distDir, config) {
                 // any logged errors are anything that are logged as "red" in the browser but aren't only an Error (console.error, Promise.reject(100))
                 case 'any-logged-error':
                     {
-                        const consoleArgs = await prepareConsoleErrorArgs(entry, ctx, distDir);
-                        forwardConsole.error(browserPrefix, ...consoleArgs);
-                        // Process enqueued logs and write to file
-                        fileLogger.logBrowser('ERROR', cleanConsoleArgsForFileLogging(consoleArgs));
+                        const { terminal, fileLog } = await prepareConsoleErrorArgs(entry, ctx, distDir);
+                        if (shouldWriteFileLogs) {
+                            const message = formatConsoleArgsForFileLogging(fileLog);
+                            if (isServerLog) {
+                                fileLogger.logServer('ERROR', message);
+                            } else {
+                                fileLogger.logBrowser('ERROR', message);
+                            }
+                        }
+                        if (shouldShow) {
+                            forwardConsole.error(browserPrefix, ...terminal);
+                        }
                         break;
                     }
                 // formatted error is an explicit error event (rejections, uncaught errors)
                 case 'formatted-error':
                     {
-                        const formattedArgs = await prepareFormattedErrorArgs(entry, ctx, distDir);
-                        forwardConsole.error(browserPrefix, ...formattedArgs);
-                        // Process enqueued logs and write to file
-                        fileLogger.logBrowser('ERROR', cleanConsoleArgsForFileLogging(formattedArgs));
+                        const mapped = await (0, _sourcemap.getSourceMappedStackFrames)(entry.stack, ctx, distDir);
+                        if (shouldWriteFileLogs) {
+                            const message = colorError(mapped, {
+                                prefix: entry.prefix,
+                                applyColor: false
+                            }) || '';
+                            if (isServerLog) {
+                                fileLogger.logServer('ERROR', message);
+                            } else {
+                                fileLogger.logBrowser('ERROR', message);
+                            }
+                        }
+                        if (shouldShow) {
+                            forwardConsole.error(browserPrefix, colorError(mapped, {
+                                prefix: entry.prefix
+                            }));
+                        }
                         break;
                     }
                 default:
                     {}
             }
         } catch  {
-            switch(entry.kind){
-                case 'any-logged-error':
-                    {
-                        const consoleArgs = await prepareConsoleErrorArgs(entry, ctx, distDir);
-                        forwardConsole.error(browserPrefix, ...consoleArgs);
-                        // Process enqueued logs and write to file
-                        fileLogger.logBrowser('ERROR', cleanConsoleArgsForFileLogging(consoleArgs));
-                        break;
+            // Source mapping failed — write best-effort message-only file log for errors
+            if (shouldWriteFileLogs && entry.kind !== 'console') {
+                try {
+                    const message = entry.kind === 'formatted-error' ? entry.prefix : formatConsoleArgsForFileLogging(entry.args.map(deserializeForFileLog));
+                    if (isServerLog) {
+                        fileLogger.logServer('ERROR', message);
+                    } else {
+                        fileLogger.logBrowser('ERROR', message);
                     }
-                case 'console':
-                    {
-                        const consoleMethod = forwardConsole[entry.method] || forwardConsole.log;
-                        const consoleArgs = await prepareConsoleArgs(entry, ctx, distDir);
-                        consoleMethod(browserPrefix, ...consoleArgs);
-                        // Process enqueued logs and write to file
-                        fileLogger.logBrowser('ERROR', cleanConsoleArgsForFileLogging(consoleArgs));
-                        break;
-                    }
-                case 'formatted-error':
-                    {
-                        forwardConsole.error(browserPrefix, `${entry.prefix}\n`, entry.stack);
-                        // Process enqueued logs and write to file
-                        fileLogger.logBrowser('ERROR', cleanConsoleArgsForFileLogging([
-                            `${entry.prefix}\n${entry.stack}`
-                        ]));
-                        break;
-                    }
-                default:
-                    {}
+                } catch  {
+                // noop
+                }
+            }
+            if (shouldShow) {
+                switch(entry.kind){
+                    case 'any-logged-error':
+                        {
+                            const { terminal } = await prepareConsoleErrorArgs(entry, ctx, distDir);
+                            forwardConsole.error(browserPrefix, ...terminal);
+                            break;
+                        }
+                    case 'console':
+                        {
+                            const consoleMethod = forwardConsole[entry.method] || forwardConsole.log;
+                            const consoleArgs = await prepareConsoleArgs(entry, ctx, distDir);
+                            consoleMethod(browserPrefix, ...consoleArgs);
+                            break;
+                        }
+                    case 'formatted-error':
+                        {
+                            forwardConsole.error(browserPrefix, `${entry.prefix}\n`, entry.stack);
+                            break;
+                        }
+                    default:
+                        {}
+                }
             }
         }
     }
@@ -548,11 +606,5 @@ async function receiveBrowserLogsTurbopack(opts) {
     };
     await handleLog(entries, ctx, distDir, opts.config);
 }
-async function handleClientFileLogs(logs) {
-    const fileLogger = (0, _filelogger.getFileLogger)();
-    for (const log of logs){
-        fileLogger.logBrowser(log.level, log.message);
-    }
-}
 
 //# sourceMappingURL=receive-logs.js.map

package/dist/node_modules/next/dist/server/dev/debug-channel.js

@@ -29,14 +29,19 @@ _export(exports, {
     }
 });
 const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
+const _nodebufferedtransformstream = require("../stream-utils/node-buffered-transform-stream");
 const _hotreloadertypes = require("./hot-reloader-types");
+// Chunks are sent to the browser in batches to reduce overhead, flushing
+// synchronously once this many bytes have accumulated.
+const MAX_DEBUG_CHANNEL_BATCH_BYTES = 128 * 1024;
 const reactDebugChannelsByHtmlRequestId = new Map();
 function connectReactDebugChannel(requestId, debugChannel, sendToClient) {
-    const reader = debugChannel.readable.pipeThrough(// We're sending the chunks in batches to reduce overhead in the browser.
-    (0, _nodewebstreamshelper.createBufferedTransformStream)({
-        maxBufferByteLength: 128 * 1024
-    })).getReader();
+    let finished = false;
     const stop = ()=>{
+        if (finished) {
+            return;
+        }
+        finished = true;
         sendToClient({
             type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK,
             requestId,
@@ -44,28 +49,48 @@ function connectReactDebugChannel(requestId, debugChannel, sendToClient) {
         });
     };
     const onError = (err)=>{
-        console.error(Object.defineProperty(new Error('React debug channel stream error', {
-            cause: err
-        }), "__NEXT_ERROR_CODE", {
-            value: "E810",
-            enumerable: false,
-            configurable: true
-        }));
+        if (!finished) {
+            console.error(Object.defineProperty(new Error('React debug channel stream error', {
+                cause: err
+            }), "__NEXT_ERROR_CODE", {
+                value: "E810",
+                enumerable: false,
+                configurable: true
+            }));
+        }
         stop();
     };
-    const progress = (entry)=>{
-        if (entry.done) {
-            stop();
-        } else {
-            sendToClient({
-                type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK,
-                requestId,
-                chunk: entry.value
-            });
-            reader.read().then(progress, onError);
-        }
+    const sendChunk = (chunk)=>{
+        sendToClient({
+            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK,
+            requestId,
+            chunk
+        });
     };
-    reader.read().then(progress, onError);
+    const { readable } = debugChannel;
+    if (readable instanceof ReadableStream) {
+        const reader = readable.pipeThrough((0, _nodewebstreamshelper.createBufferedTransformStream)({
+            maxBufferByteLength: MAX_DEBUG_CHANNEL_BATCH_BYTES
+        })).getReader();
+        const progress = (entry)=>{
+            if (entry.done) {
+                stop();
+            } else {
+                sendChunk(entry.value);
+                reader.read().then(progress, onError);
+            }
+        };
+        reader.read().then(progress, onError);
+    } else {
+        const source = readable;
+        // `pipe` does not forward source errors to the destination, so handle them
+        // on the source directly.
+        source.on('error', onError);
+        const batched = source.pipe((0, _nodebufferedtransformstream.createNodeBufferedTransformStream)(MAX_DEBUG_CHANNEL_BATCH_BYTES));
+        batched.on('data', sendChunk);
+        batched.on('end', stop);
+        batched.on('error', onError);
+    }
 }
 function connectReactDebugChannelForHtmlRequest(htmlRequestId, sendToClient) {
     const debugChannel = reactDebugChannelsByHtmlRequestId.get(htmlRequestId);