agent-dir 0.3.1 → 0.4.0

package/README.md

@@ -51,7 +51,7 @@ The Wormhole URL is only the transport endpoint. `agent-dir` authentication is e
 
 On the first interactive run, when no `agent-dir` config exists, the CLI walks you through creating your first saved profile. It asks for the profile name, directory, port, tunnel, optional Wormhole subdomain, optional npm scripts, optional allowed commands, and telemetry preference. The generated authentication token is saved with the profile.
 
-Telemetry is optional and stays local. During setup, `agent-dir` explains the available levels: **none**, **anonymous**, **basic**, and **detailed**. Telemetry is disabled by default if you choose the default option. The same choices can later be changed with `agent-dir telemetry enable|disable`.
+Telemetry is optional and stays local. During setup, `agent-dir` explains the available levels: **none**, **anonymous**, **basic**, **detailed**, and **diagnostic**. Telemetry is disabled by default if you choose the default option. The same choices can later be changed with `agent-dir telemetry enable|disable`.
 
 You can also run the setup wizard explicitly at any time:
 
@@ -130,6 +130,7 @@ Enable a privacy level with:
 agent-dir telemetry enable anonymous
 agent-dir telemetry enable basic
 agent-dir telemetry enable detailed
+agent-dir telemetry enable diagnostic
 ```
 
 Levels add bounded operational context:
@@ -138,7 +139,7 @@ Levels add bounded operational context:
 - **basic** — anonymous data plus bounded Agent Dir/Node/platform and MCP client version information.
 - **detailed** — basic data plus coarse project classification such as language, package manager, Git/CodeGraph availability, and project size.
 
-Telemetry never records file contents, command arguments, authentication tokens, environment variables, or project paths. Session telemetry separates wall-clock session lifetime from active MCP request time and the gaps between requests; those gaps may include agent reasoning, network delay, or other idle time and are not presented as agent thinking time. Persistence failures do not affect MCP requests.
+Standard telemetry levels never record file contents, command arguments, authentication tokens, environment variables, or project paths. The opt-in diagnostic level additionally records local troubleshooting metadata such as project paths, hostname, username, process identifiers, Node version, memory usage, and process uptime; it remains local and is never uploaded by Agent Dir. Session telemetry separates wall-clock session lifetime from active MCP request time and the gaps between requests; those gaps may include agent reasoning, network delay, or other idle time and are not presented as agent thinking time. Persistence failures do not affect MCP requests.
 
 Manage telemetry with:
 

package/dist/bin/agent-dir.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=agent-dir.d.ts.map

package/dist/bin/agent-dir.js

@@ -100,7 +100,7 @@ if (command === "telemetry") {
     if (action === "enable") {
         const level = positionals[2];
         if (!level || !isTelemetryLevel(level) || level === "none")
-            fail("Usage: agent-dir telemetry enable <anonymous|basic|detailed>");
+            fail("Usage: agent-dir telemetry enable <anonymous|basic|detailed|diagnostic>");
         config.telemetry = { level };
         await saveConfig(config);
         console.log(`✓ Telemetry enabled at ${level} level.`);
@@ -125,7 +125,8 @@ if (command === "telemetry") {
                 "commandCallCount",
             ],
             envelope: ["configId", "sessionId", "timestamp", "level", "event"],
-            events: ["mcp_request", "tool_call", "command_call", "session"],
+            events: ["mcp_request", "tool_call", "command_call", "tunnel", "session"],
+            levels: ["none", "anonymous", "basic", "detailed", "diagnostic"],
             successMetrics: {
                 mcp: "successful mcp_request events / mcp_request events",
                 tool: "successful tool_call events / tool_call events",
@@ -406,6 +407,12 @@ if (tunnel !== "none") {
         tunnelResult = await startTunnel({
             provider: "wormhole",
             port,
+            token,
+            telemetry: {
+                ...(config.telemetry ?? { level: "none" }),
+                ...(telemetryConfigId ? { configId: telemetryConfigId } : {}),
+                persist: true,
+            },
             random: randomTunnel,
             ...(subdomain && !randomTunnel ? { subdomain } : {}),
         });
@@ -423,7 +430,8 @@ const shutdown = async () => {
         return;
     shuttingDown = true;
     console.log("\n  Stopping agent-dir...");
-    if (tunnelResult?.child && !tunnelResult.child.killed)
+    tunnelResult?.stop?.();
+    if (tunnelResult?.child && !tunnelResult.stop && !tunnelResult.child.killed)
         tunnelResult.child.kill("SIGTERM");
     await server.close();
     process.exit(0);
@@ -456,4 +464,3 @@ function readTelemetryEvents(path) {
         return [];
     }
 }
-//# sourceMappingURL=agent-dir.js.map

package/dist/src/auth.d.ts

@@ -1,3 +1,2 @@
 export declare function authenticate(request: Request, token: string): boolean;
 export declare function unauthorized(): Response;
-//# sourceMappingURL=auth.d.ts.map

package/dist/src/auth.js

@@ -23,4 +23,3 @@ export function unauthorized() {
         },
     });
 }
-//# sourceMappingURL=auth.js.map

package/dist/src/codegraph.d.ts

@@ -30,4 +30,3 @@ export declare class CodeGraphIntegration {
     private handleProcessFailure;
     private rejectPending;
 }
-//# sourceMappingURL=codegraph.d.ts.map

package/dist/src/codegraph.js

@@ -262,4 +262,3 @@ function safeEnvironment() {
     }
     return environment;
 }
-//# sourceMappingURL=codegraph.js.map

package/dist/src/config.d.ts

@@ -3,4 +3,3 @@ export declare function loadConfig(): Promise<AgentConfig>;
 export declare function saveConfig(config: AgentConfig): Promise<void>;
 export declare function configPath(): string;
 export declare function mergeProfile(profile: Profile, overrides?: CommandConfig): CommandConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/src/config.js

@@ -91,4 +91,3 @@ function isProfile(value) {
         return false;
     return true;
 }
-//# sourceMappingURL=config.js.map

package/dist/src/logging.d.ts

@@ -15,4 +15,3 @@ export declare function printBanner(options: {
 export declare function printRequestLog(entry: RequestLog): void;
 export declare function logRequest(entry: RequestLog): void;
 export declare function printRequestHeader(): void;
-//# sourceMappingURL=logging.d.ts.map

package/dist/src/logging.js

@@ -132,7 +132,7 @@ export function printHelp() {
     writeLine("");
     writeLine("Telemetry:");
     writeLine("  agent-dir telemetry status");
-    writeLine("  agent-dir telemetry enable <anonymous|basic|detailed>");
+    writeLine("  agent-dir telemetry enable <anonymous|basic|detailed|diagnostic>");
     writeLine("  agent-dir telemetry disable");
     writeLine("  agent-dir telemetry schema");
     writeLine("  agent-dir telemetry show [--follow]");
@@ -267,4 +267,3 @@ export function printRequestHeader() {
     writeLine("  [Request logs]");
     writeLine("  ──────────────────────────────────────────────────────────────");
 }
-//# sourceMappingURL=logging.js.map

package/dist/src/mcp.d.ts

@@ -9,4 +9,3 @@ interface McpHandler {
 export declare function createMcpHandler(root: string, commandConfig?: CommandConfig, telemetry?: TelemetryConfig): McpHandler;
 export declare function validateMcpParamHeaders(inputSchema: Record<string, unknown>, args: Record<string, unknown>, headers: Headers): string | undefined;
 export {};
-//# sourceMappingURL=mcp.d.ts.map

package/dist/src/mcp.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
+import { hostname, 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";
@@ -344,7 +345,7 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
     let sessionToolCallCount = 0;
     let sessionCommandCallCount = 0;
     let sessionRecorded = false;
-    const telemetryProjectPromise = telemetry.level === "detailed"
+    const telemetryProjectPromise = telemetry.level === "detailed" || telemetry.level === "diagnostic"
         ? buildTelemetryProjectContext(root, codeGraph).catch(() => undefined)
         : undefined;
     const npmAllowed = commandConfig.npm?.allowedScripts ?? [];
@@ -1552,6 +1553,13 @@ function telemetryRuntime(params) {
         arch: process.arch,
         ...(typeof clientInfo?.name === "string" ? { mcpClientName: clientInfo.name } : {}),
         ...(typeof clientInfo?.version === "string" ? { mcpClientVersion: clientInfo.version } : {}),
+        nodeVersion: process.versions.node,
+        hostname: hostname(),
+        username: userInfo().username,
+        processId: process.pid,
+        parentProcessId: process.ppid,
+        processUptimeMs: Math.round(process.uptime() * 1000),
+        memoryRssBytes: process.memoryUsage().rss,
     };
 }
 function toolTelemetryMetrics(toolName, result) {
@@ -1618,6 +1626,8 @@ async function buildTelemetryProjectContext(root, codeGraph) {
     const projectSize = overview.files < 100 ? "small" : overview.files < 1000 ? "medium" : "large";
     const capability = await codeGraph.capability();
     return {
+        projectRoot: root,
+        workingDirectory: process.cwd(),
         ...(language ? { language } : {}),
         ...(packageManager && ["npm", "pnpm", "yarn", "bun"].includes(packageManager)
             ? { packageManager: packageManager }
@@ -1871,4 +1881,3 @@ function json(value, status = 200) {
         headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
     });
 }
-//# sourceMappingURL=mcp.js.map

package/dist/src/server.d.ts

@@ -8,4 +8,3 @@ export declare function getMcpLog(body: Buffer): {
     name: string;
     detail: string;
 } | undefined;
-//# sourceMappingURL=server.d.ts.map

package/dist/src/server.js

@@ -2,12 +2,21 @@ import http, {} from "node:http";
 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;
 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()}`,
