@simonyea/holysheep-cli 2.1.26 → 2.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "2.1.26",
+  "version": "2.1.28",
   "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

@@ -220,6 +220,63 @@ function deriveNodeProxyUrl(lease) {
   return upstream.toString().replace(/\/+$/, '')
 }
 
+// [HolySheep fork v2.1.27 / hs20] Direct HTTPS fallback.
+//
+// Background: the assigned node's forward-proxy at :3129 can be unreachable
+// (we've seen node3's proxy offline while node3's /v1/messages at :3101 is
+// up). When that happens, claude-agent-acp spawns get ECONNREFUSED on every
+// prompt and the user sees the generic "Internal error: API Error: 400".
+//
+// Fix: when the node-proxy forward fails with ECONNREFUSED (or the proxy
+// URL itself won't resolve), retry the same request directly against
+// `config.baseUrlAnthropic` (usually https://api.holysheep.ai). We still
+// send the bridge headers — the upstream CRS accepts them and reuses the
+// same lease. This gives users a usable claude path even while HolySheep
+// SRE fixes the assigned node.
+function forwardDirectHttps({ config, lease, clientReq, clientRes, trace }) {
+  const https = require('https')
+  const crsBase = config.baseUrlAnthropic || 'https://api.holysheep.ai'
+  const target = new URL(clientReq.url && clientReq.url.startsWith('http') ? clientReq.url : clientReq.url, crsBase)
+  return new Promise((resolve, reject) => {
+    // [HolySheep fork v2.1.27 / hs20] Sanitize headers before the direct
+    // upstream hit. claude-agent-acp usually runs in a clean env so these
+    // should never be present, but a future client library could set them
+    // (or a proxy earlier in the chain could tag the request) and leak the
+    // loopback origin / real client IP to api.holysheep.ai. The upstream
+    // doesn't need them — it authenticates off bridge headers + API key.
+    const sanitized = { ...clientReq.headers }
+    for (const k of Object.keys(sanitized)) {
+      if (/^x-forwarded-|^x-real-ip$|^forwarded$|^via$/i.test(k)) {
+        delete sanitized[k]
+      }
+    }
+    const headers = {
+      ...sanitized,
+      ...buildAuthHeaders(config, lease),
+      host: target.host,
+      connection: 'close',
+    }
+    const upReq = https.request({
+      hostname: target.hostname,
+      port: target.port || 443,
+      path: target.pathname + target.search,
+      method: clientReq.method,
+      headers,
+      timeout: RESPONSE_TIMEOUT_MS + 5000,
+    }, (upRes) => {
+      clientRes.writeHead(upRes.statusCode, upRes.headers)
+      upRes.pipe(clientRes)
+      upRes.on('end', resolve)
+      upRes.on('error', reject)
+    })
+    upReq.on('error', reject)
+    upReq.on('timeout', () => {
+      upReq.destroy(new Error('direct-https upstream timeout'))
+    })
+    clientReq.pipe(upReq)
+  })
+}
+
 function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, extraHeaders = {}, trace = null }) {
   const upstream = new URL(nodeProxyUrl)
   return new Promise((resolve, reject) => {
@@ -617,6 +674,36 @@ function createProcessProxyServer({ sessionId, configPath = CONFIG_PATH, allowAn
         if (!isRetryableNodeLeaseError(err) && attempt > 0) break
       }
     }
+    // [HolySheep fork v2.1.27 / hs20] Direct HTTPS fallback.
+    // If EVERY node-proxy retry failed with a connection-level error
+    // (ECONNREFUSED, EHOSTUNREACH, ETIMEDOUT, or a generic "Proxy error"
+    // mentioning ECONNREFUSED in the body), fall back to a direct HTTPS
+    // POST against api.holysheep.ai. The relay on that side recognises
+    // bridge headers + cr_ keys and forwards to an account pool even when
+    // the per-device assigned node is dead. Keeps users productive while
+    // SRE re-balances nodes.
+    if (lastError && !clientRes.headersSent) {
+      const msg = String(lastError?.message || lastError?.body || '')
+      const isConnectionLevel = /ECONNREFUSED|EHOSTUNREACH|ETIMEDOUT|ENETUNREACH|connect/i.test(msg)
+      if (isConnectionLevel) {
+        try {
+          const config = readConfig(configPath)
+          const lease = getCachedLease(sessionId) || await fetchFreshLease(config, sessionId, {})
+          logProxyTiming('request.direct-fallback', {
+            sessionId,
+            originalError: msg.slice(0, 160),
+          })
+          await forwardDirectHttps({ config, lease, clientReq, clientRes, trace: null })
+          lastError = null
+        } catch (fallbackErr) {
+          lastError = fallbackErr
+          logProxyTiming('request.direct-fallback.fail', {
+            sessionId,
+            error: String(fallbackErr?.message || fallbackErr),
+          })
+        }
+      }
+    }
     if (lastError && !clientRes.headersSent) {
       const status = Number(lastError.statusCode || 502)
       const body = String(lastError.body || lastError.message || 'Proxy error')

package/src/tools/hermes.js

@@ -24,6 +24,24 @@ const { commandExists } = require('../utils/which')
 
 const CONFIG_DIR = path.join(os.homedir(), '.hermes')
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.toml')
+// [HolySheep fork v2.1.28 / hs21] Hermes's agent runtime (the `hermes acp`
+// process) reads ~/.hermes/config.yaml — NOT config.toml — for `model.base_url`
+// and `providers.*`. The TOML is only used by the hermes CLI wrapper for
+// provider selection; the actual outbound HTTP requests come out of config.yaml.
+//
+// Historically a user or earlier setup script wrote `model.base_url:
+// http://127.0.0.1:18788/v1` into config.yaml (that's the OpenClaw local
+// bridge port). If AionUi is running but the user isn't using OpenClaw,
+// :18788 isn't listening, so every hermes prompt hangs on `provider=custom`
+// connection until the AcpAgentManager fallback fires and fabricates an
+// empty end_turn. User-visible symptom: hermes "thinks forever" then emits
+// no response.
+//
+// Fix: on every hermes.configure(), also rewrite config.yaml's
+// `model.base_url` + api_key + providers.custom to point at HolySheep
+// directly. This is idempotent and preserves every other config.yaml
+// section (toolsets, agent, memory, ...).
+const CONFIG_YAML = path.join(CONFIG_DIR, 'config.yaml')
 
 const PROVIDER_SECTION_RE = /^\[providers\.holysheep\]\s*$([\s\S]*?)(?=^\[|\Z)/m
 const DEFAULT_PROVIDER_RE = /^default_provider\s*=\s*"[^"]*"\s*$/m
@@ -37,6 +55,163 @@ function readConfig() {
   return ''
 }
 
+// [HolySheep fork v2.1.28 / hs21] Minimal YAML patcher for ~/.hermes/config.yaml.
+//
+// We don't want to pull a full YAML dependency into the holysheep-cli bundle,
+// so we do targeted line-level rewrites:
+//   - model.base_url  : overwritten
+//   - model.api_key   : inserted if absent, else overwritten
+//   - model.default   : overwritten (only if primaryModel provided)
+//   - providers       : if currently `{}` or missing, write an explicit
+//                       `custom` provider pointing at HolySheep
+//
+// Everything else in config.yaml (toolsets, agent, memory, summary_*, ...)
+// is preserved verbatim.
+function patchConfigYaml(apiKey, baseUrlOpenAI, primaryModel) {
+  if (!fs.existsSync(CONFIG_YAML)) {
+    // If the user never ran `hermes` (so no config.yaml), do nothing —
+    // hermes creates one on first launch; our next `hs setup` will patch it.
+    return
+  }
+  const cleanBase = String(baseUrlOpenAI || 'https://api.holysheep.ai/v1').replace(/\/+$/, '')
+  const model = primaryModel || 'claude-sonnet-4-6'
+  const src = fs.readFileSync(CONFIG_YAML, 'utf8')
+  const lines = src.replace(/\r\n/g, '\n').split('\n')
+  const out = []
+  let inModel = false
+  let modelBlockLines = []
+  let modelIndent = '  '
+  let modelBlockStart = -1
+  // First pass: find model: block
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (/^model:\s*$/.test(line)) {
+      out.push(line)
+      inModel = true
+      modelBlockStart = out.length
+      modelBlockLines = []
+      continue
+    }
+    if (inModel) {
+      // Model section ends at next top-level key (non-indented non-blank) or EOF
+      if (line.length > 0 && !/^\s/.test(line)) {
+        // finalize model block first
+        out.push(...rewriteModelBlock(modelBlockLines, cleanBase, apiKey, model, modelIndent))
+        inModel = false
+        out.push(line)
+        continue
+      }
+      modelBlockLines.push(line)
+      // detect indent from first key-line
+      const m = line.match(/^(\s+)[^\s]/)
+      if (m && modelBlockLines.length === 1) modelIndent = m[1]
+      continue
+    }
+    out.push(line)
+  }
+  if (inModel) {
+    // File ended inside model block
+    out.push(...rewriteModelBlock(modelBlockLines, cleanBase, apiKey, model, modelIndent))
+  }
+  // Second pass: rewrite the `providers:` block so `custom` always points
+  // at HolySheep. We locate the block by line offset so we can replace the
+  // entire block regardless of whether it's inline `{}`, empty, or a
+  // pre-existing nested map (which would otherwise duplicate `custom:`).
+  const resultLines = out.join('\n').split('\n')
+  const providersBlock = [
+    'providers:',
+    '  custom:',
+    `    base_url: ${cleanBase}`,
+    `    api_key: ${apiKey}`,
+    `    default_model: ${model}`,
+    '    type: openai',
+  ]
+  let start = -1, end = -1
+  for (let i = 0; i < resultLines.length; i++) {
+    if (/^providers:\s*($|\{\s*\}\s*$)/.test(resultLines[i])) { start = i; break }
+  }
+  if (start >= 0) {
+    // Find end = next top-level key or EOF (preserve whitespace-only lines inside)
+    end = resultLines.length
+    for (let j = start + 1; j < resultLines.length; j++) {
+      const ln = resultLines[j]
+      if (ln.length > 0 && !/^\s/.test(ln)) { end = j; break }
+    }
+    resultLines.splice(start, end - start, ...providersBlock)
+  }
+  // Third pass: hermes 0.8 also has a `custom_providers:` LIST (different
+  // from the `providers:` map). Line-by-line patch each item's base_url/api_key
+  // whose `name:` includes "holysheep" (case-insensitive) or whose base_url
+  // pointed at the stale OpenClaw bridge :18788.
+  const finalLines = resultLines.slice()
+  let inCustom = false
+  let itemStart = -1
+  let itemLines = []
+  const flushItem = () => {
+    if (itemStart < 0) return
+    const blob = itemLines.join('\n')
+    const isHolySheep = /name:\s*holysheep/i.test(blob) || /base_url:\s*http:\/\/127\.0\.0\.1:18788/.test(blob)
+    if (isHolySheep) {
+      for (let i = 0; i < itemLines.length; i++) {
+        if (/^\s+-?\s*base_url:/.test(itemLines[i])) {
+          itemLines[i] = itemLines[i].replace(/base_url:.*$/, `base_url: ${cleanBase}`)
+        } else if (/^\s+api_key:/.test(itemLines[i])) {
+          itemLines[i] = itemLines[i].replace(/api_key:.*$/, `api_key: ${apiKey}`)
+        }
+      }
+      finalLines.splice(itemStart, itemLines.length, ...itemLines)
+    }
+    itemStart = -1
+    itemLines = []
+  }
+  for (let i = 0; i < finalLines.length; i++) {
+    const ln = finalLines[i]
+    if (/^custom_providers:\s*$/.test(ln)) { inCustom = true; continue }
+    if (inCustom) {
+      // End of custom_providers: next top-level key (non-dash, non-indent, non-blank)
+      if (ln.length > 0 && !/^\s/.test(ln) && !/^-/.test(ln)) { flushItem(); inCustom = false; continue }
+      // New list item starts with dash at any indentation
+      if (/^\s*-\s/.test(ln)) { flushItem(); itemStart = i; itemLines = [ln]; continue }
+      if (itemStart >= 0) itemLines.push(ln)
+    }
+  }
+  if (inCustom) flushItem()
+  fs.writeFileSync(CONFIG_YAML, finalLines.join('\n'), { encoding: 'utf8', mode: 0o600 })
+}
+
+function rewriteModelBlock(blockLines, cleanBase, apiKey, model, indent) {
+  let sawBase = false, sawKey = false, sawDefault = false
+  const rewritten = []
+  for (const line of blockLines) {
+    if (/^\s*base_url\s*:/.test(line)) {
+      rewritten.push(`${indent}base_url: ${cleanBase}`)
+      sawBase = true
+      continue
+    }
+    if (/^\s*api_key\s*:/.test(line)) {
+      rewritten.push(`${indent}api_key: ${apiKey}`)
+      sawKey = true
+      continue
+    }
+    if (/^\s*default\s*:/.test(line)) {
+      rewritten.push(`${indent}default: ${model}`)
+      sawDefault = true
+      continue
+    }
+    rewritten.push(line)
+  }
+  // Append missing keys at the end of the model block
+  // (preserve trailing blank line if present)
+  let insertAt = rewritten.length
+  while (insertAt > 0 && rewritten[insertAt - 1].trim() === '') insertAt--
+  const toInsert = []
+  if (!sawBase) toInsert.push(`${indent}base_url: ${cleanBase}`)
+  if (!sawKey) toInsert.push(`${indent}api_key: ${apiKey}`)
+  if (!sawDefault) toInsert.push(`${indent}default: ${model}`)
+  if (toInsert.length) rewritten.splice(insertAt, 0, ...toInsert)
+  return rewritten
+}
+
 function writeConfig(content) {
   if (!fs.existsSync(CONFIG_DIR)) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 })
@@ -132,6 +307,15 @@ module.exports = {
   configure(apiKey, _baseUrlAnthropic, baseUrlOpenAI, primaryModel /*, _selectedModels */) {
     const merged = mergeConfig(apiKey, baseUrlOpenAI, primaryModel)
     writeConfig(merged)
+    // [HolySheep fork v2.1.28 / hs21] Also patch config.yaml so the actual
+    // agent runtime uses the right base_url. See CONFIG_YAML comment.
+    try {
+      patchConfigYaml(apiKey, baseUrlOpenAI, primaryModel)
+    } catch (e) {
+      // Non-fatal: hermes can still run on config.toml alone if the user
+      // manually edits config.yaml. Surface via stderr for diagnosability.
+      try { process.stderr.write(`[hermes.configure] config.yaml patch skipped: ${e.message}\n`) } catch {}
+    }
     return {
       file: CONFIG_FILE,
       hot: true, // next `hermes` run picks up the TOML on load

package/src/tools/opencode.js

@@ -109,6 +109,28 @@ module.exports = {
     // 设置默认模型
     config.model = `anthropic/${primaryModel || 'claude-sonnet-4-6'}`
 
+    // [HolySheep fork v2.1.27 / hs20] Disable the giant OpenCode tools that
+    // blow the Anthropic request body past ~25 KB. When bodies exceed ~40 KB
+    // against the HolySheep relay, Anthropic returns a plan-limit error:
+    //   "Third-party apps now draw from your extra usage, not your plan limits"
+    // which OpenCode surfaces as a silent `stop_reason: end_turn` with
+    // zero tokens (class-C failure). Removing just the biggest schemas
+    // (todowrite ~8.8 KB, task ~4.4 KB, webfetch/skill smaller) brings
+    // bodies below the threshold while keeping bash/read/glob/grep/edit/write
+    // which are the core coding tools users actually need.
+    //
+    // Users who want these tools back can set HOLYSHEEP_OPENCODE_KEEP_ALL_TOOLS=1
+    // in their shell, or manually remove the entries from opencode.json.
+    if (!process.env.HOLYSHEEP_OPENCODE_KEEP_ALL_TOOLS) {
+      const tools = { ...(config.tools || {}) }
+      if (tools.todowrite === undefined) tools.todowrite = false
+      if (tools.todoread === undefined) tools.todoread = false
+      if (tools.task === undefined) tools.task = false
+      if (tools.skill === undefined) tools.skill = false
+      if (tools.webfetch === undefined) tools.webfetch = false
+      config.tools = tools
+    }
+
     writeConfig(config)
     return { file: getConfigFile(), hot: false }
   },

package/src/webui/aionui-runtime-fetcher.js

@@ -60,10 +60,10 @@ const VENDOR_DIR = path.join(__dirname, 'vendor', 'aionui')
 // new CLI release, the next `hs web` invocation on user machines will detect
 // the version drift and upgrade the cache in place.
 const DEFAULT_RUNTIME_URL =
-  'https://mail.holysheep.ai/app/cli/aionui-runtime-v1.9.18-holysheep-hs19.tar.gz'
+  'https://mail.holysheep.ai/app/cli/aionui-runtime-v1.9.18-holysheep-hs20.tar.gz'
 const DEFAULT_RUNTIME_SHA256 =
-  '9c41c88dfcf1a836d61a5322d748e02653953b087323b7a9766b8d1459170d13'
-const DEFAULT_RUNTIME_VERSION = '1.9.18-holysheep-hs19'
+  '99ddb768cacd223a13c77d716413032e913c8be2850e7dbccaf7ae52d0797e37'
+const DEFAULT_RUNTIME_VERSION = '1.9.18-holysheep-hs20'
 
 function isValidRuntimeDir(dir) {
   if (!dir) return false