agentnetes 0.1.3 → 0.1.4

package/web/node_modules/next/dist/server/mcp/get-mcp-middleware.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getMcpMiddleware", {
+    enumerable: true,
+    get: function() {
+        return getMcpMiddleware;
+    }
+});
+const _getorcreatemcpserver = require("./get-or-create-mcp-server");
+const _parsebody = require("../api-utils/node/parse-body");
+const _streamableHttp = require("next/dist/compiled/@modelcontextprotocol/sdk/server/streamableHttp");
+function getMcpMiddleware(options) {
+    return async function(req, res, next) {
+        const { pathname } = new URL(req.url || '', 'http://n');
+        if (!pathname.startsWith('/_next/mcp')) {
+            return next();
+        }
+        const mcpServer = (0, _getorcreatemcpserver.getOrCreateMcpServer)(options);
+        const transport = new _streamableHttp.StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined
+        });
+        try {
+            res.on('close', ()=>{
+                transport.close();
+            });
+            await mcpServer.connect(transport);
+            const parsedBody = await (0, _parsebody.parseBody)(req, 1024 * 1024) // 1MB limit
+            ;
+            await transport.handleRequest(req, res, parsedBody);
+        } catch (error) {
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: 'Internal server error'
+                    },
+                    id: null
+                }));
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=get-mcp-middleware.js.map

package/web/node_modules/next/dist/server/mcp/get-or-create-mcp-server.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getOrCreateMcpServer", {
+    enumerable: true,
+    get: function() {
+        return getOrCreateMcpServer;
+    }
+});
+const _mcp = require("next/dist/compiled/@modelcontextprotocol/sdk/server/mcp");
+const _getprojectmetadata = require("./tools/get-project-metadata");
+const _geterrors = require("./tools/get-errors");
+const _getpagemetadata = require("./tools/get-page-metadata");
+const _getlogs = require("./tools/get-logs");
+const _getserveractionbyid = require("./tools/get-server-action-by-id");
+const _getroutes = require("./tools/get-routes");
+let mcpServer;
+const getOrCreateMcpServer = (options)=>{
+    if (mcpServer) {
+        return mcpServer;
+    }
+    mcpServer = new _mcp.McpServer({
+        name: 'Next.js MCP Server',
+        version: '0.2.0'
+    });
+    (0, _getprojectmetadata.registerGetProjectMetadataTool)(mcpServer, options.projectPath, options.getDevServerUrl);
+    (0, _geterrors.registerGetErrorsTool)(mcpServer, options.sendHmrMessage, options.getActiveConnectionCount);
+    (0, _getpagemetadata.registerGetPageMetadataTool)(mcpServer, options.sendHmrMessage, options.getActiveConnectionCount);
+    (0, _getlogs.registerGetLogsTool)(mcpServer, options.distDir);
+    (0, _getserveractionbyid.registerGetActionByIdTool)(mcpServer, options.distDir);
+    (0, _getroutes.registerGetRoutesTool)(mcpServer, {
+        projectPath: options.projectPath,
+        nextConfig: options.nextConfig,
+        pagesDir: options.pagesDir,
+        appDir: options.appDir
+    });
+    return mcpServer;
+};
+
+//# sourceMappingURL=get-or-create-mcp-server.js.map

package/web/node_modules/next/dist/server/mcp/mcp-telemetry-tracker.js

@@ -0,0 +1,82 @@
+/**
+ * Telemetry tracker for MCP tool call usage.
+ * Tracks invocation counts for each MCP tool to be reported via telemetry.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getMcpTelemetryUsage: null,
+    mcpTelemetryTracker: null,
+    recordMcpTelemetry: null,
+    resetMcpTelemetry: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getMcpTelemetryUsage: function() {
+        return getMcpTelemetryUsage;
+    },
+    mcpTelemetryTracker: function() {
+        return mcpTelemetryTracker;
+    },
+    recordMcpTelemetry: function() {
+        return recordMcpTelemetry;
+    },
+    resetMcpTelemetry: function() {
+        return resetMcpTelemetry;
+    }
+});
+class McpTelemetryTracker {
+    /**
+   * Record a tool call invocation
+   */ recordToolCall(toolName) {
+        const current = this.usageMap.get(toolName) || 0;
+        this.usageMap.set(toolName, current + 1);
+    }
+    /**
+   * Get all tool usages as an array
+   */ getUsages() {
+        return Array.from(this.usageMap.entries()).map(([featureName, count])=>({
+                featureName,
+                invocationCount: count
+            }));
+    }
+    /**
+   * Reset all usage tracking
+   */ reset() {
+        this.usageMap.clear();
+    }
+    /**
+   * Check if any tools have been called
+   */ hasUsage() {
+        return this.usageMap.size > 0;
+    }
+    constructor(){
+        this.usageMap = new Map();
+    }
+}
+const mcpTelemetryTracker = new McpTelemetryTracker();
+function getMcpTelemetryUsage() {
+    return mcpTelemetryTracker.getUsages();
+}
+function resetMcpTelemetry() {
+    mcpTelemetryTracker.reset();
+}
+function recordMcpTelemetry(telemetry) {
+    const mcpUsages = getMcpTelemetryUsage();
+    if (mcpUsages.length === 0) {
+        return;
+    }
+    const { eventMcpToolUsage } = require('../../telemetry/events/build');
+    const events = eventMcpToolUsage(mcpUsages);
+    for (const event of events){
+        telemetry.record(event);
+    }
+}
+
+//# sourceMappingURL=mcp-telemetry-tracker.js.map