+    });
     const server = http.createServer(async (req, res) => {
+        const startedAt = performance.now();
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        let authenticated = false;
         try {
             const body = await readBody(req);
             const requestInit = {
@@ -17,7 +26,8 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
             if (body.length)
                 requestInit.body = body;
             const request = new Request(url, requestInit);
-            if (!authenticate(request, token)) {
+            authenticated = authenticate(request, token);
+            if (!authenticated) {
                 const response = unauthorized();
                 await sendResponse(res, response);
                 logRequest({
@@ -26,6 +36,7 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                     status: 401,
                     detail: "unauthorized",
                 });
+                recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 401, authenticated, startedAt);
                 return;
             }
             if (url.pathname === "/mcp") {
@@ -38,6 +49,7 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                         status: 405,
                         detail: "method not allowed",
                     });
+                    recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 405, authenticated, startedAt);
                     return;
                 }
                 const headerError = validateMcpHeaders(request, messageBody(body));
@@ -50,6 +62,7 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                         status: headerError.status,
                         detail: errorDetail ? `MCP header validation: ${errorDetail}` : "MCP header validation",
                     });
+                    recordHttpTelemetry(httpTelemetry, req.method, url.pathname, headerError.status, authenticated, startedAt);
                     return;
                 }
                 const response = await mcp(request);
