@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-WNECKKO2.js

@@ -0,0 +1,154 @@
+import {
+  formatOpencodeDisplayLine
+} from "./chunk-AUJLW6JZ.js";
+import {
+  PROVIDER_OUTPUT_WORKER_EVENT_PREFIX
+} from "./chunk-WEW7UFWE.js";
+import {
+  isRecoverableProviderStderrChunk
+} from "./chunk-MYLH2S4G.js";
+import {
+  isQuietOutputRequested,
+  isVerboseOutputRequested
+} from "./chunk-XWIZ6B5S.js";
+import {
+  BUILD_PROVIDER_OUTPUT_EVENTS,
+  BUILD_PROVIDER_STREAMING,
+  isDebugMode,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/cli/provider-output-forwarding.ts
+function isCliProviderOutputForwardingEnabled() {
+  return readEnv(BUILD_PROVIDER_OUTPUT_EVENTS).value ?? false;
+}
+function isCliHumanProviderStreamingEnabled() {
+  const streaming = readEnv(BUILD_PROVIDER_STREAMING);
+  if (streaming.value !== true) return false;
+  if (isQuietOutputRequested()) return false;
+  if (isDebugMode() || isVerboseOutputRequested()) return true;
+  return streaming.source === "env";
+}
+function formatProviderOutputArtifactHint(artifactPath) {
+  const trimmedPath = artifactPath.trim();
+  if (!trimmedPath || isQuietOutputRequested()) return null;
+  return `Provider output artifact: ${trimmedPath}`;
+}
+function createCliProviderOutputForwarder(stdout = process.stdout) {
+  return (event) => {
+    try {
+      stdout.write(`${PROVIDER_OUTPUT_WORKER_EVENT_PREFIX}${JSON.stringify(event)}
+`);
+    } catch {
+    }
+  };
+}
+function formatCliProviderOutputLine(event) {
+  const raw = normalizeCliProviderOutputText(event);
+  if (!raw) return null;
+  if (shouldSuppressCliProviderOutputLine(event, raw)) {
+    return null;
+  }
+  const stream = event.stream === "stderr" || event.chunkKind === "stderr" ? " stderr" : "";
+  const prefix = `[${event.provider}${stream}]`;
+  return raw.split("\n").map((line) => `${prefix} ${line.trimEnd()}`).join("\n");
+}
+function shouldSuppressCliProviderOutputLine(event, raw) {
+  if (isDetailedProviderOutputRequested()) return false;
+  if (event.provider === "claude" && /sandbox-exec/i.test(raw) && /sandbox_apply/i.test(raw)) {
+    return true;
+  }
+  if ((event.stream === "stderr" || event.chunkKind === "stderr") && isRecoverableProviderStderrChunk(event.provider, raw)) {
+    return true;
+  }
+  if (event.provider === "cursor") {
+    return raw.split("\n").every((line) => shouldSuppressCursorHumanOutputLine(line.trim()));
+  }
+  return false;
+}
+function isDetailedProviderOutputRequested() {
+  return isDebugMode() || isVerboseOutputRequested();
+}
+function shouldSuppressCursorHumanOutputLine(line) {
+  if (!line) return true;
+  if (/^THINKING(?: partial)?:/i.test(line)) return true;
+  if (/^THINKING completed:?$/i.test(line)) return true;
+  if (/^TOOL (?:STARTED|COMPLETED):/i.test(line)) return true;
+  if (/^TOOL:/i.test(line)) return true;
+  if (/^MESSAGE partial:/i.test(line)) return true;
+  return false;
+}
+var CLAUDE_TRACE_LABELS_TO_SUPPRESS = /* @__PURE__ */ new Set(["Args", "RESULT", "THINKING", "TOOL"]);
+var CLAUDE_TRACE_LABEL_PATTERN = /^(TEXT|TOOL|Args|RESULT|ERROR|THINKING):\s?(.*)$/;
+function formatClaudeHumanOutputLine(line) {
+  const trimmed = line.trimEnd();
+  if (!trimmed) return null;
+  const match = CLAUDE_TRACE_LABEL_PATTERN.exec(trimmed);
+  if (!match) return trimmed;
+  const label = match[1] ?? "";
+  const detail = match[2] ?? "";
+  if (CLAUDE_TRACE_LABELS_TO_SUPPRESS.has(label)) {
+    return null;
+  }
+  if (label === "TEXT") {
+    return detail.trimEnd() || null;
+  }
+  if (label === "ERROR") {
+    return detail.trimEnd() ? `Error: ${detail.trimEnd()}` : "Error:";
+  }
+  return trimmed;
+}
+function normalizeCliProviderOutputText(event) {
+  const raw = (event.text ?? event.raw ?? "").trimEnd();
+  if (!raw) return null;
+  if (event.provider === "claude" && !isDetailedProviderOutputRequested()) {
+    const renderedLines2 = raw.split(/\r?\n/).map(formatClaudeHumanOutputLine).filter((line) => Boolean(line));
+    if (renderedLines2.length === 0) {
+      return null;
+    }
+    return renderedLines2.join("\n");
+  }
+  if (event.provider === "cursor" && !isDetailedProviderOutputRequested()) {
+    const renderedLines2 = raw.split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => !shouldSuppressCursorHumanOutputLine(line.trim()));
+    if (renderedLines2.length === 0) {
+      return null;
+    }
+    return renderedLines2.join("\n");
+  }
+  if (event.provider !== "opencode") {
+    return raw;
+  }
+  const renderedLines = raw.split(/\r?\n/).map((line) => line.trimEnd()).map((line) => formatOpencodeDisplayLine(line)).filter((line) => Boolean(line));
+  if (renderedLines.length === 0) {
+    return null;
+  }
+  return renderedLines.join("\n");
+}
+function createCliHumanProviderOutputRenderer(stdout = process.stdout) {
+  return (event) => {
+    const line = formatCliProviderOutputLine(event);
+    if (!line) return;
+    try {
+      stdout.write(`${line}
+`);
+    } catch {
+    }
+  };
+}
+function resolveCliProviderOutputListener(listener, options = {}) {
+  if (listener) return listener;
+  if (options.resultStreamer) return void 0;
+  if (isCliProviderOutputForwardingEnabled())
+    return createCliProviderOutputForwarder(options.stdout);
+  return isCliHumanProviderStreamingEnabled() ? createCliHumanProviderOutputRenderer(options.stdout) : void 0;
+}
+
+export {
+  isCliProviderOutputForwardingEnabled,
+  isCliHumanProviderStreamingEnabled,
+  formatProviderOutputArtifactHint,
+  createCliProviderOutputForwarder,
+  createCliHumanProviderOutputRenderer,
+  resolveCliProviderOutputListener
+};
+//# sourceMappingURL=chunk-WNECKKO2.js.map

