@timo972/cc-router 0.12.2-rc.0 → 0.12.2-rc.1

package/dist/telemetry/posthog-client.js

@@ -1,6 +1,6 @@
 import { PostHog } from "posthog-node";
 import { ERROR_KINDS, MAX_STACK_FRAMES, MAX_STACK_FRAME_PATH_LENGTH, OPERATIONS, POSTHOG_FLUSH_AT, POSTHOG_FLUSH_INTERVAL_MS, POSTHOG_HOST, POSTHOG_MAX_QUEUE_SIZE, POSTHOG_PROJECT_TOKEN, POSTHOG_REQUEST_TIMEOUT_MS, PROVIDERS, RUNTIME_MODES, SETUP_REASONS, SETUP_STAGES, SYSTEM_ERROR_CODES, } from "./contracts.js";
-import { reconstructAnalyticsEvent } from "./privacy.js";
+import { exceptionName, frameFunction, reconstructAnalyticsEvent } from "./privacy.js";
 /** Stamped on every capture and re-checked in before_send against live consent. */
 const CONSENT_GENERATION_PROPERTY = "cc_router.consent_generation";
 const QUEUE_KEYS = ["queue", "ai_queue", "logs_queue"];
@@ -71,17 +71,24 @@ function reconstructExceptionFrames(input) {
         const column = positiveInteger(own(candidate, "colno"));
         if (!filename || !line || !column)
             return undefined;
-        frames.push({ platform: "node:javascript", filename, lineno: line, colno: column });
+        frames.push({
+            platform: "node:javascript",
+            function: frameFunction(own(candidate, "function")),
+            filename,
+            lineno: line,
+            colno: column,
+        });
     }
     return frames;
 }