@@ -66,12 +79,14 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                         : (mcpLog?.detail ?? "MCP"),
                     ...(mcpLog ? { tool: mcpLog.name } : {}),
                 });
+                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));
@@ -83,23 +98,27 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                     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");
@@ -109,6 +128,7 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                 status: 404,
                 detail: "not found",
             });
+            recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 404, authenticated, startedAt);
         }
         catch (error) {
             const code = error.code;
@@ -120,6 +140,7 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                 status,
                 detail: error instanceof Error ? error.message : String(error),
             });
+            recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, status, authenticated, startedAt);
         }
     });
     return new Promise((resolve, reject) => {
@@ -480,6 +501,26 @@ function formatCommand(command, args) {
     const count = Array.isArray(args) ? args.length : 0;
     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";
+    recorder.record({
+        event: "http_request",
+        method,
+        route,
+        status,
+        success: status < 400,
+        durationMs: performance.now() - startedAt,
+        authenticated,
+    });
+}
 function toFetchHeaders(headers) {
     const result = new Headers();
     for (const [name, value] of Object.entries(headers)) {
@@ -556,4 +597,3 @@ async function sendResponse(res, response) {
     if (!res.destroyed)
         res.end();
 }
-//# sourceMappingURL=server.js.map

package/dist/src/setup.d.ts

@@ -6,4 +6,3 @@ export declare function shouldOfferSetup(configExists: boolean, options: {
     tunnel?: string | undefined;
 }): boolean;
 export declare function runFirstTimeSetup(config: AgentConfig, defaultDirectory?: string): Promise<string | null | undefined>;
-//# sourceMappingURL=setup.d.ts.map

package/dist/src/setup.js

@@ -119,16 +119,18 @@ 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("Never records file contents, command arguments, tokens,"),
+            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."),
         ]);
         console.log("");
         console.log(`  ${green("●")} ${white("none")}       ${dim("disabled")}`);
         console.log(`  ${cyan("●")} ${white("anonymous")}  ${dim("usage/tool metrics, success, duration, sizes, safe errors")}`);
         console.log(`  ${cyan("●")} ${white("basic")}      ${dim("anonymous + Agent Dir, Node, platform, MCP client version")}`);
         console.log(`  ${cyan("●")} ${white("detailed")}   ${dim("basic + coarse language, package manager, Git, CodeGraph, project size")}`);
+        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"], "none");
+        const telemetry = await choose(rl, "Telemetry level", ["none", "anonymous", "basic", "detailed", "diagnostic"], "none");
         const profile = { directory, port, tunnel, token: randomBytes(24).toString("hex") };
         if (subdomain)
             profile.subdomain = subdomain;
@@ -212,4 +214,3 @@ async function choose(rl, label, choices, defaultValue) {
         console.log(`  ${error("✕")} ${dim(`Choose a number from 1 to ${choices.length}.`)}`);
     }
 }
-//# sourceMappingURL=setup.js.map

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

@@ -4,9 +4,16 @@ export interface TelemetrySummary {
     totalEvents: number;
     configs: Record<string, {
         eventCount: number;
+        httpRequests: number;
+        httpAuthFailures: number;
+        httpErrors: number;
         mcpRequests: number;
         toolCalls: number;
         commandCalls: number;
+        tunnelEvents: number;
+        tunnelDisconnects: number;
+        tunnelReconnects: number;
+        tunnelFailures: number;
         mcpSuccessRate: number | null;
         toolSuccessRate: number | null;
         commandSuccessRate: number | null;
@@ -55,4 +62,3 @@ export interface TelemetrySummary {
     }>;
 }
 export declare function summarizeTelemetry(events: TelemetryEnvelope[]): TelemetrySummary;
-//# sourceMappingURL=aggregate.d.ts.map

package/dist/src/telemetry/aggregate.js

@@ -14,12 +14,15 @@ function rateForEvents(events, kind) {
     const matching = events.filter((item) => item.event.event === kind);
     return matching.length === 0
         ? null
-        : rate(matching.filter((item) => item.event.event !== "session" && item.event.success).length, matching.length);
+        : rate(matching.filter((item) => "success" in item.event && item.event.success).length, matching.length);
 }
 function collectFailures(events, kind) {
     const failures = {};
     for (const envelope of events) {
-        if (envelope.event.event !== kind || envelope.event.success || !envelope.event.errorCategory)
+        if (envelope.event.event !== kind ||
+            !("success" in envelope.event) ||
+            envelope.event.success ||
+            !envelope.event.errorCategory)
             continue;
         failures[envelope.event.errorCategory] = (failures[envelope.event.errorCategory] ?? 0) + 1;
     }
@@ -42,9 +45,16 @@ export function summarizeTelemetry(events) {
         const commands = new Map();
         const sessions = new Map();
         let legacySessionEvents = 0;
+        let httpRequests = 0;
+        let httpAuthFailures = 0;
+        let httpErrors = 0;
         let mcpRequests = 0;
         let toolCalls = 0;
         let commandCalls = 0;
+        let tunnelEvents = 0;
+        let tunnelDisconnects = 0;
+        let tunnelReconnects = 0;
+        let tunnelFailures = 0;
         for (const envelope of group) {
             const event = envelope.event;
             const session = sessions.get(envelope.sessionId) ?? {
@@ -57,6 +67,26 @@ export function summarizeTelemetry(events) {
                 failuresByCategory: { mcp: {}, tool: {}, command: {} },
             };
             session.eventCount += 1;
+            if (event.event === "http_request") {
+                httpRequests += 1;
+                if (event.status === 401)
+                    httpAuthFailures += 1;
+                if (event.status >= 400)
+                    httpErrors += 1;
+                sessions.set(envelope.sessionId, session);
+                continue;
+            }
+            if (event.event === "tunnel") {
+                tunnelEvents += 1;
+                if (event.state === "disconnected")
+                    tunnelDisconnects += 1;
+                if (event.state === "reconnected")
+                    tunnelReconnects += 1;
+                if (event.state === "failed")
+                    tunnelFailures += 1;
+                sessions.set(envelope.sessionId, session);
+                continue;
+            }
             if (event.event === "session") {
                 if (Number.isFinite(event.wallClockDurationMs) &&
                     Number.isFinite(event.activeRequestDurationMs) &&
@@ -130,9 +160,16 @@ export function summarizeTelemetry(events) {
         });
         configs[configId] = {
             eventCount: group.length,
+            httpRequests,
+            httpAuthFailures,
+            httpErrors,
             mcpRequests,
             toolCalls,
             commandCalls,
+            tunnelEvents,
+            tunnelDisconnects,
+            tunnelReconnects,
+            tunnelFailures,
             mcpSuccessRate: rateForEvents(group, "mcp_request"),
             toolSuccessRate: rateForEvents(group, "tool_call"),
             commandSuccessRate: rateForEvents(group, "command_call"),
@@ -181,4 +218,3 @@ export function summarizeTelemetry(events) {
         configs,
     };
 }
-//# sourceMappingURL=aggregate.js.map

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

@@ -2,4 +2,3 @@ import { type TelemetryConfig, type TelemetryLevel } from "./types.js";
 export declare const DEFAULT_TELEMETRY_CONFIG: TelemetryConfig;
 export declare function isTelemetryLevel(value: unknown): value is TelemetryLevel;
 export declare function parseTelemetryConfig(value: unknown): TelemetryConfig | undefined;
-//# sourceMappingURL=config.d.ts.map

package/dist/src/telemetry/config.js

@@ -13,4 +13,3 @@ export function parseTelemetryConfig(value) {
         return undefined;
     return { level };
 }
-//# sourceMappingURL=config.js.map

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

@@ -1,3 +1,2 @@
 import type { TelemetrySummary } from "./aggregate.js";
 export declare function formatTelemetrySummary(summary: TelemetrySummary, level: string): string;
-//# sourceMappingURL=format.d.ts.map

package/dist/src/telemetry/format.js

@@ -47,7 +47,7 @@ export function formatTelemetrySummary(summary, level) {
         return output.join("\n");
     }
     for (const [configId, config] of Object.entries(summary.configs)) {
-        output.push("", `  CONFIGURATION  ${configId}`, `  ${line("─", 66)}`, metric("Events", config.eventCount), metric("MCP requests", config.mcpRequests), metric("Tool calls", config.toolCalls), metric("Command calls", config.commandCalls), metric("MCP success", rate(config.mcpSuccessRate)), metric("Tool success", rate(config.toolSuccessRate)), metric("Command success", rate(config.commandSuccessRate)), "", "  SESSIONS", metric("Sessions", Object.keys(config.sessions).length));
+        output.push("", `  CONFIGURATION  ${configId}`, `  ${line("─", 66)}`, metric("Events", config.eventCount), metric("HTTP requests", config.httpRequests), metric("HTTP auth failures", config.httpAuthFailures), metric("HTTP errors", config.httpErrors), metric("MCP requests", config.mcpRequests), metric("Tool calls", config.toolCalls), metric("Command calls", config.commandCalls), metric("Tunnel events", config.tunnelEvents), metric("Tunnel disconnects", config.tunnelDisconnects), metric("Tunnel reconnects", config.tunnelReconnects), metric("Tunnel failures", config.tunnelFailures), metric("MCP success", rate(config.mcpSuccessRate)), metric("Tool success", rate(config.toolSuccessRate)), metric("Command success", rate(config.commandSuccessRate)), "", "  SESSIONS", metric("Sessions", Object.keys(config.sessions).length));
         if (config.legacySessionEvents > 0) {
             output.push(metric("Legacy sessions", config.legacySessionEvents), "  Legacy session records are excluded from session averages.");
         }
@@ -84,4 +84,3 @@ export function formatTelemetrySummary(summary, level) {
     output.push("", `  ${line()}`, "  Success rates are per event type; MCP and tool events are related but distinct.", "  Use 'telemetry show' for the raw event stream.", "");
     return output.join("\n");
 }
-//# sourceMappingURL=format.js.map

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

@@ -1,4 +1,3 @@
 import type { AnonymousTelemetryEvent, TelemetryEnvelope, TelemetryLevel, TelemetryProjectContext, TelemetryRuntimeContext } from "./types.js";
 export declare function sanitizeAnonymousEvent(event: AnonymousTelemetryEvent): AnonymousTelemetryEvent;
 export declare function createTelemetryEnvelope(level: Exclude<TelemetryLevel, "none">, event: AnonymousTelemetryEvent, runtime?: TelemetryRuntimeContext, project?: TelemetryProjectContext, configId?: string, sessionId?: string): TelemetryEnvelope;
-//# sourceMappingURL=privacy.d.ts.map

package/dist/src/telemetry/privacy.js

@@ -14,6 +14,17 @@ const SAFE_TOOL_NAME = /^[a-z][a-z0-9_]*$/;
 const SAFE_COMMAND_FAMILY = /^[a-z][a-z0-9_-]*$/;
 const SAFE_OPERATION = /^[a-z][a-z0-9_.-]*$/;
 export function sanitizeAnonymousEvent(event) {
+    if (event.event === "http_request") {
+        return {
+            event: "http_request",
+            method: sanitizeMcpMethod(event.method),
+            route: event.route,
+            status: boundedInteger(event.status),
+            success: event.success === true,
+            durationMs: boundedNumber(event.durationMs),
+            authenticated: event.authenticated === true,
+        };
+    }
     if (event.event === "mcp_request") {
         return {
             event: "mcp_request",
@@ -42,6 +53,18 @@ export function sanitizeAnonymousEvent(event) {
                 : { errorCategory: sanitizeErrorCategory(event.errorCategory) }),
         };
     }
+    if (event.event === "tunnel") {
+        return {
+            event: "tunnel",
+            state: event.state,
+            ...(event.attempt === undefined ? {} : { attempt: boundedInteger(event.attempt) }),
+            ...(event.attempts === undefined ? {} : { attempts: boundedInteger(event.attempts) }),
+            ...(event.durationMs === undefined ? {} : { durationMs: boundedNumber(event.durationMs) }),
+            ...(event.reasonCategory === undefined
+                ? {}
+                : { reasonCategory: sanitizeErrorCategory(event.reasonCategory) }),
+        };
+    }
     if (event.event === "command_call") {
         return {
             event: "command_call",
@@ -76,15 +99,45 @@ export function createTelemetryEnvelope(level, event, runtime, project, configId
         level,
         event: sanitizeAnonymousEvent(event),
     };
-    if (level === "basic" || level === "detailed") {
+    if (level === "basic" || level === "detailed" || level === "diagnostic") {
         if (runtime)
             envelope.runtime = sanitizeRuntimeContext(runtime);
     }
-    if (level === "detailed" && project) {
+    if ((level === "detailed" || level === "diagnostic") && project) {
         envelope.project = sanitizeProjectContext(project);
     }
+    if (level === "diagnostic" && runtime) {
+        envelope.runtime = sanitizeDiagnosticRuntimeContext(runtime);
+    }
+    if (level === "diagnostic" && project) {
+        envelope.project = sanitizeDiagnosticProjectContext(project);
+    }
     return envelope;
 }
+function sanitizeDiagnosticRuntimeContext(context) {
+    return {
+        ...sanitizeRuntimeContext(context),
+        ...(context.nodeVersion === undefined
+            ? {}
+            : { nodeVersion: sanitizeVersion(context.nodeVersion) }),
+        ...(context.hostname === undefined
+            ? {}
+            : { hostname: sanitizeSensitiveIdentifier(context.hostname) }),
+        ...(context.username === undefined
+            ? {}
+            : { username: sanitizeSensitiveIdentifier(context.username) }),
+        ...(context.processId === undefined ? {} : { processId: boundedInteger(context.processId) }),
+        ...(context.parentProcessId === undefined
+            ? {}
+            : { parentProcessId: boundedInteger(context.parentProcessId) }),
+        ...(context.processUptimeMs === undefined
+            ? {}
+            : { processUptimeMs: boundedNumber(context.processUptimeMs) }),
+        ...(context.memoryRssBytes === undefined
+            ? {}
+            : { memoryRssBytes: boundedNumber(context.memoryRssBytes) }),
+    };
+}
 function sanitizeRuntimeContext(context) {
     return {
         agentDirVersion: sanitizeVersion(context.agentDirVersion),
@@ -99,6 +152,17 @@ function sanitizeRuntimeContext(context) {
             : { mcpClientVersion: sanitizeVersion(context.mcpClientVersion) }),
     };
 }
+function sanitizeDiagnosticProjectContext(context) {
+    return {
+        ...sanitizeProjectContext(context),
+        ...(context.projectRoot === undefined
+            ? {}
+            : { projectRoot: sanitizeLocalPath(context.projectRoot) }),
+        ...(context.workingDirectory === undefined
+            ? {}
+            : { workingDirectory: sanitizeLocalPath(context.workingDirectory) }),
+    };
+}
 function sanitizeProjectContext(context) {
     return {
         ...(context.language ? { language: context.language } : {}),
@@ -117,6 +181,16 @@ function sanitizeIdentifier(value, pattern) {
     const normalized = value.trim().toLowerCase();
     return pattern.test(normalized) ? normalized : "unknown";
 }
+function sanitizeSensitiveIdentifier(value) {
+    const normalized = value.trim().slice(0, 128);
+    return /^[a-z0-9][a-z0-9 ._@-]*$/i.test(normalized) ? normalized : "unknown";
+}
+function sanitizeLocalPath(value) {
+    const normalized = value.trim().slice(0, 2048);
+    return normalized.startsWith("/") || /^[A-Za-z]:[\\\\/]/.test(normalized)
+        ? normalized
+        : "unknown";
+}
 function sanitizeFreeIdentifier(value) {
     const normalized = value.trim().slice(0, 64);
     return /^[a-z0-9][a-z0-9 ._-]*$/i.test(normalized) ? normalized : "unknown";
@@ -142,4 +216,3 @@ function boundedInteger(value) {
 function optionalNumber(key, value) {
     return value === undefined ? {} : { [key]: boundedNumber(value) };
 }
-//# sourceMappingURL=privacy.js.map

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

@@ -27,4 +27,3 @@ export declare class TelemetryRecorder {
     private loadPersisted;
     private persistEvent;
 }
-//# sourceMappingURL=recorder.d.ts.map

package/dist/src/telemetry/recorder.js

@@ -95,4 +95,3 @@ export class TelemetryRecorder {
         }
     }
 }
-//# sourceMappingURL=recorder.js.map