yidaconnector 2026.6.11

package/lib/core/env.js

@@ -0,0 +1,287 @@
+/**
+ * env.js - 宜搭 CLI 环境检测
+ *
+ * 通过环境变量 + 文件特征检测当前运行环境，并输出环境信息。
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  detectActiveTool,
+  findProjectRoot,
+  loadCookieData,
+  resolveBaseUrl,
+  extractInfoFromCookies,
+  resolveWukongWorkspaceRoot,
+} = require('./utils');
+const { t } = require('./i18n');
+
+const home = os.homedir();
+
+/**
+ * 获取所有已安装的 AI 工具列表（用于展示）。
+ * 不判断当前是否活跃，只判断是否安装过。
+ * 使用 path.join 拼接路径，兼容 Windows 和 macOS/Linux。
+ *
+ * @returns {Array} 已安装工具列表
+ */
+function getInstalledTools() {
+  const tools = [
+    { dirName: '.real', displayName: '悟空（Wukong）' },
+    { dirName: '.codex', displayName: 'Codex' },
+    // Windows 上配置目录为 ~/.config/opencode，macOS/Linux 为 ~/.opencode
+    {
+      dirName: process.platform === 'win32' ? path.join('.config', 'opencode') : '.opencode',
+      displayName: 'OpenCode',
+    },
+    { dirName: '.claude', displayName: 'Claude Code' },
+    { dirName: '.aone_copilot', displayName: 'Aone Copilot' },
+    { dirName: '.cursor', displayName: 'Cursor' },
+    { dirName: '.qoderwork', displayName: 'QoderWork' },
+    { dirName: '.qoder', displayName: 'Qoder' },
+  ];
+
+  return tools.filter(({ dirName }) => {
+    return fs.existsSync(path.join(home, dirName));
+  });
+}
+
+/**
+ * 检测当前 AI 工具环境。
+ * 返回当前活跃工具信息和所有已安装工具列表。
+ */
+function detectEnvironment() {
+  const activeTool = detectActiveTool();
+  const installedTools = getInstalledTools();
+  const cwdProject = path.join(process.cwd(), 'project');
+
+  // 构建结果列表
+  const results = installedTools.map(({ dirName, displayName }) => {
+    const isWukong = dirName === '.real';
+    const isActive = activeTool && activeTool.dirName === dirName;
+    // path.join 在 Windows 上自动使用反斜杠，兼容所有平台
+    const workspaceRoot = isWukong
+      ? resolveWukongWorkspaceRoot(process.env.AGENT_WORK_ROOT || path.join(home, '.real', 'workspace'))
+      : cwdProject;
+    const hasProject = fs.existsSync(workspaceRoot);
+
+    return {
+      displayName,
+      dirName,
+      isActive: !!isActive,
+      hasProject,
+      workspaceRoot,
+    };
+  });
+
+  // 当前生效环境
+  const activeToolName = activeTool ? activeTool.displayName : null;
+  const activeProjectRoot = activeTool ? activeTool.workspaceRoot : null;
+
+  return { activeToolName, activeProjectRoot, results };
+}
+function getCookieDiagnostics(projectRoot) {
+  const { getCurrentEnvConfig, getCookieFilePath } = require('./env-manager');
+  const currentEnv = getCurrentEnvConfig(projectRoot);
+  const envCookieFile = getCookieFilePath(projectRoot);
+  const legacyCookieFile = path.join(projectRoot, '.cache', 'cookies.json');
+  const envCookieFileFound = fs.existsSync(envCookieFile);
+  const legacyCookieFileFound = fs.existsSync(legacyCookieFile);
+  const selectedCookieFile = envCookieFileFound ? envCookieFile : legacyCookieFile;
+
+  return {
+    currentEnv: currentEnv.name,
+    configuredCookieFile: envCookieFile,
+    legacyCookieFile,
+    cookieFile: selectedCookieFile,
+    cookieFileFound: envCookieFileFound || legacyCookieFileFound,
+    usedLegacyCookieFile: !envCookieFileFound && legacyCookieFileFound,
+  };
+}
+
+/**
+ * 检测登录态信息。
+ */
+function detectLoginStatus(projectRoot) {
+  const cookieDiagnostics = getCookieDiagnostics(projectRoot);
+  const cookieData = loadCookieData(projectRoot);
+  const cookies = cookieData && Array.isArray(cookieData.cookies) ? cookieData.cookies : [];
+
+  if (!cookieData || !cookieData.cookies) {
+    return {
+      loggedIn: false,
+      canAutoUse: false,
+      csrfToken: null,
+      corpId: null,
+      userId: null,
+      baseUrl: null,
+      cookiesCount: 0,
+      diagnostics: {
+        ...cookieDiagnostics,
+        cacheReadable: false,
+        cookiesArrayFound: false,
+        csrfTokenFound: false,
+        corpIdFound: false,
+        userIdFound: false,
+        baseUrlFound: false,
+        failureReason: cookieDiagnostics.cookieFileFound ? 'cookie_cache_unreadable_or_invalid' : 'cookie_cache_missing',
+      },
+    };
+  }
+
+  const { csrfToken, corpId, userId } = extractInfoFromCookies(cookies);
+  const baseUrl = resolveBaseUrl(cookieData);
+  const loggedIn = !!csrfToken;
+
+  return {
+    loggedIn,
+    canAutoUse: loggedIn,
+    csrfToken,
+    corpId,
+    userId,
+    baseUrl,
+    cookiesCount: cookies.length,
+    diagnostics: {
+      ...cookieDiagnostics,
+      cacheReadable: true,
+      cookiesArrayFound: Array.isArray(cookieData.cookies),
+      csrfTokenFound: !!csrfToken,
+      corpIdFound: !!corpId,
+      userIdFound: !!userId,
+      baseUrlFound: !!baseUrl,
+      failureReason: loggedIn ? null : 'csrf_token_missing',
+    },
+  };
+}
+
+function maskSecret(value) {
+  if (!value) {return null;}
+  return `${value.slice(0, 16)}...`;
+}
+
+/**
+ * 构建适合 AI agent 读取的环境快照。
+ */
+function buildEnvironmentSnapshot() {
+  const environment = detectEnvironment();
+  const projectRoot = (environment.activeProjectRoot && fs.existsSync(environment.activeProjectRoot))
+    ? environment.activeProjectRoot
+    : findProjectRoot();
+  const loginStatus = detectLoginStatus(projectRoot);
+
+  return {
+    ok: true,
+    system: {
+      platform: process.platform,
+      arch: os.arch(),
+      node: process.version,
+      home: os.homedir(),
+      cwd: process.cwd(),
+    },
+    active: {
+      tool: environment.activeToolName,
+      toolKey: environment.results.find((item) => item.isActive)?.dirName || null,
+      isWukong: environment.results.some((item) => item.isActive && item.dirName === '.real'),
+      projectRoot,
+      projectRootExists: fs.existsSync(projectRoot),
+      hasConfig: fs.existsSync(path.join(projectRoot, 'config.json')),
+    },
+    tools: environment.results,
+    login: {
+      loggedIn: loginStatus.loggedIn,
+      canAutoUse: loginStatus.canAutoUse,
+      baseUrl: loginStatus.baseUrl,
+      corpId: loginStatus.corpId,
+      userId: loginStatus.userId,
+      csrfToken: maskSecret(loginStatus.csrfToken),
+      cookiesCount: loginStatus.cookiesCount,
+      diagnostics: loginStatus.diagnostics,
+    },
+  };
+}
+
+/**
+ * 执行环境检测并打印结果。
+ */
+function run(args = []) {
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(buildEnvironmentSnapshot(), null, 2));
+    return;
+  }
+
+  const { c, sep, banner, success, warn, label } = require('./chalk');
+
+  banner(t('env.title'), { stderr: false });
+
+  // ── 系统信息 ──────────────────────────────────────
+  console.log(`\n  ${c.bold}${c.cyan}${t('env.system_info').replace(/^[\s─=]+/, '').replace(/[\s─=]+$/, '')}${c.reset}`);
+  label('OS', `${process.platform} ${os.arch()}`, { stderr: false });
+  label('Node', process.version, { stderr: false });
+  label('Home', os.homedir(), { stderr: false });
+  label('CWD', process.cwd(), { stderr: false });
+
+  // ── AI 工具检测 ────────────────────────────────────
+  console.log(`\n  ${c.bold}${c.cyan}${t('env.ai_tools').replace(/^[\s─=]+/, '').replace(/[\s─=]+$/, '')}${c.reset}`);
+  const { activeToolName, activeProjectRoot, results } = detectEnvironment();
+
+  if (results.length === 0) {
+    warn(t('env.no_tools'), false);
+  } else {
+    for (const { displayName, isActive, hasProject } of results) {
+      let statusIcon, note;
+      if (isActive && hasProject) {
+        statusIcon = `${c.green}✔${c.reset}`;
+        note = `${c.green}${t('env.tool_active_ready')}${c.reset}`;
+      } else if (isActive && !hasProject) {
+        statusIcon = `${c.yellow}●${c.reset}`;
+        note = `${c.yellow}${t('env.tool_active_no_project')}${c.reset}`;
+      } else if (!isActive && hasProject) {
+        statusIcon = `${c.dim}○${c.reset}`;
+        note = `${c.dim}${t('env.tool_installed_has_project')}${c.reset}`;
+      } else {
+        statusIcon = `${c.dim}○${c.reset}`;
+        note = `${c.dim}${t('env.tool_installed')}${c.reset}`;
+      }
+      console.log(`      ${statusIcon} ${displayName.padEnd(18)} ${note}`);
+    }
+  }
+
+  // ── 当前生效环境 ───────────────────────────────────
+  console.log(`\n  ${c.bold}${c.cyan}${t('env.active_env').replace(/^[\s─=]+/, '').replace(/[\s─=]+$/, '')}${c.reset}`);
+  if (activeToolName && activeProjectRoot) {
+    label('AI Tool', `${c.green}${activeToolName}${c.reset}`, { stderr: false });
+    label('Project', activeProjectRoot, { stderr: false });
+  } else {
+    const activeOnly = results.filter((r) => r.isActive);
+    if (activeOnly.length > 0) {
+      warn(t('env.active_no_project', activeOnly.map((r) => r.displayName).join(', ')), false);
+    } else {
+      warn(t('env.no_active_tool'), false);
+    }
+    label('Fallback', process.cwd(), { stderr: false });
+  }
+
+  // ── 登录态检测 ─────────────────────────────────────
+  console.log(`\n  ${c.bold}${c.cyan}${t('env.login_status').replace(/^[\s─=]+/, '').replace(/[\s─=]+$/, '')}${c.reset}`);
+  const projectRoot = (activeProjectRoot && fs.existsSync(activeProjectRoot))
+    ? activeProjectRoot
+    : findProjectRoot();
+  const loginStatus = detectLoginStatus(projectRoot);
+
+  if (loginStatus.loggedIn) {
+    success(t('env.logged_in'), false);
+    label('Base URL', loginStatus.baseUrl, { stderr: false });
+    label('Corp ID', loginStatus.corpId || t('env.unknown'), { stderr: false });
+    label('User ID', loginStatus.userId || t('env.unknown'), { stderr: false });
+    label('CSRF', `${loginStatus.csrfToken ? loginStatus.csrfToken.slice(0, 16) : 'N/A'}…`, { stderr: false });
+  } else {
+    warn(t('env.not_logged_in'), false);
+  }
+
+  console.log(`\n  ${sep()}\n`);
+}
+
+module.exports = { run, detectEnvironment, detectLoginStatus, buildEnvironmentSnapshot };

