Doormile/doormilebuild
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update wings

Browse Source
This commit is contained in:
Aravind
2026-07-14 11:56:47 +05:30
parent 4b8277af70
commit 07e035dd62
1701 changed files with 0 additions and 461071 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
build/node_modules/next/dist/server/mcp/get-mcp-middleware.js generated vendored
View File

@@ -1,49 +0,0 @@
"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

41
build/node_modules/next/dist/server/mcp/get-or-create-mcp-server.js generated vendored
View File

@@ -1,41 +0,0 @@
"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

82
build/node_modules/next/dist/server/mcp/mcp-telemetry-tracker.js generated vendored
View File

@@ -1,82 +0,0 @@
/**
* 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

114
build/node_modules/next/dist/server/mcp/tools/get-errors.js generated vendored
View File

@@ -1,114 +0,0 @@
/**
* 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

67
build/node_modules/next/dist/server/mcp/tools/get-logs.js generated vendored
View File

@@ -1,67 +0,0 @@
/**
* 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

188
build/node_modules/next/dist/server/mcp/tools/get-page-metadata.js generated vendored
View File

@@ -1,188 +0,0 @@
"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

59
build/node_modules/next/dist/server/mcp/tools/get-project-metadata.js generated vendored
View File

@@ -1,59 +0,0 @@
"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

136
build/node_modules/next/dist/server/mcp/tools/get-routes.js generated vendored
View File

@@ -1,136 +0,0 @@
/**
* 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 _routediscovery = require("../../../build/route-discovery");
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 { projectPath, nextConfig, pagesDir, appDir } = options;
// Check if we have any directories to scan
if (!pagesDir && !appDir) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
error: 'No pages or app directory found in the project.'
})
}
]
};
}
const isSrcDir = pagesDir && pagesDir.includes('/src/') || appDir && appDir.includes('/src/');
const commonOpts = {
pageExtensions: nextConfig.pageExtensions,
isDev: true,
baseDir: projectPath,
isSrcDir: !!isSrcDir
};
// Discover app and pages routes independently so a failure in one
// router doesn't prevent the other from returning results.
let appRoutes = [];
let pageRoutes = [];
const wantApp = routerType !== 'pages' && appDir;
const wantPages = routerType !== 'app' && pagesDir;
const [appResult, pagesResult] = await Promise.all([
wantApp ? (0, _routediscovery.discoverRoutes)({
...commonOpts,
appDir
}).catch(()=>null) : null,
wantPages ? (0, _routediscovery.discoverRoutes)({
...commonOpts,
pagesDir
}).catch(()=>null) : null
]);
if (appResult) {
appRoutes = [
...appResult.appRoutes,
...appResult.appRouteHandlers
].map((r)=>r.route).sort();
}
if (pagesResult) {
pageRoutes = [
...pagesResult.pageRoutes,
...pagesResult.pageApiRoutes
].map((r)=>r.route).sort();
}
if (appRoutes.length === 0 && pageRoutes.length === 0) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
appRouter: [],
pagesRouter: []
})
}
]
};
}
// 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: JSON.stringify({
error: error instanceof Error ? error.message : String(error)
})
}
]
};
}
});
}
//# sourceMappingURL=get-routes.js.map

121
build/node_modules/next/dist/server/mcp/tools/get-server-action-by-id.js generated vendored
View File

@@ -1,121 +0,0 @@
"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: JSON.stringify({
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: JSON.stringify({
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: JSON.stringify({
error: `Action ID "${actionId}" not found in server-reference-manifest.json`
})
}
]
};
} catch (error) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
error: error instanceof Error ? error.message : String(error)
})
}
]
};
}
});
}
//# sourceMappingURL=get-server-action-by-id.js.map

31
build/node_modules/next/dist/server/mcp/tools/next-instance-error-state.js generated vendored
View File

@@ -1,31 +0,0 @@
/**
* 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

90
build/node_modules/next/dist/server/mcp/tools/utils/browser-communication.js generated vendored
View File

@@ -1,90 +0,0 @@
/**
* 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

137
build/node_modules/next/dist/server/mcp/tools/utils/format-errors.js generated vendored
View File

@@ -1,137 +0,0 @@
"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 formatStackFrameToObject = (frame)=>{
return {
file: frame.file || '<unknown>',
methodName: frame.methodName || '<anonymous>',
line: frame.line1,
column: frame.column1
};
};
const resolveErrorFrames = 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 ? formatStackFrameToObject(resolvedFrame.value.originalStackFrame) : formatStackFrameToObject(frames[j]));
} catch {
return frames.map(formatStackFrameToObject);
}
};
async function formatRuntimeErrorsToObjects(errors, isAppDirectory) {
const formattedErrors = [];
for (const error of errors){
var _error_error, _error_error1, _error_frames;
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';
let stack = [];
if ((_error_frames = error.frames) == null ? void 0 : _error_frames.length) {
const errorSource = (0, _errorsource.getErrorSource)(error.error);
stack = await resolveErrorFrames(error.frames, {
isServer: errorSource === 'server',
isEdgeServer: errorSource === 'edge-server',
isAppDirectory
});
}
formattedErrors.push({
type: error.type,
errorName,
message: errorMsg,
stack
});
}
return formattedErrors;
}
async function formatErrors(errorsByUrl, nextInstanceErrors = {
nextConfig: []
}) {
const output = {
configErrors: [],
sessionErrors: []
};
// Format Next.js instance errors first (e.g., next.config.js errors)
for (const error of nextInstanceErrors.nextConfig){
if (error instanceof Error) {
output.configErrors.push({
name: error.name,
message: error.message,
stack: error.stack || null
});
} else {
output.configErrors.push({
name: 'Error',
message: String(error),
stack: null
});
}
}
// Format browser session errors
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
}
const runtimeErrors = await formatRuntimeErrorsToObjects(overlayState.errors, overlayState.routerType === 'app');
output.sessionErrors.push({
url: displayUrl,
buildError: overlayState.buildError || null,
runtimeErrors
});
}
return output;
}
//# sourceMappingURL=format-errors.js.map