-function reconstructExceptionList(input, reason) {
+function reconstructExceptionList(input) {
     if (!Array.isArray(input) || input.length !== 1 || !isRecord(input[0]))
         return undefined;
     const exception = input[0];
     const mechanism = own(exception, "mechanism");
-    if (own(exception, "type") !== "Error"
-        || own(exception, "value") !== reason
+    const name = exceptionName(own(exception, "type"));
+    if (own(exception, "type") !== name
+        || own(exception, "value") !== ""
         || !isRecord(mechanism)
         || own(mechanism, "type") !== "generic"
         || own(mechanism, "handled") !== true
@@ -90,7 +97,7 @@ function reconstructExceptionList(input, reason) {
     }
     const stacktrace = own(exception, "stacktrace");
     if (stacktrace === undefined) {
-        return [{ type: "Error", value: reason, mechanism: { type: "generic", handled: true, synthetic: false } }];
+        return [{ type: name, value: "", mechanism: { type: "generic", handled: true, synthetic: false } }];
     }
     if (!isRecord(stacktrace) || own(stacktrace, "type") !== "raw")
         return undefined;
@@ -98,8 +105,8 @@ function reconstructExceptionList(input, reason) {
     if (!frames)
         return undefined;
     return [{
-            type: "Error",
-            value: reason,
+            type: name,
+            value: "",
             mechanism: { type: "generic", handled: true, synthetic: false },
             stacktrace: { type: "raw", frames },
         }];
@@ -124,7 +131,7 @@ function reconstructExceptionEvent(event, installationId) {
         || own(properties, "$exception_level") !== "error") {
         return null;
     }
-    const exceptionList = reconstructExceptionList(own(properties, "$exception_list"), reason);
+    const exceptionList = reconstructExceptionList(own(properties, "$exception_list"));
     if (!exceptionList)
         return null;
     const systemErrorCode = optionalMember(SYSTEM_ERROR_CODES, own(properties, "systemErrorCode"));

package/dist/telemetry/privacy.js

@@ -219,45 +219,58 @@ function stackHeaderName(kind) {
         default: return "Error";
     }
 }
-function normalizedFrames(input, kind) {
+/** Keep code symbols, not arbitrary messages or paths supplied as names. */
+export function exceptionName(value) {
+    return typeof value === "string" && /^[A-Za-z_$][\w.$-]{0,127}$/.test(value) ? value : "Error";
+}
+export function frameFunction(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= 256
+        && /^[\w$.[\]<> ():-]+$/.test(value) ? value : "<anonymous>";
+}
+function normalizedFrames(input) {
     const stack = input.stack;
     if (typeof stack !== "string")
         return [];
-    // The header carries the raw message. Parse frames only after removing it
-    // verbatim, so a multiline message can never inject a frame.
+    // Remove the complete raw header so multiline messages cannot inject frames.
     const rawMessage = own(input, "message");
     if (rawMessage !== undefined && typeof rawMessage !== "string")
         return [];
-    const header = `${stackHeaderName(kind)}${rawMessage ? `: ${rawMessage}` : ""}`;
+    const rawName = input.name;
+    if (typeof rawName !== "string" || /[\r\n]/.test(rawName))
+        return [];
+    const header = rawName ? `${rawName}${rawMessage ? `: ${rawMessage}` : ""}` : (rawMessage ?? "");
     if (!stack.startsWith(`${header}\n`))
         return [];
     const frames = [];
     for (const line of stack.slice(header.length + 1).split("\n")) {
         if (frames.length >= MAX_STACK_FRAMES)
             break;
-        const match = line.match(/(?:\(|\bat\s+)(.+):(\d+):(\d+)\)?\s*$/);
-        if (!match)
+        const named = line.match(/^\s*at (.+) \((.+):(\d+):(\d+)\)\s*$/);
+        const anonymous = named ? null : line.match(/^\s*at (.+):(\d+):(\d+)\s*$/);
+        if (!named && !anonymous)
             continue;
-        const path = normalizedFramePath(match[1]);
-        const frameLine = boundedInteger(Number(match[2]), Number.MAX_SAFE_INTEGER, 1);
-        const column = boundedInteger(Number(match[3]), Number.MAX_SAFE_INTEGER, 1);
+        const path = normalizedFramePath(named ? named[2] : anonymous[1]);
+        const frameLine = boundedInteger(Number(named ? named[3] : anonymous[2]), Number.MAX_SAFE_INTEGER, 1);
+        const column = boundedInteger(Number(named ? named[4] : anonymous[3]), Number.MAX_SAFE_INTEGER, 1);
         if (!path || frameLine === undefined || column === undefined)
             continue;
-        frames.push({ path, line: frameLine, column });
+        frames.push({ path, line: frameLine, column, function: frameFunction(named?.[1]) });
     }
     return frames;
 }
-function sanitizedError(reason, frames) {
-    const error = new Error(reason);
+function sanitizedError(name, frames) {
+    const error = new Error();
+    Object.defineProperty(error, "name", { value: name, configurable: true, writable: true });
     error.stack = [
-        `Error: ${reason}`,
-        ...frames.map(frame => `    at ${frame.path}:${frame.line}:${frame.column}`),
+        name,
+        ...frames.map(frame => `    at ${frameFunction(frame.function)} (${frame.path}:${frame.line}:${frame.column})`),
     ].join("\n");
     return error;
 }
-function fingerprint(kind, context, systemErrorCode, status, frames) {
+function fingerprint(kind, name, context, systemErrorCode, status, frames) {
     return createHash("sha256").update(JSON.stringify({
         errorKind: kind,
+        errorName: name,
         category: context.category,
         reason: context.reason,
         operation: context.operation,
@@ -299,7 +312,8 @@ export function sanitizeException(input, candidateContext, identity) {
             return undefined;
         const isError = input instanceof Error;
         const kind = isError ? errorKind(input) : "unexpected_error";
-        const frames = isError ? normalizedFrames(input, kind) : [];
+        const name = isError ? exceptionName(input.name) : "Error";
+        const frames = isError ? normalizedFrames(input) : [];
         const code = isError
             ? member(SYSTEM_ERROR_CODES, own(input, "code"))
             : undefined;
@@ -307,11 +321,12 @@ export function sanitizeException(input, candidateContext, identity) {
             ? httpStatusCode(own(input, "statusCode")) ?? httpStatusCode(own(input, "status"))
             : undefined;
         const output = {
-            error: sanitizedError(context.reason, frames),
+            error: sanitizedError(name, frames),
+            errorName: name,
             ...context,
             errorKind: kind,
             frames,
-            fingerprint: fingerprint(kind, context, code, status, frames),
+            fingerprint: fingerprint(kind, name, context, code, status, frames),
             diagnosticId: trustedDiagnosticId,
         };
         assignIfDefined(output, "systemErrorCode", code);
@@ -543,13 +558,18 @@ export function rebuildSanitizedException(input) {
         if ((frame.line !== undefined && line === undefined) || (frame.column !== undefined && column === undefined)) {
             return undefined;
         }
-        const safeFrame = { path: path };
+        const safeFrame = {
+            path: path,
+            function: frameFunction(frame.function),
+        };
         assignIfDefined(safeFrame, "line", line);
         assignIfDefined(safeFrame, "column", column);
         frames.push(safeFrame);
     }
+    const name = exceptionName(input.errorName ?? stackHeaderName(errorKind));
     const contract = {
-        error: sanitizedError(reason, frames),
+        error: sanitizedError(name, frames),
+        errorName: name,
         category,
         reason,
         errorKind,

package/docs/telemetry.md

@@ -118,15 +118,18 @@ Providers `anthropic` (`macos_keychain`, `claude_credentials_file`,
 ### Sanitized exceptions
 
 An unexpected failure is rebuilt as a *new* `Error` containing only: category
-(`setup`/`runtime`), one safe reason, error kind (`error`, `type_error`,
+(`setup`/`runtime`), one safe reason, the original error name (including custom
+error names), error kind (`error`, `type_error`,
 `range_error`, `reference_error`, `syntax_error`, `uri_error`, `eval_error`,
 `aggregate_error`, `unexpected_error`), optional system code (`EAI_AGAIN`,
 `ECONNREFUSED`, `ECONNRESET`, `ENETUNREACH`, `ENOTFOUND`, `EPIPE`,
 `ETIMEDOUT`), optional HTTP status, operation, provider, setup stage, runtime
 mode, stack frames normalized to `dist/...` or `node_modules/<package>/...`
-(max 20 frames, 256 chars each), a fingerprint over those safe fields, and a
-fresh random diagnostic ID. The original message, cause chain, custom
-properties, and unrecognized frames are dropped. The diagnostic ID is printed
+with function names (max 20 frames, 256 chars per path and function), a
+fingerprint over those safe fields, and a fresh random diagnostic ID. Anonymous frames use `<anonymous>`. Error names are
+bounded code identifiers (max 128 chars); malformed names fall back to `Error`.
+The exception message is empty; the classified reason remains separate metadata.
+The original message, cause chain, custom properties, and unrecognized frames are dropped. The diagnostic ID is printed
 next to the detailed local error so an issue report can reference it.
 
 A fatal (uncaught) exception cannot be sent by the crashing process. Its

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timo972/cc-router",
-  "version": "0.12.2-rc.0",
+  "version": "0.12.2-rc.1",
   "description": "Cache-aware session router for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {