@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/server/mcp/tools/get-routes.js

@@ -0,0 +1,171 @@
+/**
+ * MCP tool for getting all routes that become entry points in a Next.js application.
+ *
+ * This tool discovers routes by scanning the filesystem directly. It finds all route
+ * files in the app/ and pages/ directories and converts them to route paths.
+ *
+ * Returns routes grouped by router type:
+ * - appRouter: App Router pages and route handlers
+ * - pagesRouter: Pages Router pages and API routes
+ *
+ * Dynamic route segments appear as [id], [slug], or [...slug] patterns. This tool
+ * does NOT expand getStaticParams - it only shows the route patterns as defined in
+ * the filesystem.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetRoutesTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetRoutesTool;
+    }
+});
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+const _entries = require("../../../build/entries");
+const _findpagefile = require("../../lib/find-page-file");
+const _pagetypes = require("../../../lib/page-types");
+const _zod = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/zod"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function registerGetRoutesTool(server, options) {
+    server.registerTool('get_routes', {
+        description: 'Get all routes that will become entry points in the Next.js application by scanning the filesystem. Returns routes grouped by router type (appRouter, pagesRouter). Dynamic segments appear as [param] or [...slug] patterns. API routes are included in their respective routers (e.g., /api/* routes from pages/ are in pagesRouter). Optional parameter: routerType ("app" | "pages") - filter by specific router type, omit to get all routes.',
+        inputSchema: {
+            routerType: _zod.default.union([
+                _zod.default.literal('app'),
+                _zod.default.literal('pages')
+            ]).optional()
+        }
+    }, async (request)=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_routes');
+        try {
+            const routerType = request.routerType === 'app' || request.routerType === 'pages' ? request.routerType : undefined;
+            const routes = [];
+            const { projectPath, nextConfig, pagesDir, appDir } = options;
+            // Check if we have any directories to scan
+            if (!pagesDir && !appDir) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No pages or app directory found in the project.'
+                        }
+                    ]
+                };
+            }
+            const isSrcDir = pagesDir && pagesDir.includes('/src/') || appDir && appDir.includes('/src/');
+            // Create valid file matcher for filtering
+            const validFileMatcher = (0, _findpagefile.createValidFileMatcher)(nextConfig.pageExtensions, appDir);
+            // Collect and process App Router routes if requested
+            if (appDir && (!routerType || routerType === 'app')) {
+                try {
+                    const { appPaths } = await (0, _entries.collectAppFiles)(appDir, validFileMatcher);
+                    if (appPaths.length > 0) {
+                        const mappedAppPages = await (0, _entries.createPagesMapping)({
+                            pagePaths: appPaths,
+                            isDev: true,
+                            pagesType: _pagetypes.PAGE_TYPES.APP,
+                            pageExtensions: nextConfig.pageExtensions,
+                            pagesDir,
+                            appDir,
+                            appDirOnly: pagesDir ? false : true
+                        });
+                        const { appRoutes, appRouteHandlers } = (0, _entries.processAppRoutes)(mappedAppPages, validFileMatcher, projectPath, isSrcDir || false);
+                        // Add app page routes
+                        for (const { route } of appRoutes){
+                            routes.push({
+                                route,
+                                type: 'app'
+                            });
+                        }
+                        // Add app route handlers
+                        for (const { route } of appRouteHandlers){
+                            routes.push({
+                                route,
+                                type: 'app'
+                            });
+                        }
+                    }
+                } catch (error) {
+                // Error collecting app routes - continue anyway
+                }
+            }
+            // Collect and process Pages Router routes if requested
+            if (pagesDir && (!routerType || routerType === 'pages')) {
+                try {
+                    const pagePaths = await (0, _entries.collectPagesFiles)(pagesDir, validFileMatcher);
+                    if (pagePaths.length > 0) {
+                        const mappedPages = await (0, _entries.createPagesMapping)({
+                            pagePaths,
+                            isDev: true,
+                            pagesType: _pagetypes.PAGE_TYPES.PAGES,
+                            pageExtensions: nextConfig.pageExtensions,
+                            pagesDir,
+                            appDir,
+                            appDirOnly: false
+                        });
+                        const { pageRoutes, pageApiRoutes } = (0, _entries.processPageRoutes)(mappedPages, projectPath, isSrcDir || false);
+                        // Add page routes
+                        for (const { route } of pageRoutes){
+                            routes.push({
+                                route,
+                                type: 'page'
+                            });
+                        }
+                        // Add API routes (always included as part of pages router)
+                        for (const { route } of pageApiRoutes){
+                            routes.push({
+                                route,
+                                type: 'api'
+                            });
+                        }
+                    }
+                } catch (error) {
+                // Error collecting pages routes - continue anyway
+                }
+            }
+            if (routes.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No routes found in the project.'
+                        }
+                    ]
+                };
+            }
+            // Group routes by router type
+            const appRoutes = routes.filter((r)=>r.type === 'app').map((r)=>r.route).sort();
+            const pageRoutes = routes.filter((r)=>r.type === 'page' || r.type === 'api').map((r)=>r.route).sort();
+            // Format the output with grouped routes
+            const output = {
+                appRouter: appRoutes.length > 0 ? appRoutes : undefined,
+                pagesRouter: pageRoutes.length > 0 ? pageRoutes : undefined
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(output, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=get-routes.js.map

package/webapp-dist/vendor/next/dist/server/mcp/tools/get-server-action-by-id.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetActionByIdTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetActionByIdTool;
+    }
+});
+const _zod = require("next/dist/compiled/zod");
+const _fs = require("fs");
+const _path = require("path");
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+const INLINE_ACTION_PREFIX = '$$RSC_SERVER_ACTION_';
+function registerGetActionByIdTool(server, distDir) {
+    server.registerTool('get_server_action_by_id', {
+        description: 'Locates a Server Action by its ID in the server-reference-manifest.json. Returns the filename and export name for the action.',
+        inputSchema: {
+            actionId: _zod.z.string()
+        }
+    }, async (request)=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_server_action_by_id');
+        try {
+            const { actionId } = request;
+            if (!actionId) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Error: actionId parameter is required'
+                        }
+                    ]
+                };
+            }
+            const manifestPath = (0, _path.join)(distDir, 'server', 'server-reference-manifest.json');
+            let manifestContent;
+            try {
+                manifestContent = await _fs.promises.readFile(manifestPath, 'utf-8');
+            } catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: Could not read server-reference-manifest.json at ${manifestPath}.`
+                        }
+                    ]
+                };
+            }
+            const manifest = JSON.parse(manifestContent);
+            // Search in node entries
+            if (manifest.node && manifest.node[actionId]) {
+                const entry = manifest.node[actionId];
+                const isInlineAction = entry.exportedName.startsWith(INLINE_ACTION_PREFIX);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                actionId,
+                                runtime: 'node',
+                                filename: entry.filename,
+                                functionName: isInlineAction ? 'inline server action' : entry.exportedName,
+                                layer: entry.layer,
+                                workers: entry.workers
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            // Search in edge entries
+            if (manifest.edge && manifest.edge[actionId]) {
+                const entry = manifest.edge[actionId];
+                const isInlineAction = entry.exportedName.startsWith(INLINE_ACTION_PREFIX);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                actionId,
+                                runtime: 'edge',
+                                filename: entry.filename,
+                                functionName: isInlineAction ? 'inline server action' : entry.exportedName,
+                                layer: entry.layer,
+                                workers: entry.workers
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: Action ID "${actionId}" not found in server-reference-manifest.json`
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=get-server-action-by-id.js.map

package/webapp-dist/vendor/next/dist/server/mcp/tools/next-instance-error-state.js

@@ -0,0 +1,31 @@
+/**
+ * Global error state for Next.js instance-level errors that are not associated
+ * with a specific browser session or route. This state is exposed through the MCP server's `get_errors`
+ * tool as well. This covers the errors that are global to the Next.js instance, such as errors in next.config.js.
+ *
+ *
+ * ## Usage
+ *
+ * This state is directly manipulated by various parts of the Next.js dev server:
+ *
+ * // Reset the error state
+ * NextInstanceErrorState.[errorType] = []
+ *
+ * // Capture an error for a specific error type
+ * NextInstanceErrorState.[errorType].push(err)
+ *
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NextInstanceErrorState", {
+    enumerable: true,
+    get: function() {
+        return NextInstanceErrorState;
+    }
+});
+const NextInstanceErrorState = {
+    nextConfig: []
+};
+
+//# sourceMappingURL=next-instance-error-state.js.map

package/webapp-dist/vendor/next/dist/server/mcp/tools/utils/browser-communication.js

@@ -0,0 +1,90 @@
+/**
+ * Shared utilities for MCP tools that communicate with the browser.
+ * This module provides a common infrastructure for request-response
+ * communication between MCP endpoints and browser sessions via HMR.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DEFAULT_BROWSER_REQUEST_TIMEOUT_MS: null,
+    createBrowserRequest: null,
+    handleBrowserPageResponse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_BROWSER_REQUEST_TIMEOUT_MS: function() {
+        return DEFAULT_BROWSER_REQUEST_TIMEOUT_MS;
+    },
+    createBrowserRequest: function() {
+        return createBrowserRequest;
+    },
+    handleBrowserPageResponse: function() {
+        return handleBrowserPageResponse;
+    }
+});
+const _nanoid = require("next/dist/compiled/nanoid");
+const DEFAULT_BROWSER_REQUEST_TIMEOUT_MS = 5000;
+const pendingRequests = new Map();
+function createBrowserRequest(messageType, sendHmrMessage, getActiveConnectionCount, timeoutMs) {
+    const connectionCount = getActiveConnectionCount();
+    if (connectionCount === 0) {
+        return Promise.resolve([]);
+    }
+    const requestId = `mcp-${messageType}-${(0, _nanoid.nanoid)()}`;
+    const responsePromise = new Promise((resolve, reject)=>{
+        const timeout = setTimeout(()=>{
+            const pending = pendingRequests.get(requestId);
+            if (pending && pending.responses.length > 0) {
+                resolve(pending.responses);
+            } else {
+                reject(Object.defineProperty(new Error(`Timeout waiting for response from frontend. The browser may not be responding to HMR messages.`), "__NEXT_ERROR_CODE", {
+                    value: "E825",
+                    enumerable: false,
+                    configurable: true
+                }));
+            }
+            pendingRequests.delete(requestId);
+        }, timeoutMs);
+        pendingRequests.set(requestId, {
+            responses: [],
+            expectedCount: connectionCount,
+            resolve: resolve,
+            reject,
+            timeout
+        });
+    });
+    sendHmrMessage({
+        type: messageType,
+        requestId
+    });
+    return responsePromise;
+}
+function handleBrowserPageResponse(requestId, data, url) {
+    if (!url) {
+        throw Object.defineProperty(new Error('URL is required in MCP browser response. This is a bug in Next.js.'), "__NEXT_ERROR_CODE", {
+            value: "E824",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const pending = pendingRequests.get(requestId);
+    if (pending) {
+        pending.responses.push({
+            url,
+            data
+        });
+        if (pending.responses.length >= pending.expectedCount) {
+            clearTimeout(pending.timeout);
+            pending.resolve(pending.responses);
+            pendingRequests.delete(requestId);
+        }
+    }
+}
+
+//# sourceMappingURL=browser-communication.js.map

package/webapp-dist/vendor/next/dist/server/mcp/tools/utils/format-errors.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    formatErrors: null,
+    setStackFrameResolver: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatErrors: function() {
+        return formatErrors;
+    },
+    setStackFrameResolver: function() {
+        return setStackFrameResolver;
+    }
+});
+const _errorsource = require("../../../../shared/lib/error-source");
+// Dependency injection for stack frame resolver
+let stackFrameResolver;
+function setStackFrameResolver(fn) {
+    stackFrameResolver = fn;
+}
+async function resolveStackFrames(request) {
+    if (!stackFrameResolver) {
+        throw Object.defineProperty(new Error('Stack frame resolver not initialized. This is a bug in Next.js.'), "__NEXT_ERROR_CODE", {
+            value: "E822",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return stackFrameResolver(request);
+}
+const formatStackFrame = (frame)=>{
+    const file = frame.file || '<unknown>';
+    const method = frame.methodName || '<anonymous>';
+    const { line1: line, column1: column } = frame;
+    return line && column ? `  at ${method} (${file}:${line}:${column})` : line ? `  at ${method} (${file}:${line})` : `  at ${method} (${file})`;
+};
+const formatErrorFrames = async (frames, context)=>{
+    try {
+        const resolvedFrames = await resolveStackFrames({
+            frames: frames.map((frame)=>({
+                    file: frame.file || null,
+                    methodName: frame.methodName || '<anonymous>',
+                    arguments: [],
+                    line1: frame.line1 || null,
+                    column1: frame.column1 || null
+                })),
+            isServer: context.isServer,
+            isEdgeServer: context.isEdgeServer,
+            isAppDirectory: context.isAppDirectory
+        });
+        return resolvedFrames.filter((resolvedFrame)=>{
+            var _resolvedFrame_value_originalStackFrame;
+            return !(resolvedFrame.status === 'fulfilled' && ((_resolvedFrame_value_originalStackFrame = resolvedFrame.value.originalStackFrame) == null ? void 0 : _resolvedFrame_value_originalStackFrame.ignored));
+        }).map((resolvedFrame, j)=>resolvedFrame.status === 'fulfilled' && resolvedFrame.value.originalStackFrame ? formatStackFrame(resolvedFrame.value.originalStackFrame) : formatStackFrame(frames[j])).join('\n') + '\n';
+    } catch  {
+        return frames.map(formatStackFrame).join('\n') + '\n';
+    }
+};
+async function formatRuntimeError(errors, isAppDirectory) {
+    const formatError = async (error, index)=>{
+        var _error_error, _error_error1, _error_frames;
+        const errorHeader = `\n#### Error ${index + 1} (Type: ${error.type})\n\n`;
+        const errorName = ((_error_error = error.error) == null ? void 0 : _error_error.name) || 'Error';
+        const errorMsg = ((_error_error1 = error.error) == null ? void 0 : _error_error1.message) || 'Unknown error';
+        const errorMessage = `**${errorName}**: ${errorMsg}\n\n`;
+        if (!((_error_frames = error.frames) == null ? void 0 : _error_frames.length)) {
+            var _error_error2;
+            const stack = ((_error_error2 = error.error) == null ? void 0 : _error_error2.stack) || '';
+            return errorHeader + errorMessage + (stack ? `\`\`\`\n${stack}\n\`\`\`\n` : '');
+        }
+        const errorSource = (0, _errorsource.getErrorSource)(error.error);
+        const frames = await formatErrorFrames(error.frames, {
+            isServer: errorSource === 'server',
+            isEdgeServer: errorSource === 'edge-server',
+            isAppDirectory
+        });
+        return errorHeader + errorMessage + `\`\`\`\n${frames}\`\`\`\n`;
+    };
+    const formattedErrors = await Promise.all(errors.map(formatError));
+    return '### Runtime Errors\n' + formattedErrors.join('\n---\n');
+}
+async function formatErrors(errorsByUrl, nextInstanceErrors = {
+    nextConfig: []
+}) {
+    let output = '';
+    // Format Next.js instance errors first (e.g., next.config.js errors)
+    if (nextInstanceErrors.nextConfig.length > 0) {
+        output += `# Next.js Configuration Errors\n\n`;
+        output += `**${nextInstanceErrors.nextConfig.length} error(s) found in next.config**\n\n`;
+        nextInstanceErrors.nextConfig.forEach((error, index)=>{
+            output += `## Error ${index + 1}\n\n`;
+            output += '```\n';
+            if (error instanceof Error) {
+                output += `${error.name}: ${error.message}\n`;
+                if (error.stack) {
+                    output += error.stack;
+                }
+            } else {
+                output += String(error);
+            }
+            output += '\n```\n\n';
+        });
+        output += '---\n\n';
+    }
+    // Format browser session errors
+    if (errorsByUrl.size > 0) {
+        output += `# Found errors in ${errorsByUrl.size} browser session(s)\n\n`;
+        for (const [url, overlayState] of errorsByUrl){
+            const totalErrorCount = overlayState.errors.length + (overlayState.buildError ? 1 : 0);
+            if (totalErrorCount === 0) continue;
+            let displayUrl = url;
+            try {
+                const urlObj = new URL(url);
+                displayUrl = urlObj.pathname + urlObj.search + urlObj.hash;
+            } catch  {
+            // If URL parsing fails, use the original URL
+            }
+            output += `## Session: ${displayUrl}\n\n`;
+            output += `**${totalErrorCount} error(s) found**\n\n`;
+            // Build errors
+            if (overlayState.buildError) {
+                output += '### Build Error\n\n';
+                output += '```\n';
+                output += overlayState.buildError;
+                output += '\n```\n\n';
+            }
+            // Runtime errors with source-mapped stack traces
+            if (overlayState.errors.length > 0) {
+                const runtimeErrors = await formatRuntimeError(overlayState.errors, overlayState.routerType === 'app');
+                output += runtimeErrors;
+                output += '\n';
+            }
+            output += '---\n\n';
+        }
+    }
+    return output.trim();
+}
+
+//# sourceMappingURL=format-errors.js.map