@simonyea/holysheep-cli 2.1.30 → 2.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "2.1.30",
+  "version": "2.1.31",
   "description": "Claude Code/Cursor/Cline API relay for China \u2014 \u00a51=$1, WeChat/Alipay payment, no credit card, no VPN. One command setup for all AI coding tools.",
   "scripts": {
     "test": "node tests/droid.test.js && node tests/workspace-store.test.js && node tests/runtime-stale-upgrade.test.js && node tests/hermes.test.js && node tests/preflight.test.js",

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

@@ -616,6 +616,64 @@ function createProcessProxyServer({ sessionId, configPath = CONFIG_PATH, allowAn
       )
     }
 
+    // [HolySheep fork v2.1.30 / hs22b] Buffer the incoming request body ONCE
+    // so retries + direct-https fallback can re-send it. Before this, each
+    // retry called clientReq.pipe(forwardReq) on a stream that had already
+    // been consumed by the previous attempt, making the second/third/...
+    // retry (and the fallback) hit CRS with an EMPTY body — upstream
+    // responded 400 "model is required" and the user saw no reply. Only
+    // the very first (often doomed-to-ECONNREFUSED) attempt had the real
+    // body; every retry+fallback arrived empty.
+    //
+    // Buffer into memory before any forward. Typical claude-agent-acp
+    // POST bodies are 5-40 KB so this is fine. Override from wire type
+    // to Buffer so downstream functions can pipe(from body stream)
+    // multiple times by wrapping a fresh Readable each time.
+    let bufferedBody = null
+    if (clientReq.method && !['GET', 'HEAD', 'OPTIONS'].includes(clientReq.method.toUpperCase())) {
+      try {
+        const chunks = []
+        for await (const chunk of clientReq) chunks.push(chunk)
+        bufferedBody = Buffer.concat(chunks)
+      } catch (e) {
+        // client disconnected mid-read; bail out early.
+        if (!clientRes.headersSent) {
+          clientRes.writeHead(400, { 'content-type': 'text/plain' })
+          clientRes.end('client disconnected while uploading body: ' + (e && e.message))
+        }
+        return
+      }
+    }
+    // Shadow `clientReq` with a wrapper that yields a fresh Readable body
+    // stream each time `.pipe()` is called. This keeps the rest of the
+    // handler unchanged (node-proxy + direct-fallback both still use
+    // `clientReq.pipe(upstream)`).
+    const { Readable } = require('stream')
+    const makeBodyStream = () => {
+      if (bufferedBody === null) return null
+      const r = new Readable({ read() {} })
+      r.push(bufferedBody)
+      r.push(null)
+      return r
+    }
+    const originalClientReq = clientReq
+    clientReq = new Proxy(originalClientReq, {
+      get(target, prop, receiver) {
+        if (prop === 'pipe') {
+          return (dest, opts) => {
+            const s = makeBodyStream()
+            if (!s) {
+              // GET/HEAD — just end the dest
+              if (dest && typeof dest.end === 'function') dest.end()
+              return dest
+            }
+            return s.pipe(dest, opts)
+          }
+        }
+        return Reflect.get(target, prop, receiver)
+      },
+    })
+
     const doForward = async (lease, attempt) => {
       const config = readConfig(configPath)
       const nodeProxyUrl = deriveNodeProxyUrl(lease)