@gnaws/mcp 0.1.0

package/dist/app.js

@@ -0,0 +1,771 @@
+#!/usr/bin/env node
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var _process_env_LOG_LEVEL;
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "node:path";
+// Load .env if present (local dev convenience — ignored if no .env exists)
+if (existsSync(".env")) {
+    process.loadEnvFile(".env");
+}
+import { fromIni } from "@aws-sdk/credential-providers";
+import { Inventory, GraphBuilder, MarkdownExporter, GexfExporter, JsonExporter, LiveServiceFactory, CacheServiceFactory, CacheWriter, UnusedDetector } from "@gnaws/core";
+import { McpServer } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import * as z from "zod/v4";
+import { createLogger } from "./logger.js";
+// State
+var inventory;
+var graph;
+var logLevel = (_process_env_LOG_LEVEL = process.env.LOG_LEVEL) !== null && _process_env_LOG_LEVEL !== void 0 ? _process_env_LOG_LEVEL : "info";
+var logger = createLogger(logLevel);
+var server = new McpServer({
+    "name": "gnaws-mcp",
+    "version": "0.1.0"
+});
+// ─── Tool: status ────────────────────────────────────────────────────────────
+server.registerTool("status", {
+    "title": "Server Status",
+    "description": "Check the current state of the gnaws server: whether resources are loaded, graph size, and available actions. Call this first to understand what tools are available.",
+    "inputSchema": z.object({})
+}, function() {
+    var lines = [];
+    if (graph && inventory) {
+        var regions = inventory.getAccountRegions();
+        lines.push("✓ Resources loaded.", "  Nodes: ".concat(String(graph.order)), "  Edges: ".concat(String(graph.size)), "  Regions: ".concat(String(regions.length)), "", "Available tools:", "  • 'detect' — find unused/orphaned resources", "  • 'export' — export graph to gexf, json, or markdown", "  • 'dump' — save raw data to disk", "  • 'regions' — list enabled AWS regions", "  • 'scan' — re-scan with a different profile", "  • 'load' — load a different dump");
+    } else {
+        lines.push("✗ No resources loaded yet.", "", "To get started, call one of:", "  • 'scan' — scan live AWS resources (requires an AWS profile name)", "  • 'load' — load from a dump directory (requires a path)");
+    }
+    return {
+        "content": [
+            {
+                "type": "text",
+                "text": lines.join("\n")
+            }
+        ]
+    };
+});
+// ─── Tool: scan ──────────────────────────────────────────────────────────────
+server.registerTool("scan", {
+    "title": "Scan AWS Resources",
+    "description": "Scan AWS resources live using an AWS profile. This builds an in-memory graph of all resources and their relationships. This is a long-running operation (may take several minutes). After scanning, use 'regions' to list regions, 'detect' to find unused resources, 'export' to export the graph, or 'dump' to save raw data for offline use.",
+    "inputSchema": z.object({
+        "profile": z.string().describe("AWS profile name from ~/.aws/credentials (e.g., 'default', 'production')")
+    })
+}, function(param, ctx) {
+    var profile = param.profile;
+    return _async_to_generator(function() {
+        var _ctx_mcpReq__meta, progressToken, reportProgress, credentials, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    progressToken = (_ctx_mcpReq__meta = ctx.mcpReq._meta) === null || _ctx_mcpReq__meta === void 0 ? void 0 : _ctx_mcpReq__meta.progressToken;
+                    reportProgress = function reportProgress(progress, total, message) {
+                        return _async_to_generator(function() {
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        if (!(progressToken !== undefined)) return [
+                                            3,
+                                            2
+                                        ];
+                                        return [
+                                            4,
+                                            ctx.mcpReq.notify({
+                                                "method": "notifications/progress",
+                                                "params": {
+                                                    progressToken: progressToken,
+                                                    progress: progress,
+                                                    total: total,
+                                                    message: message
+                                                }
+                                            })
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        _state.label = 2;
+                                    case 2:
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    };
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        8,
+                        ,
+                        9
+                    ]);
+                    return [
+                        4,
+                        reportProgress(1, 4, "Resolving credentials...")
+                    ];
+                case 2:
+                    _state.sent();
+                    credentials = fromIni({
+                        profile: profile
+                    });
+                    logger.info("Scanning AWS resources with profile [".concat(profile, "]..."));
+                    return [
+                        4,
+                        reportProgress(2, 4, "Initializing services...")
+                    ];
+                case 3:
+                    _state.sent();
+                    inventory = new Inventory(credentials, new LiveServiceFactory(logger.child("aws")));
+                    return [
+                        4,
+                        inventory.init()
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        4,
+                        reportProgress(3, 4, "Loading resources (this may take several minutes)...")
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        4,
+                        inventory.loadResources()
+                    ];
+                case 6:
+                    _state.sent();
+                    return [
+                        4,
+                        reportProgress(4, 4, "Building graph...")
+                    ];
+                case 7:
+                    _state.sent();
+                    graph = new GraphBuilder().build(inventory);
+                    logger.info("Scan complete: ".concat(String(graph.order), " nodes, ").concat(String(graph.size), " edges"));
+                    return [
+                        2,
+                        {
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": [
+                                        "✓ Scan complete: ".concat(String(graph.order), " nodes, ").concat(String(graph.size), " edges."),
+                                        "",
+                                        "Available next steps:",
+                                        "  • 'regions' — list enabled AWS regions",
+                                        "  • 'detect' — find unused/orphaned resources",
+                                        "  • 'export' — export graph to gexf, json, or markdown",
+                                        "  • 'dump' — save raw data to disk for offline analysis"
+                                    ].join("\n")
+                                }
+                            ]
+                        }
+                    ];
+                case 8:
+                    error = _state.sent();
+                    graph = undefined;
+                    inventory = undefined;
+                    return [
+                        2,
+                        {
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": "✗ Scan failed: ".concat(_instanceof(error, Error) ? error.message : String(error), "\n\nEnsure the AWS profile '").concat(profile, "' exists in ~/.aws/credentials and has valid credentials.")
+                                }
+                            ],
+                            "isError": true
+                        }
+                    ];
+                case 9:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+// ─── Tool: load ──────────────────────────────────────────────────────────────
+server.registerTool("load", {
+    "title": "Load Cached Resources",
+    "description": "Load resources from a previously dumped directory (offline mode). No AWS credentials needed. After loading, use 'regions', 'detect', or 'export' to work with the data.",
+    "inputSchema": z.object({
+        "path": z.string().describe("Path to a gnaws dump directory containing manifest.json and resource files")
+    })
+}, function(param, ctx) {
+    var path = param.path;
+    return _async_to_generator(function() {
+        var _ctx_mcpReq__meta, progressToken, reportProgress, manifestPath, manifestInfo, _manifest_scannedAt, _ref, _manifest_regions, manifest, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    progressToken = (_ctx_mcpReq__meta = ctx.mcpReq._meta) === null || _ctx_mcpReq__meta === void 0 ? void 0 : _ctx_mcpReq__meta.progressToken;
+                    reportProgress = function reportProgress(progress, total, message) {
+                        return _async_to_generator(function() {
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        if (!(progressToken !== undefined)) return [
+                                            3,
+                                            2
+                                        ];
+                                        return [
+                                            4,
+                                            ctx.mcpReq.notify({
+                                                "method": "notifications/progress",
+                                                "params": {
+                                                    progressToken: progressToken,
+                                                    progress: progress,
+                                                    total: total,
+                                                    message: message
+                                                }
+                                            })
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        _state.label = 2;
+                                    case 2:
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    };
+                    if (!existsSync(path)) {
+                        return [
+                            2,
+                            {
+                                "content": [
+                                    {
+                                        "type": "text",
+                                        "text": "✗ Path not found: ".concat(path, "\n\nProvide the path to a directory created by the 'dump' tool (or gnaws-cli /dump command).")
+                                    }
+                                ],
+                                "isError": true
+                            }
+                        ];
+                    }
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        7,
+                        ,
+                        8
+                    ]);
+                    return [
+                        4,
+                        reportProgress(1, 3, "Reading manifest...")
+                    ];
+                case 2:
+                    _state.sent();
+                    manifestPath = join(path, "manifest.json");
+                    manifestInfo = "";
+                    if (existsSync(manifestPath)) {
+                        ;
+                        ;
+                        manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+                        manifestInfo = "  Scanned at: ".concat((_manifest_scannedAt = manifest.scannedAt) !== null && _manifest_scannedAt !== void 0 ? _manifest_scannedAt : "unknown", "\n  Regions: ").concat(String((_ref = (_manifest_regions = manifest.regions) === null || _manifest_regions === void 0 ? void 0 : _manifest_regions.length) !== null && _ref !== void 0 ? _ref : "unknown"));
+                    }
+                    return [
+                        4,
+                        reportProgress(2, 3, "Loading cached resources...")
+                    ];
+                case 3:
+                    _state.sent();
+                    inventory = new Inventory(new CacheServiceFactory(path, logger.child("cache")));
+                    return [
+                        4,
+                        inventory.init()
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        4,
+                        inventory.loadResources()
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        4,
+                        reportProgress(3, 3, "Building graph...")
+                    ];
+                case 6:
+                    _state.sent();
+                    graph = new GraphBuilder().build(inventory);
+                    return [
+                        2,
+                        {
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": [
+                                        "✓ Loaded from ".concat(path, ": ").concat(String(graph.order), " nodes, ").concat(String(graph.size), " edges."),
+                                        manifestInfo ? "\n".concat(manifestInfo) : "",
+                                        "",
+                                        "Available next steps:",
+                                        "  • 'regions' — list enabled AWS regions",
+                                        "  • 'detect' — find unused/orphaned resources",
+                                        "  • 'export' — export graph to gexf, json, or markdown"
+                                    ].join("\n")
+                                }
+                            ]
+                        }
+                    ];
+                case 7:
+                    error = _state.sent();
+                    graph = undefined;
+                    inventory = undefined;
+                    return [
+                        2,
+                        {
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": "✗ Load failed: ".concat(_instanceof(error, Error) ? error.message : String(error), "\n\nEnsure the directory was created by gnaws dump and contains valid resource files.")
+                                }
+                            ],
+                            "isError": true
+                        }
+                    ];
+                case 8:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+// ─── Tool: regions ───────────────────────────────────────────────────────────
+server.registerTool("regions", {
+    "title": "List Regions",
+    "description": "List enabled AWS regions from the loaded inventory. Requires 'scan' or 'load' to be called first.",
+    "inputSchema": z.object({})
+}, function() {
+    if (!inventory) {
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✗ No inventory loaded. Call 'scan' (with an AWS profile) or 'load' (with a dump directory) first."
+                }
+            ],
+            "isError": true
+        };
+    }
+    var regions = inventory.getAccountRegions();
+    var regionNames = regions.map(function(r) {
+        var _r_RegionName;
+        return (_r_RegionName = r.RegionName) !== null && _r_RegionName !== void 0 ? _r_RegionName : "unknown";
+    });
+    return {
+        "content": [
+            {
+                "type": "text",
+                "text": [
+                    "".concat(String(regions.length), " enabled regions:"),
+                    ""
+                ].concat(_to_consumable_array(regionNames.map(function(name) {
+                    return "  • ".concat(name);
+                }))).join("\n")
+            }
+        ]
+    };
+});
+// ─── Tool: detect ────────────────────────────────────────────────────────────
+server.registerTool("detect", {
+    "title": "Detect Unused Resources",
+    "description": "Detect structurally unused/orphaned resources in the loaded graph. Requires 'scan' or 'load' to be called first. Optionally export findings to a file (.json or .md).",
+    "inputSchema": z.object({
+        "outputPath": z.string().optional().describe("Optional path to write findings (.json or .md). If omitted, returns findings as text.")
+    })
+}, function(param) {
+    var outputPath = param.outputPath;
+    if (!graph || !inventory) {
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✗ No graph built yet. Call 'scan' or 'load' first to build the resource graph."
+                }
+            ],
+            "isError": true
+        };
+    }
+    try {
+        var detector = new UnusedDetector();
+        var findings = detector.detect(inventory, graph);
+        if (findings.length === 0) {
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "✓ No unused resources detected. All resources have structural connections."
+                    }
+                ]
+            };
+        }
+        // Export to file if path provided
+        if (outputPath) {
+            if (outputPath.endsWith(".json")) {
+                writeFileSync(outputPath, JSON.stringify(findings, null, 2));
+            } else if (outputPath.endsWith(".md")) {
+                var lines = [
+                    "# Unused Resources",
+                    "",
+                    "> ".concat(String(findings.length), " findings detected"),
+                    "",
+                    "| Confidence | Resource | ARN | Type | Region | Reason |",
+                    "|------------|----------|-----|------|--------|--------|"
+                ].concat(_to_consumable_array(findings.map(function(f) {
+                    return "| ".concat(f.confidence, " | ").concat(f.name, " | ").concat(f.arn, " | ").concat(f.resourceType, " | ").concat(f.region, " | ").concat(f.reason, " |");
+                })));
+                writeFileSync(outputPath, lines.join("\n"));
+            } else {
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "✗ Unsupported output format. Use .json or .md extension."
+                        }
+                    ],
+                    "isError": true
+                };
+            }
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "✓ ".concat(String(findings.length), " unused resources found and written to ").concat(outputPath, ".")
+                    }
+                ]
+            };
+        }
+        // Return findings as text
+        var summary = findings.map(function(f) {
+            return "  [".concat(f.confidence, "] ").concat(f.resourceType, " | ").concat(f.region, " | ").concat(f.name, " — ").concat(f.reason);
+        });
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": [
+                        "".concat(String(findings.length), " unused resources detected:"),
+                        ""
+                    ].concat(_to_consumable_array(summary), [
+                        "",
+                        "Tip: call 'detect' with outputPath (.json or .md) to save findings to a file."
+                    ]).join("\n")
+                }
+            ]
+        };
+    } catch (error) {
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✗ Detection failed: ".concat(_instanceof(error, Error) ? error.message : String(error))
+                }
+            ],
+            "isError": true
+        };
+    }
+});
+// ─── Tool: export ────────────────────────────────────────────────────────────
+server.registerTool("export", {
+    "title": "Export Graph",
+    "description": "Export the resource graph to a file. Requires 'scan' or 'load' to be called first. Supported formats: gexf (Gephi), json (sigma.js viewer), md (markdown report).",
+    "inputSchema": z.object({
+        "format": z.enum([
+            "gexf",
+            "json",
+            "md"
+        ]).describe("Export format: 'gexf' for Gephi, 'json' for sigma.js viewer, 'md' for markdown report"),
+        "path": z.string().optional().describe("Output file path. Defaults to graph.gexf, graph.json, or report.md")
+    })
+}, function(param) {
+    var format = param.format, path = param.path;
+    if (!graph || !inventory) {
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✗ No graph built yet. Call 'scan' or 'load' first to build the resource graph."
+                }
+            ],
+            "isError": true
+        };
+    }
+    try {
+        var ext = format === "md" ? ".md" : ".".concat(format);
+        var defaultName = format === "md" ? "report.md" : "graph.".concat(format);
+        var outputPath = path !== null && path !== void 0 ? path : defaultName;
+        if (!outputPath.endsWith(ext)) {
+            outputPath += ext;
+        }
+        if (format === "gexf") {
+            new GexfExporter().export(outputPath, inventory, graph);
+        } else if (format === "json") {
+            new JsonExporter().export(outputPath, inventory, graph);
+        } else {
+            new MarkdownExporter().export(outputPath, inventory, graph);
+        }
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✓ Exported ".concat(String(graph.order), " nodes and ").concat(String(graph.size), " edges to ").concat(outputPath, ".")
+                }
+            ]
+        };
+    } catch (error) {
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✗ Export failed: ".concat(_instanceof(error, Error) ? error.message : String(error))
+                }
+            ],
+            "isError": true
+        };
+    }
+});
+// ─── Tool: dump ──────────────────────────────────────────────────────────────
+server.registerTool("dump", {
+    "title": "Dump Resources",
+    "description": "Dump loaded resources to a directory for offline use. Requires 'scan' or 'load' to be called first. The output can later be used with 'load' for offline analysis.",
+    "inputSchema": z.object({
+        "path": z.string().optional().describe("Output directory path. Defaults to 'dump'.")
+    })
+}, function(param) {
+    var path = param.path;
+    if (!inventory) {
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✗ No inventory loaded. Call 'scan' or 'load' first."
+                }
+            ],
+            "isError": true
+        };
+    }
+    try {
+        var outputDir = path !== null && path !== void 0 ? path : "dump";
+        var writer = new CacheWriter(outputDir);
+        writer.writeAll(inventory);
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": [
+                        "✓ Resources dumped to ".concat(outputDir, "."),
+                        "",
+                        "The dump can be loaded later with the 'load' tool for offline analysis."
+                    ].join("\n")
+                }
+            ]
+        };
+    } catch (error) {
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": "✗ Dump failed: ".concat(_instanceof(error, Error) ? error.message : String(error))
+                }
+            ],
+            "isError": true
+        };
+    }
+});
+// ─── Main ────────────────────────────────────────────────────────────────────
+process.on("uncaughtException", function(error) {
+    console.error("[gnaws-mcp] Uncaught exception:", error);
+    process.exit(1);
+});
+process.on("unhandledRejection", function(reason) {
+    console.error("[gnaws-mcp] Unhandled rejection:", reason);
+    process.exit(1);
+});
+function main() {
+    return _async_to_generator(function() {
+        var transport;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    transport = new StdioServerTransport();
+                    return [
+                        4,
+                        server.connect(transport)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+main().catch(function(error) {
+    console.error("[gnaws-mcp] Fatal error in main():", error);
+    process.exit(1);
+});