yingclaw 2.5.31 → 2.5.38

package/lib/desktop.js

@@ -3,7 +3,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const { normalizeAnthropicBaseUrl } = require('./config');
+const { CLEAR_CLAUDE_ENV_KEYS, normalizeAnthropicBaseUrl } = require('./config');
 const {
   YINGCLAW_GATEWAY_PREFIX,
   buildDesktopGatewayRoutes,
@@ -13,6 +13,7 @@ const {
 const CLAUDE_DESKTOP_LABEL = 'Claude 桌面应用配置';
 const YINGCLAW_ENTRY_NAME = 'yingclaw';
 const MAC_POLICY_BUNDLE = 'com.anthropic.claudefordesktop';
+const CLAUDE_CODE_SETTINGS_SCHEMA = 'https://json.schemastore.org/claude-code-settings.json';
 const DESKTOP_GATEWAY_KEYS = [
   'inferenceProvider',
   'inferenceGatewayBaseUrl',
@@ -96,6 +97,11 @@ function readJsonFile(file) {
   }
 }
 
+function writeJsonFile(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
+}
+
 function toDesktopModelId(model) {
   return model.startsWith('claude-') ? model : `claude-${model}`;
 }
@@ -112,6 +118,215 @@ function buildGatewayBaseUrl(config) {
   return `http://127.0.0.1:${port}${YINGCLAW_GATEWAY_PREFIX}`;
 }
 
+function getClaudeCodeSettingsPath(options = {}) {
+  const homeDir = options.homeDir || os.homedir();
+  return options.settingsFile || path.join(homeDir, '.claude', 'settings.json');
+}
+
+function getClaudePluginCacheDir(options = {}) {
+  const homeDir = options.homeDir || os.homedir();
+  return options.pluginCacheDir || path.join(homeDir, '.claude', 'plugins', 'cache');
+}
+
+function getProcessStart(pid, options = {}) {
+  const runner = options.processRunner || options.runner || spawnSync;
+  const platform = options.platform || process.platform;
+  const pidText = String(pid);
+  let result;
+  if (platform === 'win32') {
+    result = runner('powershell.exe', [
+      '-NoProfile',
+      '-Command',
+      `$p = Get-Process -Id ${pidText} -ErrorAction SilentlyContinue; if ($p) { $p.StartTime.ToUniversalTime().ToString('o') }`,
+    ], { stdio: 'pipe', encoding: 'utf8', windowsHide: true });
+  } else {
+    result = runner('ps', ['-p', pidText, '-o', 'lstart='], { stdio: 'pipe', encoding: 'utf8' });
+  }
+  if (result.status !== 0) return null;
+  return (result.stdout || '').toString().trim() || null;
+}
+
+function readLockProcStart(file) {
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed.procStart === 'string' ? parsed.procStart.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function walkFiles(dir, visitor) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const file = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkFiles(file, visitor);
+    } else if (entry.isFile()) {
+      visitor(file);
+    }
+  }
+}
+
+function cleanupStaleClaudePluginLocks(options = {}) {
+  const pluginCacheDir = getClaudePluginCacheDir(options);
+  if (!pluginCacheDir || !fs.existsSync(pluginCacheDir)) {
+    return { result: 'missing', checked: 0, removed: 0, kept: 0 };
+  }
+
+  let checked = 0;
+  let removed = 0;
+  let kept = 0;
+  const processStartCache = new Map();
+
+  walkFiles(pluginCacheDir, (file) => {
+    if (path.basename(path.dirname(file)) !== '.in_use') return;
+    const pid = path.basename(file);
+    if (!/^\d+$/.test(pid)) return;
+
+    checked += 1;
+    if (!processStartCache.has(pid)) {
+      processStartCache.set(pid, getProcessStart(pid, options));
+    }
+    const currentProcStart = processStartCache.get(pid);
+    const lockProcStart = readLockProcStart(file);
+    const isStale = !currentProcStart || (lockProcStart && lockProcStart !== currentProcStart);
+
+    if (!isStale) {
+      kept += 1;
+      return;
+    }
+
+    try {
+      fs.unlinkSync(file);
+      removed += 1;
+    } catch {
+      kept += 1;
+    }
+  });
+
+  return { result: removed > 0 ? 'updated' : 'unchanged', checked, removed, kept };
+}
+
+function findDesktopRoute(routes, family) {
+  return routes.find((route) => route && route.id.includes(`claude-${family}-`))?.id;
+}
+
+function buildClaudeDesktopCodeEnv(config, options = {}) {
+  const gatewayConfig = ensureDesktopGatewayConfig(config, options);
+  const routes = buildDesktopGatewayRoutes(gatewayConfig);
+  const fallback = routes[0]?.id || 'claude-sonnet-4-6';
+  const sonnet = findDesktopRoute(routes, 'sonnet') || fallback;
+  const haiku = findDesktopRoute(routes, 'haiku') || routes[1]?.id || sonnet;
+  const opus = findDesktopRoute(routes, 'opus') || sonnet;
+
+  return {
+    ANTHROPIC_BASE_URL: buildGatewayBaseUrl(gatewayConfig),
+    ANTHROPIC_AUTH_TOKEN: gatewayConfig.desktopGatewayKey,
+    ANTHROPIC_MODEL: sonnet,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: opus,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: sonnet,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: haiku,
+    CLAUDE_CODE_SUBAGENT_MODEL: haiku,
+    CLAUDE_CODE_EFFORT_LEVEL: 'low',
+    CLAUDE_CODE_SIMPLE: '1',
+  };
+}
+
+function buildClaudeDesktopLaunchEnv(env = process.env, overrides = {}) {
+  const next = { ...env };
+  for (const key of CLEAR_CLAUDE_ENV_KEYS) {
+    delete next[key];
+  }
+  return { ...next, ...overrides };
+}
+
+function shouldWriteClaudeDesktopCodeSettings(options = {}) {
+  return options.withCode === true && options.direct !== true;
+}
+
+function shouldPromptClaudeDesktopCodeSettings(options = {}) {
+  return options.direct !== true && options.withCode !== true;
+}
+
+function writeClaudeDesktopCodeSettings(config, options = {}) {
+  const file = getClaudeCodeSettingsPath(options);
+  const current = readJsonFile(file);
+  const env = {
+    ...(current.env && typeof current.env === 'object' ? current.env : {}),
+    ...buildClaudeDesktopCodeEnv(config, options),
+  };
+  const next = {
+    ...current,
+    $schema: current.$schema || CLAUDE_CODE_SETTINGS_SCHEMA,
+    env,
+  };
+  writeJsonFile(file, next);
+  try {
+    fs.chmodSync(file, 0o600);
+  } catch {}
+  return { result: 'updated', file };
+}
+
+function checkClaudeDesktopCodeSettingsEnv(config, options = {}) {
+  const file = getClaudeCodeSettingsPath(options);
+  const settings = readJsonFile(file);
+  const env = settings.env && typeof settings.env === 'object' ? settings.env : {};
+  const expected = buildClaudeDesktopCodeEnv(config, options);
+  const missing = [];
+  const mismatched = [];
+  const hasYingclawEnv = Object.keys(expected).some((key) => Object.prototype.hasOwnProperty.call(env, key));
+
+  for (const [key, value] of Object.entries(expected)) {
+    if (!Object.prototype.hasOwnProperty.call(env, key)) {
+      missing.push(key);
+    } else if (String(env[key]) !== String(value)) {
+      mismatched.push(key);
+    }
+  }
+
+  return {
+    file,
+    configured: missing.length === 0 && mismatched.length === 0,
+    hasYingclawEnv,
+    simpleEnabled: env.CLAUDE_CODE_SIMPLE === '1',
+    missing,
+    mismatched,
+    baseUrl: env.ANTHROPIC_BASE_URL || null,
+    model: env.ANTHROPIC_MODEL || null,
+  };
+}
+
+function clearClaudeDesktopCodeSettings(options = {}) {
+  const file = getClaudeCodeSettingsPath(options);
+  if (!fs.existsSync(file)) return { result: 'missing', file };
+
+  const current = readJsonFile(file);
+  const nextEnv = { ...(current.env && typeof current.env === 'object' ? current.env : {}) };
+  let changed = false;
+  for (const key of CLEAR_CLAUDE_ENV_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(nextEnv, key)) {
+      delete nextEnv[key];
+      changed = true;
+    }
+  }
+  if (!changed) return { result: 'missing', file };
+
+  const next = { ...current };
+  if (Object.keys(nextEnv).length > 0) {
+    next.env = nextEnv;
+  } else {
+    delete next.env;
+  }
+  writeJsonFile(file, next);
+  return { result: 'updated', file };
+}
+
 function serializeGatewayModels(config) {
   return buildDesktopGatewayRoutes(config).map((route) => {
     const item = { name: route.id, displayName: route.displayName };
@@ -463,10 +678,15 @@ async function openClaudeDesktop(options = {}) {
   const runner = options.runner || spawnSync;
   const isMocked = options.runner !== undefined;
   const timeoutMs = options.timeoutMs || 5000;
+  const launchEnv = buildClaudeDesktopLaunchEnv(options.env || process.env, options.injectEnv || {});
+  const shouldCleanupPluginLocks = options.cleanupPluginLocks !== false;
 
   const trace = [];
+  let pluginLocks = shouldCleanupPluginLocks
+    ? [cleanupStaleClaudePluginLocks(options)]
+    : [];
   for (const { command, args, optional, waitAfter, shell } of commands) {
-    const result = runner(command, args, { stdio: 'pipe', encoding: 'utf8', windowsHide: true, timeout: timeoutMs, shell });
+    const result = runner(command, args, { stdio: 'pipe', encoding: 'utf8', windowsHide: true, timeout: timeoutMs, shell, env: launchEnv });
     const stderr = (result.stderr || '').toString().trim();
     trace.push({ command, args, status: result.status, stderr });
 
@@ -478,24 +698,36 @@ async function openClaudeDesktop(options = {}) {
     if (waitAfter && !isMocked) {
       await sleep(waitAfter);
     }
+    if (shouldCleanupPluginLocks && (command === 'pkill' || command === 'taskkill')) {
+      pluginLocks.push(cleanupStaleClaudePluginLocks(options));
+    }
   }
 
-  return { result: 'reopened', trace };
+  return { result: 'reopened', trace, pluginLocks };
 }
 
 module.exports = {
+  buildClaudeDesktopCodeEnv,
   buildClaudeDesktopEnterpriseConfig,
   buildClaudeDesktopDirectEnterpriseConfig,
+  buildClaudeDesktopLaunchEnv,
   buildClaudeDesktopMacDefaultsCommands,
   buildClaudeDesktopMacDefaultsDeleteCommands,
   buildClaudeDesktopOpenCommands,
+  cleanupStaleClaudePluginLocks,
+  checkClaudeDesktopCodeSettingsEnv,
+  clearClaudeDesktopCodeSettings,
   clearClaudeDesktopConfig,
+  getClaudeCodeSettingsPath,
   getClaudeDesktopConfigLibraryDir,
   getClaudeDesktopConfigPath,
   getClaudeDesktopDataDir,
   getClaudeDesktopDataDirs,
   isDesktopConfigured,
   openClaudeDesktop,
+  shouldPromptClaudeDesktopCodeSettings,
+  shouldWriteClaudeDesktopCodeSettings,
+  writeClaudeDesktopCodeSettings,
   writeClaudeDesktopConfig,
   CLAUDE_DESKTOP_LABEL,
 };

package/lib/doctor.js

@@ -2,6 +2,9 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execSync, spawnSync } = require('child_process');
+const {
+  getGatewayAutostartStatus,
+} = require('./autostart');
 const {
   loadConfig,
   validateConfig,
@@ -10,8 +13,9 @@ const {
   normalizeAnthropicBaseUrl,
   PROVIDERS,
   CLAUDE_ENV_KEYS,
+  CLEAR_CLAUDE_ENV_KEYS,
 } = require('./config');
-const { isDesktopConfigured } = require('./desktop');
+const { checkClaudeDesktopCodeSettingsEnv, getClaudeDesktopDataDirs, isDesktopConfigured } = require('./desktop');
 const { checkClaudeCodeSettingsEnv } = require('./vscode');
 
 const STATUS_OK = 'ok';
@@ -47,7 +51,7 @@ async function runDoctorChecks(options = {}) {
   });
 
   // 3. 配置文件
-  const config = loadConfig();
+  const config = options.config || loadConfig();
   if (!config) {
     checks.push({
       name: '配置文件',
@@ -142,6 +146,23 @@ async function runDoctorChecks(options = {}) {
     message: desktopConfigured ? '已通过 yingclaw 接入' : '未接入（如需运行 claw desktop）',
   });
 
+  const desktopCode = checkClaudeDesktopCodeSettingsEnv(config, options);
+  const desktopCodeProblems = desktopCode.missing.length + desktopCode.mismatched.length;
+  checks.push({
+    name: 'Claude Desktop Code',
+    status: desktopCode.configured ? STATUS_OK : desktopCode.hasYingclawEnv ? STATUS_WARN : STATUS_INFO,
+    message: desktopCode.configured
+      ? 'Code 模式环境已配置 · simple 启用'
+      : desktopCode.hasYingclawEnv
+        ? `${desktopCodeProblems} 项配置未写入或不匹配`
+        : '未接入（可选；如需 Desktop Code 运行 claw desktop --with-code）',
+    fix: desktopCode.configured || !desktopCode.hasYingclawEnv ? null : '运行 claw desktop --with-code，并完全重启 Claude 桌面应用',
+  });
+
+  if (platform === 'win32' || options.windows) {
+    checks.push(...buildWindowsDoctorChecks(config, options));
+  }
+
   // 9. DeepSeek 旧模型名提醒
   if (config.provider === 'deepseek' && (
     config.model === 'deepseek-v4-pro' ||
@@ -184,17 +205,194 @@ function checkWindowsEnvVars(options = {}) {
   return { allWritten: missing.length === 0, missing };
 }
 
+function readConfigMirror(file) {
+  try {
+    return JSON.stringify(JSON.parse(fs.readFileSync(file, 'utf8')));
+  } catch {
+    return null;
+  }
+}
+
+function checkWindowsDesktopConfigMirrors(options = {}) {
+  const dataDirs = options.dataDirs || getClaudeDesktopDataDirs({ ...options, platform: 'win32' });
+  const files = dataDirs.map((dir) => path.join(dir, 'claude_desktop_config.json'));
+  const existing = files.filter((file) => fs.existsSync(file));
+  const missing = files.filter((file) => !fs.existsSync(file));
+  if (existing.length === 0) return { status: 'missing', files: existing, missing };
+  if (existing.length !== files.length) return { status: 'partial', files: existing, missing };
+  const contents = existing.map(readConfigMirror);
+  if (contents.some((content) => content == null)) return { status: 'invalid', files: existing, missing };
+  return {
+    status: new Set(contents).size === 1 ? 'synced' : 'mismatch',
+    files: existing,
+    missing,
+  };
+}
+
+function checkWindowsClaudeProcesses(options = {}) {
+  const runner = options.runner || spawnSync;
+  const result = runner('powershell.exe', [
+    '-NoProfile',
+    '-Command',
+    `$p = @(Get-Process Claude -ErrorAction SilentlyContinue); [pscustomobject]@{count=$p.Count;pids=@($p.Id)} | ConvertTo-Json -Compress`,
+  ], { stdio: 'pipe', encoding: 'utf8', windowsHide: true });
+  if (result.status !== 0) return { running: false, count: 0, pids: [] };
+  try {
+    const parsed = JSON.parse(String(result.stdout || '').trim() || '{}');
+    const pids = Array.isArray(parsed.pids)
+      ? parsed.pids.map(Number).filter(Number.isFinite)
+      : Number.isFinite(Number(parsed.pids)) ? [Number(parsed.pids)] : [];
+    return { running: Number(parsed.count) > 0, count: Number(parsed.count) || 0, pids };
+  } catch {
+    return { running: false, count: 0, pids: [] };
+  }
+}
+
+function buildWindowsDoctorChecks(config = {}, options = {}) {
+  const checks = [];
+  const autostart = getGatewayAutostartStatus({
+    ...options,
+    platform: 'win32',
+    file: options.startupFile || options.file,
+    port: config.desktopGatewayPort || options.port || 18080,
+  });
+  checks.push({
+    name: 'Windows Gateway 端口',
+    status: autostart.running ? STATUS_OK : STATUS_WARN,
+    message: autostart.running ? `127.0.0.1:${config.desktopGatewayPort || options.port || 18080} 正在监听` : '未监听',
+    fix: autostart.running ? null : '运行 claw gateway，或重新执行 claw desktop 设置自动启动',
+  });
+  checks.push({
+    name: 'Windows Gateway 自动启动',
+    status: autostart.installed ? STATUS_OK : STATUS_WARN,
+    message: autostart.installed ? `已写入 ${autostart.file}` : '未写入启动脚本',
+    fix: autostart.installed ? null : '运行 claw desktop 重新写入启动脚本',
+  });
+
+  const mirror = checkWindowsDesktopConfigMirrors(options);
+  const mirrorOk = mirror.status === 'synced' || mirror.status === 'missing';
+  checks.push({
+    name: 'Windows Claude 配置镜像',
+    status: mirrorOk ? STATUS_OK : STATUS_WARN,
+    message: mirror.status === 'synced'
+      ? 'Roaming / Local 配置一致'
+      : mirror.status === 'missing'
+        ? '未找到桌面 3P 配置'
+        : `${mirror.status}：${mirror.files.length} 个存在，${mirror.missing.length} 个缺失`,
+    fix: mirrorOk ? null : '运行 claw desktop 同步 Roaming 和 Local 配置',
+  });
+
+  const claude = checkWindowsClaudeProcesses(options);
+  checks.push({
+    name: 'Windows Claude 进程',
+    status: STATUS_INFO,
+    message: claude.running ? `正在运行 ${claude.count} 个 Claude 进程` : '未运行',
+    fix: claude.running ? '如配置未生效，请从系统托盘退出 Claude 后重开' : null,
+  });
+  return checks;
+}
+
 function summarize(checks) {
   const counts = { ok: 0, fail: 0, warn: 0, info: 0 };
   for (const c of checks) counts[c.status] = (counts[c.status] || 0) + 1;
   return counts;
 }
 
+function redactEnvValue(key, env, expectedEnv) {
+  const present = Object.prototype.hasOwnProperty.call(env, key);
+  const expected = Object.prototype.hasOwnProperty.call(expectedEnv, key);
+  const sensitive = key.includes('TOKEN') || key.includes('KEY');
+  return {
+    present,
+    expected,
+    matchesExpected: present && expected ? String(env[key]) === String(expectedEnv[key]) : false,
+    value: present ? (sensitive ? '[redacted]' : String(env[key])) : null,
+  };
+}
+
+function buildDiagnosticReport(options = {}) {
+  const config = options.config || null;
+  const checks = options.checks || [];
+  const env = options.env || process.env;
+  const expectedEnv = options.expectedEnv || (config ? buildClaudeEnv(config) : {});
+  const provider = config ? PROVIDERS[config.provider] : null;
+  const envKeys = [...new Set([...CLEAR_CLAUDE_ENV_KEYS, ...Object.keys(expectedEnv)])];
+
+  return {
+    generatedAt: options.now || new Date().toISOString(),
+    platform: options.platform || process.platform,
+    nodeVersion: options.nodeVersion || process.version,
+    packageVersion: options.packageVersion || null,
+    config: config ? {
+      provider: config.provider,
+      providerName: config.providerName || provider?.name || config.provider,
+      baseUrl: normalizeAnthropicBaseUrl(config.baseUrl),
+      model: config.model,
+      fastModel: config.fastModel || null,
+      availableModelCount: Array.isArray(config.availableModels) ? config.availableModels.length : 0,
+      hasApiKey: Boolean(config.apiKey),
+      desktopGatewayPort: config.desktopGatewayPort || null,
+      hasDesktopGatewayKey: Boolean(config.desktopGatewayKey),
+    } : null,
+    checks: checks.map((check) => ({
+      name: check.name,
+      status: check.status,
+      message: check.message,
+      fix: check.fix || null,
+    })),
+    env: Object.fromEntries(envKeys.map((key) => [key, redactEnvValue(key, env, expectedEnv)])),
+    desktopCode: options.desktopCodeStatus ? {
+      configured: options.desktopCodeStatus.configured,
+      simpleEnabled: options.desktopCodeStatus.simpleEnabled,
+      file: options.desktopCodeStatus.file,
+      missing: options.desktopCodeStatus.missing || [],
+      mismatched: options.desktopCodeStatus.mismatched || [],
+      baseUrl: options.desktopCodeStatus.baseUrl || null,
+      model: options.desktopCodeStatus.model || null,
+    } : null,
+  };
+}
+
+function buildSupportBundle(options = {}) {
+  const diagnostic = buildDiagnosticReport(options);
+  return {
+    type: 'yingclaw-support-bundle',
+    version: 1,
+    generatedAt: diagnostic.generatedAt,
+    packageVersion: options.packageVersion || null,
+    platform: diagnostic.platform,
+    diagnostic,
+    gateway: options.gatewayStatus ? {
+      configured: options.gatewayStatus.configured,
+      running: options.gatewayStatus.running,
+      port: options.gatewayStatus.port,
+      url: options.gatewayStatus.url,
+      error: options.gatewayStatus.error || null,
+    } : null,
+    notes: [
+      'This file is generated by yingclaw and should not contain API keys.',
+      'If you share it, review it once for any provider-specific private URL before posting publicly.',
+    ],
+  };
+}
+
+function writeDiagnosticReport(file, report) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(report, null, 2) + '\n');
+  return file;
+}
+
 module.exports = {
+  buildDiagnosticReport,
+  buildSupportBundle,
+  buildWindowsDoctorChecks,
+  checkWindowsClaudeProcesses,
+  checkWindowsDesktopConfigMirrors,
   runDoctorChecks,
   checkShellRcBlock,
   checkWindowsEnvVars,
   summarize,
+  writeDiagnosticReport,
   STATUS_OK,
   STATUS_FAIL,
   STATUS_WARN,