@simonyea/holysheep-cli 2.1.37 → 2.1.40

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "2.1.37",
-  "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.",
+  "version": "2.1.40",
+  "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.",
   "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 && node tests/opencode-auth-purge.test.js && node tests/shell-winpath.test.js",
+    "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 && node tests/opencode-auth-purge.test.js && node tests/shell-winpath.test.js && node tests/openclaw-atomic-write.test.js",
     "prepublishOnly": "node scripts/check-tarball-size.js"
   },
   "keywords": [

package/src/tools/openclaw.js

@@ -25,6 +25,96 @@ const OPENCLAW_DEFAULT_CLAUDE_MODEL = 'claude-sonnet-4-6'
 const OPENCLAW_DEFAULT_MINIMAX_MODEL = 'MiniMax-M2.7-highspeed'
 const OPENCLAW_PROVIDER_NAME = 'holysheep'
 
+/**
+ * [HolySheep fork v2.1.38 / hs26] Atomic JSON write.
+ *
+ * Background: `~/.openclaw/` accumulated 30+ `openclaw.json.clobbered.*`
+ * backup files (mtime span hours apart, content identical) — OpenClaw's
+ * own config layer detected that two processes raced `writeFileSync`
+ * against the same path and renamed the half-written file aside to avoid
+ * corruption. Each race produced a backup.
+ *
+ * Root cause: `fs.writeFileSync(path, data)` is NOT atomic — it opens +
+ * truncates + writes; a concurrent reader/writer can observe a partial
+ * file or overwrite between truncation and final bytes. POSIX
+ * `rename(tmp, final)` IS atomic on the same filesystem, so we:
+ *   1. Write to `${final}.tmp.${pid}.${rand}`
+ *   2. `fs.renameSync(tmp, final)`
+ * Windows: `rename` fails if target exists → retry via copyFile + unlink.
+ *
+ * Never leaves the final path in a half-written state. If two procs race,
+ * one's write wins atomically and the other's wins the next one; no
+ * .clobbered.* files get produced by OpenClaw.
+ */
+function atomicWriteJson(filePath, data) {
+  const dir = path.dirname(filePath)
+  fs.mkdirSync(dir, { recursive: true })
+  const body = JSON.stringify(data, null, 2)
+  const tmp = `${filePath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 10)}`
+  fs.writeFileSync(tmp, body, 'utf8')
+  try {
+    fs.renameSync(tmp, filePath)
+    return
+  } catch (renameErr) {
+    // Windows: rename fails if target exists. Fall back to copy+unlink.
+    // Also handles cross-device rename (EXDEV) in edge cases.
+    if (process.platform === 'win32' || renameErr.code === 'EXDEV' || renameErr.code === 'EEXIST') {
+      try {
+        fs.copyFileSync(tmp, filePath)
+        try { fs.unlinkSync(tmp) } catch {}
+        return
+      } catch (copyErr) {
+        try { fs.unlinkSync(tmp) } catch {}
+        throw copyErr
+      }
+    }
+    try { fs.unlinkSync(tmp) } catch {}
+    throw renameErr
+  }
+}
+
+/**
+ * [HolySheep fork v2.1.38 / hs26] Prune stale OpenClaw config backup files.
+ *
+ * Removes `~/.openclaw/openclaw.json.clobbered.*` older than 7 days. These
+ * are produced by OpenClaw itself when a racy `writeFileSync` is detected,
+ * but once our atomicWriteJson is in place no new ones should appear — this
+ * cleanup just garbage-collects the historical accumulation without touching
+ * `*.last-good` / `*.bak` / `*.pre-*` which users or other tooling may need.
+ *
+ * Safe: scoped to ONLY the exact glob `openclaw.json.clobbered.*` in the
+ * known OpenClaw dir. No-op if dir doesn't exist or user has no matching
+ * files. Best-effort (each unlink wrapped in try) so a single locked file
+ * won't block the rest of configure().
+ */
+function pruneClobberedBackups(maxAgeMs = 7 * 24 * 3600 * 1000) {
+  try {
+    if (!fs.existsSync(OPENCLAW_DIR)) return { scanned: 0, removed: 0 }
+    const entries = fs.readdirSync(OPENCLAW_DIR)
+    const cutoff = Date.now() - maxAgeMs
+    let scanned = 0
+    let removed = 0
+    for (const name of entries) {
+      if (!/^openclaw\.json\.clobbered\./.test(name)) continue
+      scanned++
+      const abs = path.join(OPENCLAW_DIR, name)
+      try {
+        const st = fs.statSync(abs)
+        if (st.mtimeMs < cutoff) {
+          fs.unlinkSync(abs)
+          removed++
+        }
+      } catch {
+        // locked / race — skip
+      }
+    }
+    return { scanned, removed }
+  } catch {
+    return { scanned: 0, removed: 0 }
+  }
+}
+
+
 function getOpenClawBinaryCandidates() {
   return isWin ? ['openclaw.cmd', 'openclaw'] : ['openclaw']
 }
@@ -161,8 +251,8 @@ function readBridgeConfig() {
 }
 
 function writeBridgeConfig(data) {
-  fs.mkdirSync(OPENCLAW_DIR, { recursive: true })
-  fs.writeFileSync(BRIDGE_CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8')
+  // [HolySheep fork v2.1.38 / hs26] Atomic write — see atomicWriteJson.
+  atomicWriteJson(BRIDGE_CONFIG_FILE, data)
 }
 
 function updateBridgeConfig(patch) {
@@ -521,7 +611,9 @@ function writeManagedConfig(baseConfig, bridgeBaseUrl, apiKey, primaryModel, sel
     },
   }
 
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(nextConfig, null, 2), 'utf8')
+  // [HolySheep fork v2.1.38 / hs26] Atomic write — prevents the
+  // openclaw.json.clobbered.* pile-up from racing writeFileSync.
+  atomicWriteJson(CONFIG_FILE, nextConfig)
   return plan
 }
 