package/dist/chunk-WPKLYOAM.js

@@ -0,0 +1,195 @@
+// src/core/system-resources.ts
+import { execFileSync } from "child_process";
+import { readFileSync } from "fs";
+import * as os from "os";
+function parseVmStatValue(output, label) {
+  const match = output.match(new RegExp(`^\\s*${label}:\\s+([0-9,]+)\\.?`, "m"));
+  if (!match) return null;
+  return Number.parseInt((match[1] ?? "").replace(/,/g, ""), 10);
+}
+function getDarwinAvailableMemoryBytes() {
+  try {
+    const output = execFileSync("vm_stat", { encoding: "utf8", timeout: 2e3 });
+    const pageSizeMatch = output.match(/page size of (\d+) bytes/);
+    const pageSizeBytes = pageSizeMatch ? Number.parseInt(pageSizeMatch[1], 10) : Number.NaN;
+    if (!Number.isFinite(pageSizeBytes) || pageSizeBytes <= 0) return null;
+    const pagesFree = parseVmStatValue(output, "Pages free");
+    const pagesSpeculative = parseVmStatValue(output, "Pages speculative");
+    const pagesInactive = parseVmStatValue(output, "Pages inactive");
+    if (pagesFree === null || pagesSpeculative === null || pagesInactive === null) return null;
+    const availablePages = pagesFree + pagesSpeculative + pagesInactive;
+    return availablePages * pageSizeBytes;
+  } catch {
+    return null;
+  }
+}
+function getLinuxAvailableMemoryBytes() {
+  try {
+    const meminfo = readFileSync("/proc/meminfo", "utf8");
+    const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
+    if (!match) return null;
+    return Number.parseInt(match[1], 10) * 1024;
+  } catch {
+    return null;
+  }
+}
+function getAvailableMemoryGB() {
+  const fallbackGB = os.freemem() / 1024 ** 3;
+  const availableBytes = os.platform() === "darwin" ? getDarwinAvailableMemoryBytes() : os.platform() === "linux" ? getLinuxAvailableMemoryBytes() : null;
+  if (availableBytes === null) return fallbackGB;
+  const clampedBytes = Math.max(0, Math.min(os.totalmem(), availableBytes));
+  return clampedBytes / 1024 ** 3;
+}
+function getMemoryPressureLevel() {
+  if (os.platform() === "darwin") {
+    try {
+      const raw = execFileSync("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"], {
+        encoding: "utf8",
+        timeout: 2e3
+      });
+      const level = Number.parseInt(raw.trim(), 10);
+      if (level === 1) return "normal";
+      if (level === 2) return "warn";
+      if (level === 4) return "critical";
+      return "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  if (os.platform() === "linux") {
+    try {
+      const psi = readFileSync("/proc/pressure/memory", "utf8");
+      const some = psi.match(/^some avg10=([\d.]+)/m);
+      const full = psi.match(/^full avg10=([\d.]+)/m);
+      const someAvg10 = some ? Number.parseFloat(some[1]) : 0;
+      const fullAvg10 = full ? Number.parseFloat(full[1]) : 0;
+      if (fullAvg10 >= 10) return "critical";
+      if (someAvg10 >= 10) return "warn";
+      return "normal";
+    } catch {
+      return "unknown";
+    }
+  }
+  return "unknown";
+}
+var TIER_CONFIGS = {
+  minimal: {
+    maxWorkers: 1,
+    maxProcesses: 5,
+    heapPerWorkerMB: 512,
+    globalConcurrency: 8,
+    maxWorktreeConcurrency: 3,
+    worktreePoolSize: 2,
+    processTimeoutMs: 30 * 60 * 1e3,
+    // 30 minutes
+    conservativeMemory: true
+  },
+  standard: {
+    maxWorkers: 2,
+    maxProcesses: 10,
+    heapPerWorkerMB: 768,
+    globalConcurrency: 15,
+    maxWorktreeConcurrency: 5,
+    worktreePoolSize: 3,
+    processTimeoutMs: 45 * 60 * 1e3,
+    // 45 minutes
+    conservativeMemory: true
+  },
+  performance: {
+    maxWorkers: 3,
+    maxProcesses: 15,
+    heapPerWorkerMB: 1024,
+    globalConcurrency: 25,
+    maxWorktreeConcurrency: 8,
+    worktreePoolSize: 4,
+    processTimeoutMs: 60 * 60 * 1e3,
+    // 60 minutes
+    conservativeMemory: false
+  },
+  power: {
+    maxWorkers: 4,
+    maxProcesses: 20,
+    heapPerWorkerMB: 1536,
+    globalConcurrency: 40,
+    maxWorktreeConcurrency: 10,
+    worktreePoolSize: 5,
+    processTimeoutMs: 90 * 60 * 1e3,
+    // 90 minutes
+    conservativeMemory: false
+  },
+  ultra: {
+    maxWorkers: 6,
+    maxProcesses: 30,
+    heapPerWorkerMB: 2048,
+    globalConcurrency: 50,
+    maxWorktreeConcurrency: 15,
+    worktreePoolSize: 8,
+    processTimeoutMs: 120 * 60 * 1e3,
+    // 120 minutes
+    conservativeMemory: false
+  }
+};
+var MEMORY_THRESHOLDS = {
+  minimal: 8,
+  standard: 16,
+  performance: 32,
+  power: 64
+  // ultra: 64+ (default)
+};
+function detectSystemTierFromTotalMemoryGB(totalMemoryGB) {
+  if (totalMemoryGB < MEMORY_THRESHOLDS.minimal) return "minimal";
+  if (totalMemoryGB < MEMORY_THRESHOLDS.standard) return "standard";
+  if (totalMemoryGB < MEMORY_THRESHOLDS.performance) return "performance";
+  if (totalMemoryGB < MEMORY_THRESHOLDS.power) return "power";
+  return "ultra";
+}
+var cachedResources = null;
+function detectSystemResources(forceRefresh = false) {
+  if (cachedResources && !forceRefresh) {
+    return cachedResources;
+  }
+  const totalMemoryBytes = os.totalmem();
+  const totalMemoryGB = totalMemoryBytes / 1024 ** 3;
+  const freeMemoryGB = getAvailableMemoryGB();
+  const cpuCount = os.cpus().length;
+  const usedMemoryGB = totalMemoryGB - freeMemoryGB;
+  const memoryPressure = Math.min(1, Math.max(0, usedMemoryGB / totalMemoryGB));
+  let tier = detectSystemTierFromTotalMemoryGB(totalMemoryGB);
+  if (memoryPressure > 0.85 && tier !== "minimal") {
+    const tiers = ["minimal", "standard", "performance", "power", "ultra"];
+    const currentIndex = tiers.indexOf(tier);
+    if (currentIndex > 0) {
+      const downgradedTier = tiers[currentIndex - 1];
+      if (downgradedTier) {
+        tier = downgradedTier;
+      }
+    }
+  }
+  cachedResources = {
+    totalMemoryGB,
+    freeMemoryGB,
+    cpuCount,
+    tier,
+    memoryPressure
+  };
+  return cachedResources;
+}
+function getOverrideTier() {
+  const envTier = process.env.BUILD_RESOURCE_TIER;
+  if (envTier && ["minimal", "standard", "performance", "power", "ultra"].includes(envTier)) {
+    return envTier;
+  }
+  return null;
+}
+var overrideTier = getOverrideTier();
+if (overrideTier) {
+  const resources = detectSystemResources(true);
+  resources.tier = overrideTier;
+  cachedResources = resources;
+}
+
+export {
+  getAvailableMemoryGB,
+  getMemoryPressureLevel
+};
+//# sourceMappingURL=chunk-WPKLYOAM.js.map

