@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/src/shared/prompt-surface.ts

@@ -0,0 +1,162 @@
+import { modelRefLookupOrder } from "./harness-provider-map";
+
+/** The built-in prompt-surface variants. */
+export type PromptSurfacePreset = "full" | "light";
+
+/**
+ * The configuration consumed by prompt-surface resolution. The schema adds
+ * validation and defaults; this structural type keeps the resolver usable by
+ * every host without importing a config loader.
+ */
+export interface PromptSurfaceConfig {
+    default?: PromptSurfacePreset;
+    models?: Readonly<Record<string, PromptSurfacePreset>>;
+    guidance_override_path?: string;
+    tool_descriptions?: Readonly<Record<string, string>>;
+}
+
+/** Stable wire identity for the config fields that can alter a served prompt surface. */
+export function promptSurfaceConfigIdentity(config: PromptSurfaceConfig | undefined): string {
+    return JSON.stringify({
+        default: config?.default ?? "full",
+        models: Object.entries(config?.models ?? {}).sort(([left], [right]) =>
+            left < right ? -1 : left > right ? 1 : 0,
+        ),
+        guidanceOverridePath: config?.guidance_override_path ?? null,
+        toolDescriptions: Object.entries(config?.tool_descriptions ?? {}).sort(([left], [right]) =>
+            left < right ? -1 : left > right ? 1 : 0,
+        ),
+    });
+}
+
+export type PromptSurfaceResolutionSource = "exact" | "bare" | "wildcard" | "default";
+
+/** Validate bare model, provider/model, and provider/* routing keys. */
+export function isValidPromptSurfaceModelKey(key: string): boolean {
+    if (key.length === 0 || key.trim() !== key) return false;
+
+    const slash = key.indexOf("/");
+    if (slash < 0) return !key.includes("*");
+    if (slash === 0 || slash === key.length - 1) return false;
+
+    const provider = key.slice(0, slash);
+    const modelID = key.slice(slash + 1);
+    if (
+        provider.trim() !== provider ||
+        modelID.trim() !== modelID ||
+        provider.includes("*") ||
+        (modelID.includes("*") && modelID !== "*")
+    ) {
+        return false;
+    }
+    if (modelID === "*") return true;
+
+    return (
+        modelID.length > 0 &&
+        !modelID.startsWith("/") &&
+        !modelID.endsWith("/") &&
+        !modelID.includes("//")
+    );
+}
+
+export type ModelKeyLookupSource = Exclude<PromptSurfaceResolutionSource, "default">;
+
+export interface ModelKeyCandidate {
+    key: string;
+    source: ModelKeyLookupSource;
+}
+
+/**
+ * Return the same progressive model-key candidates used by cache_ttl. The
+ * provider/model boundary is the first slash; the rest of the string remains
+ * the model ID, including additional slashes. Candidates are case-sensitive.
+ *
+ * Known harness provider aliases are checked canonical-first at each specificity,
+ * so one shared config works on every harness and canonical wins on collisions.
+ * Provider wildcards are checked after progressively less-specific model keys,
+ * but before the caller's default. That keeps an exact or base-model override
+ * authoritative while still allowing `provider/*` to cover otherwise-unlisted
+ * models.
+ */
+export function modelKeyLookupOrder(modelKey: string | undefined): ModelKeyCandidate[] {
+    if (!modelKey) return [];
+
+    const slash = modelKey.indexOf("/");
+    if (slash <= 0 || slash === modelKey.length - 1) return [];
+
+    const provider = modelKey.slice(0, slash);
+    let modelID = modelKey.slice(slash + 1);
+    const providerRefs = modelRefLookupOrder(`${provider}/${modelID}`);
+    const candidates: ModelKeyCandidate[] = [];
+
+    while (modelID.length > 0) {
+        for (const providerRef of providerRefs) {
+            const providerSlash = providerRef.indexOf("/");
+            const providerPrefix = providerRef.slice(0, providerSlash);
+            candidates.push({ key: `${providerPrefix}/${modelID}`, source: "exact" });
+        }
+        candidates.push({ key: modelID, source: "bare" });
+
+        const lastDash = modelID.lastIndexOf("-");
+        if (lastDash <= 0) break;
+        modelID = modelID.slice(0, lastDash);
+    }
+
+    for (const providerRef of providerRefs) {
+        const providerSlash = providerRef.indexOf("/");
+        const providerPrefix = providerRef.slice(0, providerSlash);
+        candidates.push({ key: `${providerPrefix}/*`, source: "wildcard" });
+    }
+
+    const seen = new Set<string>();
+    return candidates.filter((candidate) => {
+        if (seen.has(candidate.key)) return false;
+        seen.add(candidate.key);
+        return true;
+    });
+}
+
+/** Resolve one per-model value using the shared cache_ttl lookup walk. */
+export function resolveModelConfigValue<T>(
+    values: Readonly<Record<string, T>> | undefined,
+    modelKey: string | undefined,
+): { value: T; source: ModelKeyLookupSource } | undefined {
+    if (!values) return undefined;
+
+    for (const candidate of modelKeyLookupOrder(modelKey)) {
+        const value = values[candidate.key];
+        if (value !== undefined) {
+            return { value, source: candidate.source };
+        }
+    }
+
+    return undefined;
+}
+
+/**
+ * Resolve the prompt preset for a model. Invalid or missing model keys use the
+ * configured default and are reported as a default resolution rather than a
+ * partial match.
+ */
+export function resolvePromptSurface(
+    config: PromptSurfaceConfig | undefined,
+    modelKey: string | undefined,
+): { preset: PromptSurfacePreset; source: PromptSurfaceResolutionSource } {
+    const fallback = config?.default ?? "full";
+    const match = resolveModelConfigValue(config?.models, modelKey);
+
+    if (match) {
+        return { preset: match.value, source: match.source };
+    }
+
+    return { preset: fallback, source: "default" };
+}
+
+/** Resolve a cache_ttl-style value with the shared model-key walk. */
+export function resolveModelConfigOrDefault<T>(
+    values: Readonly<Record<string, T>>,
+    modelKey: string | undefined,
+    fallback: T,
+): T {
+    return resolveModelConfigValue(values, modelKey)?.value ?? fallback;
+}