@@ -621,6 +713,17 @@ module.exports = {
     const chalk = require('chalk')
     console.log(chalk.gray('\n  ⚙️  正在配置 OpenClaw...'))
 
+    // [HolySheep fork v2.1.38 / hs26] Garbage-collect stale OpenClaw
+    // backup files from pre-atomic-write builds. Scoped to exact glob
+    // `openclaw.json.clobbered.*` older than 7 days — leaves .last-good
+    // and .bak files alone.
+    try {
+      const pruned = pruneClobberedBackups()
+      if (pruned.removed > 0) {
+        console.log(chalk.gray(`  → 已清理 ${pruned.removed} 个过期的 OpenClaw 配置备份（>7 天的 .clobbered.* 文件）`))
+      }
+    } catch {}
+
     const runtime = detectRuntime()
     if (!runtime.available) {
       throw new Error('未检测到 OpenClaw；请先全局安装，或确保 npx 可用')
@@ -816,4 +919,7 @@ module.exports = {
   },
   installCmd: 'npm install -g openclaw@latest',
   docsUrl: 'https://docs.openclaw.ai',
+  // [HolySheep fork v2.1.38 / hs26] Test-only exports.
+  _atomicWriteJson: atomicWriteJson,
+  _pruneClobberedBackups: pruneClobberedBackups,
 }

package/src/utils/which.js

@@ -1,7 +1,30 @@
 /**
  * 跨平台检测命令是否存在
  * Windows 用 where，Unix 用 which，兜底用 --version
+ *
+ * [HolySheep fork v2.1.40 / hs27] Windows-specific fallbacks.
+ *
+ * Background: some installers (notably Claude Code's Windows installer
+ * irm https://claude.ai/install.ps1 | iex) drop their binary into
+ * `%USERPROFILE%\.local\bin\` and print a warning that this directory
+ * is NOT on PATH. The *current* Node process started by hs web has a
+ * frozen process.env.PATH snapshot, so even after
+ * ensureWindowsUserPathHasLocalBin() persists the User PATH in the
+ * registry, `where claude` still reports "not found" until the next
+ * terminal is opened. The UI then shows 未安装 despite a successful
+ * install.
+ *
+ * Fix strategy (Windows only):
+ *   1. Enumerate known install locations as a fallback AFTER `where` fails:
+ *        %USERPROFILE%\.local\bin\<cmd>.exe     (Claude official installer)
+ *        %APPDATA%\npm\<cmd>.cmd                (npm global bin)
+ *        %LOCALAPPDATA%\Programs\<cmd>\<cmd>.exe
+ *        %LOCALAPPDATA%\<cmd>\<cmd>.exe
+ *   2. Also re-read the USER-level PATH from the registry via PowerShell
+ *      so we catch updates that landed after this process started.
  */
+const path = require('path')
+const fs = require('fs')
 const { exec, execSync } = require('child_process')
 
 function canRun(command, options = {}) {
@@ -13,6 +36,82 @@ function canRun(command, options = {}) {
   }
 }
 
+function canRunAsync(command, options = {}) {
+  return new Promise((resolve) => {
+    exec(command, { timeout: 3000, windowsHide: true, ...options }, (error) => {
+      resolve(!error)
+    })
+  })
+}
+
+// [HolySheep fork v2.1.40 / hs27]
+// Known absolute install locations per-CLI on Windows. Checked AFTER
+// PATH lookup fails but BEFORE we report "not found". Keeping this list
+// small on purpose — only locations that official installers actually use.
+function getWindowsKnownPaths(cmd) {
+  if (process.platform !== 'win32') return []
+  const home = process.env.USERPROFILE || process.env.HOME || ''
+  const appData = process.env.APPDATA || ''
+  const localAppData = process.env.LOCALAPPDATA || ''
+  const paths = []
+  // Claude official installer → %USERPROFILE%\.local\bin\claude.exe
+  if (home) paths.push(path.join(home, '.local', 'bin', `${cmd}.exe`))
+  // npm global → %APPDATA%\npm\<cmd>.{cmd,exe,ps1}
+  if (appData) {
+    paths.push(path.join(appData, 'npm', `${cmd}.cmd`))
+    paths.push(path.join(appData, 'npm', `${cmd}.exe`))
+  }
+  // Programs directories → %LOCALAPPDATA%\Programs\<cmd>\<cmd>.exe
+  if (localAppData) {
+    paths.push(path.join(localAppData, 'Programs', cmd, `${cmd}.exe`))
+    paths.push(path.join(localAppData, cmd, `${cmd}.exe`))
+    paths.push(path.join(localAppData, 'factory', `${cmd}.exe`)) // droid
+  }
+  return paths
+}
+
+function checkKnownPathsSync(cmd) {
+  for (const p of getWindowsKnownPaths(cmd)) {
+    try {
+      if (fs.existsSync(p)) return p
+    } catch {}
+  }
+  return null
+}
+
+// Refresh this process's PATH from the USER-level registry PATH. Cheap — only
+// runs once per commandExists miss. Noop on non-Windows. Guarded by a module
+// flag so we don't run it more than once per short window.
+let _userPathRefreshedAt = 0
+function refreshWindowsUserPath() {
+  if (process.platform !== 'win32') return
+  const now = Date.now()
+  if (now - _userPathRefreshedAt < 5000) return
+  _userPathRefreshedAt = now
+  try {
+    const out = execSync(
+      'powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "[Environment]::GetEnvironmentVariable(\'Path\', \'User\')"',
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }
+    ).trim()
+    if (!out) return
+    const userParts = out.split(';').map((s) => s.trim()).filter(Boolean)
+    const curParts = (process.env.PATH || '').split(';').map((s) => s.trim()).filter(Boolean)
+    const curSet = new Set(curParts.map((s) => s.toLowerCase()))
+    const added = []
+    for (const p of userParts) {
+      if (!curSet.has(p.toLowerCase())) {
+        curParts.push(p)
+        added.push(p)
+      }
+    }
+    if (added.length) {
+      process.env.PATH = curParts.join(';')
+    }
+  } catch {
+    // noop
+  }
+}
+
 function commandExists(cmd) {
   if (process.platform === 'win32') {
     const variants = [cmd, `${cmd}.cmd`, `${cmd}.exe`, `${cmd}.bat`]
@@ -25,6 +124,15 @@ function commandExists(cmd) {
       if (canRun(`cmd /d /s /c "${variant} --version"`, { timeout: 3000 })) return true
     }
 
+    // [HolySheep fork v2.1.40 / hs27] Last-resort: re-read the USER-level
+    // registry PATH (catches recently installed binaries) and check a
+    // handful of known install locations before giving up.
+    refreshWindowsUserPath()
+    for (const variant of variants) {
+      if (canRun(`where ${variant}`)) return true
+    }
+    if (checkKnownPathsSync(cmd)) return true
+
     return false
   }
 
@@ -34,14 +142,6 @@ function commandExists(cmd) {
   return canRun(`${cmd} --version`, { timeout: 3000 })
 }
 
-function canRunAsync(command, options = {}) {
-  return new Promise((resolve) => {
-    exec(command, { timeout: 3000, windowsHide: true, ...options }, (error) => {
-      resolve(!error)
-    })
-  })
-}
-
 async function commandExistsAsync(cmd) {
   if (process.platform === 'win32') {
     const variants = [cmd, `${cmd}.cmd`, `${cmd}.exe`, `${cmd}.bat`]
@@ -53,6 +153,13 @@ async function commandExistsAsync(cmd) {
       if (await canRunAsync(`cmd /d /s /c "${variant} --version"`)) return true
     }
 
+    // [HolySheep fork v2.1.40 / hs27] Last-resort (see commandExists).
+    refreshWindowsUserPath()
+    for (const variant of variants) {
+      if (await canRunAsync(`where ${variant}`)) return true
+    }
+    if (checkKnownPathsSync(cmd)) return true
+
     return false
   }
 
@@ -60,4 +167,10 @@ async function commandExistsAsync(cmd) {
   return canRunAsync(`${cmd} --version`)
 }
 
-module.exports = { commandExists, commandExistsAsync }
+module.exports = {
+  commandExists,
+  commandExistsAsync,
+  // test-only exports
+  _getWindowsKnownPaths: getWindowsKnownPaths,
+  _refreshWindowsUserPath: refreshWindowsUserPath,
+}

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-hs25.tar.gz'
+  'https://mail.holysheep.ai/app/cli/aionui-runtime-v1.9.18-holysheep-hs27.tar.gz'
 const DEFAULT_RUNTIME_SHA256 =
-  '9e2a47adf8a151c9ab6916d046ee9f268aa5f1589a961d1b0374b15508ed527b'
-const DEFAULT_RUNTIME_VERSION = '1.9.18-holysheep-hs25'
+  'de9cb08d071d1254f8e6ad69f249d73d8b1b8fd5c4a07ca6d6009a902e0cccb1'
+const DEFAULT_RUNTIME_VERSION = '1.9.18-holysheep-hs27'
 
 function isValidRuntimeDir(dir) {
   if (!dir) return false

package/src/webui/server.js

@@ -776,6 +776,12 @@ async function handleToolConfigure(req, res) {
   await new Promise((resolve) => {
     child.on('exit', (code) => {
       success = code === 0 && lastResult?.status === 'ok'
+      // [HolySheep fork v2.1.40 / hs27] Bust tool-check cache on success so
+      // CLI Manager's follow-up `/api/holysheep/tools` immediately sees the
+      // refreshed configured/installed state without waiting 10s for TTL.
+      if (success) {
+        toolStateCache.delete(toolId)
+      }
       sseEmit(res, {
         type: 'done',
         success,