package/dist/chunk-WSH37YQN.js

@@ -0,0 +1,243 @@
+import {
+  createDefaultPricingSources
+} from "./chunk-OZAUKWHB.js";
+import {
+  LongContextPricingSchema,
+  SpeedTierPricingSchema
+} from "./chunk-QXBKTJT6.js";
+
+// src/core/providers/model-update/pricing/config.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as YAML from "yaml";
+
+// src/core/providers/model-update/pricing/types.ts
+import { z } from "zod";
+var PricingSourceType = z.enum([
+  "openrouter",
+  "litellm",
+  "tokencost",
+  "manual",
+  "passthrough"
+]);
+var PricingProvenanceSchema = z.object({
+  /** Source type that provided this pricing */
+  source: PricingSourceType,
+  /** URL of the data source (for audit trail) */
+  source_url: z.string().url().optional(),
+  /** ISO timestamp when pricing was fetched */
+  fetched_at: z.string().datetime().optional(),
+  /** Model ID in the source system (for debugging ID mapping) */
+  source_model_id: z.string().optional(),
+  /** Original unit from source (before normalization) */
+  source_unit: z.enum(["usd_per_token", "usd_per_1k_tokens", "usd_per_1m_tokens"]).optional(),
+  /** Normalized unit in YAML (always usd_per_1m_tokens) */
+  normalized_unit: z.literal("usd_per_1m_tokens").default("usd_per_1m_tokens"),
+  /** Decimal precision used for normalized values */
+  normalized_precision_decimals: z.number().int().min(2).max(6).default(2),
+  /** Whether the ID mapping was human-verified */
+  external_id_verified: z.boolean().optional(),
+  /** Match confidence if heuristic mapping was used */
+  match_confidence: z.enum(["high", "medium", "low"]).optional(),
+  /** Version/ETag from source (for cache validation) */
+  source_version: z.string().optional()
+});
+var TokenPricingSchema = z.object({
+  /** Input token cost per 1M tokens (USD string) */
+  input_per_1m_tokens: z.string().regex(/^\d+\.\d{2,6}$/, "Must be USD with 2-6 decimal places"),
+  /** Output token cost per 1M tokens (USD string) */
+  output_per_1m_tokens: z.string().regex(/^\d+\.\d{2,6}$/, "Must be USD with 2-6 decimal places"),
+  /** Cache read cost per 1M tokens (USD string, optional) */
+  cache_read_per_1m_tokens: z.string().regex(/^\d+\.\d{2,6}$/).optional(),
+  /** Cache write cost per 1M tokens (USD string, optional) */
+  cache_write_per_1m_tokens: z.string().regex(/^\d+\.\d{2,6}$/).optional(),
+  /** Cache write cost per 1M tokens for the long (1-hour) duration (USD string, optional) */
+  cache_write_1h_per_1m_tokens: z.string().regex(/^\d+\.\d{2,6}$/).optional(),
+  /** Context window size (tokens) */
+  context_window: z.number().int().positive().optional(),
+  /** Per-request long-context multipliers, carried as declared on the pricing row */
+  long_context_pricing: LongContextPricingSchema.optional(),
+  /** Speed-tier rate sets keyed by tier name, carried as declared on the pricing row */
+  speed_tiers: z.record(z.string(), SpeedTierPricingSchema).optional(),
+  /**
+   * Speed tier a pass-through id selected and the rate set priced for it. `applied`
+   * is `standard` when the upstream row has no rates for the tier (fast requested,
+   * priced at standard), which makes the estimate incomplete.
+   */
+  routed_speed_tier: z.object({
+    requested: z.string(),
+    applied: z.string(),
+    /** Standard long-context threshold when the applied tier publishes no long-context rate. */
+    unpublishedLongContextAboveTokens: z.number().optional()
+  }).optional(),
+  /** Feature flags for this model */
+  features: z.record(z.string(), z.boolean()).optional(),
+  /** Human-readable pricing notes from provider registry data */
+  notes: z.string().optional(),
+  /** Provenance metadata (audit/debug only) */
+  _meta: PricingProvenanceSchema.optional()
+});
+var PassthroughTargetSchema = z.object({
+  /** Upstream provider ID (e.g., "claude", "codex", "gemini") */
+  provider: z.string(),
+  /** Upstream model ID (e.g., "claude-sonnet-4-5") */
+  model: z.string(),
+  /** Upstream speed tier whose rates apply (e.g., "fast"), when the upstream row declares it */
+  speed_tier: z.string().optional(),
+  /** Pricing caveat carried onto the resolved rates (e.g. a preview row standing in for a GA id) */
+  note: z.string().optional()
+});
+var PassthroughPricingSchema = z.object({
+  /** Indicates this provider uses pass-through pricing */
+  pricing_source: z.literal("passthrough"),
+  /** Model ID → upstream target mapping */
+  passthrough_map: z.record(z.string(), PassthroughTargetSchema)
+});
+var ProviderPricingMetaSchema = z.object({
+  /** Whether prices include platform fees (e.g., OpenRouter 5.5%) */
+  includes_platform_fee: z.boolean().optional(),
+  /** Estimated platform fee percentage (for documentation) */
+  platform_fee_percent_estimate: z.number().optional(),
+  /** Last successful pricing update timestamp */
+  last_pricing_update: z.string().datetime().optional(),
+  /** Pricing update source for this provider */
+  pricing_source: PricingSourceType.optional()
+});
+var PricingResolutionResultSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("resolved"),
+    provider: z.string(),
+    model: z.string(),
+    pricing: TokenPricingSchema,
+    /** Maker reference of the row that supplied the rates (e.g. `zai_docs`), or a refresh source label. */
+    source: z.string().min(1)
+  }),
+  z.object({
+    status: z.literal("fallback"),
+    pricing: TokenPricingSchema,
+    reason: z.string()
+  }),
+  z.object({
+    status: z.literal("unknown"),
+    modelId: z.string(),
+    reason: z.string()
+  })
+]);
+var LiteLLMModelPricingSchema = z.object({
+  litellm_provider: z.string().optional(),
+  mode: z.enum(["chat", "embedding", "image_generation", "audio_transcription", "rerank"]).optional(),
+  max_input_tokens: z.number().optional(),
+  max_output_tokens: z.number().optional(),
+  max_tokens: z.number().optional(),
+  input_cost_per_token: z.number().optional(),
+  output_cost_per_token: z.number().optional(),
+  cache_creation_input_token_cost: z.number().optional(),
+  cache_read_input_token_cost: z.number().optional(),
+  supports_function_calling: z.boolean().optional(),
+  supports_vision: z.boolean().optional(),
+  supports_prompt_caching: z.boolean().optional(),
+  deprecation_date: z.string().optional()
+});
+var OpenRouterModelPricingSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  created: z.number().optional(),
+  description: z.string().optional(),
+  context_length: z.number().optional(),
+  pricing: z.object({
+    prompt: z.string(),
+    // USD per token as string
+    completion: z.string(),
+    request: z.string().optional(),
+    image: z.string().optional(),
+    input_cache_read: z.string().optional(),
+    input_cache_write: z.string().optional(),
+    discount: z.number().optional()
+  }),
+  top_provider: z.object({
+    context_length: z.number().optional(),
+    max_completion_tokens: z.number().optional(),
+    is_moderated: z.boolean().optional()
+  }).optional()
+});
+var OpenRouterModelsResponseSchema = z.object({
+  data: z.array(OpenRouterModelPricingSchema)
+});
+var ExternalIdMappingSchema = z.object({
+  /** LiteLLM model ID (e.g., "claude-3-5-sonnet-20241022") */
+  litellm: z.string().optional(),
+  /** OpenRouter model ID (e.g., "anthropic/claude-3.5-sonnet") */
+  openrouter: z.string().optional(),
+  /** Whether this mapping has been human-verified */
+  verified: z.boolean().optional()
+});
+var PricingMergeConfigSchema = z.object({
+  /** Warn when price delta exceeds this percentage (default: 20) */
+  warn_threshold_percent: z.number().default(20),
+  /** Block update when price delta exceeds this percentage (default: 50) */
+  block_threshold_percent: z.number().default(50),
+  /** Per-provider threshold overrides */
+  per_provider_overrides: z.record(
+    z.string(),
+    z.object({
+      warn_threshold_percent: z.number().optional(),
+      block_threshold_percent: z.number().optional()
+    })
+  ).optional()
+});
+var PricingSourceConfigSchema = z.object({
+  name: z.string(),
+  url: z.string().url(),
+  priority: z.number().int().default(0),
+  enabled: z.boolean().default(true)
+});
+var PricingUpdateConfigSchema = z.object({
+  /** Pricing source URLs in priority order */
+  pricing_sources: z.array(PricingSourceConfigSchema).default(createDefaultPricingSources),
+  /** OpenRouter API configuration */
+  openrouter: z.object({
+    enabled: z.boolean().default(true),
+    api_url: z.string().url().default("https://openrouter.ai/api/v1/models")
+  }).optional(),
+  /** Merge policy configuration */
+  pricing_merge: PricingMergeConfigSchema.optional(),
+  /** Cache configuration */
+  cache: z.object({
+    ttl_hours: z.number().default(24),
+    directory: z.string().default(".build-project/cache/pricing")
+  }).optional()
+});
+
+// src/core/providers/model-update/pricing/config.ts
+async function loadPricingConfig(projectRoot) {
+  const configPath = path.join(projectRoot, ".build-project", "config", "model-update.yaml");
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const config = PricingUpdateConfigSchema.parse(YAML.parse(content));
+    return config;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        pricing_sources: createDefaultPricingSources(),
+        openrouter: {
+          enabled: true,
+          api_url: "https://openrouter.ai/api/v1/models"
+        },
+        pricing_merge: {
+          warn_threshold_percent: 20,
+          block_threshold_percent: 50
+        },
+        cache: {
+          ttl_hours: 24,
+          directory: ".build-project/cache/pricing"
+        }
+      };
+    }
+    throw error;
+  }
+}
+
+export {
+  loadPricingConfig
+};
+//# sourceMappingURL=chunk-WSH37YQN.js.map

