@atlaspack/inspector 0.0.19-canary.3998

package/lib/backend/controllers/CacheDataController.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCacheDataController = makeCacheDataController;
+const express_1 = require("express");
+const getCacheStats_1 = require("../services/getCacheStats");
+const cacheDataMiddleware_1 = require("../config/middleware/cacheDataMiddleware");
+function makeCacheDataController() {
+    const router = (0, express_1.Router)();
+    router.get('/api/stats', (_req, res) => {
+        const cache = (0, cacheDataMiddleware_1.getCache)(res);
+        const stats = (0, getCacheStats_1.getCacheStats)(cache);
+        res.json(stats);
+    });
+    router.get('/api/cache-invalidation-files/', (req, res) => {
+        const limit = req.query.limit != null ? Number(req.query.limit) : 100;
+        const cursor = req.query.cursor;
+        const sortBy = req.query.sortBy;
+        const requestTracker = (0, cacheDataMiddleware_1.getRequestTracker)(res);
+        // 0 is file
+        let files = requestTracker.graph.nodes
+            .filter((node) => node.type === 0)
+            .map((node) => ({
+            ...node,
+            invalidationCount: requestTracker.graph
+                .getNodeIdsConnectedTo(requestTracker.graph.getNodeIdByContentKey(node.id), -1)
+                // type 1 is request
+                .filter((node) => requestTracker.graph.getNode(node).type === 1)
+                .length,
+        }));
+        if (sortBy == null || sortBy === 'invalidationCount') {
+            files.sort((a, b) => b.invalidationCount - a.invalidationCount);
+        }
+        const count = files.length;
+        const cursorIndex = cursor != null && cursor !== ''
+            ? files.findIndex((node) => node.id === cursor) + 1
+            : 0;
+        const resultFiles = files.slice(cursorIndex, cursorIndex + limit);
+        res.json({
+            files: resultFiles,
+            count,
+            nextPageCursor: cursorIndex + limit < count
+                ? resultFiles[resultFiles.length - 1]
+                : null,
+            hasNextPage: cursorIndex + limit < count,
+            limit,
+        });
+    });
+    router.get('/api/cache-invalidation-files/:fileId', (req, res) => {
+        const requestTracker = (0, cacheDataMiddleware_1.getRequestTracker)(res);
+        const file = requestTracker.graph.nodes.find((node) => node.id === req.params.fileId);
+        if (!file) {
+            res.status(400).json({ error: 'File not found' });
+            return;
+        }
+        const nodeId = requestTracker.graph.getNodeIdByContentKey(file.id);
+        const nodes = requestTracker.graph.getNodeIdsConnectedTo(nodeId, -1);
+        const invalidatedNodes = nodes
+            .map((node) => requestTracker.graph.getNode(node))
+            .filter((node) => node.type === 1);
+        const response = {
+            file,
+            invalidatedNodesCount: invalidatedNodes.length,
+        };
+        res.json(response);
+    });
+    router.get('/api/cache-invalidation-files/:fileId/invalidated-nodes', (req, res) => {
+        const limit = req.query.limit != null ? Number(req.query.limit) : 100;
+        const cursor = req.query.cursor;
+        const requestTracker = (0, cacheDataMiddleware_1.getRequestTracker)(res);
+        const file = requestTracker.graph.nodes.find((node) => node.id === req.params.fileId);
+        if (!file) {
+            res.status(400).json({ error: 'File not found' });
+            return;
+        }
+        const nodeId = requestTracker.graph.getNodeIdByContentKey(file.id);
+        const nodes = requestTracker.graph.getNodeIdsConnectedTo(nodeId, -1);
+        const invalidatedNodes = nodes
+            .map((node) => requestTracker.graph.getNode(node))
+            .filter((node) => node.type === 1);
+        const cursorIndex = cursor != null && cursor !== ''
+            ? invalidatedNodes.findIndex((node) => node.id === cursor) + 1
+            : 0;
+        const resultNodes = invalidatedNodes.slice(cursorIndex, cursorIndex + limit);
+        const response = {
+            data: resultNodes,
+            count: invalidatedNodes.length,
+            nextPageCursor: cursorIndex + limit < invalidatedNodes.length
+                ? resultNodes[resultNodes.length - 1]
+                : null,
+            hasNextPage: cursorIndex + limit < invalidatedNodes.length,
+            limit,
+        };
+        res.json(response);
+    });
+    router.get('/api/cache-keys/', (req, res) => {
+        const cache = (0, cacheDataMiddleware_1.getCache)(res);
+        const sortBy = req.query.sortBy;
+        const limit = req.query.limit != null ? Number(req.query.limit) : 100;
+        const cursor = req.query.cursor;
+        let resultKeys = Array.from(cache.keys());
+        if (sortBy === 'size') {
+            const sizes = resultKeys.map((key) => [
+                key,
+                cache.getBlobSync(key).length,
+            ]);
+            sizes.sort((a, b) => b[1] - a[1]);
+            resultKeys = sizes.map(([key]) => key);
+        }
+        const count = resultKeys.length;
+        const cursorIndex = cursor != null ? resultKeys.indexOf(cursor) + 1 : 0;
+        resultKeys = resultKeys.slice(cursorIndex, cursorIndex + limit);
+        res.json({
+            keys: resultKeys,
+            count,
+            nextPageCursor: cursorIndex + limit < count ? resultKeys[resultKeys.length - 1] : null,
+            hasNextPage: cursorIndex + limit < count,
+            limit,
+        });
+    });
+    router.get('/api/cache-value/:key', (req, res) => {
+        const cache = (0, cacheDataMiddleware_1.getCache)(res);
+        const key = req.params.key;
+        try {
+            const value = cache.getBlobSync(key);
+            // bigger than 1MB
+            if (typeof value.length === 'number' && value.length > 1024 * 1024) {
+                res.json({
+                    size: value.length,
+                    value: value.slice(0, 1024 * 1024).toString('utf-8'),
+                });
+                return;
+            }
+            res.json({
+                size: value.length,
+                value: value.toString('utf-8'),
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    return router;
+}

package/lib/backend/controllers/FrontendAssetsController.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFrontendAssetsController = makeFrontendAssetsController;
+const path_1 = __importDefault(require("path"));
+const express_1 = __importStar(require("express"));
+/**
+ * On production builds, we intend to serve a pre-built version of the front-end `dist`
+ * directory in `src/frontend/dist`.
+ *
+ * On development mode, you should be running the front-end dev-server separately
+ * and pointing it at this host.
+ */
+function makeFrontendAssetsController() {
+    const router = (0, express_1.Router)();
+    router.use(express_1.default.static(path_1.default.join(__dirname, '../../../src/frontend/dist')));
+    router.use('/app/', (req, res, next) => {
+        if (req.method === 'GET') {
+            res.sendFile(path_1.default.join(__dirname, '../../../src/frontend/dist/index.html'));
+        }
+        else {
+            next();
+        }
+    });
+    return router;
+}

package/lib/backend/controllers/TreeMapController.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTreemapController = makeTreemapController;
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable monorepo/no-internal-import */
+const express_1 = require("express");
+const path_1 = __importDefault(require("path"));
+const cacheDataMiddleware_1 = require("../config/middleware/cacheDataMiddleware");
+const graph_1 = require("@atlaspack/graph");
+const logger_1 = require("../config/logger");
+function makeTreemapController({ sourceCodeURL, projectRoot, repositoryRoot, }) {
+    const router = (0, express_1.Router)();
+    router.get('/api/treemap/reasons', (req, res) => {
+        const bundleGraph = (0, cacheDataMiddleware_1.getBundleGraph)(res);
+        const queryPath = req.query.path;
+        const bundle = req.query.bundle;
+        const bundleNode = bundleGraph._graph.getNode(bundleGraph._graph.getNodeIdByContentKey(bundle));
+        const relevantPaths = [];
+        let tooManyPaths = false;
+        bundleGraph.traverseBundle(bundleNode.value, {
+            enter(node, context, actions) {
+                if (context == null) {
+                    context = [];
+                }
+                if (node.type === 'asset') {
+                    context.push(path_1.default.relative(repositoryRoot, node.value.filePath));
+                }
+                if (node.type === 'dependency') {
+                    try {
+                        const childNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(bundleGraph._graph.getNodeIdByContentKey(node.id), graph_1.ALL_EDGE_TYPES);
+                        let isParent = false;
+                        for (const childNodeId of childNodeIds) {
+                            const childNode = bundleGraph._graph.getNode(childNodeId);
+                            if (childNode.type === 'asset' &&
+                                path_1.default
+                                    .relative(repositoryRoot, childNode.value.filePath)
+                                    .startsWith(queryPath)) {
+                                actions.skipChildren();
+                                isParent = true;
+                            }
+                        }
+                        // For some reason we visit all nodes from the bundle, so we need to filter out
+                        // stuff that is directly connected to the bundle node, since that's not useful
+                        // information.
+                        // e.g.: On the cases where the file is included directly to the bundle either due
+                        // to manual bundling or entry dependencies, the user probably already knows about
+                        // it.
+                        if (isParent && context.length > 1) {
+                            relevantPaths.push(context.slice());
+                            if (relevantPaths.length > 50) {
+                                tooManyPaths = true;
+                                actions.stop();
+                            }
+                        }
+                    }
+                    catch (err) {
+                        logger_1.logger.error(err);
+                    }
+                }
+                return context;
+            },
+            exit(node, context = []) {
+                if (node.type === 'asset') {
+                    context.pop();
+                }
+                return context;
+            },
+        });
+        res.json({
+            tooManyPaths,
+            relevantPaths,
+            sourceCodeURL,
+            projectRoot,
+            repositoryRoot,
+        });
+    });
+    router.get('/api/treemap', (req, res) => {
+        const treemap = (0, cacheDataMiddleware_1.getTreemap)(res);
+        const limit = Number(req.query.limit ?? 10000);
+        const offset = Number(req.query.offset ?? 0);
+        const bundleId = req.query.bundle;
+        let bundles = treemap.bundles;
+        if (bundleId) {
+            bundles = bundles.filter((bundle) => bundle.id === bundleId);
+        }
+        else {
+            bundles = bundles.map((bundle) => ({
+                ...bundle,
+                assetTree: {
+                    id: `${bundle.id}::/`,
+                    path: '',
+                    children: {},
+                    size: bundle.size,
+                },
+            }));
+        }
+        res.json({
+            bundles: bundles.slice(offset, offset + limit),
+            next: offset + limit < bundles.length ? offset + limit : null,
+            count: bundles.length,
+            totalSize: treemap.totalSize,
+        });
+    });
+    return router;
+}

package/lib/backend/controllers/mcp/InspectorMCP.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectorMCP = void 0;
+/* eslint-disable monorepo/no-internal-import */
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const crypto_1 = require("crypto");
+const zod_1 = require("zod");
+const cacheDataMiddleware_1 = require("../../config/middleware/cacheDataMiddleware");
+/**
+ * Incomplete, toy MCP server for the Atlaspack Inspector.
+ */
+function makeInspectorMCPServer({ cache, bundleGraph, treemap, }) {
+    const server = new mcp_js_1.McpServer({
+        name: 'atlaspack-inspector-mcp',
+        version: '1.0.0',
+    });
+    server.registerTool('list-treemap-bundles', {
+        title: 'List Treemap Bundles',
+        description: `List the bundles in the treemap.`,
+        inputSchema: {},
+    }, () => {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        `Treemap bundles:`,
+                        ...treemap.bundles.flatMap((bundle) => [
+                            `- ${bundle.displayName} - ${bundle.id} - atlaspack://bundle-info/${bundle.id}`,
+                            `  * ${bundle.size} bytes`,
+                            `  * ${bundle.filePath} file path`,
+                            `  * Run 'query-treemap ${bundle.id}' to get more information about this bundle`,
+                        ]),
+                    ].join('\n'),
+                },
+            ],
+        };
+    });
+    server.registerTool('query-treemap', {
+        title: 'Query Treemap',
+        description: `Query the treemap for information about a given bundle.`,
+        inputSchema: {
+            bundleId: zod_1.z.string(),
+        },
+    }, ({ bundleId }) => {
+        const bundle = treemap.bundles.find((bundle) => bundle.id === bundleId);
+        if (!bundle) {
+            return {
+                content: [{ type: 'text', text: `Bundle not found: ${bundleId}` }],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        `Bundle: ${bundle.displayName}`,
+                        `Bundle size: ${bundle.size} bytes`,
+                    ].join('\n'),
+                },
+                {
+                    type: 'text',
+                    text: `Raw treemap JSON:\n${JSON.stringify(bundle)}`,
+                },
+            ],
+        };
+    });
+    server.registerTool('get-resolved-imports', {
+        title: 'Get Resolved Imports',
+        description: `Get the resolved imports for a given JavaScript/TypeScript file, if it appears on the output bundles.`,
+        inputSchema: {
+            file: zod_1.z.string(),
+        },
+    }, ({ file }) => {
+        const assetId = bundleGraph._graph.nodes.find((node) => {
+            return node.type === 'asset' && node.value.filePath === file;
+        })?.id;
+        if (!assetId) {
+            return {
+                content: [
+                    { type: 'text', text: `File not found in any bundles: ${file}` },
+                ],
+            };
+        }
+        const asset = bundleGraph.getAssetById(assetId);
+        const bundlesWithAsset = bundleGraph.getBundlesWithAsset(asset);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        `Bundles with asset:`,
+                        ...bundlesWithAsset.map((bundle) => `- ${bundle.id} - ${bundle.displayName} - atlaspack://bundle-info/${bundle.id}`),
+                    ].join('\n'),
+                },
+                {
+                    type: 'text',
+                    text: `Raw asset JSON: ${JSON.stringify(asset)}`,
+                },
+            ],
+        };
+    });
+    server.registerResource('treemap-bundle-info', new mcp_js_1.ResourceTemplate('atlaspack://bundle-info/{id}', {
+        list() {
+            const resources = treemap.bundles
+                .slice(0, 10)
+                .map((bundle) => ({
+                uri: `atlaspack://bundle-info/${bundle.id}`,
+                name: `Bundle: ${bundle.displayName}`,
+            }));
+            return {
+                resources,
+            };
+        },
+    }), {
+        name: 'Atlaspack Treemap Bundle Information',
+        description: `Information about a built JavaScript bundle in the application and its bundle size. Can be used to list available bundles in the application.`,
+    }, (uri) => {
+        const id = uri.pathname.split('/').slice(1).join('/');
+        const bundle = treemap.bundles.find((bundle) => bundle.id === id);
+        if (!bundle) {
+            return {
+                contents: [],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.toString(),
+                    text: [
+                        `Bundle: ${bundle.displayName}`,
+                        `Bundle size: ${bundle.size} bytes`,
+                    ].join('\n---\n'),
+                },
+            ],
+        };
+    });
+    server.registerResource('cache-key', new mcp_js_1.ResourceTemplate('atlaspack://cache/{key}', {
+        list: undefined,
+    }), {
+        name: 'Atlaspack Cache Entry',
+    }, (uri) => {
+        const key = uri.pathname.split('/').slice(1).join('/');
+        const value = cache.getBlobSync(key);
+        return {
+            contents: [
+                {
+                    uri: uri.toString(),
+                    type: 'text',
+                    text: [
+                        `Cache key: ${key}`,
+                        `Cache value total size: ${value.length} bytes`,
+                        `First 500KB of cache value:\n\n${value.subarray(0, 1024 * 500).toString()}`,
+                    ].join('\n---\n'),
+                },
+            ],
+        };
+    });
+    return server;
+}
+class InspectorMCP {
+    constructor() {
+        this.sessions = new Map();
+    }
+    getSession(request) {
+        const sessionId = request.headers['mcp-session-id'];
+        if (!sessionId) {
+            return undefined;
+        }
+        return this.sessions.get(sessionId);
+    }
+    async get(request, response) {
+        const session = this.getSession(request);
+        if (!session) {
+            response.status(400).send('Invalid or missing session ID');
+            return;
+        }
+        await session.transport.handleRequest(request, response);
+    }
+    async post(request, response) {
+        const sessionId = request.headers['mcp-session-id'];
+        let transport;
+        if (sessionId && this.sessions.has(sessionId)) {
+            transport = this.sessions.get(sessionId).transport;
+        }
+        else if (!sessionId && (0, types_js_1.isInitializeRequest)(request.body)) {
+            transport = await this.createSession(response);
+        }
+        else {
+            response.status(400).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Bad Request: No valid session ID provided',
+                },
+                id: null,
+            });
+            return;
+        }
+        await transport.handleRequest(request, response, request.body);
+    }
+    async createSession(response) {
+        const cache = (0, cacheDataMiddleware_1.getCache)(response);
+        const bundleGraph = (0, cacheDataMiddleware_1.getBundleGraph)(response);
+        const treemap = (0, cacheDataMiddleware_1.getTreemap)(response);
+        const server = makeInspectorMCPServer({
+            cache,
+            bundleGraph,
+            treemap,
+        });
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => (0, crypto_1.randomUUID)(),
+            onsessioninitialized: (sessionId) => {
+                this.sessions.set(sessionId, {
+                    transport,
+                    server,
+                });
+            },
+        });
+        transport.onclose = () => {
+            if (transport.sessionId) {
+                this.sessions.delete(transport.sessionId);
+            }
+        };
+        await server.connect(transport);
+        return transport;
+    }
+}
+exports.InspectorMCP = InspectorMCP;

