@infrawise/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# @infrawise/mcp-server
+
+Claude Code MCP server for Infrawise Azure FinOps recommendations.
+
+## What it provides
+
+Tools exposed to Claude Code:
+
+- `get_idle_resources`
+- `get_sku_optimizations`
+- `get_general_recommendations`
+- `get_savings_summary`
+
+All tools support optional `subscription_filter` (subscription UUID).
+
+## 5-minute setup
+
+```bash
+# 1) Authenticate once with Azure AD device code flow
+npx @infrawise/mcp-server auth
+```
+
+Add this to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "infrawise": {
+      "command": "npx",
+      "args": ["@infrawise/mcp-server"]
+    }
+  }
+}
+```
+
+Restart Claude Code.
+
+## Local development
+
+```bash
+cd packages/claude-mcp
+npm install
+npm run build
+node dist/index.js auth
+```
+
+## Environment variables
+
+- `INFRAWISE_API_BASE` (default: `https://api.infrawiseai.com/api`)
+- `INFRAWISE_AZURE_CLIENT_ID` (default: Infrawise API app ID)
+- `INFRAWISE_AZURE_API_SCOPE` (default: `api://<clientId>/delegated_access`)
+- `INFRAWISE_AZURE_AUTHORITY` (default: `https://login.microsoftonline.com/common`)
+
+## Security
+
+- Token cache is stored at `~/.infrawise/mcp-credentials.json`
+- Credentials file is written with `0600` mode (best effort on Windows)
+- Server is read-only and uses GET calls only

package/dist/auth.d.ts

@@ -0,0 +1,10 @@
+export declare class NotAuthenticatedError extends Error {
+    constructor(message?: string);
+}
+export interface AuthSettings {
+    authority: string;
+    clientId: string;
+    scope: string;
+}
+export declare function runDeviceCodeAuth(): Promise<void>;
+export declare function getAccessToken(): Promise<string>;

package/dist/auth.js

