agent-dir 0.4.0 → 0.5.0

package/dist/src/mcp.js

@@ -1,6 +1,7 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { hostname, userInfo } from "node:os";
+import { hostname, release, userInfo } from "node:os";
 import { CodeGraphIntegration } from "./codegraph.js";
 import { TelemetryRecorder } from "./telemetry/recorder.js";
 import { findDefinition, findExports, findFiles, findImports, findReferences, findSymbol, searchCode, searchFiles, } from "./tools/code.js";
@@ -345,6 +346,9 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
     let sessionToolCallCount = 0;
     let sessionCommandCallCount = 0;
     let sessionRecorded = false;
+    let sessionOutputBytes = 0;
+    let sessionEstimatedOutputTokens = 0;
+    const seenOutputFingerprints = new Set();
     const telemetryProjectPromise = telemetry.level === "detailed" || telemetry.level === "diagnostic"
         ? buildTelemetryProjectContext(root, codeGraph).catch(() => undefined)
         : undefined;
@@ -570,16 +574,30 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
                         const result = await callTool(toolName, argumentsValue, root, npmAllowed, allowedCommands, blacklistedCommands, gitEnabled, notify, request.signal, codeGraph);
                         const durationMs = performance.now() - startedAt;
                         const count = resultCount(result);
+                        const serializedResult = JSON.stringify(result);
+                        const outputBytes = Buffer.byteLength(serializedResult, "utf8");
+                        const estimatedOutputTokens = estimateTokens(serializedResult);
+                        sessionOutputBytes += outputBytes;
+                        sessionEstimatedOutputTokens += estimatedOutputTokens;
                         const runtime = telemetryRuntime(params);
                         telemetryRecorder.record({
                             event: "tool_call",
                             tool: toolName,
+                            requestIdHash: telemetryHash(String(message.id)),
                             success: true,
                             durationMs,
                             inputBytes: Buffer.byteLength(JSON.stringify(argumentsValue), "utf8"),
-                            outputBytes: Buffer.byteLength(JSON.stringify(result), "utf8"),
+                            outputBytes,
+                            estimatedInputTokens: estimateTokens(JSON.stringify(argumentsValue)),
+                            estimatedOutputTokens,
+                            cumulativeOutputBytes: sessionOutputBytes,
+                            cumulativeEstimatedOutputTokens: sessionEstimatedOutputTokens,
+                            inputFingerprint: telemetryHash(JSON.stringify({ toolName, argumentsValue })),
+                            ...(telemetry.level === "diagnostic"
+                                ? { diagnosticDetails: diagnosticToolDetails(argumentsValue, result) }
+                                : {}),
                             ...(count === undefined ? {} : { resultCount: count }),
-                            ...toolTelemetryMetrics(toolName, result),
+                            ...toolTelemetryMetrics(toolName, result, seenOutputFingerprints),
                         }, runtime, telemetryProject);
                         const command = commandTelemetryDescriptor(toolName);
                         if (command) {
@@ -590,7 +608,7 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
                                 operation: command.operation,
                                 success: true,
                                 durationMs,
-                                outputBytes: Buffer.byteLength(JSON.stringify(result), "utf8"),
+                                outputBytes,
                             }, runtime, telemetryProject);
                         }
                         mcpSuccess = true;
@@ -607,9 +625,21 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
                         telemetryRecorder.record({
                             event: "tool_call",
                             tool: toolName,
+                            requestIdHash: telemetryHash(String(message.id)),
                             success: false,
                             durationMs,
                             inputBytes: Buffer.byteLength(JSON.stringify(argumentsValue), "utf8"),
+                            estimatedInputTokens: estimateTokens(JSON.stringify(argumentsValue)),
+                            inputFingerprint: telemetryHash(JSON.stringify({ toolName, argumentsValue })),
+                            ...(telemetry.level === "diagnostic"
+                                ? {
+                                    diagnosticDetails: diagnosticToolDetails(argumentsValue, {
+                                        error: error instanceof Error
+                                            ? { name: error.name, message: error.message, stack: error.stack }
+                                            : String(error),
+                                    }),
+                                }
+                                : {}),
                             errorCategory,
                         }, runtime, telemetryProject);
                         const command = commandTelemetryDescriptor(toolName);
@@ -1554,6 +1584,8 @@ function telemetryRuntime(params) {
         ...(typeof clientInfo?.name === "string" ? { mcpClientName: clientInfo.name } : {}),
         ...(typeof clientInfo?.version === "string" ? { mcpClientVersion: clientInfo.version } : {}),
         nodeVersion: process.versions.node,
+        ...linuxDistribution(),
+        kernelVersion: release(),
         hostname: hostname(),
         username: userInfo().username,
         processId: process.pid,
@@ -1562,37 +1594,106 @@ function telemetryRuntime(params) {
         memoryRssBytes: process.memoryUsage().rss,
     };
 }
