@sodiumhq/mcp-pm 0.1.0-beta.4445 → 0.1.0-beta.4457

package/README.md

@@ -62,8 +62,7 @@ Only enable write mode with an AI client you trust — it hands the client the a
 - **`get_practice_dashboard`** — one-call "state of the practice right now": overdue/blocked/due-soon work, what clients are sitting on, unassigned steps, unbilled time, open proposal pipeline. *"Give me my morning briefing."*
 - **`get_practice_details`** — consolidated practice overview (counts, connections, settings)
 - **`whoami`** — show the authenticated user (name, email, code), tenant (name, code, status), and practice name. Useful for verifying which account is connected.
-- **`list_practices`** — list the practices you belong to, marking the active one. *"Which practices can I access?"*
-- **`set_active_practice`** — choose which practice to work in, or switch mid-session. *"Switch to Oceans."* Needed when you belong to more than one practice.
+- **`list_practices`** — list the practices you belong to. *"Which practices can I access?"* If you belong to more than one, tools take an optional `practice` code to say which one a request is about; with a single practice it is selected automatically.
 
 **Clients**
 - **`list_clients`** — list and filter clients by search, status, type, assignee, services, saved filters

package/dist/http.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { t as buildServer } from "./src-BRf2g74U.mjs";
+import { t as buildServer } from "./src-uJ9liBF-.mjs";
 import { createRequire } from "node:module";
 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) {
@@ -140,25 +240,22 @@ 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 sessions = /* @__PURE__ */ new Map();
-const SESSION_IDLE_MS = Number(process.env.MCP_SESSION_IDLE_MS ?? 30 * 6e4);
-const SWEEP_INTERVAL_MS = 6e4;
-function touch(sessionId) {
-	const session = sessions.get(sessionId);
-	if (session) session.lastActivity = Date.now();
-}
-async function sweepIdleSessions() {
-	const cutoff = Date.now() - SESSION_IDLE_MS;
-	for (const [sessionId, session] of sessions) {
-		if (session.lastActivity > cutoff) continue;
-		sessions.delete(sessionId);
-		console.error(`[sodium-pm-mcp-http] session ${sessionId} swept (idle)`);
-		try {
-			await session.transport.close();
-		} catch (error) {
-			console.error(`[sodium-pm-mcp-http] error closing swept session: ${String(error)}`);
+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) {
@@ -182,47 +279,71 @@ function sendJsonError(res, status, message) {
 		id: null
 	}));
 }
-async function createSession(req) {
-	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 server = await buildServer({
-		context: {
-			bearerToken: apiToken,
-			tenant,
-			baseUrl: BASE_URL,
-			writesEnabled: writesAllowed
-		},
-		serverName: "Sodium Practice Management",
-		serverVersion: VERSION
-	});
-	const transport = new StreamableHTTPServerTransport({
-		sessionIdGenerator: () => randomUUID(),
-		onsessioninitialized: (sessionId) => {
-			sessions.set(sessionId, {
-				transport,
-				lastActivity: Date.now()
-			});
-			console.error(`[sodium-pm-mcp-http] session ${sessionId} started (tenant: ${tenant}, live: ${sessions.size})`);
-		}
-	});
-	transport.onclose = () => {
-		if (transport.sessionId) {
-			sessions.delete(transport.sessionId);
-			console.error(`[sodium-pm-mcp-http] session ${transport.sessionId} closed`);
-		}
+async function handleMcpPost(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
+		});
 	};
-	await server.connect(transport);
-	return transport;
+	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) {
@@ -235,8 +356,7 @@ async function handle(req, res) {
 	if (req.method === "GET" && url.pathname === "/health") {
 		res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({
 			status: "ok",
-			version: VERSION,
-			sessions: sessions.size
+			version: VERSION
 		}));
 		return;
 	}
@@ -248,25 +368,14 @@ async function handle(req, res) {
 		sendJsonError(res, 404, `Not found. MCP endpoint is ${ENDPOINT_PATH}.`);
 		return;
 	}
-	const sessionId = req.headers["mcp-session-id"];
-	const existing = typeof sessionId === "string" ? sessions.get(sessionId) : void 0;
-	if (existing && typeof sessionId === "string") {
-		touch(sessionId);
-		await existing.transport.handleRequest(req, res);
-		return;
-	}
 	if (req.method !== "POST") {
-		sendJsonError(res, 400, "No valid MCP session. Send an initialize request first.");
-		return;
-	}
-	const body = await readJsonBody(req);
-	if (!isInitializeRequest(body)) {
-		sendJsonError(res, 400, "No valid MCP session. Send an initialize request first.");
+		res.setHeader("Allow", "POST");
+		sendJsonError(res, 405, "Stateless MCP endpoint. Send requests as POST.");
 		return;
 	}
-	await (await createSession(req)).handleRequest(req, res, body);
+	await handleMcpPost(req, res, await readJsonBody(req));
 }
-const httpServer = createServer((req, res) => {
+createServer((req, res) => {
 	handle(req, res).catch((error) => {
 		const message = error instanceof Error ? error.message : String(error);
 		console.error(`[sodium-pm-mcp-http] ${req.method} ${req.url} failed: ${message}`);
@@ -280,11 +389,7 @@ const httpServer = createServer((req, res) => {
 		if (AUTH && error instanceof HttpError && error.status === 401) res.setHeader("WWW-Authenticate", buildChallenge(AUTH));
 		sendJsonError(res, error instanceof HttpError ? error.status : 500, message);
 	});
-});
-setInterval(() => {
-	sweepIdleSessions();
-}, SWEEP_INTERVAL_MS).unref();
-httpServer.listen(PORT, HOST, () => {
+}).listen(PORT, HOST, () => {
 	console.error(`[sodium-pm-mcp-http] v${VERSION} listening on http://${HOST}:${PORT}${ENDPOINT_PATH} (api: ${BASE_URL}, writes: ${WRITES_ENABLED ? "enabled" : "disabled"})`);
 });
 //#endregion

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as buildServer } from "./src-BRf2g74U.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";