@togglhq/mcp 1.7.2 → 1.8.1

package/README.md

@@ -94,6 +94,18 @@ One tool per domain (for example `tasks`, `projects`, `time-blocks`, `time-entri
 
 Agent-oriented guidance ships in `skills/toggl-mcp/SKILL.md` inside this package.
 
+## Privacy & analytics
+
+Public builds may send product analytics: tool name, entity-tool `action` (for example `list`), outcome (`success`, `error`, or `confirmation_required`), client, session id and package version. Tool arguments and results are never collected. Signed-in sessions are identified by your Toggl account id so repeat use is not counted as a new person each time; unauthenticated processes stay anonymous.
+
+Disable product analytics:
+
+```bash
+TOGGL_PRODUCT_ANALYTICS=off
+```
+
+Optional error reporting via Sentry is off unless you set `TOGGL_SENTRY=1` and `SENTRY_DSN`.
+
 ## License
 
 Proprietary Toggl software. See [LICENSE](LICENSE) and [Toggl legal terms](https://toggl.com/legal/).

package/build/cli.js

@@ -1,7 +1,189 @@
 #!/usr/bin/env node
-import { n as runMcpCli } from "./src-BSqkikrb.js";
+import { a as initProductAnalytics, c as shutdownProductAnalytics, i as getProductAnalyticsDistinctId, n as runMcpCli, o as redactUnsafeSentryMessages, r as captureToolInvocation, s as resolveProductAnalyticsDistinctId } from "./src-Dh4qJKIU.js";
+import * as Sentry from "@sentry/node";
+//#region src/analytics-tool-metadata.ts
+/**
+* Every entity tool takes `{ action, data, … }`, and `action` is a picklist of
+* catalog identifiers, so it is the one argument that is safe to record.
+*/
+function readToolAction(handlerArgs) {
+	const params = handlerArgs[0];
+	if (!params || typeof params !== "object") return null;
+	const action = params.action;
+	return typeof action === "string" ? action : null;
+}
+/**
+* Read the first text block of a non-error result as JSON.
+*
+* Handshake payloads are the awkward case for classification: they are shaped
+* like successes — plain text content, no `isError` — so the only way to tell
+* them apart is the object they carry. Nothing read here is retained.
+*/
+function firstTextPayload(result, marker) {
+	if (!result || typeof result !== "object") return null;
+	if (result.isError === true) return null;
+	const content = result.content;
+	if (!Array.isArray(content)) return null;
+	const first = content[0];
+	if (first?.type !== "text" || typeof first.text !== "string") return null;
+	if (!first.text.includes(marker)) return null;
+	try {
+		const payload = JSON.parse(first.text);
+		return payload && typeof payload === "object" ? payload : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* The confirm-gate response is a handshake, not an outcome: it carries no
+* `isError`, so it used to be recorded as a success and the confirmed write was
+* recorded as a second success for the same logical mutation.
+*
+* Detected from the payload `withMutationApproval` builds (`confirm_required`
+* plus a `confirm_token`) rather than from the gate internals, so it keeps
+* working when tool registration moves out of this package.
+*/
+function isConfirmationGateResult(result) {
+	const payload = firstTextPayload(result, "\"confirm_required\"");
+	return payload?.confirm_required === true && typeof payload.confirm_token === "string";
+}
+/**
+* `auth` on a multi-workspace account is the same handshake in different clothes:
+* it returns `{ authenticated: false, requires_workspace_selection: true }` with
+* no `isError`, and the caller has to call `auth` again with `workspace_id`.
+* Counting the first leg as a success double-counts one login — and, because
+* `auth` refreshes identity on success, would report an identity change that had
+* not happened yet.
+*/
+function isAuthWorkspaceSelectionResult(result) {
+	const payload = firstTextPayload(result, "\"requires_workspace_selection\"");
+	return payload?.requires_workspace_selection === true && payload.authenticated === false;
+}
+function classifyToolResult(result) {
+	if (isConfirmationGateResult(result)) return "confirmation_required";
+	if (isAuthWorkspaceSelectionResult(result)) return "confirmation_required";
+	return result?.isError === true ? "error" : "success";
+}
+//#endregion
+//#region src/public-analytics.ts
+function envEnabled(raw) {
+	if (raw === void 0) return false;
+	const normalized = raw.trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "on" || normalized === "yes";
+}
+function initPublicSentry(environment) {
+	if (!envEnabled(process.env.TOGGL_SENTRY)) return false;
+	const dsn = process.env.SENTRY_DSN;
+	if (!dsn || dsn === "off") {
+		console.error("[Analytics] TOGGL_SENTRY is set but SENTRY_DSN is missing; Sentry left disabled");
+		return false;
+	}
+	Sentry.init({
+		dsn,
+		environment: environment ?? "production",
+		tracesSampleRate: .2,
+		enableLogs: false,
+		sendDefaultPii: false,
+		beforeSend: (event) => redactUnsafeSentryMessages(event)
+	});
+	return true;
+}
+function wrapPublicServerWithSentry(server) {
+	return Sentry.wrapMcpServerWithSentry(server, {
+		recordInputs: false,
+		recordOutputs: false
+	});
+}
+function tagPublicSentrySession() {
+	Sentry.setTag("mcp.session.id", crypto.randomUUID());
+}
+async function shutdownPublicSentry() {
+	await Sentry.close(2e3);
+}
+function initMcpProductAnalytics(context) {
+	return initProductAnalytics({
+		...context,
+		client: "mcp"
+	});
+}
+async function flushPublicAnalytics(sentryEnabled) {
+	const tasks = [shutdownProductAnalytics()];
+	if (sentryEnabled) tasks.push(shutdownPublicSentry());
+	await Promise.allSettled(tasks);
+}
+/**
+* Tools that replace the active MCP credential row on success, so their event
+* belongs to the profile they leave behind. `profile-remove` is included because
+* removing the active profile promotes the next one, and attributing the event to
+* the profile just deleted files it under an identity that no longer exists.
+*
+* `logout` is deliberately absent: it only ever clears, so it is always the
+* account that signed out.
+*/
+const IDENTITY_CHANGING_MCP_TOOLS = new Set([
+	"auth",
+	"profile-switch",
+	"profile-remove"
+]);
+function wrapServerWithProductAnalytics(server) {
+	const originalRegisterTool = server.registerTool.bind(server);
+	server.registerTool = new Proxy(originalRegisterTool, { apply(target, thisArg, argArray) {
+		const [name, config, toolHandlerCandidate] = argArray;
+		if (typeof toolHandlerCandidate !== "function") return Reflect.apply(target, thisArg, argArray);
+		const toolHandler = toolHandlerCandidate;
+		const wrappedHandler = async (...handlerArgs) => {
+			const action = readToolAction(handlerArgs);
+			let distinctId = resolveProductAnalyticsDistinctId("mcp") ?? getProductAnalyticsDistinctId();
+			let outcome = "error";
+			let result;
+			let thrown;
+			try {
+				result = await toolHandler(...handlerArgs);
+				outcome = classifyToolResult(result);
+				if (IDENTITY_CHANGING_MCP_TOOLS.has(name) && outcome === "success") distinctId = resolveProductAnalyticsDistinctId("mcp") ?? distinctId;
+				return result;
+			} catch (error) {
+				thrown = error;
+				outcome = "error";
+				throw error;
+			} finally {
+				captureToolInvocation({
+					toolName: name,
+					action,
+					outcome,
+					distinctId,
+					error: outcome === "error" ? thrown ?? result : void 0
+				});
+			}
+		};
+		return Reflect.apply(target, thisArg, [
+			name,
+			config,
+			wrappedHandler
+		]);
+	} });
+}
+//#endregion
 //#region src/cli.ts
-runMcpCli();
+const packageVersion = "1.8.1";
+let sentryEnabled = false;
+let productAnalyticsEnabled = false;
+runMcpCli({
+	beforeRegister(server) {
+		productAnalyticsEnabled = initMcpProductAnalytics({ packageVersion });
+		sentryEnabled = initPublicSentry(process.env.NODE_ENV);
+		let next = server;
+		if (sentryEnabled) next = wrapPublicServerWithSentry(next);
+		if (productAnalyticsEnabled) wrapServerWithProductAnalytics(next);
+		return next;
+	},
+	beforeConnect() {
+		if (sentryEnabled) tagPublicSentrySession();
+	},
+	async beforeExit() {
+		if (sentryEnabled || productAnalyticsEnabled) await flushPublicAnalytics(sentryEnabled);
+	}
+});
 //#endregion
 export {};
 

package/build/index.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { n as runMcpCli, t as bootstrapServer } from "./src-BSqkikrb.js";
+import { n as runMcpCli, t as bootstrapServer } from "./src-Dh4qJKIU.js";
 export { bootstrapServer, runMcpCli };

package/build/{src-BSqkikrb.js → src-Dh4qJKIU.js}

@@ -31111,6 +31111,14 @@ async function deleteMyWorkingHours(httpClient, organization_id, data, signal) {
 	if ([204, 205].includes(response.status)) return null;
 	return response.json();
 }
+//#endregion
+//#region ../cli-core/build/focus-client-B2l1BZIW.js
+/** Request header the API reads to attribute traffic to MCP or CLI. */
+const TOGGL_CLIENT_HEADER = "X-Toggl-Client";
+/** Headers that attribute a raw `fetch` to MCP or CLI (FocusClient sets these itself). */
+function togglClientHeaders(clientSurface) {
+	return { [TOGGL_CLIENT_HEADER]: clientSurface };
+}
 const customFieldValuesEntry = /* @__PURE__ */ optional$1(/* @__PURE__ */ nullable$1(/* @__PURE__ */ pipe$2(/* @__PURE__ */ record$1(/* @__PURE__ */ string$1(), /* @__PURE__ */ nullable$1(/* @__PURE__ */ union$1([
 	/* @__PURE__ */ array$1(/* @__PURE__ */ number$2()),
 	/* @__PURE__ */ string$1(),
@@ -31288,6 +31296,7 @@ var FocusClient = class {
 	timeOffMeHttp;
 	sharedDataHttp;
 	tokenProvider;
+	clientSurface;
 	userId;
 	organizationIdNum;
 	workspaceId;
@@ -31296,6 +31305,7 @@ var FocusClient = class {
 		let baseUrl = config.baseUrl.replace(/\/+$/, "");
 		if (!baseUrl.endsWith("/api")) baseUrl += "/api";
 		this.tokenProvider = config.tokenProvider;
+		this.clientSurface = config.clientSurface;
 		this.userId = config.userId;
 		this.workspaceId = config.workspaceId;
 		const orgParsed = Number.parseInt(config.organizationId, 10);
@@ -31311,6 +31321,7 @@ var FocusClient = class {
 				request.headers.set("Authorization", `Bearer ${token}`);
 				if (!request.headers.get("Content-Type")?.startsWith("multipart/form-data")) request.headers.set("Content-Type", "application/json");
 				request.headers.set("X-Toggl-PostHog-Data", JSON.stringify({ platform_origin: "web" }));
+				request.headers.set(TOGGL_CLIENT_HEADER, this.clientSurface);
 			}
 		});
 		const orgBase = accountsOrgApiBaseUrl(config.accountsApiUrl);
@@ -31322,6 +31333,7 @@ var FocusClient = class {
 				request.headers.set("Authorization", `Bearer ${token}`);
 				request.headers.set("Content-Type", "application/json");
 				request.headers.set("X-Toggl-PostHog-Data", JSON.stringify({ platform_origin: "web" }));
+				request.headers.set(TOGGL_CLIENT_HEADER, this.clientSurface);
 			}
 		});
 		this.timeOffMeHttp = createHttpClient({
@@ -31333,6 +31345,7 @@ var FocusClient = class {
 				request.headers.set("Content-Type", "application/json");
 				request.headers.set("X-Toggl-Product", "focus");
 				request.headers.set("X-Toggl-PostHog-Data", JSON.stringify({ platform_origin: "web" }));
+				request.headers.set(TOGGL_CLIENT_HEADER, this.clientSurface);
 			}
 		});
 		this.sharedDataHttp = createHttpClient({
@@ -31343,6 +31356,7 @@ var FocusClient = class {
 				request.headers.set("Authorization", `Bearer ${token}`);
 				request.headers.set("Content-Type", "application/json");
 				request.headers.set("X-Toggl-PostHog-Data", JSON.stringify({ platform_origin: "web" }));
+				request.headers.set(TOGGL_CLIENT_HEADER, this.clientSurface);
 			}
 		});
 	}
@@ -32441,7 +32455,7 @@ function waitForOAuthCallback(port = TOGGL_OAUTH_CALLBACK_PORT, timeoutMs = TOGG
 		});
 	});
 }
-async function exchangeAuthorizationCode(accountsApiUrl, code, verifier, redirectUri = togglOAuthRedirectUri(), clientId = TOGGL_OAUTH_CLIENT_ID) {
+async function exchangeAuthorizationCode(accountsApiUrl, code, verifier, clientSurface, redirectUri = togglOAuthRedirectUri(), clientId = TOGGL_OAUTH_CLIENT_ID) {
 	const params = new URLSearchParams({
 		grant_type: "authorization_code",
 		code,
@@ -32449,7 +32463,10 @@ async function exchangeAuthorizationCode(accountsApiUrl, code, verifier, redirec
 		client_id: clientId,
 		redirect_uri: redirectUri
 	});
-	const response = await fetch(`${accountsApiUrl}/api/oauth/token?${params}`, { method: "POST" });
+	const response = await fetch(`${accountsApiUrl}/api/oauth/token?${params}`, {
+		method: "POST",
+		headers: togglClientHeaders(clientSurface)
+	});
 	if (!response.ok) {
 		const text = await response.text();
 		throw new Error(`Token exchange failed (${response.status}): ${text}`);
@@ -32549,18 +32566,20 @@ var WorkspaceSelectionRequiredError$1 = class extends Error {
 		this.workspaces = workspaces;
 	}
 };
-async function fetchAccountsApiMe(accountsApiUrl, token) {
+async function fetchAccountsApiMe(accountsApiUrl, token, clientSurface) {
 	const response = await fetch(`${accountsApiUrl}/api/me`, { headers: {
 		Authorization: `Bearer ${token}`,
-		"Content-Type": "application/json"
+		"Content-Type": "application/json",
+		...togglClientHeaders(clientSurface)
 	} });
 	if (!response.ok) throw new Error(`Failed to fetch user info (${response.status})`);
 	return response.json();
 }
-async function fetchAccessibleWorkspaces(accountsApiUrl, token) {
+async function fetchAccessibleWorkspaces(accountsApiUrl, token, clientSurface) {
 	const response = await fetch(`${accountsApiUrl}/org/api/organizations/me`, { headers: {
 		Authorization: `Bearer ${token}`,
-		"Content-Type": "application/json"
+		"Content-Type": "application/json",
+		...togglClientHeaders(clientSurface)
 	} });
 	if (!response.ok) throw new Error(`Failed to fetch organizations (${response.status})`);
 	return (await response.json()).flatMap((org) => (org.workspaces ?? []).filter((ws) => (ws.toggl_products ?? []).includes("focus")).map((ws) => {
@@ -32604,13 +32623,16 @@ const PUBLIC_MCP_PACKAGE_NAME = "@togglhq/mcp";
 function npxMcpAuthCommand() {
 	return `npx ${PUBLIC_MCP_PACKAGE_NAME} auth`;
 }
-async function refreshTokens(accountsApiUrl, refreshToken, clientId = TOGGL_OAUTH_CLIENT_ID) {
+async function refreshTokens(accountsApiUrl, refreshToken, clientSurface, clientId = TOGGL_OAUTH_CLIENT_ID) {
 	const params = new URLSearchParams({
 		grant_type: "refresh_token",
 		refresh_token: refreshToken,
 		client_id: clientId
 	});
-	const response = await fetch(`${accountsApiUrl}/api/oauth/token?${params}`, { method: "POST" });
+	const response = await fetch(`${accountsApiUrl}/api/oauth/token?${params}`, {
+		method: "POST",
+		headers: togglClientHeaders(clientSurface)
+	});
 	if (!response.ok) {
 		const text = await response.text();
 		throw new Error(`Token refresh failed (${response.status}): ${text}`);
@@ -32622,7 +32644,7 @@ async function getValidToken$1(scope = "cli", profile) {
 	if (!authConfig) throw new Error(scope === "cli" ? "Not authenticated. Run `toggl auth` to sign in." : `Not authenticated. Run \`${npxMcpAuthCommand()}\` to sign in.`);
 	const now = Date.now() / 1e3;
 	if (authConfig.expires_at > now + 60) return authConfig.access_token;
