@simonyea/holysheep-cli 1.7.131 → 1.7.133

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "1.7.131",
+  "version": "1.7.133",
   "description": "Claude Code/Cursor/Cline API relay for China — ¥1=$1, WeChat/Alipay payment, no credit card, no VPN. One command setup for all AI coding tools.",
   "keywords": [
     "openai-china",

package/src/tools/claude-process-proxy.js

@@ -47,6 +47,41 @@ function getControlPlaneUrl(config) {
 
 const leaseCache = new Map()
 const MAX_PROXY_RETRIES = 3
+const ENABLE_TIMING_LOG = process.env.HS_CLAUDE_TIMING_LOG === '1'
+const SLOW_PATH_LOG_MS = Number(process.env.HS_CLAUDE_SLOW_PATH_LOG_MS) || 5000
+
+function sanitizeUrl(value) {
+  if (!value) return ''
+  try {
+    const url = new URL(String(value))
+    return `${url.protocol}//${url.host}${url.pathname}`
+  } catch {
+    return String(value)
+  }
+}
+
+function logProxyTiming(event, details = {}) {
+  if (!ENABLE_TIMING_LOG) return
+  const payload = Object.fromEntries(
+    Object.entries(details).filter(([, value]) => value !== undefined && value !== null && value !== '')
+  )
+  console.error(`[hs-claude-proxy] ${event} ${JSON.stringify(payload)}`)
+}
+
+function createForwardTrace({ clientReq, targetUrl, nodeProxyUrl, sessionId, lease, attempt, isDirect }) {
+  return {
+    requestId: crypto.randomUUID().slice(0, 8),
+    sessionId,
+    nodeId: lease?.nodeId || '',
+    attempt,
+    isDirect,
+    method: clientReq?.method || '',
+    target: sanitizeUrl(targetUrl),
+    nodeProxy: sanitizeUrl(nodeProxyUrl),
+    leaseOpenMs: lease?._hsLeaseOpenMs,
+    leaseAgeMs: lease?._hsLeaseOpenedAt ? Date.now() - lease._hsLeaseOpenedAt : undefined,
+  }
+}
 
 function createForwardError(statusCode, body) {
   const error = new Error(`HTTP ${statusCode}: ${String(body || '').slice(0, 200)}`)
@@ -55,6 +90,16 @@ function createForwardError(statusCode, body) {
   return error
 }
 
+function createClientValidationErrorBody(message) {
+  return JSON.stringify({
+    type: 'error',
+    error: {
+      type: 'client_validation_error',
+      message,
+    },
+  })
+}
+
 function shouldRefreshLeaseAfterError(err) {
   const statusCode = Number(err?.statusCode || 0)
   const body = String(err?.body || err?.message || '')
@@ -87,6 +132,8 @@ function isRetryableNodeLeaseError(err) {
     'HTTP 503',
     'HTTP 504',
     'client_validation_error',
+    'upstream response timeout',
+    'upstream stream stalled',
     '不可用'
   ].some((token) => message.includes(token))
 }
@@ -107,6 +154,7 @@ async function fetchFreshLease(config, sessionId, options = {}) {
   const controlPlaneUrl = getControlPlaneUrl(config)
   if (!controlPlaneUrl) throw new Error('Claude relay control plane is not configured')
 
+  const startedAt = Date.now()
   const response = await fetch(`${controlPlaneUrl}/session/open`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
@@ -124,6 +172,17 @@ async function fetchFreshLease(config, sessionId, options = {}) {
   if (!response.ok || !payload?.success || !payload?.data?.ticket) {
     throw new Error(payload?.error?.message || `Failed to open Claude session (HTTP ${response.status})`)
   }
+  const openedAt = Date.now()
+  payload.data._hsLeaseOpenMs = openedAt - startedAt
+  payload.data._hsLeaseOpenedAt = openedAt
+  if (payload.data._hsLeaseOpenMs >= SLOW_PATH_LOG_MS) {
+    logProxyTiming('lease.open', {
+      sessionId,
+      nodeId: payload.data.nodeId || '',
+      leaseOpenMs: payload.data._hsLeaseOpenMs,
+      forceReassign: options.forceReassign === true,
+    })
+  }
   leaseCache.set(sessionId, payload.data)
   return payload.data
 }
@@ -158,15 +217,27 @@ function deriveNodeProxyUrl(lease) {
   return upstream.toString().replace(/\/+$/, '')
 }
 
-function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, extraHeaders = {} }) {
+function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, extraHeaders = {}, trace = null }) {
   const upstream = new URL(nodeProxyUrl)
   return new Promise((resolve, reject) => {
+    const requestStartedAt = Date.now()
+    const resolvedTrace = trace || createForwardTrace({
+      clientReq,
+      targetUrl,
+      nodeProxyUrl,
+      sessionId: clientReq.headers['x-hs-session-id'] || '',
+      lease: null,
+      attempt: 0,
+      isDirect: !String(clientReq.url || '').startsWith('http'),
+    })
     let settled = false
     let responseTimer = null
     let stallTimer = null
     let sawUpstreamResponse = false
     let sawUpstreamData = false
     let forwardReq = null
+    let upstreamAssignedAt = null
+    let firstByteAt = null
 
     const clearResponseTimer = () => {
       if (responseTimer) {
@@ -191,6 +262,18 @@ function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, ex
       if (settled) return
       settled = true
       clearTimers()
+      const finishedAt = Date.now()
+      const totalMs = finishedAt - requestStartedAt
+      if (totalMs >= SLOW_PATH_LOG_MS) {
+        logProxyTiming('request.complete', {
+          ...resolvedTrace,
+          totalMs,
+          connectMs: upstreamAssignedAt ? upstreamAssignedAt - requestStartedAt : undefined,
+          firstByteMs: firstByteAt ? firstByteAt - requestStartedAt : undefined,
+          streamMs: firstByteAt ? finishedAt - firstByteAt : undefined,
+          bytesStarted: sawUpstreamData,
+        })
+      }
       resolve()
     }
 
@@ -198,21 +281,21 @@ function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, ex
       if (settled) return
       settled = true
       clearTimers()
+      const failedAt = Date.now()
+      logProxyTiming('request.fail', {
+        ...resolvedTrace,
+        totalMs: failedAt - requestStartedAt,
+        connectMs: upstreamAssignedAt ? upstreamAssignedAt - requestStartedAt : undefined,
+        firstByteMs: firstByteAt ? firstByteAt - requestStartedAt : undefined,
+        bytesStarted: sawUpstreamData,
+        error: message,
+      })
       if (forwardReq && !forwardReq.destroyed) {
         forwardReq.destroy()
       }
-      if (!clientRes.headersSent && !clientRes.destroyed) {
-        clientRes.writeHead(400, { 'content-type': 'application/json; charset=utf-8' })
-        clientRes.end(JSON.stringify({
-          type: 'error',
-          error: {
-            type: 'client_validation_error',
-            message,
-          },
-        }))
-        return resolve()
-      }
-      reject(new Error(message))
+      const error = createForwardError(400, createClientValidationErrorBody(message))
+      error.message = message
+      reject(error)
     }
 
     const fail = (error) => {
@@ -257,14 +340,31 @@ function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, ex
           settled = true
           clearTimers()
           const body = Buffer.concat(chunks).toString('utf8')
-          reject(createForwardError(status, body))
+          const error = createForwardError(status, body)
+          logProxyTiming('request.upstream_error', {
+            ...resolvedTrace,
+            status,
+            totalMs: Date.now() - requestStartedAt,
+            body: String(body || '').slice(0, 200),
+          })
+          reject(error)
         })
         forwardRes.on('error', fail)
         return
       }
 
+      upstreamAssignedAt = upstreamAssignedAt || Date.now()
       clientRes.writeHead(status, forwardRes.headers)
-      forwardRes.on('data', armStallTimer)
+      forwardRes.on('data', () => {
+        if (!firstByteAt) {
+          firstByteAt = Date.now()
+          logProxyTiming('request.first_byte', {
+            ...resolvedTrace,
+            firstByteMs: firstByteAt - requestStartedAt,
+          })
+        }
+        armStallTimer()
+      })
       forwardRes.once('end', () => {
         clearStallTimer()
         finish()
@@ -277,6 +377,12 @@ function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, ex
       forwardRes.pipe(clientRes)
     })
 
+    forwardReq.on('socket', (socket) => {
+      upstreamAssignedAt = upstreamAssignedAt || Date.now()
+      socket.once('connect', () => {
+        upstreamAssignedAt = upstreamAssignedAt || Date.now()
+      })
+    })
     forwardReq.setTimeout(RESPONSE_TIMEOUT_MS, () => {
       if (!sawUpstreamResponse) failWithAnthropicError('upstream response timeout')
     })
@@ -319,8 +425,8 @@ function createConnectTunnel(proxyUrl, target, headers) {
 
 // 等上游返回 first byte 的最大时间。
 // 这里不能默认等 5 分钟，否则上游/代理链路卡死时，用户会感觉每次下一条请求都被“挂住”。
-// 默认快速失败为 15 秒，仍可通过环境变量覆盖。
-const RESPONSE_TIMEOUT_MS = Number(process.env.HS_CLAUDE_RESPONSE_TIMEOUT_MS) || 15000
+// 默认快速失败为 30 秒，仍可通过环境变量覆盖。
+const RESPONSE_TIMEOUT_MS = Number(process.env.HS_CLAUDE_RESPONSE_TIMEOUT_MS) || 30000
 // 上游 stream 已开始后，相邻两个 chunk 之间的最大间隔。
 const STALL_TIMEOUT_MS = Number(process.env.HS_CLAUDE_STALL_TIMEOUT_MS) || 120000
 
@@ -383,7 +489,7 @@ function createProcessProxyServer({ sessionId, configPath = CONFIG_PATH, allowAn
   const server = http.createServer(async (clientReq, clientRes) => {
     const isDirect = !clientReq.url.startsWith('http')
 
-    const doForward = async (lease) => {
+    const doForward = async (lease, attempt) => {
       const config = readConfig(configPath)
       const nodeProxyUrl = deriveNodeProxyUrl(lease)
 
@@ -396,19 +502,38 @@ function createProcessProxyServer({ sessionId, configPath = CONFIG_PATH, allowAn
           clientReq,
           clientRes,
           extraHeaders: buildAuthHeaders(config, lease),
+          trace: createForwardTrace({
+            clientReq,
+            targetUrl: target,
+            nodeProxyUrl,
+            sessionId,
+            lease,
+            attempt,
+            isDirect,
+          }),
         })
       }
 
+      const targetUrl = new URL(clientReq.url)
       const headers = {
         ...buildAuthHeaders(config, lease),
-        host: new URL(clientReq.url).host,
+        host: targetUrl.host,
       }
       return forwardViaNodeProxy({
         nodeProxyUrl,
-        targetUrl: new URL(clientReq.url),
+        targetUrl,
         clientReq,
         clientRes,
         extraHeaders: headers,
+        trace: createForwardTrace({
+          clientReq,
+          targetUrl,
+          nodeProxyUrl,
+          sessionId,
+          lease,
+          attempt,
+          isDirect,
+        }),
       })
     }
 
@@ -416,7 +541,7 @@ function createProcessProxyServer({ sessionId, configPath = CONFIG_PATH, allowAn
     for (let attempt = 0; attempt <= MAX_PROXY_RETRIES; attempt++) {
       try {
         if (attempt === 0) {
-          await doForward(getCachedLease(sessionId))
+          await doForward(getCachedLease(sessionId), attempt)
         } else {
           const config = readConfig(configPath)
           leaseCache.delete(sessionId)
@@ -426,12 +551,19 @@ function createProcessProxyServer({ sessionId, configPath = CONFIG_PATH, allowAn
           const freshLease = await fetchFreshLease(config, sessionId, {
             forceReassign: shouldRefreshLeaseAfterError(lastError),
           })
-          await doForward(freshLease)
+          await doForward(freshLease, attempt)
         }
         lastError = null
         break
       } catch (err) {
         lastError = err
+        logProxyTiming('request.retry', {
+          sessionId,
+          attempt,
+          error: String(err?.message || err),
+          retryable: isRetryableNodeLeaseError(err),
+          forceReassign: shouldRefreshLeaseAfterError(err),
+        })
         if (clientRes.headersSent) return
         if (!isRetryableNodeLeaseError(err) && attempt > 0) break
       }