package/lib/core/i18n.js

@@ -0,0 +1,177 @@
+/**
+ * i18n.js - 国际化支持模块
+ *
+ * 支持语言：
+ *   zh      - 简体中文（默认）
+ *   zh-HK   - 繁體中文（香港）
+ *   en      - English
+ *   ja      - 日本語
+ *   ko      - 한국어
+ *   fr      - Français
+ *   de      - Deutsch
+ *   es      - Español
+ *   pt      - Português
+ *   vi      - Tiếng Việt
+ *   hi      - हिन्दी
+ *   ar      - العربية
+ *
+ * 语言检测优先级：
+ *   1. YIDACONNECTOR_LANG 环境变量（如：YIDACONNECTOR_LANG=en）
+ *   2. LANG / LC_ALL 系统环境变量
+ *   3. 默认：zh（简体中文）
+ *
+ * 用法：
+ *   const { t } = require('./i18n');
+ *   console.log(t('login.success'));
+ *   console.log(t('create_app.usage', 'yidaconnector'));
+ */
+
+'use strict';
+
+const SUPPORTED_LANGUAGES = ['zh', 'zh-HK', 'en', 'ja', 'ko', 'fr', 'de', 'es', 'pt', 'vi', 'hi', 'ar'];
+const DEFAULT_LANGUAGE = 'zh';
+
+/**
+ * 将系统 locale 代码映射到支持的语言代码。
+ * @param {string} code - 系统 locale 代码（小写）
+ * @returns {string|null}
+ */
+function mapLocaleToLanguage(code) {
+  const localeMap = {
+    zh: 'zh',
+    'zh-hk': 'zh-HK',
+    'zh-mo': 'zh-HK',
+    'zh-hant': 'zh-HK',
+    'zh-tw': 'zh-HK',
+    en: 'en',
+    ja: 'ja',
+    ko: 'ko',
+    fr: 'fr',
+    de: 'de',
+    es: 'es',
+    pt: 'pt',
+    vi: 'vi',
+    hi: 'hi',
+    ar: 'ar',
+  };
+  return localeMap[code] || null;
+}
+
+/**
+ * 从环境变量或系统 locale 中检测当前语言。
+ * @returns {string} 支持的语言代码
+ */
+function detectLanguage() {
+  // 优先级1：YIDACONNECTOR_LANG 环境变量（支持完整 locale，如 zh-HK、en-US）
+  const envLang = process.env.YIDACONNECTOR_LANG;
+  if (envLang) {
+    const normalized = envLang.toLowerCase().replace(/_/g, '-');
+    // 先尝试完整匹配（如 zh-HK）
+    const fullMatch = mapLocaleToLanguage(normalized);
+    if (fullMatch) {return fullMatch;}
+    // 再尝试主语言代码匹配（如 en-US → en）
+    const primaryCode = normalized.split('-')[0];
+    const primaryMatch = mapLocaleToLanguage(primaryCode);
+    if (primaryMatch) {return primaryMatch;}
+  }
+
+  // 优先级2：系统 LANG / LC_ALL 环境变量（如 zh_HK.UTF-8、en_US.UTF-8）
+  const systemLang = process.env.LC_ALL || process.env.LANG || '';
+  const normalizedSystem = systemLang.toLowerCase().replace(/_/g, '-').split('.')[0];
+  const systemMatch = mapLocaleToLanguage(normalizedSystem);
+  if (systemMatch) {return systemMatch;}
+  const systemPrimary = normalizedSystem.split('-')[0];
+  const systemPrimaryMatch = mapLocaleToLanguage(systemPrimary);
+  if (systemPrimaryMatch) {return systemPrimaryMatch;}
+
+  // 优先级3：默认简体中文
+  return DEFAULT_LANGUAGE;
+}
+
+let currentLanguage = detectLanguage();
+let translations = null;
+
+/**
+ * 懒加载翻译文件。
+ * @returns {object} 翻译字典
+ */
+function loadTranslations() {
+  if (translations) {return translations;}
+  try {
+    translations = require(`./locales/${currentLanguage}`);
+  } catch {
+    // 加载失败时回退到中文
+    translations = require('./locales/zh');
+  }
+  return translations;
+}
+
+/**
+ * 翻译函数，支持 {0} {1} 占位符插值。
+ * @param {string} key - 翻译键（支持点号分隔的嵌套路径，如 "login.success"）
+ * @param {...string} args - 插值参数
+ * @returns {string}
+ */
+function t(key, ...args) {
+  const dict = loadTranslations();
+
+  // 支持嵌套路径：如 "login.success" → dict.login.success
+  const value = key.split('.').reduce((obj, segment) => {
+    return obj && typeof obj === 'object' ? obj[segment] : undefined;
+  }, dict);
+
+  if (typeof value !== 'string') {
+    // 找不到翻译时，尝试中文兜底
+    if (currentLanguage !== 'zh') {
+      const zhDict = require('./locales/zh');
+      const zhValue = key.split('.').reduce((obj, segment) => {
+        return obj && typeof obj === 'object' ? obj[segment] : undefined;
+      }, zhDict);
+      if (typeof zhValue === 'string') {
+        return interpolate(zhValue, args);
+      }
+    }
+    // 最终兜底：返回 key 本身
+    return key;
+  }
+
+  return interpolate(value, args);
+}
+
+/**
+ * 将 {0} {1} 占位符替换为实际参数。
+ * @param {string} template
+ * @param {string[]} args
+ * @returns {string}
+ */
+function interpolate(template, args) {
+  if (!args || args.length === 0) {return template;}
+  return template.replace(/\{(\d+)\}/g, (match, index) => {
+    const argValue = args[parseInt(index, 10)];
+    return argValue !== undefined ? String(argValue) : match;
+  });
+}
+
+/**
+ * 获取当前语言。
+ * @returns {string}
+ */
+function getLanguage() {
+  return currentLanguage;
+}
+
+/**
+ * 手动设置语言（主要用于测试）。
+ * @param {string} lang - 支持的语言代码（如 "zh"、"en"、"zh-HK"、"ko" 等）
+ */
+function setLanguage(lang) {
+  const normalized = typeof lang === 'string'
+    ? mapLocaleToLanguage(lang.toLowerCase().replace(/_/g, '-'))
+    : null;
+  if (SUPPORTED_LANGUAGES.includes(normalized)) {
+    currentLanguage = normalized;
+    translations = null; // 清空缓存，下次 t() 时重新加载
+  }
+}
+
+module.exports = { t, getLanguage, setLanguage, detectLanguage, SUPPORTED_LANGUAGES };