-	const tokens = await refreshTokens(authConfig.accounts_api_url, authConfig.refresh_token, authConfig.oauth_client_id ?? "000000");
+	const tokens = await refreshTokens(authConfig.accounts_api_url, authConfig.refresh_token, scope, authConfig.oauth_client_id ?? "000000");
 	authConfig.access_token = tokens.access_token;
 	authConfig.refresh_token = tokens.refresh_token;
 	authConfig.expires_at = now + tokens.expires_in;
@@ -32650,7 +32672,7 @@ async function refreshMcpWorkspaces(profile) {
 	const token = await getValidToken$1("mcp", profile);
 	const dev = loadDeveloperToolsConfig();
 	const auth = dev.profiles[profileKey];
-	auth.workspaces = await fetchAccessibleWorkspaces(auth.accounts_api_url, token);
+	auth.workspaces = await fetchAccessibleWorkspaces(auth.accounts_api_url, token, "mcp");
 	dev.profiles[profileKey] = auth;
 	saveDeveloperToolsConfig(dev);
 	return listCachedMcpWorkspaces(profile);
@@ -32667,6 +32689,253 @@ function listCachedMcpWorkspaces(profile) {
 		active: workspace.workspace_id === auth.workspace_id
 	}));
 }
+const CLI_GENERIC_ERROR_CATEGORY = "cli.command_error";
+const MCP_GENERIC_ERROR_CATEGORY = "mcp.tool_error";
+const ERROR_CATEGORY_SET = new Set([
+	"cli.validation_error",
+	"cli.api_error",
+	CLI_GENERIC_ERROR_CATEGORY,
+	"mcp.validation_error",
+	"mcp.api_error",
+	"mcp.auth_error",
+	MCP_GENERIC_ERROR_CATEGORY
+]);
+function isDeclaredErrorCategory(value) {
+	return typeof value === "string" && ERROR_CATEGORY_SET.has(value);
+}
+function firstToolResultText(source) {
+	if (!source || typeof source !== "object") return null;
+	const content = source.content;
+	if (!Array.isArray(content)) return null;
+	const first = content[0];
+	if (first?.type === "text" && typeof first.text === "string") return first.text;
+	return null;
+}
+function errorTextForClassification(source) {
+	if (source instanceof Error) return source.message;
+	if (typeof source === "string") return source;
+	const toolText = firstToolResultText(source);
+	if (toolText !== null) return toolText;
+	return "";
+}
+function classifyCli(message) {
+	if (message.startsWith("Invalid input:") || message.startsWith("Invalid input ")) return "cli.validation_error";
+	if (/^\d{3}:\s/.test(message)) return "cli.api_error";
+	return CLI_GENERIC_ERROR_CATEGORY;
+}
+function classifyMcp(message) {
+	if (message.startsWith("Invalid input:") || message.startsWith("Invalid input ")) return "mcp.validation_error";
+	if (message.startsWith("API Error (")) return "mcp.api_error";
+	if (message.startsWith("Authentication failed:") || message.startsWith("Not authenticated.")) return "mcp.auth_error";
+	return MCP_GENERIC_ERROR_CATEGORY;
+}
+function classifyErrorCategory(client, source) {
+	const message = errorTextForClassification(source);
+	if (isDeclaredErrorCategory(message) && message.startsWith(`${client}.`)) return message;
+	return client === "cli" ? classifyCli(message) : classifyMcp(message);
+}
+/**
+* Exception messages are the one channel `sendDefaultPii: false` does not cover,
+* and this repo's errors put user data in them: validation failures embed the
+* rejected input (valibot renders `issue.received`) and API failures embed the
+* response body. Sentry also captures uncaught exceptions and `cause` chains
+* through its own global handlers, which bypass any call-site scrubbing, so the
+* last word has to be `beforeSend`.
+*
+* Shared between the CLI and the public MCP build so the two cannot drift.
+*/
+/**
+* Fixed categories are the seven declared `<surface>.<snake_case>` values, not
+* a `cli|mcp` prefix regex. A prefix or regex test would pass a caught message
+* like `cli.customer_name`. A real filename message such as
+* `cli.ts:12: unexpected token "secret"` would also begin with `cli.`.
+*/
+const REDACTED_SENTRY_MESSAGE = "redacted";
+function isSafeSentryMessage(value) {
+	return isDeclaredErrorCategory(value);
+}
+/**
+* Replace every exception message that is not a known category, and any top-level
+* message. Stack frames are left alone: they carry file, function and line, never
+* payloads.
+*/
+function redactUnsafeSentryMessages(event) {
+	if (event.message !== void 0 && !isSafeSentryMessage(event.message)) event.message = REDACTED_SENTRY_MESSAGE;
+	for (const value of event.exception?.values ?? []) if (!isSafeSentryMessage(value.value)) value.value = REDACTED_SENTRY_MESSAGE;
+	return event;
+}
+const DEFAULT_POSTHOG_HOST = "https://eu.i.posthog.com";
+/**
+* The shared Toggl **production** PostHog project — the same token the Track
+* webapp (`posthogApiKey.production`), the marketing site (`GATSBY_POSTHOG_ID`)
+* and the Focus mobile app (`EXPO_PUBLIC_POSTHOG_KEY`) send to. MCP/CLI events
+* therefore land beside product events for the same people, which is why the
+* `distinct_id` has to be the accounts nanoid and why `$lib` has to separate the
+* developer tools out again.
+*/
+const SHARED_TOGGL_PRODUCTION_POSTHOG_TOKEN = "phc_PiFIHfmVYQVICbsScOwEv7D9wBwoNvrUFZ1Fq9WxBrp";
+/**
+* PostHog splits usage and billing by `$lib`, so it has to name the sending
+* client rather than this module: sharing the Toggl production project with the
+* webapp, marketing site and mobile app means a single library value would leave
+* MCP and CLI volume indistinguishable in that breakdown.
+*/
+const POSTHOG_LIB_BY_CLIENT = {
+	mcp: "MCP",
+	cli: "CLI"
+};
+const TOOL_INVOCATION_EVENT = "toggl_tool_invocation";
+/** Bound collector I/O so analytics cannot hang a completed CLI/MCP exit path. */
+const CAPTURE_TIMEOUT_MS = 2e3;
+const FLUSH_TIMEOUT_MS = 2e3;
+/** Actions are catalog identifiers, so anything else is a caller bug, not data. */
+const ACTION_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
+let enabled = false;
+let apiKey = null;
+let host = DEFAULT_POSTHOG_HOST;
+let sessionId = "";
+let distinctId = "";
+let client = "mcp";
+let packageVersion$1 = "0.0.0";
+const pending = /* @__PURE__ */ new Set();
+function envFlagDisabled(raw) {
+	if (raw === void 0 || raw === "") return false;
+	const normalized = raw.trim().toLowerCase();
+	return normalized === "0" || normalized === "false" || normalized === "off" || normalized === "no";
+}
+function getProductAnalyticsDistinctId() {
+	return distinctId;
+}
+/**
+* Initialize product analytics for a public MCP/CLI process.
+* No-ops when TOGGL_PRODUCT_ANALYTICS is 0/false/off, or when the API key is "off".
+*/
+function initProductAnalytics(context) {
+	if (envFlagDisabled(process.env.TOGGL_PRODUCT_ANALYTICS)) {
+		enabled = false;
+		return false;
+	}
+	const key = (process.env.TOGGL_POSTHOG_API_KEY ?? SHARED_TOGGL_PRODUCTION_POSTHOG_TOKEN).trim();
+	if (!key || key.toLowerCase() === "off") {
+		enabled = false;
+		return false;
+	}
+	apiKey = key;
+	host = (process.env.TOGGL_POSTHOG_HOST ?? DEFAULT_POSTHOG_HOST).replace(/\/$/, "");
+	sessionId = context.sessionId ?? crypto.randomUUID();
+	distinctId = context.distinctId ?? `anon:${sessionId}`;
+	client = context.client;
+	packageVersion$1 = context.packageVersion;
+	enabled = true;
+	return true;
+}
+function normalizeAction(action) {
+	if (typeof action !== "string") return null;
+	const trimmed = action.trim();
+	return ACTION_PATTERN.test(trimmed) ? trimmed : null;
+}
+/** Strict allowlist — never accept args/results. */
+function captureToolInvocation(event) {
+	if (!enabled || !apiKey) return;
+	const properties = {
+		tool_name: event.toolName,
+		action: normalizeAction(event.action),
+		outcome: event.outcome,
+		success: event.outcome === "success",
+		client,
+		session_id: sessionId,
+		package_version: packageVersion$1
+	};
+	if (event.outcome === "error") properties.error_category = classifyErrorCategory(client, event.error);
+	const task = sendCapture(TOOL_INVOCATION_EVENT, properties, event.distinctId).finally(() => {
+		pending.delete(task);
+	});
+	pending.add(task);
+}
+async function sendCapture(event, properties, eventDistinctId) {
+	if (!apiKey) return;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), CAPTURE_TIMEOUT_MS);
+	try {
+		const response = await fetch(`${host}/i/v0/e/`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				api_key: apiKey,
+				event,
+				distinct_id: eventDistinctId ?? distinctId,
+				properties: {
+					...properties,
+					$lib: POSTHOG_LIB_BY_CLIENT[client]
+				}
+			}),
+			signal: controller.signal
+		});
+		if (!response.ok) await response.text().catch(() => void 0);
+	} catch {} finally {
+		clearTimeout(timer);
+	}
+}
+async function shutdownProductAnalytics() {
+	if (pending.size === 0) {
+		enabled = false;
+		return;
+	}
+	const inflight = [...pending];
+	let flushTimer;
+	try {
+		await Promise.race([Promise.allSettled(inflight), new Promise((resolve) => {
+			flushTimer = setTimeout(resolve, FLUSH_TIMEOUT_MS);
+		})]);
+	} finally {
+		if (flushTimer !== void 0) clearTimeout(flushTimer);
+		pending.clear();
+		enabled = false;
+	}
+}
+/**
+* Accounts mints the base62 nanoid as the JWT `sub`; it is the same value
+* accounts-be sends to PostHog as `distinct_id`, so it is short and URL-safe.
+*/
+const NANOID_PATTERN = /^[0-9A-Za-z_-]{6,64}$/;
+/**
+* Read `sub` out of a Toggl accounts access token without verifying it.
+*
+* Verification would need the accounts JWKS; the value is only used as an
+* analytics key, and a forged token would only mislabel the forger's own events.
+*/
+function decodeAccessTokenSubject(token) {
+	if (!token) return null;
+	const payloadSegment = token.split(".")[1];
+	if (!payloadSegment) return null;
+	try {
+		const sub = JSON.parse(Buffer.from(payloadSegment, "base64url").toString("utf8")).sub;
+		if (typeof sub !== "string" || !NANOID_PATTERN.test(sub)) return null;
+		return sub;
+	} catch {
+		return null;
+	}
+}
+/**
+* Stable PostHog identity for a signed-in MCP/CLI process.
+*
+* The nanoid comes from the persisted profile, so the same person keeps one
+* `distinct_id` across process restarts and across MCP and CLI — a per-process
+* UUID would make every invocation look like a new user and every funnel
+* one-step-deep.
+*
+* The profile's numeric `user_id` is `user_account_id`, which is deliberately
+* *not* used here: accounts-be, toggl_api and the Track webapp all identify a
+* person in PostHog by the nanoid, so a bigint key would orphan these events
+* from every other identity we already have for the same user.
+*/
+function resolveProductAnalyticsDistinctId(scope) {
+	try {
+		return decodeAccessTokenSubject(loadProfile(scope)?.access_token);
+	} catch {
+		return null;
+	}
+}
 //#endregion
 //#region src/auth.ts
 var WorkspaceSelectionRequiredError = class extends Error {
@@ -32723,11 +32992,11 @@ async function runAuthFlow(accountsApiUrl = "https://accounts.toggl.com", focusA
 			log
 		});
 		log("Exchanging authorization code...");
