infrawise 0.12.5 → 0.12.6

package/README.md

@@ -149,7 +149,7 @@ Add to your editor's MCP config:
 
 | Tool                         | What it provides                                                                                            |
 | ---------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `get_infra_overview`         | Complete snapshot — all services, counts, and high-severity findings                                        |
+| `get_infra_overview`         | Complete snapshot — all services, counts, high-severity findings, and a `configured` flag                   |
 | `get_graph_summary`          | Full infrastructure graph — all nodes, edges, and findings                                                  |
 | `analyze_function`           | Issues in a specific function — scans, missing indexes, N+1, trigger event shapes                           |
 | `suggest_gsi`                | Exact GSI config for a DynamoDB table + attribute                                                           |

package/dist/cli/commands/serve.js

@@ -2,8 +2,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
-import { loadConfig, formatError, readCache, setCacheDir } from '../../core/index.js';
-import { createServer, setGraphState } from '../../server/index.js';
+import { loadConfig, readCache, setCacheDir } from '../../core/index.js';
+import { createServer, setGraphState, setConfigured } from '../../server/index.js';
 import { log, printHeader } from '../utils.js';
 import { runAnalyze, runCodeRefresh } from './analyze.js';
 import { runStdio } from './stdio.js';
@@ -26,8 +26,10 @@ const TOOL_MAP = [
     { name: 'get_api_routes', service: 'apiGateway' },
     { name: 'get_log_errors', service: 'cloudwatchLogs' },
 ];
+// With no config every registered tool is shown as active (the server exposes
+// all of them); a config narrows the list to its enabled services.
 function isEnabled(cfg, service) {
-    if (!service)
+    if (!service || !cfg)
         return true;
     const svc = cfg[service];
     return svc?.enabled === true;
@@ -63,16 +65,18 @@ export async function runServe(options = {}) {
     }
     const port = options.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : 3000);
     printHeader('MCP Server');
+    setCacheDir(path.dirname(path.resolve(options.config ?? 'infrawise.yaml')));
+    // A hosted MCP runtime may launch the server with no infrawise.yaml. Start
+    // anyway with an empty graph so the host can connect and list tools.
     let config;
     try {
         config = loadConfig(options.config);
-        setCacheDir(path.dirname(path.resolve(options.config ?? 'infrawise.yaml')));
         log.success('Config loaded', options.config ?? 'infrawise.yaml');
     }
     catch (err) {
-        console.error(formatError(err));
-        process.exit(1);
+        log.warn(`Starting with empty graph (no config loaded): ${err instanceof Error ? err.message : String(err)}`);
     }
+    setConfigured(config !== undefined);
     const repoPath = process.cwd();
     // Auto-analyze if no cache
     const cachedGraph = readCache('graph');
@@ -81,7 +85,7 @@ export async function runServe(options = {}) {
         log.success('Cached analysis loaded', `${cachedGraph.nodes.length} nodes · ${cachedGraph.edges.length} edges · ${cachedFindings.length} finding(s)`);
         setGraphState(cachedGraph, cachedFindings);
     }
