agent-dir 0.4.1 → 1.0.0

package/dist/src/server.d.ts

@@ -4,7 +4,7 @@ export interface ServerHandle {
 }
 export declare function startServer({ root, port, token, commandConfig, telemetry, }: ServerOptions): Promise<ServerHandle>;
 export declare function validateMcpHeaders(request: Request, message: Record<string, unknown> | null): Response | undefined;
-export declare function getMcpLog(body: Buffer): {
+export declare function getMcpLog(body: Buffer, responseBody?: unknown): {
     name: string;
     detail: string;
 } | undefined;

package/dist/src/server.js

@@ -3,7 +3,6 @@ import { authenticate, unauthorized } from "./auth.js";
 import { logRequest } from "./logging.js";
 import { createMcpHandler } from "./mcp.js";
 import { TelemetryRecorder } from "./telemetry/recorder.js";
-import { deleteFile, listFiles, readFile, writeFile } from "./tools/files.js";
 const MAX_BODY_BYTES = 10 * 1024 * 1024;
 const REQUEST_BODY_TIMEOUT_MS = 30_000;
 const REQUEST_TIMEOUT_MS = 120_000;
@@ -16,7 +15,7 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
         level: telemetry.level,
         persist: telemetry.persist ?? false,
         ...(telemetry.configId ? { configId: telemetry.configId } : {}),
-        sessionId: `http-${Date.now()}`,
+        sessionId: telemetry.sessionId ?? `http-${Date.now()}`,
     });
     const server = http.createServer(async (req, res) => {
         const startedAt = performance.now();
@@ -29,6 +28,11 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
         let authenticated = false;
         try {
+            if (url.pathname === HEALTH_PATH && req.method === "HEAD") {
+                res.setHeader("cache-control", "no-store");
+                sendText(res, 200, "ok\n");
+                return;
+            }
             const body = await readBody(req, requestController.signal);
             const requestInit = {
                 method: req.method ?? "GET",
@@ -51,10 +55,6 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                 recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 401, authenticated, startedAt);
                 return;
             }
-            if (url.pathname === HEALTH_PATH && req.method === "HEAD") {
-                sendText(res, 200, "ok\n");
-                return;
-            }
             if (url.pathname === "/mcp") {
                 if (req.method !== "POST") {
                     res.setHeader("allow", "POST");
@@ -82,9 +82,13 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                     return;
                 }
                 const response = await mcp(request);
+                const mcpResponseBody = await response
+                    .clone()
+                    .json()
+                    .catch(() => undefined);
                 const errorDetail = await getResponseErrorDetail(response);
+                const mcpLog = getMcpLog(body, mcpResponseBody);
                 await sendResponse(res, response);
-                const mcpLog = getMcpLog(body);
                 const mcpErrorContext = response.status >= 400 ? getMcpErrorContext(body, request) : undefined;
                 logRequest({
                     method: req.method,
@@ -98,50 +102,6 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                 recordHttpTelemetry(httpTelemetry, req.method, url.pathname, response.status, authenticated, startedAt);
                 return;
             }
-            if (url.pathname === "/__tree" && req.method === "GET") {
-                const tree = await listFiles(root);
-                sendText(res, 200, JSON.stringify(tree, null, 2), "application/json; charset=utf-8");
-                logRequest({ method: req.method, path: url.pathname, status: 200, detail: "directory" });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            const relative = decodeURIComponent(url.pathname.slice(1));
-            if (!relative) {
-                sendText(res, 200, "agent-dir\n");
-                logRequest({
-                    method: req.method ?? "UNKNOWN",
-                    path: url.pathname,
-                    status: 200,
-                    detail: "server",
-                });
-                recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            if (req.method === "GET") {
-                sendText(res, 200, await readFile(root, relative), "text/plain; charset=utf-8");
-                logRequest({ method: req.method, path: url.pathname, status: 200, detail: "REST GET" });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            if (req.method === "PUT") {
-                await writeFile(root, relative, body.toString("utf8"));
-                sendText(res, 200, "File updated successfully\n");
-                logRequest({ method: req.method, path: url.pathname, status: 200, detail: "REST PUT" });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
-            if (req.method === "DELETE") {
-                await deleteFile(root, relative);
-                sendText(res, 200, "File deleted successfully\n");
-                logRequest({
-                    method: req.method,
-                    path: url.pathname,
-                    status: 200,
-                    detail: "REST DELETE",
-                });
-                recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
-                return;
-            }
             sendText(res, 404, "Not found\n");
             logRequest({
                 method: req.method ?? "UNKNOWN",
@@ -323,7 +283,7 @@ async function getResponseErrorDetail(response) {
     }
     return undefined;
 }
-export function getMcpLog(body) {
+export function getMcpLog(body, responseBody) {
     try {
         const message = JSON.parse(body.toString("utf8"));
         if (typeof message.method !== "string")
@@ -336,20 +296,7 @@ export function getMcpLog(body) {
         const name = message.params.name;
         const args = isRecordValue(message.params.arguments) ? message.params.arguments : {};
         const detail = (() => {
-            const paths = Array.isArray(args.paths)
-                ? args.paths.filter((value) => typeof value === "string")
-                : [];
-            const files = Array.isArray(args.files)
-                ? args.files
-                    .filter((value) => typeof value === "object" && value !== null)
-                    .map((value) => value.path)
-                    .filter((value) => typeof value === "string")
-                : [];
             switch (name) {
-                case "list_files":
-                    return "all project files";
-                case "list_dirs":
-                    return paths.join(", ");
                 case "read_range": {
                     const path = typeof args.path === "string" ? args.path : "";
                     const startLine = typeof args.startLine === "number" ? args.startLine : undefined;
@@ -358,21 +305,12 @@ export function getMcpLog(body) {
                         ? `${path}:${startLine}-${endLine}`
                         : path;
                 }
-                case "read_files":
-                case "delete_files":
-                case "git_stage":
-                case "git_unstage":
-                    return paths.join(", ");
-                case "write_files":
-                case "patch_files":
-                    return files.join(", ");
                 case "run_npm_batch": {
                     const scripts = Array.isArray(args.scripts)
                         ? args.scripts.filter((value) => typeof value === "string")
                         : [];
                     return scripts.map((script) => `npm run ${script}`).join(", ");
                 }
-                case "search_files":
                 case "search_code": {
                     const query = typeof args.query === "string" ? args.query : "";
                     const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
@@ -396,15 +334,6 @@ export function getMcpLog(body) {
                             : `symbol: ${symbol}`
                         : "";
                 }
-                case "find_definition": {
-                    const symbol = typeof args.symbol === "string" ? args.symbol : "";
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return symbol
-                        ? maxResults !== undefined
-                            ? `definition: ${symbol} (max ${maxResults})`
-                            : `definition: ${symbol}`
-                        : "";
-                }
                 case "find_references": {
                     const symbol = typeof args.symbol === "string" ? args.symbol : "";
                     const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
@@ -414,36 +343,36 @@ export function getMcpLog(body) {
                             : `references: ${symbol}`
                         : "";
                 }
-                case "git_commit":
-                    return "commit (message omitted)";
-                case "find_imports": {
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return maxResults !== undefined ? `all imports (max ${maxResults})` : "all imports";
-                }
-                case "find_exports": {
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return maxResults !== undefined ? `all exports (max ${maxResults})` : "all exports";
-                }
-                case "diagnostics": {
-                    const maxResults = typeof args.maxResults === "number" ? args.maxResults : undefined;
-                    return maxResults !== undefined ? `max ${maxResults}` : "";
-                }
-                case "git_restore":
-                    return paths.join(", ");
-                case "git_push":
-                    return "push (remote/branch omitted)";
-                case "git_diff": {
-                    const staged = args.staged === true ? "staged" : "working tree";
-                    const path = typeof args.path === "string" ? args.path : "";
-                    return path ? `${staged}: ${path}` : staged;
-                }
-                case "git_log": {
-                    const limit = typeof args.limit === "number" ? args.limit : 20;
-                    const path = typeof args.path === "string" ? args.path : "";
-                    return path ? `last ${limit}: ${path}` : `last ${limit}`;
-                }
                 case "file_info":
                     return typeof args.path === "string" ? args.path : "";
+                case "apply_changes": {
+                    const response = isRecordValue(responseBody) ? responseBody : undefined;
+                    const result = response && isRecordValue(response.result) ? response.result : undefined;
+                    if (result?.isError === true || response?.error !== undefined)
+                        return "change failed";
+                    const applied = Array.isArray(result?.structuredContent) ? result.structuredContent : [];
+                    if (applied.length) {
+                        const entries = applied
+                            .filter((item) => isRecordValue(item) && item.changed === true)
+                            .map((item) => {
+                            const kind = item.kind === "write" || item.kind === "patch" || item.kind === "delete"
+                                ? item.kind
+                                : "change";
+                            const path = typeof item.path === "string" ? item.path : "(unknown path)";
+                            return `${kind} ${path}`;
+                        });
+                        if (!entries.length)
+                            return args.dryRun === true ? "preview: no file changes" : "no file changes";
+                        const shown = entries.slice(0, 5);
+                        const suffix = entries.length > shown.length ? ` • +${entries.length - shown.length} more` : "";
+                        return `${args.dryRun === true ? "preview" : "changed"}: ${shown.join(" • ")}${suffix}`;
+                    }
+                    const changes = Array.isArray(args.changes) ? args.changes : [];
+                    const paths = changes
+                        .filter((item) => isRecordValue(item))
+                        .map((item) => (typeof item.path === "string" ? item.path : "(unknown path)"));
+                    return `requested: ${paths.slice(0, 5).join(" • ")}${paths.length > 5 ? ` • +${paths.length - 5} more` : ""}`;
+                }
                 case "run_command_batch": {
                     const commands = Array.isArray(args.commands) ? args.commands : [];
                     return commands
@@ -463,33 +392,7 @@ export function getMcpLog(body) {
 }
 function getMcpMethodDetail(method, params) {
     const value = params ?? {};
-    const capabilities = isRecordValue(value.capabilities)
-        ? Object.keys(value.capabilities).sort()
-        : [];
-    const clientInfo = isRecordValue(value.clientInfo) ? value.clientInfo : undefined;
-    const clientName = typeof clientInfo?.name === "string" ? clientInfo.name : undefined;
-    const clientVersion = typeof clientInfo?.version === "string" ? clientInfo.version : undefined;
-    const protocol = typeof value.protocolVersion === "string"
-        ? value.protocolVersion
-        : isRecordValue(value._meta) &&
-            typeof value._meta["io.modelcontextprotocol/protocolVersion"] === "string"
-            ? value._meta["io.modelcontextprotocol/protocolVersion"]
-            : undefined;
     switch (method) {
-        case "initialize": {
-            const client = clientName
-                ? clientVersion
-                    ? `${clientName} v${clientVersion}`
-                    : clientName
-                : undefined;
-            return ([
-                protocol ? `protocol: ${protocol}` : undefined,
-                client ? `client: ${client}` : undefined,
-                capabilities.length ? `capabilities: ${capabilities.join(", ")}` : undefined,
-            ]
-                .filter((part) => Boolean(part))
-                .join(" • ") || "initialization handshake");
-        }
         case "notifications/initialized":
             return "initialization complete";
         case "tools/list":
@@ -534,15 +437,7 @@ function formatCommand(command, args) {
     return count ? `${command} (args: ${count})` : command;
 }
 function recordHttpTelemetry(recorder, method, pathname, status, authenticated, startedAt) {
-    const route = pathname === "/mcp"
-        ? "mcp"
-        : pathname === "/__tree"
-            ? "tree"
-            : pathname === "/"
-                ? "root"
-                : pathname.startsWith("/") && pathname.length > 1
-                    ? "file"
-                    : "other";
+    const route = pathname === "/mcp" ? "mcp" : "other";
     recorder.record({
         event: "http_request",
         method,

package/dist/src/setup.js

@@ -104,12 +104,26 @@ export async function runFirstTimeSetup(config, defaultDirectory = ".") {
         const name = await requiredText(rl, "Profile name", "default");
         const directory = resolve(await requiredText(rl, "Directory to expose", defaultDirectory));
         const port = await requiredPort(rl, 3002);
-        const tunnel = await choose(rl, "Tunnel", ["wormhole", "none"], "wormhole");
+        let hostname;
+        let cloudflaredToken;
         let subdomain;
-        if (tunnel === "wormhole" &&
+        console.log("");
+        console.log(`${section("◆")} ${section(bold("Cloudflare Tunnel"))}`);
+        console.log(rule());
+        const useCloudflared = await confirm(rl, "Set up Cloudflare Tunnel?", true);
+        if (useCloudflared) {
+            hostname = await requiredHostname(rl, "Public hostname (must be routed to this tunnel)");
+            cloudflaredToken = await requiredSecret(rl, "Cloudflare tunnel token");
+        }
+        console.log("");
+        console.log(`${section("◆")} ${section(bold("Wormhole"))}`);
+        console.log(rule());
+        const useWormhole = await confirm(rl, "Set up Wormhole too?", false);
+        if (useWormhole &&
             (await confirm(rl, "Use a custom Wormhole subdomain? (No uses a random URL.)", false))) {
             subdomain = await requiredText(rl, "Wormhole subdomain");
         }
+        const tunnel = useCloudflared ? "cloudflared" : useWormhole ? "wormhole" : "none";
         const npm = await optionalList(rl, "Allowed npm scripts (comma-separated, blank for none)");
         const commands = await optionalList(rl, "Allowed commands (comma-separated, blank for none)");
         console.log("");
@@ -119,9 +133,9 @@ export async function runFirstTimeSetup(config, defaultDirectory = ".") {
             bold("Privacy first"),
             dim("Telemetry is optional and stays local on this machine."),
             dim("It helps us understand usage, failures, and reliability improvements."),
-            dim("Standard levels never record file contents, command arguments, tokens,"),
-            dim("environment variables, or project paths."),
-            dim("Diagnostic mode is a separate opt-in local troubleshooting mode and records identifying metadata."),
+            dim("Standard levels avoid file contents, command arguments, tokens, and project paths."),
+            dim("Diagnostic mode records bounded raw tool inputs/outputs and identifying metadata."),
+            dim("It may contain source code or other sensitive project data; it stays local."),
         ]);
         console.log("");
         console.log(`  ${green("●")} ${white("none")}       ${dim("disabled")}`);
@@ -131,9 +145,25 @@ export async function runFirstTimeSetup(config, defaultDirectory = ".") {
         console.log(`  ${cyan("●")} ${white("diagnostic")} ${dim("detailed + local paths, host/user, PID, Node version, memory/uptime")}`);
         console.log("");
         const telemetry = await choose(rl, "Telemetry level", ["none", "anonymous", "basic", "detailed", "diagnostic"], "none");
-        const profile = { directory, port, tunnel, token: randomBytes(24).toString("hex") };
+        const profile = {
+            directory,
+            port,
+            tunnel,
+            defaultTunnel: tunnel,
+            token: randomBytes(24).toString("hex"),
+        };
         if (subdomain)
             profile.subdomain = subdomain;
+        if (hostname)
+            profile.hostname = hostname;
+        if (useCloudflared || useWormhole) {
+            profile.tunnels = {
+                ...(useWormhole ? { wormhole: { ...(subdomain ? { subdomain } : { random: true }) } } : {}),
+                ...(useCloudflared && hostname
+                    ? { cloudflared: { hostname, ...(cloudflaredToken ? { token: cloudflaredToken } : {}) } }
+                    : {}),
+            };
+        }
         if (npm.length)
             profile.npm = { allowedScripts: npm };
         if (commands.length)
@@ -168,6 +198,37 @@ async function requiredText(rl, label, defaultValue) {
         console.log(`  ${error("✕")} ${dim("A value is required.")}`);
     }
 }
+async function requiredSecret(rl, label) {
+    while (true) {
+        output.write(`  ${bold(label)}: `);
+        const writableRl = rl;
+        const writeToOutput = writableRl._writeToOutput;
+        writableRl._writeToOutput = () => { };
+        let value;
+        try {
+            value = (await rl.question("")).trim();
+        }
+        finally {
+            writableRl._writeToOutput = writeToOutput;
+            output.write("\n");
+        }
+        if (value)
+            return value;
+        console.log(`  ${error("✕")} ${dim("A value is required.")}`);
+    }
+}
+async function requiredHostname(rl, label) {
+    while (true) {
+        const value = (await rl.question(`  ${bold(label)}: `)).trim().toLowerCase();
+        const labels = value.split(".");
+        const valid = value.length <= 253 &&
+            labels.length >= 2 &&
+            labels.every((part) => part.length >= 1 && part.length <= 63 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(part));
+        if (valid)
+            return value;
+        console.log(`  ${error("✕")} ${dim("Enter a hostname only, such as agent-dir-mcp.scriptr.uk (no spaces, https://, or path).")}`);
+    }
+}
 async function requiredPort(rl, defaultValue) {
     while (true) {
         const value = (await rl.question(`  ${bold("Port")} ${dim(`[${defaultValue}]`)}: `)).trim() ||

package/dist/src/telemetry/privacy.js

@@ -31,6 +31,8 @@ export function sanitizeAnonymousEvent(event) {
             method: sanitizeMcpMethod(event.method),
             success: event.success === true,
             durationMs: boundedNumber(event.durationMs),
+            ...optionalNumber("responseBytes", event.responseBytes),
+            ...optionalNumber("estimatedResponseTokens", event.estimatedResponseTokens),
             ...(event.errorCategory === undefined
                 ? {}
                 : { errorCategory: sanitizeErrorCategory(event.errorCategory) }),
@@ -40,6 +42,33 @@ export function sanitizeAnonymousEvent(event) {
         return {
             event: "tool_call",
             tool: sanitizeIdentifier(event.tool, SAFE_TOOL_NAME),
+            ...(event.requestIdHash === undefined
+                ? {}
+                : { requestIdHash: sanitizeHash(event.requestIdHash) }),
+            ...(event.inputFingerprint === undefined
+                ? {}
+                : { inputFingerprint: sanitizeHash(event.inputFingerprint) }),
+            ...(event.outputFingerprint === undefined
+                ? {}
+                : { outputFingerprint: sanitizeHash(event.outputFingerprint) }),
+            ...optionalNumber("estimatedInputTokens", event.estimatedInputTokens),
+            ...optionalNumber("estimatedOutputTokens", event.estimatedOutputTokens),
+            ...optionalNumber("cumulativeOutputBytes", event.cumulativeOutputBytes),
+            ...optionalNumber("cumulativeEstimatedOutputTokens", event.cumulativeEstimatedOutputTokens),
+            ...optionalNumber("duplicateOutputBytes", event.duplicateOutputBytes),
+            ...optionalNumber("textOutputBytes", event.textOutputBytes),
+            ...optionalNumber("uniqueFileCount", event.uniqueFileCount),
+            ...(event.files === undefined
+                ? {}
+                : {
+                    files: event.files.slice(0, 100).map((file) => ({
+                        pathHash: sanitizeHash(file.pathHash),
+                        ...(file.contentHash === undefined
+                            ? {}
+                            : { contentHash: sanitizeHash(file.contentHash) }),
+                        bytes: boundedNumber(file.bytes),
+                    })),
+                }),
             success: event.success === true,
             durationMs: boundedNumber(event.durationMs),
             ...optionalNumber("inputBytes", event.inputBytes),
@@ -100,6 +129,12 @@ export function createTelemetryEnvelope(level, event, runtime, project, configId
         level,
         event: sanitizeAnonymousEvent(event),
     };
+    if (level === "diagnostic" &&
+        event.event === "tool_call" &&
+        event.diagnosticDetails &&
+        envelope.event.event === "tool_call") {
+        envelope.event.diagnosticDetails = event.diagnosticDetails;
+    }
     if (level === "basic" || level === "detailed" || level === "diagnostic") {
         if (runtime)
             envelope.runtime = sanitizeRuntimeContext(runtime);
@@ -121,6 +156,16 @@ function sanitizeDiagnosticRuntimeContext(context) {
         ...(context.nodeVersion === undefined
             ? {}
             : { nodeVersion: sanitizeVersion(context.nodeVersion) }),
+        ...(context.distroId === undefined
+            ? {}
+            : { distroId: sanitizeSensitiveIdentifier(context.distroId) }),
+        ...(context.distroName === undefined ? {} : { distroName: context.distroName.slice(0, 128) }),
+        ...(context.distroVersion === undefined
+            ? {}
+            : { distroVersion: context.distroVersion.slice(0, 64) }),
+        ...(context.kernelVersion === undefined
+            ? {}
+            : { kernelVersion: context.kernelVersion.slice(0, 128) }),
         ...(context.hostname === undefined
             ? {}
             : { hostname: sanitizeSensitiveIdentifier(context.hostname) }),
@@ -202,6 +247,9 @@ function sanitizeVersion(value) {
         ? normalized
         : "unknown";
 }
+function sanitizeHash(value) {
+    return /^[a-f0-9]{64}$/.test(value) ? value : "unknown";
+}
 function sanitizeErrorCategory(value) {
     const normalized = value.trim().toLowerCase();
     return SAFE_ERROR_CATEGORIES.has(normalized) ? normalized : "unknown";

package/dist/src/telemetry/recorder.js

@@ -1,10 +1,9 @@
+import { randomUUID } from "node:crypto";
 import { appendFileSync, chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 import { createTelemetryEnvelope } from "./privacy.js";
+import { telemetrySessionPath } from "./storage.js";
 const DEFAULT_MAX_EVENTS = 500;
-const DEFAULT_PERSISTED_EVENTS = 500;
-const TELEMETRY_FILE = join(homedir(), ".config", "agent-dir", "telemetry.jsonl");
 export class TelemetryRecorder {
     level;
     maxEvents;
@@ -21,9 +20,9 @@ export class TelemetryRecorder {
         this.runtime = options.runtime;
         this.project = options.project;
         this.persist = options.persist ?? false;
-        this.persistPath = options.persistPath ?? TELEMETRY_FILE;
         this.configId = options.configId ?? "default";
-        this.sessionId = options.sessionId ?? "default";
+        this.sessionId = options.sessionId ?? randomUUID();
+        this.persistPath = options.persistPath ?? telemetrySessionPath(this.configId, this.sessionId);
         if (this.persist && this.level !== "none")
             this.loadPersisted();
     }
@@ -64,8 +63,9 @@ export class TelemetryRecorder {
                 .filter((event) => event &&
                 event.schemaVersion === 1 &&
                 event.level === this.level &&
-                event.configId === this.configId)
-                .slice(-Math.min(this.maxEvents, DEFAULT_PERSISTED_EVENTS));
+                event.configId === this.configId &&
+                event.sessionId === this.sessionId)
+                .slice(-this.maxEvents);
             this.events.push(...persisted);
         }
         catch {
@@ -80,15 +80,6 @@ export class TelemetryRecorder {
                 mode: 0o600,
             });
             chmodSync(this.persistPath, 0o600);
-            if (this.events.length === this.maxEvents) {
-                const lines = readFileSync(this.persistPath, "utf8").split("\n").filter(Boolean);
-                if (lines.length > this.maxEvents) {
-                    writeFileSync(this.persistPath, `${lines.slice(-this.maxEvents).join("\n")}\n`, {
-                        encoding: "utf8",
-                        mode: 0o600,
-                    });
-                }
-            }
         }
         catch {
             // Telemetry persistence must never affect the MCP request path.

package/dist/src/telemetry/storage.d.ts

@@ -0,0 +1,9 @@
+import type { TelemetryEnvelope } from "./types.js";
+export declare const TELEMETRY_DIRECTORY: string;
+export declare const LEGACY_TELEMETRY_FILE: string;
+export declare function telemetrySessionPath(configId: string, sessionId: string): string;
+/** Migrate the old shared file once, preserving an archive and avoiding duplicate lines. */
+export declare function migrateLegacyTelemetry(): void;
+export declare function readAllTelemetryEvents(): TelemetryEnvelope[];
+export declare function resetTelemetry(profile?: string, all?: boolean): void;
+export declare function ensureTelemetryDirectory(): void;