package/dist/chunk-WV3KQDPE.js

@@ -0,0 +1,84 @@
+import {
+  isSensitiveKey
+} from "./chunk-VSWC5ZXI.js";
+import {
+  redactBlockerContext
+} from "./chunk-XV7NZL4B.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/telemetry/privacy-redaction.ts
+var REDACTED = "[REDACTED]";
+function redactString(value) {
+  return sanitizeString(redactBlockerContext(value));
+}
+function maybeRedactJsonString(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2 || !(trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+    return redactString(value);
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return JSON.stringify(redactTelemetryValue(parsed));
+  } catch {
+    return redactString(value);
+  }
+}
+function redactTelemetryValue(value, visited = /* @__PURE__ */ new Set()) {
+  if (typeof value === "string") {
+    return maybeRedactJsonString(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean" || value === null || value === void 0) {
+    return value ?? null;
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) {
+      return "[Circular]";
+    }
+    visited.add(value);
+    const mapped = value.map((entry) => redactTelemetryValue(entry, visited));
+    visited.delete(value);
+    return mapped;
+  }
+  if (typeof value !== "object") {
+    return redactString(String(value));
+  }
+  if (visited.has(value)) {
+    return "[Circular]";
+  }
+  visited.add(value);
+  const redacted = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    redacted[key] = isSensitiveKey(key) ? REDACTED : redactTelemetryValue(nestedValue, visited);
+  }
+  visited.delete(value);
+  return redacted;
+}
+function redactTelemetryObject(value) {
+  return redactTelemetryValue(value);
+}
+function redactPersistedTelemetryValue(value) {
+  return redactTelemetryValue(value);
+}
+function redactPersistedTestsExecuted(value) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  return redactPersistedTelemetryValue(value);
+}
+function redactPersistedTelemetryString(value) {
+  return String(redactTelemetryValue(value));
+}
+
+export {
+  redactTelemetryValue,
+  redactTelemetryObject,
+  redactPersistedTelemetryValue,
+  redactPersistedTestsExecuted,
+  redactPersistedTelemetryString
+};
+//# sourceMappingURL=chunk-WV3KQDPE.js.map