yymaxapi 1.0.116 → 1.0.118

package/bin/yymaxapi.js

@@ -74,11 +74,15 @@ if (!process.__yymaxapiWarningFilterInstalled && typeof process.emitWarning ===
 const DEFAULT_ENDPOINTS = [
   {
     "name": "默认主节点",
-    "url": "https://yunyi.cfd"
+    "url": "https://yunyi.yun"
   },
   {
-    "name": "CF国外节点1",
-    "url": "https://cdn2.yunyi.cfd"
+    "name": "CDN节点1",
+    "url": "https://cdn1.yunyi.yun"
+  },
+  {
+    "name": "CDN节点2",
+    "url": "https://cdn2.yunyi.yun"
   }
 ];
 
@@ -849,9 +853,29 @@ function buildPosixAuthCandidates(baseDirs) {
   return auths;
 }
 
-function findExistingWslFile(candidates = []) {
+function formatWslArg(value) {
+  const str = String(value || '');
+  return /^[A-Za-z0-9_.:-]+$/.test(str) ? str : shellQuote(str);
+}
+
+function buildWslCommand(command, target = {}) {
+  const parts = ['wsl'];
+  const distro = String(target.distro || target.wslDistro || '').trim();
+  const user = String(target.user || target.wslUser || '').trim();
+  if (distro) parts.push('-d', formatWslArg(distro));
+  if (user) parts.push('-u', formatWslArg(user));
+  parts.push('--', 'bash', target.login ? '-lc' : '-c', shellQuote(command));
+  return parts.join(' ');
+}
+
+function runWslCommand(command, options = {}, target = {}) {
+  return safeExec(buildWslCommand(command, target), options);
+}
+
+function findExistingWslFile(candidates = [], target = {}) {
   for (const candidate of candidates) {
-    const check = safeExec(`wsl -- bash -c "test -f '${candidate}' && echo yes"`, { timeout: 5000 });
+    const quotedCandidate = `'${escapeSingleQuotedShell(candidate)}'`;
+    const check = runWslCommand(`test -f ${quotedCandidate} && echo yes`, { timeout: 5000 }, target);
     if (check.ok && check.output.trim() === 'yes') {
       return candidate;
     }
@@ -1312,7 +1336,7 @@ function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id
   const configPath = path.join(dataDir, 'config.yaml');
   const envPath = getHermesEnvPath();
   const existingConfigPath = getHermesConfigPath();
-  const wslMirror = getHermesWslMirrorInfo();
+  const wslMirror = getHermesWslMirrorInfo(options);
   const modelType = options.type || options.provider || '';
   const resolvedType = resolveHermesModelType(modelId, modelType);
   const runtimeProvider = resolvedType === 'codex' ? 'custom' : 'anthropic';
@@ -1320,12 +1344,12 @@ function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id
 
   let existingConfigRaw = readTextIfExists(existingConfigPath);
   if (!existingConfigRaw && wslMirror.sourceConfigPath) {
-    existingConfigRaw = readWslTextFile(wslMirror.sourceConfigPath);
+    existingConfigRaw = readWslTextFile(wslMirror.sourceConfigPath, wslMirror.target);
   }
 
   let existingEnvRaw = readTextIfExists(envPath);
   if (!existingEnvRaw && wslMirror.envPath) {
-    existingEnvRaw = readWslTextFile(wslMirror.envPath);
+    existingEnvRaw = readWslTextFile(wslMirror.envPath, wslMirror.target);
   }
 
   const normalizedBaseUrl = (
@@ -1353,10 +1377,10 @@ function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id
   fs.writeFileSync(envPath, nextEnvRaw, 'utf8');
 
   if (wslMirror.configPath) {
-    try { syncFileToWsl(configPath, wslMirror.configPath); } catch { /* best-effort */ }
+    try { syncFileToWsl(configPath, wslMirror.configPath, wslMirror.target); } catch { /* best-effort */ }
   }
   if (wslMirror.envPath) {
-    try { syncFileToWsl(envPath, wslMirror.envPath); } catch { /* best-effort */ }
+    try { syncFileToWsl(envPath, wslMirror.envPath, wslMirror.target); } catch { /* best-effort */ }
   }
 
   return {
@@ -1365,6 +1389,8 @@ function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id
     envPath,
     wslConfigPath: wslMirror.configPath,
     wslEnvPath: wslMirror.envPath,
+    wslUser: wslMirror.target?.user || '',
+    wslDistro: wslMirror.target?.distro || '',
     modelId,
     modelType: resolvedType,
     provider: runtimeProvider,
@@ -1629,12 +1655,18 @@ function isWslAvailable() {
   return _wslAvailCache;
 }
 
-function getWslHome() {
-  if (_wslHomeCache !== undefined) return _wslHomeCache;
+function getWslHome(target = {}) {
+  const hasTarget = !!String(target.user || target.wslUser || target.distro || target.wslDistro || '').trim();
+  if (!hasTarget && _wslHomeCache !== undefined) return _wslHomeCache;
   try {
-    _wslHomeCache = execFileSync('wsl', ['bash', '-c', 'echo $HOME'], { encoding: 'utf8', timeout: 5000, stdio: 'pipe' }).trim() || null;
-  } catch { _wslHomeCache = null; }
-  return _wslHomeCache;
+    const result = runWslCommand('echo $HOME', { timeout: 5000 }, target);
+    const home = result.ok ? (result.output || '').trim() || null : null;
+    if (!hasTarget) _wslHomeCache = home;
+    return home;
+  } catch {
+    if (!hasTarget) _wslHomeCache = null;
+    return null;
+  }
 }
 
 // 获取 WSL 内 openclaw CLI 的完整路径（缓存）
@@ -3191,13 +3223,19 @@ function toWslMountPath(windowsPath) {
   return `/mnt/${match[1].toLowerCase()}/${match[2]}`;
 }
 
-function syncFileToWsl(windowsPath, wslDestPath) {
+function syncFileToWsl(windowsPath, wslDestPath, target = {}) {
   if (process.platform !== 'win32' || !wslDestPath) return false;
   const wslSrc = toWslMountPath(windowsPath);
   if (!wslSrc) return false;
 
   const wslDir = path.posix.dirname(wslDestPath);
-  execFileSync('wsl', ['bash', '-lc', `mkdir -p ${shellQuote(wslDir)} && cp ${shellQuote(wslSrc)} ${shellQuote(wslDestPath)}`], {
+  const args = [];
+  const distro = String(target.distro || target.wslDistro || '').trim();
+  const user = String(target.user || target.wslUser || '').trim();
+  if (distro) args.push('-d', distro);
+  if (user) args.push('-u', user);
+  args.push('--', 'bash', '-lc', `mkdir -p ${shellQuote(wslDir)} && cp ${shellQuote(wslSrc)} ${shellQuote(wslDestPath)}`);
+  execFileSync('wsl', args, {
     timeout: 10000,
     stdio: 'pipe'
   });
@@ -3738,35 +3776,124 @@ function getHermesEnvPath() {
   return path.join(getHermesDataDir(), '.env');
 }
 
-function getHermesWslMirrorInfo() {
+function normalizeHermesWslOptions(options = {}) {
+  return {
+    user: String(options.wslUser || options['wsl-user'] || '').trim(),
+    distro: String(options.wslDistro || options['wsl-distro'] || '').trim(),
+    hermesHome: String(options.hermesHome || options['hermes-home'] || options.hermesDataDir || '').trim()
+  };
+}
+
+function hasWslFile(filePath, target = {}) {
+  if (!filePath) return false;
+  const quoted = `'${escapeSingleQuotedShell(filePath)}'`;
+  const result = runWslCommand(`test -f ${quoted} && echo yes`, { timeout: 5000 }, target);
+  return result.ok && (result.output || '').trim() === 'yes';
+}
+
+function hasWslDir(dirPath, target = {}) {
+  if (!dirPath) return false;
+  const quoted = `'${escapeSingleQuotedShell(dirPath)}'`;
+  const result = runWslCommand(`test -d ${quoted} && echo yes`, { timeout: 5000 }, target);
+  return result.ok && (result.output || '').trim() === 'yes';
+}
+
+function probeHermesWslCommand(target = {}) {
+  const result = runWslCommand(
+    'command -v hermes 2>/dev/null || { test -x "$HOME/.local/bin/hermes" && echo "$HOME/.local/bin/hermes"; } || true',
+    { timeout: 5000 },
+    target
+  );
+  return result.ok ? (result.output || '').trim() : '';
+}
+
+function buildHermesWslCandidate(target = {}, explicitHermesHome = '') {
+  const user = String(target.user || '').trim();
+  const distro = String(target.distro || '').trim();
+  const home = explicitHermesHome
+    ? ''
+    : (getWslHome({ user, distro }) || (user === 'root' ? '/root' : ''));
+  const dataDir = explicitHermesHome || (home ? path.posix.join(home, '.hermes') : '');
+  if (!dataDir) return null;
+  return {
+    target: { user, distro },
+    dataDir,
+    configPath: path.posix.join(dataDir, 'config.yaml'),
+    legacyConfigPath: path.posix.join(dataDir, 'config.yml'),
+    envPath: path.posix.join(dataDir, '.env')
+  };
+}
+
+function scoreHermesWslCandidate(candidate) {
+  if (!candidate) return { score: -1, commandPath: '', sourceConfigPath: null };
+  const commandPath = probeHermesWslCommand(candidate.target);
+  const sourceConfigPath = findExistingWslFile(
+    [candidate.configPath, candidate.legacyConfigPath],
+    candidate.target
+  );
+  let score = 0;
+  if (commandPath) score += 4;
+  if (sourceConfigPath) score += 3;
+  if (hasWslFile(candidate.envPath, candidate.target)) score += 1;
+  if (hasWslDir(candidate.dataDir, candidate.target)) score += 1;
+  return { score, commandPath, sourceConfigPath };
+}
+
+function getHermesWslMirrorInfo(options = {}) {
   if (process.platform !== 'win32' || !isWslAvailable()) {
     return {
       dataDir: null,
       sourceConfigPath: null,
       configPath: null,
-      envPath: null
+      envPath: null,
+      target: null
     };
   }
 
-  const wslHome = getWslHome() || '/root';
-  const dataDir = path.posix.join(wslHome, '.hermes');
-  const sourceConfigPath = findExistingWslFile([
-    path.posix.join(dataDir, 'config.yaml'),
-    path.posix.join(dataDir, 'config.yml')
-  ]);
+  const normalized = normalizeHermesWslOptions(options);
+  const candidates = [];
+  const seen = new Set();
+  const addCandidate = (candidate) => {
+    if (!candidate) return;
+    const key = `${candidate.target.distro}|${candidate.target.user}|${candidate.dataDir}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    candidates.push(candidate);
+  };
+
+  if (normalized.hermesHome || normalized.user || normalized.distro) {
+    addCandidate(buildHermesWslCandidate({
+      user: normalized.user,
+      distro: normalized.distro
+    }, normalized.hermesHome));
+  }
+
+  addCandidate(buildHermesWslCandidate({ distro: normalized.distro }, ''));
+  addCandidate(buildHermesWslCandidate({ user: 'root', distro: normalized.distro }, normalized.hermesHome && !normalized.user ? normalized.hermesHome : ''));
+
+  const scored = candidates
+    .map(candidate => ({ candidate, ...scoreHermesWslCandidate(candidate) }))
+    .sort((a, b) => b.score - a.score);
+  const selected = scored.find(item => item.score > 0) || scored[0];
+  const candidate = selected?.candidate || buildHermesWslCandidate({}, '') || buildHermesWslCandidate({ user: 'root' }, '/root/.hermes');
+  const sourceConfigPath = selected?.sourceConfigPath || findExistingWslFile([
+    candidate.configPath,
+    candidate.legacyConfigPath
+  ], candidate.target);
 
   return {
-    dataDir,
+    dataDir: candidate.dataDir,
     sourceConfigPath,
-    configPath: path.posix.join(dataDir, 'config.yaml'),
-    envPath: path.posix.join(dataDir, '.env')
+    configPath: candidate.configPath,
+    envPath: candidate.envPath,
+    target: candidate.target
   };
 }
 
-function readWslTextFile(filePath) {
+function readWslTextFile(filePath, target = {}) {
   if (process.platform !== 'win32' || !filePath) return '';
   const quoted = shellQuote(filePath);
-  const result = safeExec(`wsl -- bash -lc "cat ${quoted} 2>/dev/null"`, { timeout: 10000 });
+  const result = runWslCommand(`cat ${quoted} 2>/dev/null`, { timeout: 10000 }, target);
   return result.ok ? (result.output || result.stdout || '') : '';
 }
 
@@ -5719,7 +5846,12 @@ async function activateHermes(paths, args = {}) {
   const typeLabel = selectedType === 'codex' ? 'GPT' : 'Claude';
   const hermesBaseUrl = buildFullUrl(selectedEndpoint.url, selectedType === 'codex' ? 'codex' : 'claude');
   const writeSpinner = ora({ text: '正在写入 Hermes 配置...', spinner: 'dots' }).start();
-  const hermesPaths = writeHermesConfig(hermesBaseUrl, apiKey, selectedModel.id, { type: selectedType });
+  const hermesPaths = writeHermesConfig(hermesBaseUrl, apiKey, selectedModel.id, {
+    type: selectedType,
+    hermesHome: args['hermes-home'] || args.hermesHome,
+    wslUser: args['wsl-user'] || args.wslUser,
+    wslDistro: args['wsl-distro'] || args.wslDistro
+  });
   writeSpinner.succeed('Hermes 配置写入完成');
 
   console.log(chalk.green('\n✅ Hermes 配置完成！'));
@@ -5732,10 +5864,14 @@ async function activateHermes(paths, args = {}) {
   console.log(chalk.gray(`   • ${hermesPaths.configPath}`));
   console.log(chalk.gray(`   • ${hermesPaths.envPath}`));
   if (hermesPaths.wslConfigPath && hermesPaths.wslEnvPath) {
-    console.log(chalk.gray('   • 已额外同步到 WSL ~/.hermes'));
+    const targetLabel = hermesPaths.wslUser
+      ? `WSL ${hermesPaths.wslUser} 用户`
+      : 'WSL 默认用户';
+    console.log(chalk.gray(`   • 已额外同步到 ${targetLabel}: ${hermesPaths.wslConfigPath}`));
   }
   console.log(chalk.yellow('\n   提示: Hermes doctor 当前会固定检查官方 Anthropic /v1/models，不会读取 model.base_url；第三方 Anthropic 中转可能被误报为 invalid API key'));
   console.log(chalk.yellow('   建议: 以 yymaxapi 的 Hermes CLI 运行时测试，或 `hermes chat -Q -q "请只回复 OK"` 的结果为准'));
+  console.log(chalk.yellow('   如通过飞书/Telegram/Discord 调用，请重启网关: `hermes gateway restart` 或 `hermes gateway run`'));
 
   if (await confirmImmediateTest(args, '是否立即测试 Hermes CLI 连接？')) {
     await testAdditionalCliConnections(args, { only: ['hermes'] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yymaxapi",
-  "version": "1.0.116",
+  "version": "1.0.118",
   "description": "跨平台 OpenClaw/Clawdbot 配置管理工具 - 管理中转地址、模型切换、API Keys、测速优化",
   "main": "bin/yymaxapi.js",
   "bin": {