package/src/shared/provider-response-completion.ts

@@ -0,0 +1,23 @@
+/** Failure markers take precedence over a completion timestamp or token usage. */
+export function providerResponseFailed(input: { finish?: unknown; error?: unknown }): boolean {
+    if (input.error !== undefined && input.error !== null && input.error !== "") return true;
+    const finish = typeof input.finish === "string" ? input.finish.trim().toLowerCase() : "";
+    return ["error", "failed", "abort", "aborted", "interrupted", "cancelled", "canceled"].includes(
+        finish,
+    );
+}
+
+/** A terminal, non-failed assistant response can refresh a cache without usage. */
+export function isSuccessfulProviderCompletion(input: {
+    completedAt?: unknown;
+    finish?: unknown;
+    error?: unknown;
+}): boolean {
+    if (providerResponseFailed(input)) return false;
+    return (
+        (typeof input.completedAt === "number" &&
+            Number.isFinite(input.completedAt) &&
+            input.completedAt > 0) ||
+        (typeof input.finish === "string" && input.finish.trim().length > 0)
+    );
+}

package/src/shared/record-type-guard.ts

@@ -0,0 +1,3 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/shared/redaction.test.ts

@@ -0,0 +1,134 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, test } from "bun:test";
+
+import {
+    hasShareabilitySensitiveText,
+    isSecretKey,
+    redactSecretText,
+    sanitizeConfigValue,
+} from "./redaction";
+
+describe("redactSecretText — token counts and scalar diagnostics stay visible", () => {
+    test("keeps numeric/boolean values whose key merely contains a secret word", () => {
+        // These log shapes are counts/flags, not secrets, so they must stay readable.
+        expect(redactSecretText("tokens.input=45000 cache.read=0 cache.write=0")).toBe(
+            "tokens.input=45000 cache.read=0 cache.write=0",
+        );
+        expect(redactSecretText("hasUsageTokens=true")).toBe("hasUsageTokens=true");
+        expect(redactSecretText("totalInputTokens=132000")).toBe("totalInputTokens=132000");
+        expect(redactSecretText("max_tokens=4096")).toBe("max_tokens=4096");
+    });
+
+    test("keeps quoted numeric values matched only on the key word", () => {
+        expect(redactSecretText('"max_tokens": "4096"')).toBe('"max_tokens": "4096"');
+    });
+
+    test("still redacts real secret string values", () => {
+        // High-entropy / non-scalar values must always be redacted; only bare
+        // numeric/boolean scalars are exempt from the key-based match.
+        expect(redactSecretText("api_key=sk-abc123XYZsecretvalue")).toContain("<REDACTED:");
+        expect(redactSecretText("api_key=sk-abc123XYZsecretvalue")).not.toContain(
+            "sk-abc123XYZsecretvalue",
+        );
+        expect(redactSecretText('"auth_token": "tok_live_9f8e7d6c5b"')).toContain("<REDACTED:");
+    });
+
+    test("value-shaped secret patterns still fire independent of key name", () => {
+        // A bearer/JWT value is caught by its own pattern even if its key is bland.
+        expect(redactSecretText("Authorization: Bearer abc123def456ghi789")).toContain(
+            "<REDACTED:bearer>",
+        );
+        expect(redactSecretText("blob=eyJhbGciOi.eyJzdWIiOiIx.SflKxwRJSMeKKF2QT4")).toContain(
+            "<JWT_REDACTED>",
+        );
+    });
+});
+
+describe("hasShareabilitySensitiveText", () => {
+    test("safe project facts are shareable", () => {
+        expect(
+            hasShareabilitySensitiveText(
+                "The historian runs as a hidden subagent and never busts the prompt cache.",
+            ),
+        ).toBe(false);
+        expect(
+            hasShareabilitySensitiveText("Migration v45 adds the retrospective watermark column."),
+        ).toBe(false);
+    });
+
+    test("flags inline key:value / key=value secrets the keyed redactor misses in prose", () => {
+        expect(hasShareabilitySensitiveText("Set api_key: sk-live-abc123 in the env.")).toBe(true);
+        expect(hasShareabilitySensitiveText("password=hunter2 for the staging box")).toBe(true);
+        expect(hasShareabilitySensitiveText("client_secret = abcdef in the OAuth app")).toBe(true);
+    });
+
+    test("flags Windows forward-slash home (sanitizePathString only rewrites backslash form)", () => {
+        expect(hasShareabilitySensitiveText("logs are under C:/Users/ufuk/AppData/mc")).toBe(true);
+    });
+
+    test("flags ~/ rooted personal paths", () => {
+        expect(hasShareabilitySensitiveText("config lives at ~/.config/opencode/x.jsonc")).toBe(
+            true,
+        );
+    });
+
+    test("flags local / private endpoints", () => {
+        expect(hasShareabilitySensitiveText("embed endpoint is http://localhost:1234/v1")).toBe(
+            true,
+        );
+        expect(hasShareabilitySensitiveText("the box answers on 127.0.0.1:8080")).toBe(true);
+        expect(hasShareabilitySensitiveText("LAN host 192.168.1.42 runs the model")).toBe(true);
+        expect(hasShareabilitySensitiveText("internal 10.0.0.5 endpoint")).toBe(true);
+    });
+
+    test("a public IP / port alone is not flagged by the private-range rules", () => {
+        // 8.8.8.8 is public; no private-range or localhost pattern should match.
+        expect(hasShareabilitySensitiveText("DNS resolver at 8.8.8.8")).toBe(false);
+    });
+});
+
+describe("redaction gaps: unambiguous secret key names and header/URL credentials", () => {
+    test("object keys naming a password, secret, credential or ID token are redacted", () => {
+        for (const key of [
+            "db_password",
+            "id_token",
+            "secret_value",
+            "smtp_password",
+            "aws_credentials",
+        ]) {
+            expect(isSecretKey(key)).toBe(true);
+            expect(sanitizeConfigValue({ [key]: "hunter2-value" })).toEqual({
+                [key]: expect.stringContaining("<REDACTED:"),
+            });
+        }
+    });
+
+    test("ambiguous key/token compounds that are counts or labels stay visible", () => {
+        for (const key of [
+            "max_tokens",
+            "input_tokens",
+            "cache_key",
+            "sort_key",
+            "password_min_length",
+        ]) {
+            expect(isSecretKey(key)).toBe(false);
+        }
+    });
+
+    test("URL userinfo credentials are redacted", () => {
+        const redacted = redactSecretText(
+            "connecting to https://alice:s3cretPass@db.example.com/x",
+        );
+        expect(redacted).not.toContain("s3cretPass");
+        expect(redacted).toContain("db.example.com");
+    });
+
+    test("Basic authorization and API-key headers are redacted", () => {
+        const basic = redactSecretText("Authorization: Basic YWxpY2U6czNjcmV0UGFzcw==");
+        expect(basic).not.toContain("YWxpY2U6czNjcmV0UGFzcw==");
+        const apiKey = redactSecretText("x-api-key: live_9f8e7d6c5b4a3");
+        expect(apiKey).not.toContain("live_9f8e7d6c5b4a3");
+        expect(apiKey).toContain("x-api-key");
+    });
+});