-    else {
+    else if (config) {
         log.warn('No cache found — running analysis now...');
         console.log('');
         await runAnalyze({ repo: repoPath, config: options.config });
@@ -89,6 +93,9 @@ export async function runServe(options = {}) {
         const freshFindings = readCache('findings') ?? [];
         setGraphState(freshGraph, freshFindings);
     }
+    else {
+        setGraphState({ nodes: [], edges: [] }, []);
+    }
     console.log('');
     // Start server
     const spin = ora({ text: chalk.dim('Starting server...'), color: 'cyan' }).start();
@@ -127,49 +134,55 @@ export async function runServe(options = {}) {
     console.log(chalk.dim(`  claude mcp add --transport http infrawise ${mcpUrl}`));
     console.log('');
     console.log(chalk.dim('  Watching for file changes... Press Ctrl+C to stop\n'));
-    // File watch — re-run code analysis on save, skip slow AWS/DB extraction
-    let debounceTimer = null;
-    let refreshing = false;
-    const configFile = path.resolve(options.config ?? 'infrawise.yaml');
-    try {
-        fs.watch(repoPath, { recursive: true }, (_, filename) => {
-            if (!filename)
-                return;
-            const abs = path.join(repoPath, filename);
-            if (abs === configFile) {
-                console.log(chalk.dim('\n  infrawise.yaml changed — restart to apply config changes\n'));
-                return;
-            }
-            const ext = path.extname(filename);
-            if (!['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext))
-                return;
-            if (filename.includes('node_modules') || filename.startsWith('.infrawise'))
-                return;
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(async () => {
-                if (refreshing)
+    // File watch — re-run code analysis on save (needs a config to drive analyzers)
+    if (config) {
+        const cfg = config;
+        let debounceTimer = null;
+        let refreshing = false;
+        const configFile = path.resolve(options.config ?? 'infrawise.yaml');
+        try {
+            fs.watch(repoPath, { recursive: true }, (_, filename) => {
+                if (!filename)
+                    return;
+                const abs = path.join(repoPath, filename);
+                if (abs === configFile) {
+                    console.log(chalk.dim('\n  infrawise.yaml changed — restart to apply config changes\n'));
                     return;
-                refreshing = true;
-                const spin = ora({ text: chalk.dim('Refreshing code analysis...'), color: 'cyan' }).start();
-                try {
-                    const { graph, findings } = await runCodeRefresh(repoPath, config);
-                    setGraphState(graph, findings);
-                    spin.succeed(chalk.green('Analysis refreshed') +
-                        chalk.dim(`  ${graph.nodes.length} nodes · ${findings.length} finding(s)`));
-                }
-                catch (err) {
-                    spin.warn(chalk.yellow('Refresh failed') +
-                        chalk.dim(`  ${err instanceof Error ? err.message : String(err)}`));
-                }
-                finally {
-                    refreshing = false;
                 }
-            }, 2000);
-        });
-    }
-    catch {
-        // fs.watch may not support recursive on all platforms — silently skip
+                const ext = path.extname(filename);
+                if (!['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext))
+                    return;
+                if (filename.includes('node_modules') || filename.startsWith('.infrawise'))
+                    return;
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(async () => {
+                    if (refreshing)
+                        return;
+                    refreshing = true;
+                    const spin = ora({
+                        text: chalk.dim('Refreshing code analysis...'),
+                        color: 'cyan',
+                    }).start();
+                    try {
+                        const { graph, findings } = await runCodeRefresh(repoPath, cfg);
+                        setGraphState(graph, findings);
+                        spin.succeed(chalk.green('Analysis refreshed') +
+                            chalk.dim(`  ${graph.nodes.length} nodes · ${findings.length} finding(s)`));
+                    }
+                    catch (err) {
+                        spin.warn(chalk.yellow('Refresh failed') +
+                            chalk.dim(`  ${err instanceof Error ? err.message : String(err)}`));
+                    }
+                    finally {
+                        refreshing = false;
+                    }
+                }, 2000);
+            });
+        }
+        catch {
+            // fs.watch may not support recursive on all platforms — silently skip
+        }
     }
     process.on('SIGINT', () => {
         console.log(chalk.dim('\n  Shutting down...\n'));

package/dist/cli/commands/stdio.js

@@ -1,72 +1,81 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { loadConfig, formatError, readCache, setCacheDir } from '../../core/index.js';
-import { createMcpServer, setGraphState } from '../../server/index.js';
+import { loadConfig, readCache, setCacheDir } from '../../core/index.js';
+import { createMcpServer, setGraphState, setConfigured } from '../../server/index.js';
 import { runAnalyze, runCodeRefresh } from './analyze.js';
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 export async function runStdio(configPath) {
+    const resolvedConfigPath = configPath ?? 'infrawise.yaml';
+    setCacheDir(path.dirname(path.resolve(resolvedConfigPath)));
+    // A hosted MCP runtime (e.g. Glama) launches the server with no infrawise.yaml.
+    // Start anyway with an empty graph so the host can connect and list tools;
+    // analysis populates once a config is present.
     let config;
     try {
         config = loadConfig(configPath);
     }
     catch (err) {
-        process.stderr.write(formatError(err) + '\n');
-        process.exit(1);
+        process.stderr.write(`infrawise: starting with empty graph (no config loaded: ${err instanceof Error ? err.message : String(err)})\n`);
     }
-    const resolvedConfigPath = configPath ?? 'infrawise.yaml';
-    setCacheDir(path.dirname(path.resolve(resolvedConfigPath)));
+    setConfigured(config !== undefined);
     const cachedGraph = readCache('graph', CACHE_TTL_MS);
     const cachedFindings = readCache('findings', CACHE_TTL_MS);
     if (cachedGraph && cachedFindings) {
         setGraphState(cachedGraph, cachedFindings);
     }
-    else {
+    else if (config) {
         await runAnalyze({ config: configPath });
         const graph = readCache('graph', CACHE_TTL_MS) ?? { nodes: [], edges: [] };
         const findings = readCache('findings', CACHE_TTL_MS) ?? [];
         setGraphState(graph, findings);
     }
-    // File watching — re-run code analysis on save (no AWS calls, instant)
-    // stderr is safe in stdio transport; stdout is reserved for MCP JSON-RPC
-    const repoPath = process.cwd();
-    const configFile = path.resolve(resolvedConfigPath);
-    let debounceTimer = null;
-    let refreshing = false;
-    try {
-        fs.watch(repoPath, { recursive: true }, (_, filename) => {
-            if (!filename)
-                return;
-            const abs = path.join(repoPath, filename);
-            if (abs === configFile)
-                return;
-            const ext = path.extname(filename);
-            if (!['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext))
-                return;
-            if (filename.includes('node_modules') || filename.startsWith('.infrawise'))
-                return;
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(async () => {
-                if (refreshing)
-                    return;
-                refreshing = true;
-                try {
-                    const { graph, findings } = await runCodeRefresh(repoPath, config);
-                    setGraphState(graph, findings);
-                    process.stderr.write(`infrawise: code graph refreshed (${graph.nodes.length} nodes · ${findings.length} finding(s))\n`);
-                }
-                catch {
-                    // don't break the MCP connection on watcher errors
-                }
-                finally {
-                    refreshing = false;
-                }
-            }, 2000);
-        });
+    else {
+        setGraphState({ nodes: [], edges: [] }, []);
     }
-    catch {
-        // fs.watch recursive not supported on all platforms — silently skip
+    // File watching drives runCodeRefresh, which needs a config — skip it without one.
+    // stderr is safe in stdio transport; stdout is reserved for MCP JSON-RPC.
+    if (config) {
+        const cfg = config;
+        const repoPath = process.cwd();
+        const configFile = path.resolve(resolvedConfigPath);
+        let debounceTimer = null;
+        let refreshing = false;
+        try {
+            fs.watch(repoPath, { recursive: true }, (_, filename) => {
+                if (!filename)
+                    return;
+                const abs = path.join(repoPath, filename);
+                if (abs === configFile)
+                    return;
+                const ext = path.extname(filename);
+                if (!['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext))
+                    return;
+                if (filename.includes('node_modules') || filename.startsWith('.infrawise'))
+                    return;
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(async () => {
+                    if (refreshing)
+                        return;
+                    refreshing = true;
+                    try {
+                        const { graph, findings } = await runCodeRefresh(repoPath, cfg);
+                        setGraphState(graph, findings);
+                        process.stderr.write(`infrawise: code graph refreshed (${graph.nodes.length} nodes · ${findings.length} finding(s))\n`);
+                    }
+                    catch {
+                        // don't break the MCP connection on watcher errors
+                    }
+                    finally {
+                        refreshing = false;
+                    }
+                }, 2000);
+            });
+        }
+        catch {
+            // fs.watch recursive not supported on all platforms — silently skip
+        }
     }
     const mcp = createMcpServer();
     const transport = new StdioServerTransport();

package/dist/server/index.js

@@ -12,10 +12,17 @@ import { getTableNodes, getFunctionNodes, getQueueNodes, getTopicNodes, getSecre
 // ── State ────────────────────────────────────────────────────────────────────
 let currentGraph = { nodes: [], edges: [] };
 let currentFindings = [];
+// False when the server booted without an infrawise.yaml (e.g. a hosted MCP
+// runtime). Used to return a "run locally" hint instead of a bare empty graph.
+let configured = true;
 export function setGraphState(graph, findings) {
     currentGraph = graph;
     currentFindings = findings;
 }
+export function setConfigured(value) {
+    configured = value;
+}
+const NOT_CONFIGURED_HINT = 'No infrastructure loaded. infrawise reads your live infra locally — run `npx infrawise start` in your project (with AWS credentials and an infrawise.yaml) so these tools return your real DynamoDB/RDS/SQS/Lambda/etc. context. A remotely hosted instance has no access to your cloud account or code, so it returns empty results by design.';
 // ── Helpers ──────────────────────────────────────────────────────────────────
 function toText(data) {
     return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
@@ -31,7 +38,7 @@ function logged(name, fn) {
 export function createMcpServer() {
     const mcp = new McpServer({ name: 'infrawise', version });
     mcp.registerTool('get_infra_overview', {
-        description: 'Returns a compact infrastructure snapshot: service counts, all databases, queues, topics, secrets, lambdas, and high-severity findings. Call this first at the start of any database or infrastructure task to understand what services are in scope. Prefer this over get_graph_summary for quick orientation; use get_graph_summary only when you need every node, edge, and finding in full.',
+        description: 'Returns a compact infrastructure snapshot: service counts, all databases, queues, topics, secrets, lambdas, and high-severity findings. Call this first at the start of any database or infrastructure task to understand what services are in scope. Prefer this over get_graph_summary for quick orientation; use get_graph_summary only when you need every node, edge, and finding in full. Also returns a `configured` flag — when false, the server has no infrawise.yaml loaded (e.g. a remotely hosted instance) and all tools return empty results; a `setupHint` explains how to run infrawise locally.',
         inputSchema: z.object({}),
     }, logged('get_infra_overview', async () => {
         const tables = getTableNodes(currentGraph);
@@ -44,6 +51,8 @@ export function createMcpServer() {
         const functions = getFunctionNodes(currentGraph);
         const buckets = getBucketNodes(currentGraph);
         return toText({
+            configured,
+            ...(configured ? {} : { setupHint: NOT_CONFIGURED_HINT }),
             summary: {
                 tables: tables.length,
                 functions: functions.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infrawise",
-  "version": "0.12.5",
+  "version": "0.12.6",
   "mcpName": "io.github.Sidd27/infrawise",
   "description": "CLI-first infrastructure intelligence platform — analyzes DynamoDB, PostgreSQL, MySQL, MongoDB, SQS, SNS, SSM, Secrets Manager, Lambda, S3, API Gateway, CloudWatch Logs and exposes findings as an MCP server for Claude Code",
   "keywords": [