opencode-anthropic-multi-account 0.2.15 → 0.2.16

package/dist/chunk-RVXWLAVK.js

@@ -0,0 +1,1130 @@
+import {
+  scrubTemplate
+} from "./chunk-IETVH43F.js";
+
+// src/fingerprint-capture.ts
+import { spawn } from "child_process";
+import { createServer } from "http";
+import { basename, dirname as dirname2, join as join2 } from "path";
+import {
+  existsSync as existsSync2,
+  readFileSync,
+  renameSync
+} from "fs";
+import {
+  mkdir as mkdir2,
+  rename,
+  writeFile as writeFile2
+} from "fs/promises";
+
+// src/fingerprint-data.json
+var fingerprint_data_default = {
+  _version: 1,
+  _schemaVersion: 1,
+  _captured: "2026-04-18T02:05:42.332Z",
+  _source: "bundled",
+  agent_identity: "You are Claude Code, an interactive CLI tool that helps users with software engineering tasks.",
+  system_prompt: "You are Claude Code, an interactive CLI tool that helps users with software engineering tasks. Use the available tools to inspect the workspace, make precise changes, and verify the result before responding.\n\nYour default posture is practical, careful, and completion-oriented. Build context from the repository before making assumptions. Prefer direct evidence from files, commands, tests, and diagnostics over memory or guesswork.\n\nWhen working on code:\n- inspect existing patterns before editing\n- keep changes scoped to the requested outcome\n- preserve surrounding style, naming, and structure\n- avoid speculative refactors unless they are required to complete the requested task\n- verify every meaningful change with the strongest local check available\n\nWhen using tools:\n- use read, search, and symbol tools to understand the codebase before writing code\n- use shell commands for builds, tests, package scripts, and runtime verification\n- explain non-trivial actions briefly and clearly\n- prefer small, reviewable edits over broad rewrites\n- if multiple independent checks are available, run them efficiently\n\nWhen editing files:\n- keep the implementation easy to read from top to bottom\n- use descriptive names instead of magic values\n- avoid hidden side effects and surprising behavior\n- keep related logic together\n- add comments only when they clarify non-obvious intent\n\nWhen validating work:\n- run diagnostics on touched files when possible\n- run focused tests for affected behavior\n- run typechecking in typed projects\n- run builds when the package exposes a build step\n- if a check fails, fix the root cause and re-run verification\n\nWhen responding to the user:\n- be concise, direct, and accurate\n- focus on the task that was requested\n- summarize what changed and what was verified\n- mention important assumptions or follow-up risks only when they matter\n\nOperational guidance:\n- treat repository state as the source of truth\n- prefer deterministic behavior over clever shortcuts\n- do not invent undocumented APIs or file formats when local evidence is missing\n- if a requested detail is ambiguous, choose the simplest implementation that still satisfies the observable contract\n- preserve user data and existing behavior unless the requested change requires otherwise\n\nSafety guidance:\n- support defensive security work, debugging, testing, and code maintenance\n- refuse requests to create or improve malware, credential theft, bulk secret harvesting, or other clearly harmful capabilities\n- do not exfiltrate secrets from the environment, local files, or external services\n- avoid destructive operations unless they are explicitly required and safe to perform\n\nTool execution discipline:\n- use task tracking for multi-step work so progress stays visible\n- complete one active step at a time\n- after each code change, move immediately to verification\n- if verification reveals a problem, continue until the implementation and checks agree\n\nRepository interaction discipline:\n- prefer local source files, tests, and configuration over informal assumptions\n- preserve compatibility with existing consumers when editing shared interfaces\n- keep bundled fallback data conservative when live capture data is unavailable\n- when request templates depend on multiple system blocks, preserve the extracted fields that downstream code needs rather than reconstructing unrelated runtime state\n\nYou should act like a reliable engineering assistant inside a terminal environment: inspect first, edit precisely, verify thoroughly, and only then report the result.",
+  tools: [
+    {
+      name: "Bash",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "Read",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "Write",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "Edit",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "Glob",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "Grep",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "WebFetch",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "TodoWrite",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "TaskCreate",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "TaskGet",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "TaskList",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "TaskOutput",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "TaskStop",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "LSP",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "Monitor",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "NotebookEdit",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    {
+      name: "Skill",
+      input_schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    }
+  ],
+  tool_names: [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "WebFetch",
+    "TodoWrite",
+    "TaskCreate",
+    "TaskGet",
+    "TaskList",
+    "TaskOutput",
+    "TaskStop",
+    "LSP",
+    "Monitor",
+    "NotebookEdit",
+    "Skill"
+  ],
+  anthropic_beta: "claude-code-20250219,oauth-2025-04-20,context-1m-2025-08-07,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24",
+  header_values: {
+    "anthropic-version": "2023-06-01",
+    "anthropic-beta": "claude-code-20250219,oauth-2025-04-20,context-1m-2025-08-07,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24",
+    "x-app": "cli"
+  },
+  header_order: [
+    "Accept",
+    "Authorization",
+    "Content-Type",
+    "User-Agent",
+    "X-Claude-Code-Session-Id",
+    "X-Stainless-Arch",
+    "X-Stainless-Lang",
+    "X-Stainless-OS",
+    "X-Stainless-Package-Version",
+    "X-Stainless-Retry-Count",
+    "X-Stainless-Runtime",
+    "X-Stainless-Runtime-Version",
+    "X-Stainless-Timeout",
+    "anthropic-beta",
+    "anthropic-dangerous-direct-browser-access",
+    "anthropic-version",
+    "x-app",
+    "Connection",
+    "Host",
+    "Accept-Encoding",
+    "Content-Length"
+  ],
+  body_field_order: [
+    "model",
+    "messages",
+    "system",
+    "tools",
+    "metadata",
+    "max_tokens",
+    "thinking",
+    "context_management",
+    "output_config",
+    "stream"
+  ],
+  cc_version: "2.1.111"
+};
+
+// src/cli-version.ts
+import { execFileSync } from "child_process";
+var DEFAULT_CLI_VERSION = "2.1.100";
+var CLI_VERSION_PATTERN = /(\d+\.\d+\.\d+)/;
+var CLAUDE_VERSION_TIMEOUT_MS = 3e3;
+var detectedVersion = null;
+function parseCliVersion(output) {
+  return output.match(CLI_VERSION_PATTERN)?.[1] ?? null;
+}
+function detectCliVersion() {
+  if (detectedVersion !== null) {
+    return detectedVersion;
+  }
+  const overriddenVersion = process.env.ANTHROPIC_CLI_VERSION;
+  if (overriddenVersion) {
+    detectedVersion = overriddenVersion;
+    return detectedVersion;
+  }
+  try {
+    const output = execFileSync("claude", ["--version"], {
+      encoding: "utf8",
+      timeout: CLAUDE_VERSION_TIMEOUT_MS
+    });
+    detectedVersion = parseCliVersion(output) ?? DEFAULT_CLI_VERSION;
+  } catch {
+    detectedVersion = DEFAULT_CLI_VERSION;
+  }
+  return detectedVersion;
+}
+
+// src/oauth-config-detect.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir, platform } from "os";
+import { dirname, join } from "path";
+
+// src/fixtures/defaults/cc-derived-defaults.json
+var cc_derived_defaults_default = {
+  request: {
+    baseApiUrl: "https://api.anthropic.com",
+    anthropicVersion: "2023-06-01",
+    xApp: "cli",
+    betaHeader: "claude-code-20250219,oauth-2025-04-20,context-1m-2025-08-07,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24"
+  },
+  oauth: {
+    clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+    authorizeUrl: "https://claude.com/cai/oauth/authorize",
+    tokenUrl: "https://platform.claude.com/v1/oauth/token",
+    scopes: "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload",
+    baseApiUrl: "https://api.anthropic.com"
+  }
+};
+
+// src/utils.ts
+import {
+  createMinimalClient,
+  formatWaitTime,
+  getAccountLabel,
+  getConfigDir,
+  getErrorCode,
+  sleep
+} from "opencode-multi-account-core";
+
+// src/constants.ts
+import { anthropicOAuthAdapter } from "opencode-multi-account-core";
+var ANTHROPIC_OAUTH_ADAPTER = anthropicOAuthAdapter;
+var ANTHROPIC_CLIENT_ID = ANTHROPIC_OAUTH_ADAPTER.oauthClientId;
+var ANTHROPIC_TOKEN_ENDPOINT = ANTHROPIC_OAUTH_ADAPTER.tokenEndpoint;
+var ANTHROPIC_USAGE_ENDPOINT = ANTHROPIC_OAUTH_ADAPTER.usageEndpoint;
+var ANTHROPIC_PROFILE_ENDPOINT = ANTHROPIC_OAUTH_ADAPTER.profileEndpoint;
+var ACCOUNTS_FILENAME = ANTHROPIC_OAUTH_ADAPTER.accountStorageFilename;
+var CLAIMS_FILENAME = "anthropic-multi-account-claims.json";
+var PLAN_LABELS = ANTHROPIC_OAUTH_ADAPTER.planLabels;
+var TOKEN_EXPIRY_BUFFER_MS = 6e4;
+var TOKEN_REFRESH_TIMEOUT_MS = 3e4;
+
+// src/config.ts
+import {
+  createConfigLoader
+} from "opencode-multi-account-core";
+var configLoader = createConfigLoader("claude-multiauth.json");
+var { getConfig, loadConfig, resetConfigCache, updateConfigField } = configLoader;
+
+// src/utils.ts
+async function showToast(client, message, variant) {
+  if (getConfig().quiet_mode) return;
+  try {
+    await client.tui.showToast({ body: { message, variant } });
+  } catch {
+  }
+}
+function debugLog(client, message, extra) {
+  if (!getConfig().debug) return;
+  client.app.log({
+    body: { service: ANTHROPIC_OAUTH_ADAPTER.serviceLogName, level: "debug", message, extra }
+  }).catch(() => {
+  });
+}
+
+// src/oauth-config-detect.ts
+var CONFIG_SCAN_WINDOW_CHARS = 4096;
+var CONFIG_SCAN_LOOKBACK_CHARS = 512;
+var REJECTED_SCOPE = ["org", "create_api_key"].join(":");
+var SAFE_FALLBACK_SCOPES = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var CACHE_FILE_NAME = "anthropic-oauth-config-cache.json";
+var derivedDefaults = cc_derived_defaults_default;
+var FALLBACK = {
+  clientId: derivedDefaults.oauth?.clientId || "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+  authorizeUrl: derivedDefaults.oauth?.authorizeUrl || "https://claude.com/cai/oauth/authorize",
+  tokenUrl: derivedDefaults.oauth?.tokenUrl || "https://platform.claude.com/v1/oauth/token",
+  scopes: sanitizeScopes(derivedDefaults.oauth?.scopes),
+  baseApiUrl: derivedDefaults.oauth?.baseApiUrl || "https://api.anthropic.com",
+  source: "fallback"
+};
+function sanitizeScopes(scopes) {
+  if (!scopes || scopes.includes(REJECTED_SCOPE)) {
+    return SAFE_FALLBACK_SCOPES;
+  }
+  return scopes;
+}
+function pickNearestScopes(block, centerIndex) {
+  return pickNearestValue(block, centerIndex, /SCOPES\s*:\s*"([^"]+)"/gi) || pickNearestValue(block, centerIndex, /scope[s]?\s*:\s*"([^"]+)"/gi) || null;
+}
+function isLikelyLocalUrl(value) {
+  if (!value) {
+    return false;
+  }
+  try {
+    const host = new URL(value).hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "0.0.0.0" || host.endsWith(".local");
+  } catch {
+    return false;
+  }
+}
+function extractCandidateBlocks(binaryText) {
+  const blocks = [];
+  const seenRanges = /* @__PURE__ */ new Set();
+  const clientIdMatches = [...binaryText.matchAll(/CLIENT_ID\s*:\s*"([0-9a-f-]{36})"/gi)];
+  for (let index = 0; index < clientIdMatches.length; index += 1) {
+    const currentMatch = clientIdMatches[index];
+    if (!currentMatch) {
+      continue;
+    }
+    const currentIndex = currentMatch.index ?? 0;
+    const previousClientIdIndex = clientIdMatches[index - 1]?.index;
+    const nextClientIdIndex = clientIdMatches[index + 1]?.index;
+    const leftBoundary = previousClientIdIndex === void 0 ? Math.max(0, currentIndex - CONFIG_SCAN_LOOKBACK_CHARS) : Math.floor((previousClientIdIndex + currentIndex) / 2);
+    const rightBoundary = nextClientIdIndex === void 0 ? Math.min(binaryText.length, currentIndex + CONFIG_SCAN_WINDOW_CHARS) : Math.floor((currentIndex + nextClientIdIndex) / 2);
+    const start = Math.max(0, leftBoundary);
+    const end = Math.min(binaryText.length, Math.max(currentIndex + 1, rightBoundary));
+    const key = `${start}:${end}`;
+    if (seenRanges.has(key)) {
+      continue;
+    }
+    seenRanges.add(key);
+    blocks.push(binaryText.slice(start, end));
+  }
+  if (blocks.length === 0 && binaryText.length > 0) {
+    blocks.push(binaryText.slice(0, Math.min(binaryText.length, CONFIG_SCAN_WINDOW_CHARS)));
+  }
+  return blocks;
+}
+function pickNearestValue(block, centerIndex, pattern) {
+  let nearestValue;
+  let nearestDistance = Number.POSITIVE_INFINITY;
+  for (const match of block.matchAll(pattern)) {
+    const matchIndex = match.index ?? 0;
+    const distance = Math.abs(matchIndex - centerIndex);
+    if (distance < nearestDistance) {
+      nearestDistance = distance;
+      nearestValue = match[1];
+    }
+  }
+  return nearestValue;
+}
+function scoreCandidate(candidate, extractedScopes) {
+  let score = 0;
+  if (UUID_PATTERN.test(candidate.clientId)) score += 4;
+  if (candidate.baseApiUrl.startsWith("https://")) score += 3;
+  if (!isLikelyLocalUrl(candidate.baseApiUrl)) score += 5;
+  if (!isLikelyLocalUrl(candidate.authorizeUrl)) score += 2;
+  if (!isLikelyLocalUrl(candidate.tokenUrl)) score += 2;
+  if (extractedScopes) score += 2;
+  if (candidate.scopes.includes("user:sessions:claude_code")) score += 1;
+  return score;
+}
+function extractCandidateFromBlock(block) {
+  const clientIdMatch = /CLIENT_ID\s*:\s*"([0-9a-f-]{36})"/i.exec(block);
+  if (!clientIdMatch?.[1]) {
+    return null;
+  }
+  const clientIdIndex = clientIdMatch.index ?? 0;
+  const authorizeUrl = pickNearestValue(block, clientIdIndex, /CLAUDE_AI_AUTHORIZE_URL\s*:\s*"([^"]+)"/gi);
+  const baseApiUrl = pickNearestValue(block, clientIdIndex, /BASE_API_URL\s*:\s*"([^"]+)"/gi);
+  const tokenUrl = pickNearestValue(block, clientIdIndex, /TOKEN_URL\s*:\s*"(https:\/\/[^\"]*\/oauth\/token[^\"]*)"/gi);
+  const extractedScopes = pickNearestScopes(block, clientIdIndex);
+  const payload = {
+    clientId: clientIdMatch[1],
+    authorizeUrl: authorizeUrl || FALLBACK.authorizeUrl,
+    tokenUrl: tokenUrl || FALLBACK.tokenUrl,
+    scopes: sanitizeScopes(extractedScopes),
+    baseApiUrl: baseApiUrl || FALLBACK.baseApiUrl
+  };
+  if (!isDetectedOAuthConfigPayload(payload)) {
+    return null;
+  }
+  return {
+    payload,
+    score: scoreCandidate(payload, extractedScopes)
+  };
+}
+var memoizedConfig = null;
+var detectorTestOverrides = {};
+function candidatePaths() {
+  const home = homedir();
+  if (platform() === "win32") {
+    return [
+      join(home, ".local", "bin", "claude.exe"),
+      join(home, "AppData", "Roaming", "npm", "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+      join(home, "AppData", "Roaming", "npm", "node_modules", "@anthropic-ai", "claude-code", "cli.mjs"),
+      join(home, ".claude", "local", "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+      join(home, ".claude", "local", "node_modules", "@anthropic-ai", "claude-code", "cli.mjs")
+    ];
+  }
+  return [
+    join(home, ".local", "bin", "claude"),
+    "/usr/local/bin/claude",
+    "/opt/homebrew/bin/claude",
+    "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js",
+    "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.mjs",
+    "/opt/homebrew/lib/node_modules/@anthropic-ai/claude-code/cli.js",
+    join(home, ".claude", "local", "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+    join(home, ".claude", "local", "node_modules", "@anthropic-ai", "claude-code", "cli.mjs")
+  ];
+}
+function getCachePath() {
+  return join(getConfigDir(), CACHE_FILE_NAME);
+}
+function isValidUrl(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDetectedOAuthConfigPayload(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.clientId === "string" && UUID_PATTERN.test(candidate.clientId) && typeof candidate.authorizeUrl === "string" && isValidUrl(candidate.authorizeUrl) && typeof candidate.tokenUrl === "string" && isValidUrl(candidate.tokenUrl) && typeof candidate.scopes === "string" && candidate.scopes.length > 0;
+}
+function toFallbackConfig(ccPath, ccHash) {
+  return {
+    ...FALLBACK,
+    ...ccPath ? { ccPath } : {},
+    ...ccHash ? { ccHash } : {}
+  };
+}
+function findCCBinary() {
+  const override = process.env.DARIO_CC_PATH;
+  if (override && existsSync(override)) {
+    return override;
+  }
+  for (const candidatePath of candidatePaths()) {
+    if (existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return null;
+}
+async function fingerprintBinary(path) {
+  const binaryContents = await readFile(path);
+  return createHash("sha256").update(binaryContents).digest("hex").slice(0, 16);
+}
+function scanBinaryForOAuthConfig(buf) {
+  const binaryText = buf.toString("latin1");
+  const candidates = extractCandidateBlocks(binaryText).map(extractCandidateFromBlock).filter((candidate) => candidate !== null).sort((left, right) => right.score - left.score);
+  return candidates[0]?.payload ?? null;
+}
+async function loadCache() {
+  try {
+    const raw = await readFile(getCachePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.entries !== "object" || parsed.entries === null) {
+      return {};
+    }
+    const validEntries = {};
+    for (const [hash, value] of Object.entries(parsed.entries)) {
+      if (isDetectedOAuthConfigPayload(value)) {
+        validEntries[hash] = value;
+      }
+    }
+    return validEntries;
+  } catch {
+    return {};
+  }
+}
+async function saveCache(hash, config) {
+  try {
+    const cachePath = getCachePath();
+    const currentEntries = await loadCache();
+    currentEntries[hash] = config;
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(
+      cachePath,
+      JSON.stringify({ entries: currentEntries, savedAt: Date.now() }, null, 2),
+      "utf-8"
+    );
+  } catch {
+  }
+}
+async function detectOAuthConfig() {
+  if (memoizedConfig) {
+    return memoizedConfig;
+  }
+  try {
+    const ccPath = (detectorTestOverrides.findCCBinary || findCCBinary)();
+    if (!ccPath) {
+      memoizedConfig = FALLBACK;
+      return memoizedConfig;
+    }
+    const ccHash = await fingerprintBinary(ccPath);
+    const cachedEntries = await loadCache();
+    const cachedConfig = cachedEntries[ccHash];
+    if (cachedConfig) {
+      memoizedConfig = {
+        ...cachedConfig,
+        source: "cached",
+        ccPath,
+        ccHash
+      };
+      return memoizedConfig;
+    }
+    const readBinaryFile = detectorTestOverrides.readBinaryFile || readFile;
+    const scannedConfig = scanBinaryForOAuthConfig(await readBinaryFile(ccPath));
+    if (!scannedConfig || !isDetectedOAuthConfigPayload(scannedConfig)) {
+      memoizedConfig = toFallbackConfig(ccPath, ccHash);
+      return memoizedConfig;
+    }
+    await saveCache(ccHash, scannedConfig);
+    memoizedConfig = {
+      ...scannedConfig,
+      source: "detected",
+      ccPath,
+      ccHash
+    };
+    return memoizedConfig;
+  } catch {
+    memoizedConfig = FALLBACK;
+    return memoizedConfig;
+  }
+}
+
+// src/fingerprint-capture.ts
+var CURRENT_SCHEMA_VERSION = 1;
+var LIVE_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_CAPTURE_TIMEOUT_MS = 1e4;
+var CACHE_FILE_NAME2 = "fingerprint-cache.json";
+var CORRUPT_SUFFIX = ".corrupt";
+var LOOPBACK_HOST = "127.0.0.1";
+var STATIC_HEADER_NAMES = [
+  "accept",
+  "anthropic-beta",
+  "anthropic-dangerous-direct-browser-access",
+  "anthropic-version",
+  "content-type",
+  "user-agent",
+  "x-app",
+  "x-stainless-timeout"
+];
+var SUPPORTED_CC_RANGE = {
+  min: "1.0.0",
+  maxTested: "2.1.104"
+};
+var bundledTemplate = fingerprint_data_default;
+var fingerprintCaptureTestOverrides = {};
+function now() {
+  return fingerprintCaptureTestOverrides.now?.() ?? Date.now();
+}
+function getCachePath2() {
+  return join2(getConfigDir(), CACHE_FILE_NAME2);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTemplateTool(value) {
+  return isRecord(value) && typeof value.name === "string" && value.name.length > 0;
+}
+function isTemplateData(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value._version === "number" && typeof value._captured === "string" && typeof value._source === "string" && typeof value.agent_identity === "string" && typeof value.system_prompt === "string" && Array.isArray(value.tools) && value.tools.every(isTemplateTool) && Array.isArray(value.tool_names) && value.tool_names.every((toolName) => typeof toolName === "string");
+}
+function hasUsableToolSchemas(template) {
+  return template.tools.length > 0 && template.tools.every((tool) => tool.name.startsWith("mcp__") || isRecord(tool.input_schema));
+}
+function isUsableTemplate(template) {
+  return template._schemaVersion === CURRENT_SCHEMA_VERSION && hasUsableToolSchemas(template);
+}
+function cloneTemplate(template, sourceOverride) {
+  return {
+    ...template,
+    _source: sourceOverride ?? template._source,
+    tools: template.tools.map((tool) => ({ ...tool })),
+    tool_names: [...template.tool_names],
+    header_order: template.header_order ? [...template.header_order] : void 0,
+    header_values: template.header_values ? { ...template.header_values } : void 0,
+    body_field_order: template.body_field_order ? [...template.body_field_order] : void 0
+  };
+}
+function prepareBundledTemplate(template) {
+  const rest = cloneTemplate(template, "bundled");
+  return {
+    ...rest,
+    _version: CURRENT_SCHEMA_VERSION,
+    _schemaVersion: CURRENT_SCHEMA_VERSION,
+    _source: "bundled",
+    tool_names: rest.tools.map((tool) => tool.name)
+  };
+}
+function loadBundledTemplate() {
+  if (bundledTemplate._schemaVersion !== CURRENT_SCHEMA_VERSION) {
+    throw new Error(
+      `bundled fingerprint schema version ${bundledTemplate._schemaVersion} does not match CURRENT_SCHEMA_VERSION ${CURRENT_SCHEMA_VERSION}`
+    );
+  }
+  return prepareBundledTemplate(bundledTemplate);
+}
+function quarantineCorruptCache(cachePath) {
+  if (!existsSync2(cachePath)) {
+    return;
+  }
+  try {
+    const quarantinedPath = `${cachePath}${CORRUPT_SUFFIX}-${now()}-${process.pid}`;
+    renameSync(cachePath, quarantinedPath);
+  } catch {
+  }
+}
+function readLiveCacheSync(sourceOverride = "cached") {
+  const cachePath = getCachePath2();
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+    if (!isTemplateData(parsed)) {
+      quarantineCorruptCache(cachePath);
+      return null;
+    }
+    return cloneTemplate(parsed, sourceOverride);
+  } catch (error) {
+    if (existsSync2(cachePath)) {
+      const isMissingFileError = error instanceof Error && "code" in error && error.code === "ENOENT";
+      if (!isMissingFileError) {
+        quarantineCorruptCache(cachePath);
+      }
+    }
+    return null;
+  }
+}
+function isFreshTemplate(template) {
+  const capturedAt = Date.parse(template._captured);
+  return Number.isFinite(capturedAt) && now() - capturedAt < LIVE_TTL_MS;
+}
+async function atomicWriteJson(targetPath, payload) {
+  const tmpPath = join2(
+    dirname2(targetPath),
+    `${basename(targetPath)}.${process.pid}.${now()}.tmp`
+  );
+  await mkdir2(dirname2(targetPath), { recursive: true });
+  await writeFile2(tmpPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  await rename(tmpPath, targetPath);
+}
+async function writeLiveCache(template) {
+  await atomicWriteJson(getCachePath2(), cloneTemplate(template, "live"));
+}
+function toText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isRecord(value) && typeof value.text === "string") {
+    return value.text;
+  }
+  return null;
+}
+function pickTextBlock(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const text = toText(item);
+      if (text) {
+        return text;
+      }
+    }
+    return null;
+  }
+  return toText(value);
+}
+function extractCCVersion(...sources) {
+  for (const source of sources) {
+    if (!source) {
+      continue;
+    }
+    const billingMatch = /cc_version=([0-9]+\.[0-9]+\.[0-9]+)/i.exec(source);
+    if (billingMatch?.[1]) {
+      return billingMatch[1];
+    }
+    const userAgentMatch = /(?:claude(?:-code)?[\s/]|v)([0-9]+\.[0-9]+\.[0-9]+)/i.exec(source);
+    if (userAgentMatch?.[1]) {
+      return userAgentMatch[1];
+    }
+  }
+  return void 0;
+}
+function extractHeaderOrder(rawHeaders) {
+  if (rawHeaders.length === 0) {
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const orderedHeaders = [];
+  for (let index = 0; index < rawHeaders.length; index += 2) {
+    const headerName = rawHeaders[index];
+    if (!headerName) {
+      continue;
+    }
+    const key = headerName.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    orderedHeaders.push(headerName);
+  }
+  return orderedHeaders.length > 0 ? orderedHeaders : void 0;
+}
+function extractStaticHeaderValues(headers) {
+  const values = {};
+  for (const headerName of STATIC_HEADER_NAMES) {
+    const value = headers[headerName];
+    if (typeof value === "string" && value.length > 0) {
+      values[headerName] = value;
+    }
+  }
+  return Object.keys(values).length > 0 ? values : void 0;
+}
+function normalizeHeaders(req) {
+  const normalized = {};
+  for (const [headerName, headerValue] of Object.entries(req.headers)) {
+    if (typeof headerValue === "string") {
+      normalized[headerName] = headerValue;
+      continue;
+    }
+    if (Array.isArray(headerValue)) {
+      normalized[headerName] = headerValue.join(",");
+    }
+  }
+  return normalized;
+}
+function createSseResponseBody() {
+  return [
+    'event: message_start\ndata: {"type":"message_start","message":{"id":"msg_capture","type":"message","role":"assistant","model":"claude-sonnet-4-5","content":[]}}\n',
+    'event: content_block_start\ndata: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}\n',
+    'event: content_block_delta\ndata: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ok"}}\n',
+    'event: content_block_stop\ndata: {"type":"content_block_stop","index":0}\n',
+    'event: message_delta\ndata: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":1,"output_tokens":1}}\n',
+    'event: message_stop\ndata: {"type":"message_stop"}\n'
+  ].join("\n");
+}
+async function captureRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    req.on("error", reject);
+  });
+}
+async function runClaudeCapture(params) {
+  if (fingerprintCaptureTestOverrides.runClaudeCapture) {
+    await fingerprintCaptureTestOverrides.runClaudeCapture(params);
+    return;
+  }
+  const isNodeScript = /\.(?:cjs|mjs|js)$/.test(params.binaryPath);
+  const command = isNodeScript ? process.execPath : params.binaryPath;
+  const args = isNodeScript ? [params.binaryPath, "--print", "-p", "hi"] : ["--print", "-p", "hi"];
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env: {
+        ...process.env,
+        ANTHROPIC_BASE_URL: params.baseUrl
+      },
+      stdio: "ignore"
+    });
+    const timeout = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error("capture timed out"));
+    }, params.timeoutMs);
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+function findClaudeBinary() {
+  if (fingerprintCaptureTestOverrides.findClaudeBinary) {
+    return fingerprintCaptureTestOverrides.findClaudeBinary();
+  }
+  return findCCBinary();
+}
+function probeInstalledCCVersion() {
+  try {
+    return fingerprintCaptureTestOverrides.detectCliVersion?.() ?? detectCliVersion();
+  } catch {
+    return null;
+  }
+}
+function loadTemplate() {
+  const cached = readLiveCacheSync("cached");
+  if (cached && isUsableTemplate(cached)) {
+    return cached;
+  }
+  return loadBundledTemplate();
+}
+function extractTemplate(captured) {
+  const systemBlocks = captured.body.system;
+  const tools = captured.body.tools;
+  if (!Array.isArray(systemBlocks) || systemBlocks.length !== 3 || !Array.isArray(tools) || tools.length === 0) {
+    return null;
+  }
+  const billingHeader = pickTextBlock(systemBlocks[0]);
+  const agentIdentity = pickTextBlock(systemBlocks[1]);
+  const systemPrompt = pickTextBlock(systemBlocks[2]);
+  const extractedTools = tools.filter(isTemplateTool).map((tool) => ({ ...tool }));
+  if (!billingHeader || !agentIdentity || !systemPrompt || extractedTools.length === 0) {
+    return null;
+  }
+  const toolNames = extractedTools.map((tool) => tool.name);
+  const headerValues = extractStaticHeaderValues(captured.headers);
+  const bodyFieldOrder = Object.keys(captured.body);
+  return {
+    _version: CURRENT_SCHEMA_VERSION,
+    _schemaVersion: CURRENT_SCHEMA_VERSION,
+    _captured: new Date(now()).toISOString(),
+    _source: "live",
+    agent_identity: agentIdentity,
+    system_prompt: systemPrompt,
+    tools: extractedTools,
+    tool_names: toolNames,
+    anthropic_beta: captured.headers["anthropic-beta"],
+    cc_version: extractCCVersion(billingHeader, captured.headers["user-agent"]),
+    header_order: extractHeaderOrder(captured.rawHeaders),
+    header_values: headerValues,
+    body_field_order: bodyFieldOrder.length > 0 ? bodyFieldOrder : void 0
+  };
+}
+async function captureLiveTemplateAsync(timeoutMs = DEFAULT_CAPTURE_TIMEOUT_MS) {
+  const binaryPath = findClaudeBinary();
+  if (!binaryPath) {
+    return null;
+  }
+  let capturedRequest = null;
+  const responseBody = createSseResponseBody();
+  const server = createServer(async (req, res) => {
+    try {
+      const bodyText = await captureRequestBody(req);
+      const parsedBody = JSON.parse(bodyText);
+      capturedRequest = {
+        body: parsedBody,
+        headers: normalizeHeaders(req),
+        rawHeaders: [...req.rawHeaders]
+      };
+      res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+        "anthropic-ratelimit-unified-status": "accepted"
+      });
+      res.end(responseBody);
+    } catch {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end('{"error":"capture_failed"}');
+    }
+  });
+  try {
+    const address = await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, LOOPBACK_HOST, () => {
+        const resolvedAddress = server.address();
+        if (resolvedAddress && typeof resolvedAddress === "object") {
+          resolve({ port: resolvedAddress.port });
+          return;
+        }
+        reject(new Error("capture server failed to bind"));
+      });
+    });
+    const baseUrl = `http://${LOOPBACK_HOST}:${address.port}`;
+    await runClaudeCapture({ binaryPath, baseUrl, timeoutMs });
+    if (!capturedRequest) {
+      return null;
+    }
+    return extractTemplate(capturedRequest);
+  } catch {
+    return null;
+  } finally {
+    await new Promise((resolve) => {
+      server.close(() => resolve());
+    });
+  }
+}
+async function refreshLiveFingerprintAsync(options) {
+  if (!options?.force) {
+    const cached = readLiveCacheSync("cached");
+    if (cached && isUsableTemplate(cached) && isFreshTemplate(cached)) {
+      return cached;
+    }
+  }
+  if (!findClaudeBinary()) {
+    return null;
+  }
+  try {
+    const live = await captureLiveTemplateAsync(options?.timeoutMs ?? DEFAULT_CAPTURE_TIMEOUT_MS);
+    if (!live) {
+      return null;
+    }
+    const scrubbed = scrubTemplate(live, { dropMcpTools: false });
+    await writeLiveCache(scrubbed);
+    return scrubbed;
+  } catch {
+    return null;
+  }
+}
+function parseVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  if (!match) {
+    return null;
+  }
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareVersions(left, right) {
+  const leftVersion = parseVersion(left);
+  const rightVersion = parseVersion(right);
+  if (!leftVersion || !rightVersion) {
+    return null;
+  }
+  for (let index = 0; index < leftVersion.length; index += 1) {
+    const leftPart = leftVersion[index] ?? 0;
+    const rightPart = rightVersion[index] ?? 0;
+    const diff = leftPart - rightPart;
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+function detectDrift(template, installedOverride) {
+  const cachedVersion = template.cc_version ?? null;
+  const installedVersion = installedOverride ?? probeInstalledCCVersion();
+  if (!cachedVersion) {
+    return {
+      drifted: false,
+      cachedVersion: null,
+      installedVersion,
+      message: "template version unavailable"
+    };
+  }
+  if (!installedVersion) {
+    return {
+      drifted: false,
+      cachedVersion,
+      installedVersion: null,
+      message: "probe failed"
+    };
+  }
+  if (installedVersion === cachedVersion) {
+    return {
+      drifted: false,
+      cachedVersion,
+      installedVersion,
+      message: `cache v${cachedVersion} matches installed v${installedVersion}`
+    };
+  }
+  return {
+    drifted: true,
+    cachedVersion,
+    installedVersion,
+    message: `cache v${cachedVersion} != installed v${installedVersion}`
+  };
+}
+function checkCCCompat(installedOverride) {
+  const installedVersion = installedOverride ?? probeInstalledCCVersion();
+  if (!installedVersion) {
+    return {
+      status: "unknown",
+      installedVersion: null,
+      range: SUPPORTED_CC_RANGE,
+      message: "installed Claude Code version is unknown"
+    };
+  }
+  const minComparison = compareVersions(installedVersion, SUPPORTED_CC_RANGE.min);
+  const maxComparison = compareVersions(installedVersion, SUPPORTED_CC_RANGE.maxTested);
+  if (minComparison === null || maxComparison === null) {
+    return {
+      status: "unknown",
+      installedVersion,
+      range: SUPPORTED_CC_RANGE,
+      message: `installed Claude Code version "${installedVersion}" is not a strict semver`
+    };
+  }
+  if (minComparison < 0) {
+    return {
+      status: "below-min",
+      installedVersion,
+      range: SUPPORTED_CC_RANGE,
+      message: `installed Claude Code v${installedVersion} is below supported minimum v${SUPPORTED_CC_RANGE.min}`
+    };
+  }
+  if (maxComparison > 0) {
+    return {
+      status: "untested-above",
+      installedVersion,
+      range: SUPPORTED_CC_RANGE,
+      message: `installed Claude Code v${installedVersion} is above max tested v${SUPPORTED_CC_RANGE.maxTested}`
+    };
+  }
+  return {
+    status: "ok",
+    installedVersion,
+    range: SUPPORTED_CC_RANGE,
+    message: `installed Claude Code v${installedVersion} is within supported range`
+  };
+}
+function setFingerprintCaptureTestOverridesForTest(overrides) {
+  fingerprintCaptureTestOverrides = overrides ?? {};
+}
+function resetFingerprintCaptureForTest() {
+  fingerprintCaptureTestOverrides = {};
+}
+
+export {
+  fingerprint_data_default,
+  detectCliVersion,
+  cc_derived_defaults_default,
+  ANTHROPIC_OAUTH_ADAPTER,
+  ANTHROPIC_USAGE_ENDPOINT,
+  ANTHROPIC_PROFILE_ENDPOINT,
+  ACCOUNTS_FILENAME,
+  CLAIMS_FILENAME,
+  PLAN_LABELS,
+  TOKEN_EXPIRY_BUFFER_MS,
+  TOKEN_REFRESH_TIMEOUT_MS,
+  getConfig,
+  loadConfig,
+  updateConfigField,
+  showToast,
+  debugLog,
+  createMinimalClient,
+  formatWaitTime,
+  getAccountLabel,
+  getConfigDir,
+  sleep,
+  detectOAuthConfig,
+  LIVE_TTL_MS,
+  SUPPORTED_CC_RANGE,
+  prepareBundledTemplate,
+  loadTemplate,
+  extractTemplate,
+  captureLiveTemplateAsync,
+  refreshLiveFingerprintAsync,
+  detectDrift,
+  checkCCCompat,
+  setFingerprintCaptureTestOverridesForTest,
+  resetFingerprintCaptureForTest
+};
+//# sourceMappingURL=chunk-RVXWLAVK.js.map