@@ -0,0 +1,135 @@
+import { PublicClientApplication } from "@azure/msal-node";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_AUTHORITY = "https://login.microsoftonline.com/common";
+const DEFAULT_API_CLIENT_ID = "06dc6d06-11f1-4543-bb2c-9c91b263df56";
+const DEFAULT_SCOPE = `api://${DEFAULT_API_CLIENT_ID}/delegated_access`;
+const CREDENTIALS_DIR = ".infrawise";
+const CREDENTIALS_FILE = "mcp-credentials.json";
+export class NotAuthenticatedError extends Error {
+    constructor(message = "Not authenticated. Run: npx @infrawise/mcp-server auth") {
+        super(message);
+        this.name = "NotAuthenticatedError";
+    }
+}
+function getAuthSettings() {
+    const clientId = process.env.INFRAWISE_AZURE_CLIENT_ID ?? DEFAULT_API_CLIENT_ID;
+    const scope = process.env.INFRAWISE_AZURE_API_SCOPE ?? `api://${clientId}/delegated_access`;
+    return {
+        authority: process.env.INFRAWISE_AZURE_AUTHORITY ?? DEFAULT_AUTHORITY,
+        clientId,
+        scope,
+    };
+}
+function getCredentialFilePath() {
+    return path.join(os.homedir(), CREDENTIALS_DIR, CREDENTIALS_FILE);
+}
+async function readCachePayload() {
+    const credentialPath = getCredentialFilePath();
+    try {
+        const raw = await fs.readFile(credentialPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.cache !== "string" || typeof parsed.clientId !== "string" || typeof parsed.scope !== "string") {
+            return null;
+        }
+        return {
+            authority: parsed.authority ?? DEFAULT_AUTHORITY,
+            clientId: parsed.clientId,
+            scope: parsed.scope,
+            homeAccountId: parsed.homeAccountId,
+            cache: parsed.cache,
+            updatedAt: parsed.updatedAt ?? new Date(0).toISOString(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCachePayload(payload) {
+    const credentialPath = getCredentialFilePath();
+    const credentialDir = path.dirname(credentialPath);
+    await fs.mkdir(credentialDir, { recursive: true });
+    await fs.writeFile(credentialPath, JSON.stringify(payload, null, 2), { encoding: "utf8", mode: 0o600 });
+    try {
+        await fs.chmod(credentialPath, 0o600);
+    }
+    catch {
+        // Best-effort on Windows.
+    }
+}
+async function createClientFromSettings(settings) {
+    const payload = await readCachePayload();
+    const client = new PublicClientApplication({
+        auth: {
+            clientId: settings.clientId,
+            authority: settings.authority,
+        },
+    });
+    if (payload?.cache) {
+        await client.getTokenCache().deserialize(payload.cache);
+    }
+    return { client, payload };
+}
+async function getPreferredAccount(client, homeAccountId) {
+    if (homeAccountId) {
+        const exact = await client.getTokenCache().getAccountByHomeId(homeAccountId);
+        if (exact) {
+            return exact;
+        }
+    }
+    const allAccounts = await client.getTokenCache().getAllAccounts();
+    return allAccounts[0] ?? null;
+}
+async function persistClientCache(client, settings, account) {
+    const serialized = await client.getTokenCache().serialize();
+    await writeCachePayload({
+        authority: settings.authority,
+        clientId: settings.clientId,
+        scope: settings.scope,
+        homeAccountId: account?.homeAccountId,
+        cache: serialized,
+        updatedAt: new Date().toISOString(),
+    });
+}
+export async function runDeviceCodeAuth() {
+    const settings = getAuthSettings();
+    const { client } = await createClientFromSettings(settings);
+    const request = {
+        scopes: [settings.scope, "openid", "profile"],
+        deviceCodeCallback: (response) => {
+            const msg = response.message ??
+                `To authenticate, visit https://microsoft.com/devicelogin and enter the code: ${response.userCode}`;
+            console.error(`[Infrawise MCP] ${msg}`);
+        },
+    };
+    const result = await client.acquireTokenByDeviceCode(request);
+    if (!result || !result.account) {
+        throw new Error("Device Code authentication did not return an account.");
+    }
+    await persistClientCache(client, settings, result.account);
+    console.error(`[Infrawise MCP] Authentication complete. Token cache saved to ${getCredentialFilePath()}`);
+}
+export async function getAccessToken() {
+    const settings = getAuthSettings();
+    const { client, payload } = await createClientFromSettings(settings);
+    const account = await getPreferredAccount(client, payload?.homeAccountId);
+    if (!account) {
+        throw new NotAuthenticatedError();
+    }
+    const request = {
+        account,
+        scopes: [settings.scope],
+    };
+    try {
+        const result = await client.acquireTokenSilent(request);
+        if (!result?.accessToken) {
+            throw new NotAuthenticatedError();
+        }
+        await persistClientCache(client, settings, result.account ?? account);
+        return result.accessToken;
+    }
+    catch {
+        throw new NotAuthenticatedError();
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,7 @@
+export type InfrawiseErrorCode = "NOT_AUTHENTICATED" | "NOT_ONBOARDED" | "PENDING_DELEGATION" | "UPSTREAM_ERROR";
+export declare class InfrawiseClientError extends Error {
+    code: InfrawiseErrorCode;
+    status?: number;
+    constructor(code: InfrawiseErrorCode, message: string, status?: number);
+}
+export declare function getInfrawiseData<T>(path: string): Promise<T>;

package/dist/client.js

@@ -0,0 +1,102 @@
+import { NotAuthenticatedError, getAccessToken } from "./auth.js";
+const DEFAULT_API_BASE = "https://api.infrawiseai.com/api";
+const REQUEST_TIMEOUT_MS = 120_000;
+export class InfrawiseClientError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.name = "InfrawiseClientError";
+        this.code = code;
+        this.status = status;
+    }
+}
+function getApiBase() {
+    const value = process.env.INFRAWISE_API_BASE ?? DEFAULT_API_BASE;
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function getEndpoint(path) {
+    const base = getApiBase();
+    return `${base}${path.startsWith("/") ? path : `/${path}`}`;
+}
+async function fetchJson(path, token) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(getEndpoint(path), {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+            },
+            signal: controller.signal,
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new InfrawiseClientError("NOT_AUTHENTICATED", "Token rejected by Infrawise API. Re-authenticate with: npx @infrawise/mcp-server auth", response.status);
+        }
+        if (!response.ok) {
+            const body = await response.text();
+            throw new InfrawiseClientError("UPSTREAM_ERROR", `Infrawise API error (${response.status}) at ${path}: ${body || response.statusText}`, response.status);
+        }
+        return {
+            data: (await response.json()),
+            status: response.status,
+        };
+    }
+    catch (error) {
+        if (error instanceof InfrawiseClientError) {
+            throw error;
+        }
+        if (error instanceof NotAuthenticatedError) {
+            throw new InfrawiseClientError("NOT_AUTHENTICATED", error.message);
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new InfrawiseClientError("UPSTREAM_ERROR", "Infrawise API request timed out after 120 seconds.");
+        }
+        throw new InfrawiseClientError("UPSTREAM_ERROR", `Unexpected Infrawise API error: ${String(error)}`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function normalizeOnboardingState(status) {
+    const normalized = (status ?? "").toUpperCase();
+    if (normalized === "ACTIVE" || normalized === "PENDING_DELEGATION" || normalized === "EXPIRED" || normalized === "SUSPENDED") {
+        return normalized;
+    }
+    return "UNKNOWN";
+}
+async function assertTenantReady(token) {
+    const tenantValidation = await fetchJson("/auth/validate-tenant", token);
+    if (!tenantValidation.data?.authorized) {
+        throw new InfrawiseClientError("NOT_ONBOARDED", "Tenant is not authorized in Infrawise. Complete onboarding at https://infrawiseai.com/onboard", tenantValidation.status);
+    }
+    const onboarding = await fetchJson("/onboarding/status", token);
+    if (!Array.isArray(onboarding.data) || onboarding.data.length === 0) {
+        // Legacy allowlisted tenants may have no onboarding records.
+        return;
+    }
+    const states = onboarding.data.map((entry) => normalizeOnboardingState(entry.status));
+    if (states.includes("ACTIVE")) {
+        return;
+    }
+    if (states.includes("PENDING_DELEGATION")) {
+        throw new InfrawiseClientError("PENDING_DELEGATION", "Infrawise onboarding is pending Lighthouse delegation. Complete setup at https://infrawiseai.com/onboard");
+    }
+    throw new InfrawiseClientError("NOT_ONBOARDED", "No active Infrawise subscription found. Complete onboarding at https://infrawiseai.com/onboard");
+}
+export async function getInfrawiseData(path) {
+    let token;
+    try {
+        token = await getAccessToken();
+    }
+    catch (error) {
+        if (error instanceof NotAuthenticatedError) {
+            throw new InfrawiseClientError("NOT_AUTHENTICATED", error.message);
+        }
+        throw error;
+    }
+    await assertTenantReady(token);
+    const response = await fetchJson(path, token);
+    return response.data;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { runDeviceCodeAuth } from "./auth.js";
+import { InfrawiseClientError } from "./client.js";
+import { getGeneralRecommendations } from "./tools/general-recommendations.js";
+import { getIdleResources } from "./tools/idle-resources.js";
+import { getSavingsSummary } from "./tools/summary.js";
+import { getSkuOptimizations } from "./tools/sku-optimizations.js";
+function toToolSuccess(payload) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(payload, null, 2),
+            },
+        ],
+    };
+}
+function toToolError(error) {
+    if (error instanceof InfrawiseClientError) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        code: error.code,
+                        message: error.message,
+                        status: error.status,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        isError: true,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    code: "UPSTREAM_ERROR",
+                    message: error instanceof Error ? error.message : String(error),
+                }, null, 2),
+            },
+        ],
+    };
+}
+async function runAuthMode() {
+    try {
+        await runDeviceCodeAuth();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[Infrawise MCP] Authentication failed: ${message}`);
+        process.exitCode = 1;
+    }
+}
+async function runServerMode() {
+    const server = new McpServer({
+        name: "@infrawise/mcp-server",
+        version: "0.1.0",
+    });
+    const filterSchema = {
+        subscription_filter: z
+            .string()
+            .uuid()
+            .optional()
+            .describe("Optional subscription ID to filter results. When omitted, returns merged results across all accessible subscriptions."),
+    };
+    server.tool("get_idle_resources", "Retrieve idle and zombie Azure resources that can be deleted or deallocated for cost savings.", filterSchema, async ({ subscription_filter }) => {
+        try {
+            const result = await getIdleResources(subscription_filter);
+            return toToolSuccess(result);
+        }
+        catch (error) {
+            return toToolError(error);
+        }
+    });
+    server.tool("get_sku_optimizations", "Retrieve rightsizing recommendations for overprovisioned resources.", filterSchema, async ({ subscription_filter }) => {
+        try {
+            const result = await getSkuOptimizations(subscription_filter);
+            return toToolSuccess(result);
+        }
+        catch (error) {
+            return toToolError(error);
+        }
+    });
+    server.tool("get_general_recommendations", "Retrieve strategic purchasing and licensing optimization recommendations.", filterSchema, async ({ subscription_filter }) => {
+        try {
+            const result = await getGeneralRecommendations(subscription_filter);
+            return toToolSuccess(result);
+        }
+        catch (error) {
+            return toToolError(error);
+        }
+    });
+    server.tool("get_savings_summary", "Aggregate savings totals across idle resources, SKU rightsizing, and general recommendations.", filterSchema, async ({ subscription_filter }) => {
+        try {
+            const result = await getSavingsSummary(subscription_filter);
+            return toToolSuccess(result);
+        }
+        catch (error) {
+            return toToolError(error);
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+async function main() {
+    const mode = process.argv[2];
+    if (mode === "auth") {
+        await runAuthMode();
+        return;
+    }
+    await runServerMode();
+}
+await main();

package/dist/tools/general-recommendations.d.ts

@@ -0,0 +1,2 @@
+import { type GeneralRecommendation } from "./types.js";
+export declare function getGeneralRecommendations(subscriptionFilter?: string): Promise<GeneralRecommendation[]>;

package/dist/tools/general-recommendations.js

@@ -0,0 +1,7 @@
+import { getInfrawiseData } from "../client.js";
+import { filterBySubscription } from "./types.js";
+export async function getGeneralRecommendations(subscriptionFilter) {
+    const data = await getInfrawiseData("/general-recommendations");
+    const rows = Array.isArray(data) ? data : [];
+    return filterBySubscription(rows, subscriptionFilter);
+}

package/dist/tools/idle-resources.d.ts

@@ -0,0 +1,2 @@
+import { type IdleResource } from "./types.js";
+export declare function getIdleResources(subscriptionFilter?: string): Promise<IdleResource[]>;

package/dist/tools/idle-resources.js

@@ -0,0 +1,7 @@
+import { getInfrawiseData } from "../client.js";
+import { filterBySubscription } from "./types.js";
+export async function getIdleResources(subscriptionFilter) {
+    const data = await getInfrawiseData("/idle-resources");
+    const rows = Array.isArray(data) ? data : [];
+    return filterBySubscription(rows, subscriptionFilter);
+}

package/dist/tools/sku-optimizations.d.ts

@@ -0,0 +1,2 @@
+import { type SkuOptimization } from "./types.js";
+export declare function getSkuOptimizations(subscriptionFilter?: string): Promise<SkuOptimization[]>;

package/dist/tools/sku-optimizations.js

@@ -0,0 +1,7 @@
+import { getInfrawiseData } from "../client.js";
+import { filterBySubscription } from "./types.js";
+export async function getSkuOptimizations(subscriptionFilter) {
+    const data = await getInfrawiseData("/sku-optimizations");
+    const rows = Array.isArray(data) ? data : [];
+    return filterBySubscription(rows, subscriptionFilter);
+}

package/dist/tools/summary.d.ts

@@ -0,0 +1,23 @@
+interface SavingsBucket {
+    count: number;
+    totalMonthlySavings: number;
+    totalAnnualSavings: number;
+}
+interface IdleSavingsBucket extends SavingsBucket {
+    highRisk: number;
+    mediumRisk: number;
+    lowRisk: number;
+}
+export interface SavingsSummary {
+    idleResources: IdleSavingsBucket;
+    skuOptimizations: SavingsBucket;
+    generalRecommendations: SavingsBucket;
+    grandTotal: {
+        totalMonthlySavings: number;
+        totalAnnualSavings: number;
+    };
+    subscription: string;
+    generatedAt: string;
+}
+export declare function getSavingsSummary(subscriptionFilter?: string): Promise<SavingsSummary>;
+export {};

package/dist/tools/summary.js

@@ -0,0 +1,79 @@
+import { getGeneralRecommendations } from "./general-recommendations.js";
+import { getIdleResources } from "./idle-resources.js";
+import { getSkuOptimizations } from "./sku-optimizations.js";
+import { toNumber } from "./types.js";
+function roundCurrency(value) {
+    return Math.round(value * 100) / 100;
+}
+export async function getSavingsSummary(subscriptionFilter) {
+    const [idleResources, skuOptimizations, generalRecommendations] = await Promise.all([
+        getIdleResources(subscriptionFilter),
+        getSkuOptimizations(subscriptionFilter),
+        getGeneralRecommendations(subscriptionFilter),
+    ]);
+    const idleMonthly = idleResources.reduce((sum, item) => sum + toNumber(item.monthlyCost), 0);
+    const idleAnnual = idleResources.reduce((sum, item) => {
+        const annual = toNumber(item.annualCost);
+        if (annual > 0) {
+            return sum + annual;
+        }
+        return sum + toNumber(item.monthlyCost) * 12;
+    }, 0);
+    const skuMonthly = skuOptimizations.reduce((sum, item) => sum + toNumber(item.monthlySavings), 0);
+    const skuAnnual = skuOptimizations.reduce((sum, item) => {
+        const annual = toNumber(item.annualSavings);
+        if (annual > 0) {
+            return sum + annual;
+        }
+        return sum + toNumber(item.monthlySavings) * 12;
+    }, 0);
+    const generalMonthly = generalRecommendations.reduce((sum, item) => sum + toNumber(item.estimatedMonthlySavings), 0);
+    const generalAnnual = generalRecommendations.reduce((sum, item) => {
+        const annual = toNumber(item.estimatedAnnualSavings);
+        if (annual > 0) {
+            return sum + annual;
+        }
+        return sum + toNumber(item.estimatedMonthlySavings) * 12;
+    }, 0);
+    const idleRiskCounts = idleResources.reduce((acc, item) => {
+        const risk = (item.riskLevel ?? "").toLowerCase();
+        if (risk === "high") {
+            acc.highRisk += 1;
+        }
+        else if (risk === "medium") {
+            acc.mediumRisk += 1;
+        }
+        else if (risk === "low") {
+            acc.lowRisk += 1;
+        }
+        return acc;
+    }, { highRisk: 0, mediumRisk: 0, lowRisk: 0 });
+    const grandMonthly = idleMonthly + skuMonthly + generalMonthly;
+    const grandAnnual = idleAnnual + skuAnnual + generalAnnual;
+    return {
+        idleResources: {
+            count: idleResources.length,
+            totalMonthlySavings: roundCurrency(idleMonthly),
+            totalAnnualSavings: roundCurrency(idleAnnual),
+            highRisk: idleRiskCounts.highRisk,
+            mediumRisk: idleRiskCounts.mediumRisk,
+            lowRisk: idleRiskCounts.lowRisk,
+        },
+        skuOptimizations: {
+            count: skuOptimizations.length,
+            totalMonthlySavings: roundCurrency(skuMonthly),
+            totalAnnualSavings: roundCurrency(skuAnnual),
+        },
+        generalRecommendations: {
+            count: generalRecommendations.length,
+            totalMonthlySavings: roundCurrency(generalMonthly),
+            totalAnnualSavings: roundCurrency(generalAnnual),
+        },
+        grandTotal: {
+            totalMonthlySavings: roundCurrency(grandMonthly),
+            totalAnnualSavings: roundCurrency(grandAnnual),
+        },
+        subscription: subscriptionFilter ?? "all",
+        generatedAt: new Date().toISOString(),
+    };
+}

package/dist/tools/types.d.ts

@@ -0,0 +1,48 @@
+export interface IdleResource {
+    resourceId?: string;
+    resourceName?: string;
+    resourceType?: string;
+    monthlyCost?: number | null;
+    annualCost?: number | null;
+    lastActivityDays?: number | null;
+    utilizationPercent?: number | null;
+    recommendation?: string;
+    reason?: string;
+    riskLevel?: string;
+    difficulty?: string;
+}
+export interface SkuOptimization {
+    resourceId?: string;
+    resourceName?: string;
+    resourceType?: string;
+    currentSku?: string;
+    recommendedSku?: string;
+    currentMonthlyCost?: number | null;
+    projectedMonthlyCost?: number | null;
+    monthlySavings?: number | null;
+    annualSavings?: number | null;
+    reason?: string;
+    riskLevel?: string;
+    difficulty?: string;
+}
+export interface GeneralRecommendation {
+    resourceId?: string;
+    resourceName?: string;
+    resourceType?: string;
+    category?: string;
+    title?: string;
+    reason?: string;
+    estimatedMonthlySavings?: number | null;
+    estimatedAnnualSavings?: number | null;
+    impact?: string;
+    riskLevel?: string;
+    difficulty?: string;
+}
+export interface ToolFilterInput {
+    subscription_filter?: string;
+}
+export declare function extractSubscriptionId(resourceId: string | undefined): string | null;
+export declare function filterBySubscription<T extends {
+    resourceId?: string;
+}>(items: T[], subscriptionFilter?: string): T[];
+export declare function toNumber(value: number | null | undefined): number;

package/dist/tools/types.js

@@ -0,0 +1,17 @@
+export function extractSubscriptionId(resourceId) {
+    if (!resourceId) {
+        return null;
+    }
+    const match = resourceId.match(/\/subscriptions\/([^/]+)/i);
+    return match?.[1]?.toLowerCase() ?? null;
+}
+export function filterBySubscription(items, subscriptionFilter) {
+    if (!subscriptionFilter) {
+        return items;
+    }
+    const normalized = subscriptionFilter.trim().toLowerCase();
+    return items.filter((item) => extractSubscriptionId(item.resourceId) === normalized);
+}
+export function toNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@infrawise/mcp-server",
+  "version": "0.1.0",
+  "description": "Infrawise MCP server for Claude Code",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "infrawise-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/admonitor-inc/infrawise.git",
+    "directory": "packages/claude-mcp"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "azure",
+    "finops",
+    "infrawise"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@azure/msal-node": "^3.8.3",
+    "@modelcontextprotocol/sdk": "^1.18.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.6",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.2"
+  }
+}