@simonyea/holysheep-cli 2.1.27 → 2.1.28

package/package.json

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