-		const tokens = await exchangeAuthorizationCode(accountsApiUrl, code, verifier, redirectUri, clientId);
+		const tokens = await exchangeAuthorizationCode(accountsApiUrl, code, verifier, "mcp", redirectUri, clientId);
 		log("Fetching account info...");
-		const user = await fetchAccountsApiMe(accountsApiUrl, tokens.access_token);
+		const user = await fetchAccountsApiMe(accountsApiUrl, tokens.access_token, "mcp");
 		if (!user.user_account_id) throw new Error("Could not determine user ID from API response.");
-		const workspaces = await fetchAccessibleWorkspaces(accountsApiUrl, tokens.access_token);
+		const workspaces = await fetchAccessibleWorkspaces(accountsApiUrl, tokens.access_token, "mcp");
 		pendingContext = {
 			access_token: tokens.access_token,
 			refresh_token: tokens.refresh_token,
@@ -32825,7 +33094,8 @@ function createAuthenticatedClientProxy() {
 			tokenProvider: getValidToken,
 			userId: config.user_id,
 			organizationId: String(config.organization_id),
-			workspaceId: String(config.workspace_id)
+			workspaceId: String(config.workspace_id),
+			clientSurface: "mcp"
 		});
 		cachedKey = key;
 		return cachedClient;
