@sodiumhq/mcp-pm 0.1.0-beta.4448 → 0.1.0-beta.4465

package/dist/http.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { t as buildServer } from "./src-DEbTNFXg.mjs";
+import { t as buildServer } from "./src-uJ9liBF-.mjs";
 import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { createRemoteJWKSet, decodeJwt, jwtVerify } from "jose";
+import { hostname } from "node:os";
 //#region src/obo.ts
 const EXPIRY_MARGIN_MS = 6e4;
 const cache = /* @__PURE__ */ new Map();
@@ -62,6 +63,105 @@ function resolveExpiry(accessToken, expiresIn) {
 	return Date.now() + seconds * 1e3 - EXPIRY_MARGIN_MS;
 }
 //#endregion
+//#region src/telemetry.ts
+const FLUSH_INTERVAL_MS = Number(process.env.MCP_TELEMETRY_FLUSH_MS ?? 1e4);
+const MAX_BATCH = 20;
+const MAX_QUEUE = 1e3;
+const ERROR_LOG_THROTTLE_MS = 6e4;
+function loadTelemetryConfig(options) {
+	const raw = process.env.APPLICATIONINSIGHTS_CONNECTION_STRING?.trim();
+	if (!raw) return null;
+	const parts = new Map(raw.split(";").map((p) => p.trim()).filter(Boolean).map((p) => {
+		const eq = p.indexOf("=");
+		return [p.slice(0, eq).toLowerCase(), p.slice(eq + 1)];
+	}));
+	const instrumentationKey = parts.get("instrumentationkey");
+	const ingestionEndpoint = parts.get("ingestionendpoint");
+	if (!instrumentationKey || !ingestionEndpoint) return null;
+	return {
+		instrumentationKey,
+		ingestionEndpoint: ingestionEndpoint.replace(/\/+$/, ""),
+		roleName: options.roleName,
+		applicationVersion: options.applicationVersion
+	};
+}
+function formatDuration(ms) {
+	const clamped = Math.max(0, Math.round(ms));
+	const h = Math.floor(clamped / 36e5);
+	const m = Math.floor(clamped % 36e5 / 6e4);
+	const s = Math.floor(clamped % 6e4 / 1e3);
+	const f = clamped % 1e3;
+	const pad = (n, w = 2) => String(n).padStart(w, "0");
+	return `${pad(h)}:${pad(m)}:${pad(s)}.${pad(f, 3)}`;
+}
+var TelemetryClient = class {
+	queue = [];
+	lastErrorLogAt = 0;
+	constructor(config) {
+		this.config = config;
+		setInterval(() => void this.flush(), FLUSH_INTERVAL_MS).unref();
+		process.on("SIGTERM", () => void this.flush());
+	}
+	trackRequest(request) {
+		const properties = {};
+		if (request.practice) properties.practice = request.practice;
+		if (request.tool) properties.tool = request.tool;
+		if (request.outcome) properties.outcome = request.outcome;
+		if (request.aiClient) properties.aiClient = request.aiClient;
+		if (request.error) properties.error = request.error.slice(0, 1024);
+		this.enqueue({
+			name: `Microsoft.ApplicationInsights.${this.config.instrumentationKey.replace(/-/g, "")}.Request`,
+			time: (/* @__PURE__ */ new Date()).toISOString(),
+			iKey: this.config.instrumentationKey,
+			tags: {
+				"ai.cloud.role": this.config.roleName,
+				"ai.cloud.roleInstance": hostname(),
+				"ai.application.ver": this.config.applicationVersion,
+				"ai.operation.id": randomUUID(),
+				"ai.operation.name": request.name,
+				...request.userSubject ? { "ai.user.authUserId": request.userSubject } : {}
+			},
+			data: {
+				baseType: "RequestData",
+				baseData: {
+					ver: 2,
+					id: randomUUID().replace(/-/g, "").slice(0, 16),
+					name: request.name,
+					duration: formatDuration(request.durationMs),
+					responseCode: String(request.responseCode),
+					success: request.success,
+					properties
+				}
+			}
+		});
+	}
+	enqueue(envelope) {
+		this.queue.push(envelope);
+		if (this.queue.length > MAX_QUEUE) this.queue.splice(0, this.queue.length - MAX_QUEUE);
+		if (this.queue.length >= MAX_BATCH) this.flush();
+	}
+	async flush() {
+		if (this.queue.length === 0) return;
+		const batch = this.queue.splice(0, this.queue.length);
+		try {
+			const response = await fetch(`${this.config.ingestionEndpoint}/v2.1/track`, {
+				method: "POST",
+				headers: { "Content-Type": "application/x-json-stream" },
+				body: batch.map((e) => JSON.stringify(e)).join("\n")
+			});
+			if (!response.ok) this.logError(`ingestion responded ${response.status}`);
+		} catch (error) {
+			this.logError(error instanceof Error ? error.message : String(error));
+		}
+	}
+	logError(message) {
+		const now = Date.now();
+		if (now - this.lastErrorLogAt < ERROR_LOG_THROTTLE_MS) return;
+		this.lastErrorLogAt = now;
+		console.error(`[sodium-pm-mcp-http] telemetry flush failed: ${message}`);
+	}
+};
+//#endregion
 //#region src/auth.ts
 var AuthError = class extends Error {
 	constructor(status, code, message) {
@@ -71,11 +171,11 @@ var AuthError = class extends Error {
 	}
 };
 function loadAuthConfig() {
-	const resourceUrl = process.env.MCP_RESOURCE_URL;
+	const resourceUrl = process.env.MCP_RESOURCE_URL?.trim();
 	const issuer = process.env.AUTH0_ISSUER;
 	if (!resourceUrl || !issuer) return null;
 	return {
-		resourceUrl: resourceUrl.replace(/\/+$/, ""),
+		resourceUrl,
 		issuer: issuer.endsWith("/") ? issuer : `${issuer}/`,
 		scopes: {
 			read: process.env.MCP_SCOPE_READ ?? "mcp:read",
@@ -139,7 +239,25 @@ const writesRaw = (process.env.SODIUM_ENABLE_WRITES ?? "").trim().toLowerCase();
 const WRITES_ENABLED = writesRaw === "true" || writesRaw === "1";
 const AUTH = loadAuthConfig();
 const OBO = AUTH ? loadOboConfig(AUTH.issuer) : null;
-const ENDPOINT_PATH = AUTH ? new URL(AUTH.resourceUrl).pathname : process.env.MCP_ENDPOINT_PATH ?? "/mcp";
+const RESOURCE_PATH = AUTH ? new URL(AUTH.resourceUrl).pathname : process.env.MCP_ENDPOINT_PATH ?? "/mcp";
+const ENDPOINT_PATH = RESOURCE_PATH.length > 1 ? RESOURCE_PATH.replace(/\/+$/, "") : RESOURCE_PATH;
+const TELEMETRY_CONFIG = loadTelemetryConfig({
+	roleName: "sodium-pm-mcp",
+	applicationVersion: VERSION
+});
+const TELEMETRY = TELEMETRY_CONFIG ? new TelemetryClient(TELEMETRY_CONFIG) : null;
+function describeRequest(body) {
+	if (Array.isArray(body)) return "POST batch";
+	if (typeof body === "object" && body !== null && "method" in body) {
+		const method = String(body.method);
+		if (method === "tools/call") {
+			const params = body.params;
+			return `POST tools/call ${typeof params?.name === "string" ? params.name : "?"}`;
+		}
+		return `POST ${method}`;
+	}
+	return "POST unknown";
+}
 const MAX_BODY_BYTES = 4 * 1024 * 1024;
 async function readJsonBody(req) {
 	const chunks = [];
@@ -163,38 +281,70 @@ function sendJsonError(res, status, message) {
 	}));
 }
 async function handleMcpPost(req, res, body) {
-	const authHeader = req.headers.authorization;
-	if (!authHeader?.startsWith("Bearer ")) throw new HttpError(401, "Authorization: Bearer <token> header is required.");
-	const bearerToken = authHeader.slice(7).trim();
-	let writesAllowed = WRITES_ENABLED;
-	let apiToken = bearerToken;
-	if (AUTH) {
-		const verified = await verifyAccessToken(AUTH, bearerToken);
-		writesAllowed = WRITES_ENABLED && verified.scopes.includes(AUTH.scopes.write);
-		if (OBO) apiToken = await getDownstreamToken(OBO, bearerToken);
-	}
-	const tenantHeader = req.headers["x-sodium-tenant"];
-	const tenant = (Array.isArray(tenantHeader) ? tenantHeader[0] : tenantHeader) ?? process.env.SODIUM_TENANT;
-	const isInit = isInitializeRequest(body);
-	const server = await buildServer({
-		context: {
-			bearerToken: apiToken,
-			tenant,
-			baseUrl: BASE_URL,
-			writesEnabled: writesAllowed
-		},
-		serverName: "Sodium Practice Management",
-		serverVersion: VERSION,
-		includeStartupContext: isInit
-	});
-	const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
-	res.on("close", () => {
-		transport.close();
-		server.close();
-	});
-	if (isInit) console.error(`[sodium-pm-mcp-http] initialize (tenant: ${tenant || "per-call"}, writes: ${writesAllowed})`);
-	await server.connect(transport);
-	await transport.handleRequest(req, res, body);
+	const started = Date.now();
+	const requestName = describeRequest(body);
+	const userAgent = req.headers["user-agent"];
+	let subject;
+	let toolCall;
+	let tracked = false;
+	const track = (responseCode, error) => {
+		if (!TELEMETRY || tracked) return;
+		tracked = true;
+		TELEMETRY.trackRequest({
+			name: requestName,
+			durationMs: Date.now() - started,
+			responseCode,
+			success: responseCode < 400 && toolCall?.outcome !== "error",
+			userSubject: subject,
+			practice: toolCall?.practice || void 0,
+			tool: toolCall?.tool,
+			outcome: toolCall?.outcome,
+			aiClient: typeof userAgent === "string" ? userAgent : void 0,
+			error
+		});
+	};
+	try {
+		const authHeader = req.headers.authorization;
+		if (!authHeader?.startsWith("Bearer ")) throw new HttpError(401, "Authorization: Bearer <token> header is required.");
+		const bearerToken = authHeader.slice(7).trim();
+		let writesAllowed = WRITES_ENABLED;
+		let apiToken = bearerToken;
+		if (AUTH) {
+			const verified = await verifyAccessToken(AUTH, bearerToken);
+			subject = verified.subject;
+			writesAllowed = WRITES_ENABLED && verified.scopes.includes(AUTH.scopes.write);
+			if (OBO) apiToken = await getDownstreamToken(OBO, bearerToken);
+		}
+		const tenantHeader = req.headers["x-sodium-tenant"];
+		const tenant = (Array.isArray(tenantHeader) ? tenantHeader[0] : tenantHeader) ?? process.env.SODIUM_TENANT;
+		const isInit = isInitializeRequest(body);
+		const server = await buildServer({
+			context: {
+				bearerToken: apiToken,
+				tenant,
+				baseUrl: BASE_URL,
+				writesEnabled: writesAllowed
+			},
+			serverName: "Sodium Practice Management",
+			serverVersion: VERSION,
+			includeStartupContext: isInit,
+			onToolCall: (info) => {
+				toolCall = info;
+			}
+		});
+		const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+		res.on("close", () => {
+			track(res.statusCode ?? 200);
+			transport.close();
+			server.close();
+		});
+		if (isInit) console.error(`[sodium-pm-mcp-http] initialize (tenant: ${tenant || "per-call"}, writes: ${writesAllowed})`);
+		await server.connect(transport);
+		await transport.handleRequest(req, res, body);
+	} catch (error) {
+		track(error instanceof HttpError || error instanceof AuthError ? error.status : 500, error instanceof Error ? error.message : String(error));
+		throw error;
+	}
 }
 var HttpError = class extends Error {
 	constructor(status, message) {

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as buildServer } from "./src-DEbTNFXg.mjs";
+import { t as buildServer } from "./src-uJ9liBF-.mjs";
 import { createRequire } from "node:module";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { parseArgs } from "node:util";

package/dist/{src-DEbTNFXg.mjs → src-uJ9liBF-.mjs}

@@ -2236,6 +2236,15 @@ var SodiumApiClient = class {
 		if (!this.activeTenant) throw new Error("No practice specified. Pass a practice code from list_practices in the tool's 'practice' argument.");
 		return this.activeTenant;
 	}
+	toolCallListener = null;
+	setToolCallListener(listener) {
+		this.toolCallListener = listener;
+	}
+	notifyToolCall(info) {
+		try {
+			this.toolCallListener?.(info);
+		} catch {}
+	}
 	hasActiveTenant() {
 		return this.activeTenant.length > 0;
 	}
@@ -8752,16 +8761,43 @@ function registerTenantTool(server, api, name, config, cb) {
 		...config,
 		inputSchema
 	}, async (args, extra) => {
+		const started = Date.now();
 		const { practice, ...rest } = args;
 		const resolution = await resolveTenantForCall(api, typeof practice === "string" ? practice : void 0);
-		if (!resolution.ok) return {
-			content: [{
-				type: "text",
-				text: resolution.message
-			}],
-			isError: true
-		};
-		return cb(rest, extra);
+		if (!resolution.ok) {
+			api.notifyToolCall({
+				tool: name,
+				practice: "",
+				durationMs: Date.now() - started,
+				outcome: "refused"
+			});
+			return {
+				content: [{
+					type: "text",
+					text: resolution.message
+				}],
+				isError: true
+			};
+		}
+		try {
+			const result = await cb(rest, extra);
+			const isError = typeof result === "object" && result !== null && result.isError === true;
+			api.notifyToolCall({
+				tool: name,
+				practice: api.getActiveTenant(),
+				durationMs: Date.now() - started,
+				outcome: isError ? "error" : "ok"
+			});
+			return result;
+		} catch (error) {
+			api.notifyToolCall({
+				tool: name,
+				practice: api.getActiveTenant(),
+				durationMs: Date.now() - started,
+				outcome: "error"
+			});
+			throw error;
+		}
 	});
 }
 function registerWriteTool(server, api, ctx, name, config, cb) {
@@ -8770,6 +8806,7 @@ function registerWriteTool(server, api, ctx, name, config, cb) {
 }
 async function buildServer(config) {
 	const api = new SodiumApiClient(config.context, { serverVersion: config.serverVersion });
+	if (config.onToolCall) api.setToolCallListener(config.onToolCall);
 	let instructions;
 	if (config.includeStartupContext !== false) {
 		const selection = api.hasActiveTenant() ? { kind: "explicit" } : await resolveTenant(api);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sodiumhq/mcp-pm",
-  "version": "0.1.0-beta.4448",
+  "version": "0.1.0-beta.4465",
   "description": "Sodium Practice Management MCP server — lets AI assistants interact with your Sodium tenant",
   "type": "module",
   "bin": {