package/web/node_modules/next/dist/server/mcp/tools/get-errors.js

@@ -0,0 +1,114 @@
+/**
+ * MCP tool for retrieving error state from Next.js dev server.
+ *
+ * This tool provides comprehensive error reporting including:
+ * - Next.js global errors (e.g., next.config validation errors)
+ * - Browser runtime errors with source-mapped stack traces
+ * - Build errors from webpack/turbopack compilation
+ *
+ * For browser errors, it leverages the HMR infrastructure for server-to-browser communication.
+ *
+ * Flow:
+ *   MCP client → server generates request ID → HMR message to browser →
+ *   browser queries error overlay state → HMR response back → server performs source mapping →
+ *   combined with global errors → formatted output.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handleErrorStateResponse: null,
+    registerGetErrorsTool: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handleErrorStateResponse: function() {
+        return handleErrorStateResponse;
+    },
+    registerGetErrorsTool: function() {
+        return registerGetErrorsTool;
+    }
+});
+const _hotreloadertypes = require("../../dev/hot-reloader-types");
+const _formaterrors = require("./utils/format-errors");
+const _browsercommunication = require("./utils/browser-communication");
+const _nextinstanceerrorstate = require("./next-instance-error-state");
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+function registerGetErrorsTool(server, sendHmrMessage, getActiveConnectionCount) {
+    server.registerTool('get_errors', {
+        description: 'Get the current error state from the Next.js dev server, including Next.js global errors (e.g., next.config validation), browser runtime errors, and build errors with source-mapped stack traces',
+        inputSchema: {}
+    }, async (_request)=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_errors');
+        try {
+            const connectionCount = getActiveConnectionCount();
+            if (connectionCount === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'No browser sessions connected. Please open your application in a browser to retrieve error state.'
+                            })
+                        }
+                    ]
+                };
+            }
+            const responses = await (0, _browsercommunication.createBrowserRequest)(_hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REQUEST_CURRENT_ERROR_STATE, sendHmrMessage, getActiveConnectionCount, _browsercommunication.DEFAULT_BROWSER_REQUEST_TIMEOUT_MS);
+            // The error state for each route
+            // key is the route path, value is the error state
+            const routesErrorState = new Map();
+            for (const response of responses){
+                if (response.data) {
+                    routesErrorState.set(response.url, response.data);
+                }
+            }
+            const hasRouteErrors = Array.from(routesErrorState.values()).some((state)=>state.errors.length > 0 || !!state.buildError);
+            const hasInstanceErrors = _nextinstanceerrorstate.NextInstanceErrorState.nextConfig.length > 0;
+            if (!hasRouteErrors && !hasInstanceErrors) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                configErrors: [],
+                                sessionErrors: []
+                            })
+                        }
+                    ]
+                };
+            }
+            const output = await (0, _formaterrors.formatErrors)(routesErrorState, _nextinstanceerrorstate.NextInstanceErrorState);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(output)
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error)
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+function handleErrorStateResponse(requestId, errorState, url) {
+    (0, _browsercommunication.handleBrowserPageResponse)(requestId, errorState, url || '');
+}
+
+//# sourceMappingURL=get-errors.js.map

package/web/node_modules/next/dist/server/mcp/tools/get-logs.js

@@ -0,0 +1,67 @@
+/**
+ * MCP tool for getting the path to the Next.js development log file.
+ *
+ * This tool returns the path to the {nextConfig.distDir}/logs/next-development.log file
+ * that contains browser console logs and other development information.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetLogsTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetLogsTool;
+    }
+});
+const _promises = require("fs/promises");
+const _path = require("path");
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+function registerGetLogsTool(server, distDir) {
+    server.registerTool('get_logs', {
+        description: 'Get the path to the Next.js development log file. Returns the file path so the agent can read the logs directly.'
+    }, async ()=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_logs');
+        try {
+            const logFilePath = (0, _path.join)(distDir, 'logs', 'next-development.log');
+            // Check if the log file exists
+            try {
+                await (0, _promises.stat)(logFilePath);
+            } catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Log file not found at ${logFilePath}.`
+                            })
+                        }
+                    ]
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            logFilePath
+                        })
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Error getting log file path: ${error instanceof Error ? error.message : String(error)}`
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=get-logs.js.map

package/web/node_modules/next/dist/server/mcp/tools/get-page-metadata.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handlePageMetadataResponse: null,
+    registerGetPageMetadataTool: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handlePageMetadataResponse: function() {
+        return handlePageMetadataResponse;
+    },
+    registerGetPageMetadataTool: function() {
+        return registerGetPageMetadataTool;
+    }
+});
+const _hotreloadertypes = require("../../dev/hot-reloader-types");
+const _browsercommunication = require("./utils/browser-communication");
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+function registerGetPageMetadataTool(server, sendHmrMessage, getActiveConnectionCount) {
+    server.registerTool('get_page_metadata', {
+        description: 'Get runtime metadata about what contributes to the current page render from active browser sessions.',
+        inputSchema: {}
+    }, async (_request)=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_page_metadata');
+        try {
+            const connectionCount = getActiveConnectionCount();
+            if (connectionCount === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'No browser sessions connected. Please open your application in a browser to retrieve page metadata.'
+                            })
+                        }
+                    ]
+                };
+            }
+            const responses = await (0, _browsercommunication.createBrowserRequest)(_hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REQUEST_PAGE_METADATA, sendHmrMessage, getActiveConnectionCount, _browsercommunication.DEFAULT_BROWSER_REQUEST_TIMEOUT_MS);
+            if (responses.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessions: []
+                            })
+                        }
+                    ]
+                };
+            }
+            const sessionMetadata = [];
+            for (const response of responses){
+                if (response.data) {
+                    // TODO: Add other metadata for the current page render here. Currently, we only have segment trie data.
+                    const pageMetadata = convertSegmentTrieToPageMetadata(response.data);
+                    sessionMetadata.push({
+                        url: response.url,
+                        metadata: pageMetadata
+                    });
+                }
+            }
+            if (sessionMetadata.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessions: []
+                            })
+                        }
+                    ]
+                };
+            }
+            const output = formatPageMetadata(sessionMetadata);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(output)
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error)
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+function handlePageMetadataResponse(requestId, segmentTrieData, url) {
+    (0, _browsercommunication.handleBrowserPageResponse)(requestId, segmentTrieData, url || '');
+}
+function convertSegmentTrieToPageMetadata(data) {
+    const segments = [];
+    if (data.segmentTrie) {
+        // Traverse the trie and collect all segments
+        function traverseTrie(node) {
+            if (node.value) {
+                segments.push({
+                    type: node.value.type,
+                    pagePath: node.value.pagePath,
+                    boundaryType: node.value.boundaryType
+                });
+            }
+            for (const childNode of Object.values(node.children)){
+                if (childNode) {
+                    traverseTrie(childNode);
+                }
+            }
+        }
+        traverseTrie(data.segmentTrie);
+    }
+    return {
+        segments,
+        routerType: data.routerType
+    };
+}
+function formatPageMetadata(sessionMetadata) {
+    const sessions = [];
+    for (const { url, metadata } of sessionMetadata){
+        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
+        }
+        // Ensure consistent output to avoid flaky tests
+        const sortedSegments = [
+            ...metadata.segments
+        ].sort((a, b)=>{
+            const typeOrder = (segment)=>{
+                const type = segment.boundaryType || segment.type;
+                if (type === 'layout') return 0;
+                if (type.startsWith('boundary:')) return 1;
+                if (type === 'page') return 2;
+                return 3;
+            };
+            const aOrder = typeOrder(a);
+            const bOrder = typeOrder(b);
+            if (aOrder !== bOrder) return aOrder - bOrder;
+            return a.pagePath.localeCompare(b.pagePath);
+        });
+        const formattedSegments = [];
+        for (const segment of sortedSegments){
+            const path = segment.pagePath;
+            const isBuiltin = path.startsWith('__next_builtin__');
+            const type = segment.boundaryType || segment.type;
+            const isBoundary = type.startsWith('boundary:');
+            let displayPath = path.replace(/@boundary$/, '').replace(/^__next_builtin__/, '');
+            if (!isBuiltin && !displayPath.startsWith('app/')) {
+                displayPath = `app/${displayPath}`;
+            }
+            formattedSegments.push({
+                path: displayPath,
+                type,
+                isBoundary,
+                isBuiltin
+            });
+        }
+        sessions.push({
+            url: displayUrl,
+            routerType: metadata.routerType,
+            segments: formattedSegments
+        });
+    }
+    return {
+        sessions
+    };
+}
+
+//# sourceMappingURL=get-page-metadata.js.map

package/web/node_modules/next/dist/server/mcp/tools/get-project-metadata.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetProjectMetadataTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetProjectMetadataTool;
+    }
+});
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+function registerGetProjectMetadataTool(server, projectPath, getDevServerUrl) {
+    server.registerTool('get_project_metadata', {
+        description: 'Returns the the metadata of this Next.js project, including project path, dev server URL, etc.',
+        inputSchema: {}
+    }, async (_request)=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_project_metadata');
+        try {
+            if (!projectPath) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'Unable to determine the absolute path of the Next.js project.'
+                            })
+                        }
+                    ]
+                };
+            }
+            const devServerUrl = getDevServerUrl();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            projectPath,
+                            devServerUrl
+                        })
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error)
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=get-project-metadata.js.map