@@ -45216,7 +45486,7 @@ import_main.default.config({
 	quiet: true,
 	ignore: ["MISSING_ENV_FILE"]
 });
-const packageVersion = "1.7.2";
+const packageVersion = "1.8.1";
 function resolvePublicUrls() {
 	return {
 		focusApiUrl: process.env.TOGGL_FOCUS_API_URL ?? "https://focus.toggl.com",
@@ -45278,6 +45548,6 @@ function bootstrapServer(options = {}) {
 	if (options.beforeExit) process.on("beforeExit", async () => await options.beforeExit?.());
 }
 //#endregion
-export { runMcpCli as n, bootstrapServer as t };
+export { initProductAnalytics as a, shutdownProductAnalytics as c, getProductAnalyticsDistinctId as i, runMcpCli as n, redactUnsafeSentryMessages as o, captureToolInvocation as r, resolveProductAnalyticsDistinctId as s, bootstrapServer as t };
 
-//# sourceMappingURL=src-BSqkikrb.js.map
+//# sourceMappingURL=src-Dh4qJKIU.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@togglhq/mcp",
-  "version": "1.7.2",
+  "version": "1.8.1",
   "description": "Toggl 2.0 MCP server for Claude Code, Claude Desktop, and other MCP clients.",
   "license": "UNLICENSED",
   "type": "module",
@@ -48,10 +48,10 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@sentry/node": "10.47.0",
     "date-fns": "4.1.0"
   },
   "devDependencies": {
-    "@sentry/node": "10.47.0",
     "@toggl/cli-core": "workspace:^",
     "@toggl/focus-queries": "workspace:^",
     "@toggl/operations": "workspace:^",