-function toolTelemetryMetrics(toolName, result) {
+function linuxDistribution() {
+    if (process.platform !== "linux")
+        return {};
+    try {
+        const values = Object.fromEntries(readFileSync("/etc/os-release", "utf8")
+            .split("\n")
+            .map((line) => line.match(/^([A-Z_]+)=(.*)$/))
+            .filter((match) => match !== null)
+            .map((match) => [match[1], match[2]?.replace(/^"|"$/g, "")]));
+        return {
+            ...(values.ID ? { distroId: values.ID } : {}),
+            ...(values.PRETTY_NAME ? { distroName: values.PRETTY_NAME } : {}),
+            ...(values.VERSION_ID ? { distroVersion: values.VERSION_ID } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function diagnosticToolDetails(input, output) {
+    const serialize = (value) => {
+        try {
+            const json = JSON.stringify(value);
+            if (json === undefined)
+                return null;
+            if (Buffer.byteLength(json, "utf8") <= 64_000)
+                return value;
+            return {
+                truncated: true,
+                byteLength: Buffer.byteLength(json, "utf8"),
+                preview: json.slice(0, 64_000),
+            };
+        }
+        catch {
+            return { serializationFailed: true };
+        }
+    };
+    return { input: serialize(input), output: serialize(output) };
+}
+function telemetryHash(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+// A rough byte-based proxy, not a model-tokenizer count or Claude billing measurement.
+function estimateTokens(value) {
+    return Math.ceil(Buffer.byteLength(value, "utf8") / 4);
+}
+function toolTelemetryMetrics(toolName, result, seenOutputFingerprints) {
     const structured = result.structuredContent;
     if (!Array.isArray(structured) && !isRecord(structured))
         return {};
     const paths = new Set();
+    const files = new Map();
     let truncated = false;
     let paginated = false;
+    let textOutputBytes = 0;
     const visit = (value) => {
+        if (typeof value === "string") {
+            textOutputBytes += Buffer.byteLength(value, "utf8");
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const child of value)
+                visit(child);
+            return;
+        }
         if (!isRecord(value))
             return;
-        if (typeof value.path === "string")
+        if (typeof value.path === "string") {
             paths.add(value.path);
+            const content = typeof value.content === "string" ? value.content : undefined;
+            files.set(value.path, {
+                pathHash: telemetryHash(value.path),
+                ...(content === undefined ? {} : { contentHash: telemetryHash(content) }),
+                bytes: content === undefined ? 0 : Buffer.byteLength(content, "utf8"),
+            });
+        }
         if (value.truncated === true)
             truncated = true;
         if (value.nextCursor !== undefined)
             paginated = true;
-        for (const child of Object.values(value)) {
-            if (Array.isArray(child))
-                for (const item of child)
-                    visit(item);
-            else if (isRecord(child))
-                visit(child);
-        }
+        for (const child of Object.values(value))
+            visit(child);
     };
     visit(structured);
+    const outputJson = JSON.stringify(result);
+    const outputFingerprint = telemetryHash(outputJson);
+    const outputBytes = Buffer.byteLength(outputJson, "utf8");
+    const duplicateOutputBytes = seenOutputFingerprints.has(outputFingerprint) ? outputBytes : 0;
+    seenOutputFingerprints.add(outputFingerprint);
     return {
         ...(paths.size > 0 && /^(write|patch|delete|read|file|git_changes|inspect)/.test(toolName)
             ? { affectedFiles: paths.size }
             : {}),
         ...(truncated ? { truncated: true } : {}),
         ...(paginated ? { paginated: true } : {}),
+        outputFingerprint,
+        duplicateOutputBytes,
+        textOutputBytes,
+        uniqueFileCount: files.size,
+        ...(files.size ? { files: [...files.values()].slice(0, 100) } : {}),
     };
 }
 function commandTelemetryDescriptor(toolName) {

package/dist/src/server.js

@@ -5,23 +5,40 @@ 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;
+const HEADERS_TIMEOUT_MS = 30_000;
+const KEEP_ALIVE_TIMEOUT_MS = 5_000;
+const HEALTH_PATH = "/__health";
 export function startServer({ root, port, token, commandConfig = {}, telemetry = { level: "none" }, }) {
     const mcp = createMcpHandler(root, commandConfig, telemetry);
     const httpTelemetry = new TelemetryRecorder({
         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();
+        const requestController = new AbortController();
+        req.once("aborted", () => requestController.abort());
+        res.once("close", () => {
+            if (!res.writableFinished)
+                requestController.abort();
+        });
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
         let authenticated = false;
         try {
-            const body = await readBody(req);
+            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",
                 headers: toFetchHeaders(req.headers),
+                signal: requestController.signal,
             };
             if (body.length)
                 requestInit.body = body;
@@ -117,7 +134,12 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
             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" });
+                logRequest({
+                    method: req.method,
+                    path: url.pathname,
+                    status: 200,
+                    detail: "REST DELETE",
+                });
                 recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
                 return;
             }
@@ -131,8 +153,16 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
             recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 404, authenticated, startedAt);
         }
         catch (error) {
+            if (requestController.signal.aborted || res.destroyed)
+                return;
             const code = error.code;
-            const status = code === "ENOENT" ? 404 : code === "PAYLOAD_TOO_LARGE" ? 413 : 500;
+            const status = code === "ENOENT"
+                ? 404
+                : code === "PAYLOAD_TOO_LARGE"
+                    ? 413
+                    : code === "REQUEST_TIMEOUT"
+                        ? 408
+                        : 500;
             sendText(res, status, `${error instanceof Error ? error.message : String(error)}\n`);
             logRequest({
                 method: req.method ?? "UNKNOWN",
@@ -143,6 +173,9 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
             recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, status, authenticated, startedAt);
         }
     });
+    server.requestTimeout = REQUEST_TIMEOUT_MS;
+    server.headersTimeout = HEADERS_TIMEOUT_MS;
+    server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
     return new Promise((resolve, reject) => {
         server.once("error", reject);
         server.listen(port, "127.0.0.1", () => resolve({
@@ -531,12 +564,39 @@ function toFetchHeaders(headers) {
     }
     return result;
 }
-function readBody(req) {
+function readBody(req, signal) {
     return new Promise((resolve, reject) => {
         const chunks = [];
         let size = 0;
         let tooLarge = false;
-        req.on("data", (chunk) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            const error = new Error(`Request body timed out after ${REQUEST_BODY_TIMEOUT_MS / 1000}s.`);
+            error.code = "REQUEST_TIMEOUT";
+            finish(error);
+        }, REQUEST_BODY_TIMEOUT_MS);
+        const cleanup = () => {
+            clearTimeout(timer);
+            req.removeListener("aborted", onAborted);
+            req.removeListener("error", onError);
+            req.removeListener("data", onData);
+            req.removeListener("end", onEnd);
+            signal.removeEventListener("abort", onSignalAbort);
+        };
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error)
+                reject(error);
+            else
+                resolve(value ?? Buffer.alloc(0));
+        };
+        const onAborted = () => finish(new Error("Request aborted by the client."));
+        const onError = (error) => finish(error);
+        const onSignalAbort = () => finish(new Error("Request aborted by the client."));
+        const onData = (chunk) => {
             if (tooLarge)
                 return;
             const buffer = Buffer.from(chunk);
@@ -546,17 +606,25 @@ function readBody(req) {
                 return;
             }
             chunks.push(buffer);
-        });
-        req.on("end", () => {
+        };
+        const onEnd = () => {
             if (tooLarge) {
                 const error = new Error(`Request body exceeds the ${MAX_BODY_BYTES / 1024 / 1024} MiB limit.`);
                 error.code = "PAYLOAD_TOO_LARGE";
-                reject(error);
+                finish(error);
                 return;
             }
-            resolve(Buffer.concat(chunks));
-        });
-        req.on("error", reject);
+            finish(undefined, Buffer.concat(chunks));
+        };
+        if (signal.aborted) {
+            onSignalAbort();
+            return;
+        }
+        req.once("aborted", onAborted);
+        req.once("error", onError);
+        signal.addEventListener("abort", onSignalAbort, { once: true });
+        req.on("data", onData);
+        req.on("end", onEnd);
     });
 }
 function sendText(res, status, text, contentType = "text/plain; charset=utf-8") {

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

@@ -40,6 +40,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),
@@ -57,6 +84,7 @@ export function sanitizeAnonymousEvent(event) {
         return {
             event: "tunnel",
             state: event.state,
+            ...(event.healthState === undefined ? {} : { healthState: event.healthState }),
             ...(event.attempt === undefined ? {} : { attempt: boundedInteger(event.attempt) }),
             ...(event.attempts === undefined ? {} : { attempts: boundedInteger(event.attempts) }),
             ...(event.durationMs === undefined ? {} : { durationMs: boundedNumber(event.durationMs) }),
@@ -99,6 +127,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);
@@ -120,6 +154,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) }),
@@ -201,6 +245,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;