@simonyea/holysheep-cli 2.1.27 → 2.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "2.1.27",
+  "version": "2.1.29",
   "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 })
@@ -130,8 +305,30 @@ module.exports = {
     return isConfiguredInToml(readConfig())
   },
   configure(apiKey, _baseUrlAnthropic, baseUrlOpenAI, primaryModel /*, _selectedModels */) {
-    const merged = mergeConfig(apiKey, baseUrlOpenAI, primaryModel)
+    // [HolySheep fork v2.1.29 / hs22] Hermes talks to its provider via the
+    // OpenAI-compatible Chat Completions API (`/v1/chat/completions`), which
+    // the HolySheep CRS relay does NOT support for `claude-*` model IDs at
+    // the moment (returns 503 "Service temporarily unavailable"). Only the
+    // anthropic native `/v1/messages` path accepts Claude. GPT-family models
+    // work on both paths.
+    //
+    // To give users a usable hermes out of the box we pick a safe default
+    // here: if the caller passes a `claude-*` model, silently downgrade to
+    // gpt-5.4 (HolySheep's default GPT model) for hermes only. The TOML
+    // keeps the real choice so `hermes --provider holysheep --model claude-*`
+    // still works if the user overrides it later (and CRS fixes the upstream).
+    const hermesPrimaryModel = /^claude-/i.test(primaryModel || '') ? 'gpt-5.4' : (primaryModel || 'gpt-5.4')
+    const merged = mergeConfig(apiKey, baseUrlOpenAI, hermesPrimaryModel)
     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, hermesPrimaryModel)
+    } 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/pty-hermes-wrapper.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-[HolySheep fork v2.1.25 / hs19] Hermes ACP PTY wrapper.
+[HolySheep fork v2.1.29 / hs22] Hermes ACP PTY wrapper.
 
 Why: bun 1.3.9's subprocess.spawn with stdio:['pipe','pipe','pipe']
 passes sockets to the child. Python's asyncio.connect_write_pipe()
@@ -13,9 +13,22 @@ captures Python tracebacks separately. Master side pumps bytes between
 our (bun-spawned) stdin/stdout and the PTY, so bun reads through kernel
 PTY buffer which hermes's asyncio transport drives correctly.
 
-Disable ECHO on slave so stdin bytes are not echoed back as stdout bytes
-(the old BSD `script -q /dev/null` wrapper had this bug).
-Disable ONLCR so '\\n' is not rewritten to '\\r\\n'.
+CRITICAL: disable ICANON (canonical/line-buffered mode) on the slave.
+Default macOS/Linux PTY slaves have ICANON on, which means:
+  1. Input is buffered line-by-line and each line is capped at MAX_CANON
+     (1024B on macOS, ~4096B on Linux). Longer lines get truncated.
+  2. Special chars (^C, ^D, ^Z, erase/kill) are interpreted instead of
+     passed through — breaks JSON containing random bytes.
+
+ACP session/prompt JSON can exceed 4KB easily (system prompt + skill
+list + assistant rules). Before hs22 we only disabled ECHO + ONLCR, so
+id=1 (initialize, ~150B) and id=2/3 (newSession, setSessionMode, <400B)
+went through, but id=4 (prompt, ~4-8KB) was truncated by MAX_CANON —
+hermes got invalid JSON, returned an SDK error with empty data, our
+AcpAgentManager 60s fallback masked it. User saw "hermes thinks forever".
+
+Also disable ICRNL and IXON so we don't have \\r<->\\n rewriting or
+flow-control pauses on large bursts.
 
 Usage: python3 pty-hermes-wrapper.py
 HERMES_BIN is auto-resolved from $PATH; override via $HOLYSHEEP_HERMES_BIN.
@@ -39,9 +52,30 @@ def main() -> None:
     hermes_bin = _resolve_hermes_bin()
     master_fd, slave_fd = pty.openpty()
     attrs = termios.tcgetattr(slave_fd)
-    attrs[3] &= ~termios.ECHO
-    attrs[1] &= ~termios.ONLCR
+    # attrs = [iflag, oflag, cflag, lflag, ispeed, ospeed, cc]
+    # lflag (attrs[3]): disable canonical-mode line buffering, ECHO*, signal chars
+    attrs[3] &= ~(termios.ICANON | termios.ECHO | termios.ECHOE | termios.ECHOK
+                  | termios.ECHONL | termios.ISIG)
+    # iflag (attrs[0]): disable \r<->\n translation, XON/XOFF flow control,
+    # and parity checking (we carry raw bytes only).
+    attrs[0] &= ~(termios.ICRNL | termios.INLCR | termios.IGNCR | termios.IXON
+                  | termios.IXOFF | termios.ISTRIP | termios.IGNBRK | termios.BRKINT
+                  | termios.INPCK | termios.PARMRK)
+    # oflag (attrs[1]): disable post-processing (ONLCR \n -> \r\n, tabs, etc.)
+    attrs[1] &= ~termios.OPOST
+    # Non-blocking reads: return as soon as 1 byte is available.
+    attrs[6][termios.VMIN] = 1
+    attrs[6][termios.VTIME] = 0
     termios.tcsetattr(slave_fd, termios.TCSANOW, attrs)
+    # Best-effort: print the applied flags once so future regressions are
+    # easy to diagnose from hs web logs.
+    try:
+        sys.stderr.write(
+            f'[pty-hermes-wrapper] slave configured raw: ICANON off, ECHO off, OPOST off\n'
+        )
+        sys.stderr.flush()
+    except OSError:
+        pass
 
     pid = os.fork()
     if pid == 0:
@@ -103,9 +137,28 @@ def main() -> None:
                     except ProcessLookupError:
                         pass
                     break
-                try:
-                    os.write(master_fd, data)
-                except OSError:
+                # [HolySheep fork v2.1.29 / hs22] Diagnostic trace when enabled —
+                # emits one line per stdin chunk so we can see exactly what bun
+                # pushed to us and verify hermes received the full payload. Only
+                # active when HOLYSHEEP_PTY_TRACE=1 is set to avoid log flood.
+                if os.environ.get('HOLYSHEEP_PTY_TRACE') == '1':
+                    try:
+                        sys.stderr.write(f'[pty-hermes-wrapper] stdin chunk len={len(data)}\n')
+                        sys.stderr.flush()
+                    except OSError:
+                        pass
+                # Write in full — os.write may short-write on large buffers; loop.
+                total = 0
+                while total < len(data):
+                    try:
+                        n = os.write(master_fd, data[total:])
+                    except OSError:
+                        total = -1
+                        break
+                    if n <= 0:
+                        break
+                    total += n
+                if total < 0:
                     break
     finally:
         try:

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-hs20.tar.gz'
+  'https://mail.holysheep.ai/app/cli/aionui-runtime-v1.9.18-holysheep-hs22.tar.gz'
 const DEFAULT_RUNTIME_SHA256 =
-  '99ddb768cacd223a13c77d716413032e913c8be2850e7dbccaf7ae52d0797e37'
-const DEFAULT_RUNTIME_VERSION = '1.9.18-holysheep-hs20'
+  '03e386ea83660b4074e29026dfc53be6ed01fcd51fa35a9379ed64a396e99f33'
+const DEFAULT_RUNTIME_VERSION = '1.9.18-holysheep-hs22'
 
 function isValidRuntimeDir(dir) {
   if (!dir) return false