package/src/shared/redaction.ts

@@ -0,0 +1,298 @@
+import { homedir, userInfo } from "node:os";
+
+function escapeRegex(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// Whole-segment match: the key (or its components when split on common
+// separators) must BE one of these words, not merely contain them as a
+// substring. Bare substring matching wrongly redacts benign fields like
+// `pin_key_files`, `token_budget`, and `injection_budget_tokens`.
+const SECRET_WORDS = [
+    "key",
+    "token",
+    "secret",
+    "password",
+    "auth",
+    "authorization",
+    "bearer",
+    "credential",
+];
+const SECRET_SEGMENT_PATTERN = new RegExp(
+    `^(?:${SECRET_WORDS.map((w) => `${w}s?`).join("|")})$`,
+    "i",
+);
+const TRAILING_DESCRIPTORS = new Set(["id", "ids", "value", "values", "header", "headers"]);
+
+function redactionTypeForKey(key: string): string {
+    const normalized = key
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, "_");
+    const suffix = normalized.split(".").filter(Boolean).at(-1) ?? normalized;
+    return suffix || "secret";
+}
+
+// A bare number / boolean / null is never a secret — an API key, bearer token,
+// password, or credential is always a high-entropy string. So when a key-based
+// pattern (the `name=value` / `"name":"value"` forms below) matches purely on
+// the KEY containing a word like "token", but the VALUE is numeric/boolean, it's
+// a count or flag, not a secret. These must stay readable in logs:
+// `tokens.input=45000`, `hasUsageTokens=true`, `max_tokens=4096` are diagnostics,
+// not credentials. (High-entropy secret VALUES are still caught by the
+// value-shaped patterns above — bearer, JWT, AKIA, gh*_, etc. — independent of
+// the key name, so relaxing the key-based match for scalars loses no coverage.)
+function isNonSecretScalarValue(value: string): boolean {
+    const v = value.trim();
+    if (v === "true" || v === "false" || v === "null" || v === "undefined") return true;
+    // Integer or decimal, optional sign/exponent — token counts, ports, sizes.
+    return /^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(v);
+}
+
+const SECRET_QUALIFIERS = new Set([
+    "api",
+    "access",
+    "private",
+    "client",
+    "auth",
+    "authorization",
+    "secret",
+    "bearer",
+    "session",
+    "refresh",
+    "service",
+    "x",
+    "openai",
+    "anthropic",
+    "google",
+    "github",
+    "huggingface",
+    "aws",
+    "azure",
+    // OpenID Connect `id_token`.
+    "id",
+]);
+
+/**
+ * Words that name a secret on their own. `key` and `token` need a qualifier
+ * (`api_key`, `access_token`) because `max_tokens` or `cache_key` are not
+ * secrets, but `db_password`, `secret_value` or `aws_credentials` are secrets
+ * whatever comes before them.
+ */
+const UNQUALIFIED_SECRET_SEGMENT_PATTERN =
+    /^(?:password|secret|credential|bearer|authorization)s?$/;
+
+export function isSecretKey(key: string): boolean {
+    const segments = key
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .split(/[._-]+/)
+        .filter(Boolean);
+    if (segments.length === 0) return false;
+
+    if (segments.length === 1) {
+        const first = segments[0];
+        return Boolean(first && SECRET_SEGMENT_PATTERN.test(first));
+    }
+
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (!seg || !SECRET_SEGMENT_PATTERN.test(seg)) continue;
+
+        let trailingOk = true;
+        for (let j = i + 1; j < segments.length; j++) {
+            const tail = segments[j];
+            if (!tail) continue;
+            if (TRAILING_DESCRIPTORS.has(tail)) continue;
+            if (SECRET_SEGMENT_PATTERN.test(tail)) continue;
+            trailingOk = false;
+            break;
+        }
+        if (!trailingOk) continue;
+        if (UNQUALIFIED_SECRET_SEGMENT_PATTERN.test(seg)) return true;
+
+        for (let k = i - 1; k >= 0; k--) {
+            const lead = segments[k];
+            if (lead && SECRET_QUALIFIERS.has(lead)) return true;
+        }
+    }
+    return false;
+}
+
+export function sanitizePathString(value: string): string {
+    const home = process.env.HOME || process.env.USERPROFILE || homedir();
+    const username = userInfo().username;
+    let sanitized = value;
+    if (home) {
+        sanitized = sanitized.replace(new RegExp(escapeRegex(home), "g"), "~");
+    }
+    sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
+    sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
+    sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
+    if (username) {
+        sanitized = sanitized.replace(new RegExp(escapeRegex(username), "g"), "<USER>");
+    }
+    return sanitized;
+}
+
+const SECRET_TEXT_PATTERNS: Array<{
+    pattern: RegExp;
+    replacement: string | ((match: string, ...groups: string[]) => string);
+}> = [
+    {
+        pattern: /\bsk-ant-(?:api03-)?[A-Za-z0-9_-]{32,}/g,
+        replacement: "<ANTHROPIC_API_KEY_REDACTED>",
+    },
+    {
+        pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{12,}/g,
+        replacement: "<OPENAI_API_KEY_REDACTED>",
+    },
+    {
+        pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+        replacement: "<GITHUB_PAT_REDACTED>",
+    },
+    {
+        pattern: /\b(?:gh[opsu]|ghr)_[A-Za-z0-9]{30,}/g,
+        replacement: "<GITHUB_TOKEN_REDACTED>",
+    },
+    {
+        pattern: /\bhf_[A-Za-z0-9]{30,}/g,
+        replacement: "<HUGGINGFACE_TOKEN_REDACTED>",
+    },
+    {
+        pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+        replacement: "<AWS_ACCESS_KEY_ID_REDACTED>",
+    },
+    {
+        pattern: /\bxox[abprsuvc]-[A-Za-z0-9-]{10,}/g,
+        replacement: "<SLACK_TOKEN_REDACTED>",
+    },
+    {
+        pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g,
+        replacement: "<GOOGLE_API_KEY_REDACTED>",
+    },
+    {
+        pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi,
+        replacement: (_full: string, prefix: string) => `${prefix}<REDACTED:bearer>`,
+    },
+    {
+        // Other Authorization schemes carry credentials too; Basic is just
+        // base64 of user:password.
+        pattern:
+            /\b((?:Proxy-)?Authorization\s*:\s*(?:Basic|Digest|Token|Negotiate|NTLM)\s+)([A-Za-z0-9._~+/=-]{4,})/gi,
+        replacement: (_full: string, prefix: string) => `${prefix}<REDACTED:authorization>`,
+    },
+    {
+        // API-key style headers (`x-api-key: ...`), which the `name=value`
+        // pattern below does not reach because of the colon separator.
+        pattern:
+            /\b((?:x-)?(?:api-?key|api-?token|auth-?token|access-?token)\s*:\s*)([^\s'"`,;<>]{6,})/gi,
+        replacement: (full: string, prefix: string, value: string) =>
+            isNonSecretScalarValue(value) ? full : `${prefix}<REDACTED:api_key>`,
+    },
+    {
+        // Credentials embedded in a URL: scheme://user:password@host.
+        pattern: /\b([a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)([^\s/@]+)(@)/gi,
+        replacement: (_full: string, prefix: string, _password: string, at: string) =>
+            `${prefix}<REDACTED:password>${at}`,
+    },
+    {
+        pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+        replacement: "<JWT_REDACTED>",
+    },
+    {
+        pattern:
+            /(["'])([^"']*(?:key|token|secret|password|auth|bearer|credential)[^"']*)\1(\s*:\s*)(["'])([^"']*)\4/gi,
+        replacement: (
+            full: string,
+            quote: string,
+            key: string,
+            separator: string,
+            valueQuote: string,
+            value: string,
+        ) =>
+            // A numeric/boolean value matched only because the KEY contains a
+            // secret word (e.g. "max_tokens": "4096") is a count, not a secret.
+            isNonSecretScalarValue(value)
+                ? full
+                : `${quote}${key}${quote}${separator}${valueQuote}<REDACTED:${redactionTypeForKey(key)}>${valueQuote}`,
+    },
+    {
+        pattern:
+            /\b([A-Za-z0-9_.-]*(?:key|token|secret|password|auth|bearer|credential)[A-Za-z0-9_.-]*)\s*=\s*([^\s'"`]+)/gi,
+        replacement: (full: string, key: string, value: string) =>
+            // tokens.input=45000 / hasUsageTokens=true are diagnostics, not
+            // secrets — keep them readable. Real secret values are still caught
+            // by the value-shaped patterns above.
+            isNonSecretScalarValue(value) ? full : `${key}=<REDACTED:${redactionTypeForKey(key)}>`,
+    },
+];
+
+export function redactSecretText(value: string): string {
+    let redacted = value;
+    for (const { pattern, replacement } of SECRET_TEXT_PATTERNS) {
+        if (typeof replacement === "string") {
+            redacted = redacted.replace(pattern, replacement);
+        } else {
+            redacted = redacted.replace(
+                pattern,
+                replacement as (match: string, ...groups: string[]) => string,
+            );
+        }
+    }
+    return redacted;
+}
+
+export function sanitizeDiagnosticText(value: string): string {
+    return redactSecretText(sanitizePathString(value));
+}
+
+// Extra shareability-only signals — patterns that mark text as unsafe to share
+// with teammates but that the diagnostic sanitizer (tuned for secret/path
+// REDACTION, not share-gating) does not rewrite. Kept here, NOT in
+// sanitizeDiagnosticText, so diagnostic redaction output is unchanged.
+const SHAREABILITY_SENSITIVE_PATTERNS: RegExp[] = [
+    // Windows user home, forward- OR back-slash (sanitizePathString only rewrites
+    // the backslash form).
+    /\bC:\/Users\/[^/\s]+/i,
+    // A `~`-rooted home path (personal/local).
+    /(?:^|\s)~\/[^\s]+/,
+    // Inline `key: value` / `key=value` secrets the keyed redactor misses in free
+    // text (it keys on config OBJECT keys, not prose).
+    /\b(?:api[_-]?key|secret|token|password|passwd|pwd|client[_-]?secret|access[_-]?key)\b\s*[:=]\s*\S+/i,
+    // Local / private endpoints — environment-specific, not a shared truth.
+    /\b(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?\b/i,
+    /\b(?:10|127)\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,
+    /\b192\.168\.\d{1,3}\.\d{1,3}\b/,
+    /\b172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}\b/,
+];
+
+export function hasShareabilitySensitiveText(text: string): boolean {
+    try {
+        if (sanitizeDiagnosticText(text) !== text) return true;
+        return SHAREABILITY_SENSITIVE_PATTERNS.some((pattern) => pattern.test(text));
+    } catch {
+        return true;
+    }
+}
+
+export function sanitizeConfigValue(value: unknown, keyPath: string[] = []): unknown {
+    if (value === null || typeof value === "number" || typeof value === "boolean") return value;
+    const key = keyPath.at(-1) ?? "";
+    if (key && isSecretKey(key)) {
+        return `<REDACTED:${redactionTypeForKey(key)}>`;
+    }
+    if (typeof value === "string") return sanitizeDiagnosticText(value);
+    if (Array.isArray(value)) {
+        return value.map((entry, index) => sanitizeConfigValue(entry, [...keyPath, String(index)]));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(
+            Object.entries(value).map(([entryKey, entry]) => [
+                entryKey,
+                sanitizeConfigValue(entry, [...keyPath, entryKey]),
+            ]),
+        );
+    }
+    return value;
+}