@tenonhq/dovetail-mcp 0.0.1

package/dist/registry.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Tool registration glue. Exports TOOL_NAMES (the canonical 12-tuple) and
+ * registerAllTools(), which wires every handler with telemetry + JSON
+ * serialization for MCP transport.
+ *
+ * Dependencies are passed in by the caller — server.ts builds them from
+ * loadConfig(), tests inject mocks. This split keeps registry.ts pure of
+ * env access.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_NAMES = void 0;
+exports.registerAllTools = registerAllTools;
+exports.buildDescriptorsForTests = buildDescriptorsForTests;
+const telemetry_1 = require("./telemetry");
+const errors_1 = require("./errors");
+const clickup_1 = require("./schemas/clickup");
+const gmail_1 = require("./schemas/gmail");
+const calendar_1 = require("./schemas/calendar");
+const servicenow_1 = require("./schemas/servicenow");
+const clickup_2 = require("./tools/clickup");
+const gmail_2 = require("./tools/gmail");
+const calendar_2 = require("./tools/calendar");
+const servicenow_2 = require("./tools/servicenow");
+exports.TOOL_NAMES = [
+    "clickup_list_tasks",
+    "clickup_get_task",
+    "clickup_search_tasks",
+    "clickup_get_team_sync",
+    "gmail_get_unread",
+    "gmail_get_starred",
+    "gmail_search",
+    "gmail_get_action_required",
+    "calendar_get_today",
+    "calendar_get_week",
+    "calendar_get_event",
+    "servicenow_query_table"
+];
+function buildDescriptors(deps) {
+    var clickupReady = !!deps.clickup;
+    var googleReady = !!deps.gmail && !!deps.calendar;
+    return [
+        {
+            name: "clickup_list_tasks",
+            description: "List ClickUp tasks assigned to the authenticated user, grouped by status. teamId optional if CLICKUP_TEAM_ID is set.",
+            shape: clickup_1.clickupListTasksSchema.shape,
+            handler: requireConfig(clickupReady, "ClickUp", deps.missingDescription, function (args) {
+                return (0, clickup_2.clickupListTasks)(args, deps.clickup);
+            })
+        },
+        {
+            name: "clickup_get_task",
+            description: "Fetch a single ClickUp task by ID.",
+            shape: clickup_1.clickupGetTaskSchema.shape,
+            handler: requireConfig(clickupReady, "ClickUp", deps.missingDescription, function (args) {
+                return (0, clickup_2.clickupGetTask)(args, deps.clickup);
+            })
+        },
+        {
+            name: "clickup_search_tasks",
+            description: "Search team tasks by substring match against task name/description. teamId optional if CLICKUP_TEAM_ID is set.",
+            shape: clickup_1.clickupSearchTasksSchema.shape,
+            handler: requireConfig(clickupReady, "ClickUp", deps.missingDescription, function (args) {
+                return (0, clickup_2.clickupSearchTasks)(args, deps.clickup);
+            })
+        },
+        {
+            name: "clickup_get_team_sync",
+            description: "Returns a structured JSON team sync with the 7-stage pipeline (Blocked, In Progress, In Review, QA, UAT, Ready for Release, Done) plus unmapped statuses and unassigned tasks.",
+            shape: clickup_1.clickupGetTeamSyncSchema.shape,
+            handler: requireConfig(clickupReady, "ClickUp", deps.missingDescription, function (args) {
+                return (0, clickup_2.clickupGetTeamSync)(args, deps.clickup);
+            })
+        },
+        {
+            name: "gmail_get_unread",
+            description: "Fetch unread emails from the inbox.",
+            shape: gmail_1.gmailGetUnreadSchema.shape,
+            handler: requireConfig(googleReady, "Google (Gmail)", deps.missingDescription, function (args) {
+                return (0, gmail_2.gmailGetUnread)(args, deps.gmail);
+            })
+        },
+        {
+            name: "gmail_get_starred",
+            description: "Fetch starred emails.",
+            shape: gmail_1.gmailGetStarredSchema.shape,
+            handler: requireConfig(googleReady, "Google (Gmail)", deps.missingDescription, function (args) {
+                return (0, gmail_2.gmailGetStarred)(args, deps.gmail);
+            })
+        },
+        {
+            name: "gmail_search",
+            description: "Search emails using Gmail query syntax (e.g. 'from:alice has:attachment').",
+            shape: gmail_1.gmailSearchSchema.shape,
+            handler: requireConfig(googleReady, "Google (Gmail)", deps.missingDescription, function (args) {
+                return (0, gmail_2.gmailSearch)(args, deps.gmail);
+            })
+        },
+        {
+            name: "gmail_get_action_required",
+            description: "Fetch unread action-required emails matched against subject patterns and labels (defaults: 'action required', 'urgent', 'asap', 'time sensitive').",
+            shape: gmail_1.gmailGetActionRequiredSchema.shape,
+            handler: requireConfig(googleReady, "Google (Gmail)", deps.missingDescription, function (args) {
+                return (0, gmail_2.gmailGetActionRequired)(args, deps.gmail);
+            })
+        },
+        {
+            name: "calendar_get_today",
+            description: "Fetch today's calendar events.",
+            shape: calendar_1.calendarGetTodaySchema.shape,
+            handler: requireConfig(googleReady, "Google (Calendar)", deps.missingDescription, function (args) {
+                return (0, calendar_2.calendarGetToday)(args, deps.calendar);
+            })
+        },
+        {
+            name: "calendar_get_week",
+            description: "Fetch the next 7 days of calendar events.",
+            shape: calendar_1.calendarGetWeekSchema.shape,
+            handler: requireConfig(googleReady, "Google (Calendar)", deps.missingDescription, function (args) {
+                return (0, calendar_2.calendarGetWeek)(args, deps.calendar);
+            })
+        },
+        {
+            name: "calendar_get_event",
+            description: "Fetch a single calendar event by ID.",
+            shape: calendar_1.calendarGetEventSchema.shape,
+            handler: requireConfig(googleReady, "Google (Calendar)", deps.missingDescription, function (args) {
+                return (0, calendar_2.calendarGetEvent)(args, deps.calendar);
+            })
+        },
+        {
+            name: "servicenow_query_table",
+            description: "Read-only GET against the ServiceNow Table API. Required: table (lower-case identifier), sysparm_query (ServiceNow encoded query). Optional: fields[] limits the columns returned, limit caps row count (default 100, max 1000). Tables on the deny list (sys_user_password, sys_credential, etc.) are rejected unless SINC_MCP_SN_TABLE_OVERRIDE=<table> is set.",
+            shape: servicenow_1.servicenowQueryTableSchema.shape,
+            handler: function (args) {
+                return (0, servicenow_2.servicenowQueryTable)(args, deps.servicenow);
+            }
+        }
+    ];
+}
+function requireConfig(ready, label, missingDescription, fn) {
+    if (ready) {
+        return fn;
+    }
+    return async function () {
+        var detail = missingDescription || "missing required env vars";
+        throw new Error(label + " is not configured — " + detail);
+    };
+}
+function registerAllTools(server, deps) {
+    var descriptors = buildDescriptors(deps);
+    for (var i = 0; i < descriptors.length; i++) {
+        registerOne(server, descriptors[i]);
+    }
+}
+function registerOne(server, desc) {
+    // Cast at the SDK boundary: registerTool's deep generic inference over
+    // ZodRawShapeCompat blows past the TypeScript instantiation depth limit
+    // when a heterogeneous descriptor list feeds the same call site.
+    server.registerTool(desc.name, {
+        description: desc.description,
+        inputSchema: desc.shape
+    }, async function (args) {
+        try {
+            var result = await (0, telemetry_1.withTelemetry)(desc.name, args, function () {
+                return desc.handler(args);
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result)
+                    }
+                ]
+            };
+        }
+        catch (err) {
+            var mapped = (0, errors_1.mapToolError)(err);
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: mapped.message,
+                            retryable: mapped.retryable,
+                            tool: desc.name
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+function buildDescriptorsForTests(deps) {
+    return buildDescriptors(deps);
+}

package/dist/schemas/calendar.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare var calendarGetTodaySchema: z.ZodObject<{
+    calendarId: z.ZodOptional<z.ZodString>;
+    timeZone: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    timeZone?: string | undefined;
+    calendarId?: string | undefined;
+}, {
+    timeZone?: string | undefined;
+    calendarId?: string | undefined;
+}>;
+export declare var calendarGetWeekSchema: z.ZodObject<{
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    calendarId: z.ZodOptional<z.ZodString>;
+    timeZone: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    timeZone?: string | undefined;
+    maxResults?: number | undefined;
+    calendarId?: string | undefined;
+}, {
+    timeZone?: string | undefined;
+    maxResults?: number | undefined;
+    calendarId?: string | undefined;
+}>;
+export declare var calendarGetEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    calendarId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    eventId: string;
+    calendarId?: string | undefined;
+}, {
+    eventId: string;
+    calendarId?: string | undefined;
+}>;
+export type CalendarGetTodayInput = z.infer<typeof calendarGetTodaySchema>;
+export type CalendarGetWeekInput = z.infer<typeof calendarGetWeekSchema>;
+export type CalendarGetEventInput = z.infer<typeof calendarGetEventSchema>;

package/dist/schemas/calendar.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calendarGetEventSchema = exports.calendarGetWeekSchema = exports.calendarGetTodaySchema = void 0;
+const zod_1 = require("zod");
+exports.calendarGetTodaySchema = zod_1.z.object({
+    calendarId: zod_1.z.string().optional(),
+    timeZone: zod_1.z.string().optional()
+}).strict();
+exports.calendarGetWeekSchema = zod_1.z.object({
+    maxResults: zod_1.z.number().int().min(1).max(250).optional(),
+    calendarId: zod_1.z.string().optional(),
+    timeZone: zod_1.z.string().optional()
+}).strict();
+exports.calendarGetEventSchema = zod_1.z.object({
+    eventId: zod_1.z.string().min(1),
+    calendarId: zod_1.z.string().optional()
+}).strict();

package/dist/schemas/clickup.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export declare var clickupListTasksSchema: z.ZodObject<{
+    teamId: z.ZodOptional<z.ZodString>;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    statuses?: string[] | undefined;
+    teamId?: string | undefined;
+}, {
+    statuses?: string[] | undefined;
+    teamId?: string | undefined;
+}>;
+export declare var clickupGetTaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+export declare var clickupSearchTasksSchema: z.ZodObject<{
+    query: z.ZodString;
+    teamId: z.ZodOptional<z.ZodString>;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    spaceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    query: string;
+    statuses?: string[] | undefined;
+    teamId?: string | undefined;
+    spaceIds?: string[] | undefined;
+}, {
+    query: string;
+    statuses?: string[] | undefined;
+    teamId?: string | undefined;
+    spaceIds?: string[] | undefined;
+}>;
+export declare var clickupGetTeamSyncSchema: z.ZodObject<{
+    teamId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    teamId?: string | undefined;
+}, {
+    teamId?: string | undefined;
+}>;
+export type ClickupListTasksInput = z.infer<typeof clickupListTasksSchema>;
+export type ClickupGetTaskInput = z.infer<typeof clickupGetTaskSchema>;
+export type ClickupSearchTasksInput = z.infer<typeof clickupSearchTasksSchema>;
+export type ClickupGetTeamSyncInput = z.infer<typeof clickupGetTeamSyncSchema>;

package/dist/schemas/clickup.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickupGetTeamSyncSchema = exports.clickupSearchTasksSchema = exports.clickupGetTaskSchema = exports.clickupListTasksSchema = void 0;
+const zod_1 = require("zod");
+exports.clickupListTasksSchema = zod_1.z.object({
+    teamId: zod_1.z.string().min(1).optional(),
+    statuses: zod_1.z.array(zod_1.z.string()).optional()
+}).strict();
+exports.clickupGetTaskSchema = zod_1.z.object({
+    taskId: zod_1.z.string().min(1)
+}).strict();
+exports.clickupSearchTasksSchema = zod_1.z.object({
+    query: zod_1.z.string().min(1),
+    teamId: zod_1.z.string().min(1).optional(),
+    statuses: zod_1.z.array(zod_1.z.string()).optional(),
+    spaceIds: zod_1.z.array(zod_1.z.string()).optional()
+}).strict();
+exports.clickupGetTeamSyncSchema = zod_1.z.object({
+    teamId: zod_1.z.string().min(1).optional()
+}).strict();

package/dist/schemas/gmail.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare var gmailGetUnreadSchema: z.ZodObject<{
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}, {
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}>;
+export declare var gmailGetStarredSchema: z.ZodObject<{
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}, {
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}>;
+export declare var gmailSearchSchema: z.ZodObject<{
+    query: z.ZodString;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    query: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}, {
+    query: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}>;
+export declare var gmailGetActionRequiredSchema: z.ZodObject<{
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    subjectPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    labels?: string[] | undefined;
+    maxResults?: number | undefined;
+    subjectPatterns?: string[] | undefined;
+}, {
+    labels?: string[] | undefined;
+    maxResults?: number | undefined;
+    subjectPatterns?: string[] | undefined;
+}>;
+export type GmailGetUnreadInput = z.infer<typeof gmailGetUnreadSchema>;
+export type GmailGetStarredInput = z.infer<typeof gmailGetStarredSchema>;
+export type GmailSearchInput = z.infer<typeof gmailSearchSchema>;
+export type GmailGetActionRequiredInput = z.infer<typeof gmailGetActionRequiredSchema>;

package/dist/schemas/gmail.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gmailGetActionRequiredSchema = exports.gmailSearchSchema = exports.gmailGetStarredSchema = exports.gmailGetUnreadSchema = void 0;
+const zod_1 = require("zod");
+exports.gmailGetUnreadSchema = zod_1.z.object({
+    maxResults: zod_1.z.number().int().min(1).max(100).optional(),
+    pageToken: zod_1.z.string().optional()
+}).strict();
+exports.gmailGetStarredSchema = zod_1.z.object({
+    maxResults: zod_1.z.number().int().min(1).max(100).optional(),
+    pageToken: zod_1.z.string().optional()
+}).strict();
+exports.gmailSearchSchema = zod_1.z.object({
+    query: zod_1.z.string().min(1),
+    maxResults: zod_1.z.number().int().min(1).max(100).optional(),
+    pageToken: zod_1.z.string().optional()
+}).strict();
+exports.gmailGetActionRequiredSchema = zod_1.z.object({
+    labels: zod_1.z.array(zod_1.z.string()).optional(),
+    subjectPatterns: zod_1.z.array(zod_1.z.string()).optional(),
+    maxResults: zod_1.z.number().int().min(1).max(100).optional()
+}).strict();

package/dist/schemas/servicenow.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare var servicenowQueryTableSchema: z.ZodObject<{
+    table: z.ZodString;
+    sysparm_query: z.ZodString;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    table: string;
+    sysparm_query: string;
+    fields?: string[] | undefined;
+    limit?: number | undefined;
+}, {
+    table: string;
+    sysparm_query: string;
+    fields?: string[] | undefined;
+    limit?: number | undefined;
+}>;
+export type ServicenowQueryTableInput = z.infer<typeof servicenowQueryTableSchema>;

package/dist/schemas/servicenow.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.servicenowQueryTableSchema = void 0;
+const zod_1 = require("zod");
+exports.servicenowQueryTableSchema = zod_1.z.object({
+    table: zod_1.z.string().regex(/^[a-z][a-z0-9_]*$/, "Table name must match /^[a-z][a-z0-9_]*$/"),
+    sysparm_query: zod_1.z.string(),
+    fields: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+    limit: zod_1.z.number().int().min(1).max(1000).optional()
+}).strict();

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Bin entry. Library exports come from index.ts; this file only runs the
+ * stdio transport and supports a `--smoke` flag for CI verification that
+ * doesn't depend on a live MCP client.
+ */
+import { createServer } from "./index";
+export { createServer };

package/dist/server.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Bin entry. Library exports come from index.ts; this file only runs the
+ * stdio transport and supports a `--smoke` flag for CI verification that
+ * doesn't depend on a live MCP client.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const index_1 = require("./index");
+Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return index_1.createServer; } });
+const registry_1 = require("./registry");
+async function runSmoke() {
+    // List the registered tools and exit. Verifies wiring without a transport.
+    var lines = [];
+    lines.push("dovetail-mcp smoke test");
+    lines.push("Registered tools (" + registry_1.TOOL_NAMES.length + "):");
+    for (var i = 0; i < registry_1.TOOL_NAMES.length; i++) {
+        lines.push("  - " + registry_1.TOOL_NAMES[i]);
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+}
+async function runStdio() {
+    var server = (0, index_1.createServer)();
+    var transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+async function main() {
+    if (process.argv.indexOf("--smoke") !== -1) {
+        await runSmoke();
+        return;
+    }
+    await runStdio();
+}
+if (require.main === module) {
+    main().catch(function (err) {
+        process.stderr.write("dovetail-mcp fatal: " + (err && err.message ? err.message : String(err)) + "\n");
+        process.exit(1);
+    });
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * JSONL telemetry — one append per tool call to ~/.dovetail-mcp/telemetry.jsonl
+ * (mode 0600, dir 0700). Disable with SINC_MCP_TELEMETRY_DISABLE=1; override
+ * the path with SINC_MCP_TELEMETRY_PATH.
+ *
+ * Fire-and-forget — handler latency must not depend on disk I/O, and a write
+ * failure must never surface to the MCP client.
+ */
+export interface TelemetryEvent {
+    ts: string;
+    tool: string;
+    args: unknown;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+}
+export declare function getTelemetryPath(): string;
+export declare function isTelemetryDisabled(): boolean;
+export declare function recordEvent(event: Omit<TelemetryEvent, "args"> & {
+    args: unknown;
+}): void;
+export declare function withTelemetry<T>(tool: string, args: unknown, fn: () => Promise<T>): Promise<T>;
+/**
+ * Reset internal state. Test-only; not exported from index.ts.
+ */
+export declare function _resetForTests(): void;
+/**
+ * Flush all pending writes. Test-only.
+ */
+export declare function _flushForTests(): Promise<void>;

package/dist/telemetry.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * JSONL telemetry — one append per tool call to ~/.dovetail-mcp/telemetry.jsonl
+ * (mode 0600, dir 0700). Disable with SINC_MCP_TELEMETRY_DISABLE=1; override
+ * the path with SINC_MCP_TELEMETRY_PATH.
+ *
+ * Fire-and-forget — handler latency must not depend on disk I/O, and a write
+ * failure must never surface to the MCP client.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTelemetryPath = getTelemetryPath;
+exports.isTelemetryDisabled = isTelemetryDisabled;
+exports.recordEvent = recordEvent;
+exports.withTelemetry = withTelemetry;
+exports._resetForTests = _resetForTests;
+exports._flushForTests = _flushForTests;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const redact_1 = require("./redact");
+var dirEnsured = false;
+var writeQueue = Promise.resolve();
+function getTelemetryPath() {
+    if (process.env.SINC_MCP_TELEMETRY_PATH) {
+        return process.env.SINC_MCP_TELEMETRY_PATH;
+    }
+    return path.join(os.homedir(), ".dovetail-mcp", "telemetry.jsonl");
+}
+function isTelemetryDisabled() {
+    var v = process.env.SINC_MCP_TELEMETRY_DISABLE;
+    return v === "1" || v === "true";
+}
+function ensureFile(filePath) {
+    if (dirEnsured) {
+        return;
+    }
+    var dir = path.dirname(filePath);
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        // Directory may exist with different perms; appendFile will fail
+        // separately if that's the real problem.
+    }
+    if (!fs.existsSync(filePath)) {
+        try {
+            fs.writeFileSync(filePath, "", { mode: 0o600 });
+        }
+        catch {
+            // Swallowed — telemetry must not break callers.
+        }
+    }
+    else {
+        try {
+            fs.chmodSync(filePath, 0o600);
+        }
+        catch {
+            // Best-effort: if we can't chmod we can still append.
+        }
+    }
+    dirEnsured = true;
+}
+function recordEvent(event) {
+    if (isTelemetryDisabled()) {
+        return;
+    }
+    var safe = {
+        ts: event.ts,
+        tool: event.tool,
+        args: (0, redact_1.redactArgs)(event.args),
+        durationMs: event.durationMs,
+        success: event.success,
+        error: event.error
+    };
+    var line = JSON.stringify(safe) + "\n";
+    var filePath = getTelemetryPath();
+    writeQueue = writeQueue.then(function () {
+        return new Promise(function (resolve) {
+            try {
+                ensureFile(filePath);
+            }
+            catch {
+                resolve();
+                return;
+            }
+            fs.appendFile(filePath, line, function () {
+                resolve();
+            });
+        });
+    });
+}
+async function withTelemetry(tool, args, fn) {
+    var started = Date.now();
+    var ts = new Date().toISOString();
+    try {
+        var result = await fn();
+        recordEvent({
+            ts: ts,
+            tool: tool,
+            args: args,
+            durationMs: Date.now() - started,
+            success: true
+        });
+        return result;
+    }
+    catch (err) {
+        var msg = err instanceof Error ? err.message : String(err);
+        recordEvent({
+            ts: ts,
+            tool: tool,
+            args: args,
+            durationMs: Date.now() - started,
+            success: false,
+            error: msg
+        });
+        throw err;
+    }
+}
+/**
+ * Reset internal state. Test-only; not exported from index.ts.
+ */
+function _resetForTests() {
+    dirEnsured = false;
+    writeQueue = Promise.resolve();
+}
+/**
+ * Flush all pending writes. Test-only.
+ */
+function _flushForTests() {
+    return writeQueue;
+}