Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
8.4 kB · 260 lines
TypeScript
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261import type { APIError } from '@anthropic-ai/sdk'
// SSL/TLS error codes from OpenSSL (used by both Node.js and Bun)// See: https://www.openssl.org/docs/man3.1/man3/X509_STORE_CTX_get_error.htmlconst SSL_ERROR_CODES = new Set([ // Certificate verification errors 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'UNABLE_TO_GET_ISSUER_CERT', 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY', 'CERT_SIGNATURE_FAILURE', 'CERT_NOT_YET_VALID', 'CERT_HAS_EXPIRED', 'CERT_REVOKED', 'CERT_REJECTED', 'CERT_UNTRUSTED', // Self-signed certificate errors 'DEPTH_ZERO_SELF_SIGNED_CERT', 'SELF_SIGNED_CERT_IN_CHAIN', // Chain errors 'CERT_CHAIN_TOO_LONG', 'PATH_LENGTH_EXCEEDED', // Hostname/altname errors 'ERR_TLS_CERT_ALTNAME_INVALID', 'HOSTNAME_MISMATCH', // TLS handshake errors 'ERR_TLS_HANDSHAKE_TIMEOUT', 'ERR_SSL_WRONG_VERSION_NUMBER', 'ERR_SSL_DECRYPTION_FAILED_OR_BAD_RECORD_MAC',])
export type ConnectionErrorDetails = { code: string message: string isSSLError: boolean}
/** * Extracts connection error details from the error cause chain. * The Anthropic SDK wraps underlying errors in the `cause` property. * This function walks the cause chain to find the root error code/message. */export function extractConnectionErrorDetails( error: unknown,): ConnectionErrorDetails | null { if (!error || typeof error !== 'object') { return null }
// Walk the cause chain to find the root error with a code let current: unknown = error const maxDepth = 5 // Prevent infinite loops let depth = 0
while (current && depth < maxDepth) { if ( current instanceof Error && 'code' in current && typeof current.code === 'string' ) { const code = current.code const isSSLError = SSL_ERROR_CODES.has(code) return { code, message: current.message, isSSLError, } }
// Move to the next cause in the chain if ( current instanceof Error && 'cause' in current && current.cause !== current ) { current = current.cause depth++ } else { break } }
return null}
/** * Returns an actionable hint for SSL/TLS errors, intended for contexts outside * the main API client (OAuth token exchange, preflight connectivity checks) * where `formatAPIError` doesn't apply. * * Motivation: enterprise users behind TLS-intercepting proxies (Zscaler et al.) * see OAuth complete in-browser but the CLI's token exchange silently fails * with a raw SSL code. Surfacing the likely fix saves a support round-trip. */export function getSSLErrorHint(error: unknown): string | null { const details = extractConnectionErrorDetails(error) if (!details?.isSSLError) { return null } return `SSL certificate error (${details.code}). If you are behind a corporate proxy or TLS-intercepting firewall, set NODE_EXTRA_CA_CERTS to your CA bundle path, or ask IT to allowlist *.anthropic.com. Run /doctor for details.`}
/** * Strips HTML content (e.g., CloudFlare error pages) from a message string, * returning a user-friendly title or empty string if HTML is detected. * Returns the original message unchanged if no HTML is found. */function sanitizeMessageHTML(message: string): string { if (message.includes('<!DOCTYPE html') || message.includes('<html')) { const titleMatch = message.match(/<title>([^<]+)<\/title>/) if (titleMatch && titleMatch[1]) { return titleMatch[1].trim() } return '' } return message}
/** * Detects if an error message contains HTML content (e.g., CloudFlare error pages) * and returns a user-friendly message instead */export function sanitizeAPIError(apiError: APIError): string { const message = apiError.message if (!message) { // Sometimes message is undefined // TODO: figure out why return '' } return sanitizeMessageHTML(message)}
/** * Shapes of deserialized API errors from session JSONL. * * After JSON round-tripping, the SDK's APIError loses its `.message` property. * The actual message lives at different nesting levels depending on the provider: * * - Bedrock/proxy: `{ error: { message: "..." } }` * - Standard Anthropic API: `{ error: { error: { message: "..." } } }` * (the outer `.error` is the response body, the inner `.error` is the API error) * * See also: `getErrorMessage` in `logging.ts` which handles the same shapes. */type NestedAPIError = { error?: { message?: string error?: { message?: string } }}
function hasNestedError(value: unknown): value is NestedAPIError { return ( typeof value === 'object' && value !== null && 'error' in value && typeof value.error === 'object' && value.error !== null )}
/** * Extract a human-readable message from a deserialized API error that lacks * a top-level `.message`. * * Checks two nesting levels (deeper first for specificity): * 1. `error.error.error.message` — standard Anthropic API shape * 2. `error.error.message` — Bedrock shape */function extractNestedErrorMessage(error: APIError): string | null { if (!hasNestedError(error)) { return null }
// Access `.error` via the narrowed type so TypeScript sees the nested shape // instead of the SDK's `Object | undefined`. const narrowed: NestedAPIError = error const nested = narrowed.error
// Standard Anthropic API shape: { error: { error: { message } } } const deepMsg = nested?.error?.message if (typeof deepMsg === 'string' && deepMsg.length > 0) { const sanitized = sanitizeMessageHTML(deepMsg) if (sanitized.length > 0) { return sanitized } }
// Bedrock shape: { error: { message } } const msg = nested?.message if (typeof msg === 'string' && msg.length > 0) { const sanitized = sanitizeMessageHTML(msg) if (sanitized.length > 0) { return sanitized } }
return null}
export function formatAPIError(error: APIError): string { // Extract connection error details from the cause chain const connectionDetails = extractConnectionErrorDetails(error)
if (connectionDetails) { const { code, isSSLError } = connectionDetails
// Handle timeout errors if (code === 'ETIMEDOUT') { return 'Request timed out. Check your internet connection and proxy settings' }
// Handle SSL/TLS errors with specific messages if (isSSLError) { switch (code) { case 'UNABLE_TO_VERIFY_LEAF_SIGNATURE': case 'UNABLE_TO_GET_ISSUER_CERT': case 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY': return 'Unable to connect to API: SSL certificate verification failed. Check your proxy or corporate SSL certificates' case 'CERT_HAS_EXPIRED': return 'Unable to connect to API: SSL certificate has expired' case 'CERT_REVOKED': return 'Unable to connect to API: SSL certificate has been revoked' case 'DEPTH_ZERO_SELF_SIGNED_CERT': case 'SELF_SIGNED_CERT_IN_CHAIN': return 'Unable to connect to API: Self-signed certificate detected. Check your proxy or corporate SSL certificates' case 'ERR_TLS_CERT_ALTNAME_INVALID': case 'HOSTNAME_MISMATCH': return 'Unable to connect to API: SSL certificate hostname mismatch' case 'CERT_NOT_YET_VALID': return 'Unable to connect to API: SSL certificate is not yet valid' default: return `Unable to connect to API: SSL error (${code})` } } }
if (error.message === 'Connection error.') { // If we have a code but it's not SSL, include it for debugging if (connectionDetails?.code) { return `Unable to connect to API (${connectionDetails.code})` } return 'Unable to connect to API. Check your internet connection' }
// Guard: when deserialized from JSONL (e.g. --resume), the error object may // be a plain object without a `.message` property. Return a safe fallback // instead of undefined, which would crash callers that access `.length`. if (!error.message) { return ( extractNestedErrorMessage(error) ?? `API error (status ${error.status ?? 'unknown'})` ) }
const sanitizedMessage = sanitizeAPIError(error) // Use sanitized message if it's different from the original (i.e., HTML was sanitized) return sanitizedMessage !== error.message && sanitizedMessage.length > 0 ? sanitizedMessage : error.message}