package/lib/backend/controllers/mcp/InspectorMCPController.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeInspectorMCPController = makeInspectorMCPController;
+const express_1 = require("express");
+const InspectorMCP_1 = require("./InspectorMCP");
+function makeInspectorMCPController() {
+    const router = (0, express_1.Router)();
+    const mcp = new InspectorMCP_1.InspectorMCP();
+    router.post('/api/mcp', (req, res) => {
+        mcp.post(req, res);
+    });
+    router.get('/api/mcp', (req, res) => {
+        mcp.get(req, res);
+    });
+    return router;
+}

package/lib/backend/errors/HTTPError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPError = void 0;
+/**
+ * A custom error class for HTTP errors.
+ *
+ * The {@link errorHandlingMiddleware} will automatically set HTTP response
+ * status codes for instances of this class.
+ */
+class HTTPError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.HTTPError = HTTPError;

package/lib/backend/errors/HTTPError.test.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const HTTPError_1 = require("./HTTPError");
+describe('HTTPError', function () {
+    it('should create HTTPError with message and status', function () {
+        const error = new HTTPError_1.HTTPError('Not found', 404);
+        assert_1.default.equal(error.message, 'Not found');
+        assert_1.default.equal(error.status, 404);
+        (0, assert_1.default)(error instanceof Error);
+        (0, assert_1.default)(error instanceof HTTPError_1.HTTPError);
+    });
+    it('should be throwable', function () {
+        assert_1.default.throws(() => {
+            throw new HTTPError_1.HTTPError('Server error', 500);
+        }, HTTPError_1.HTTPError);
+    });
+});