1314mc-helper 0.2.21

package/src/index.js

@@ -0,0 +1,359 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { configureClaudeCode } from './tools/claude.js';
+import { configureOpenClaw } from './tools/openclaw.js';
+import { configureCursor } from './tools/cursor.js';
+import { configureCline } from './tools/cline.js';
+import { configureCodex } from './tools/codex.js';
+import { configureContinue } from './tools/continue.js';
+import { configureOpenCode } from './tools/opencode.js';
+import { configureDroid } from './tools/droid.js';
+
+// API 配置
+export const API_CONFIG = {
+  baseUrl: 'http://www.1314mc.net:3333',
+  // 动态模型列表（运行时填充）
+  models: null,
+  // 原始模型数据（包含 endpoint 信息）
+  rawModels: null,
+};
+
+function normalizeBaseUrl(url) {
+  return `${url || ''}`.replace(/\/+$/, '');
+}
+
+function withV1(url) {
+  const normalized = normalizeBaseUrl(url);
+  return normalized.endsWith('/v1') ? normalized : `${normalized}/v1`;
+}
+
+function withoutV1(url) {
+  const normalized = normalizeBaseUrl(url);
+  return normalized.endsWith('/v1') ? normalized.slice(0, -3) : normalized;
+}
+
+export function getApiBaseForProtocol(protocol = '') {
+  const normalizedProtocol = `${protocol}`.toLowerCase();
+
+  const openaiProtocols = new Set([
+    'openai',
+    'openai-response',
+    'openai-responses',
+    'openai-completion',
+    'openai-completions',
+    'responses',
+    'chat',
+  ]);
+
+  if (openaiProtocols.has(normalizedProtocol)) {
+    return withV1(API_CONFIG.baseUrl);
+  }
+
+  return withoutV1(API_CONFIG.baseUrl);
+}
+
+/**
+ * 根据模型 ID 和支持的 endpoint 类型判断可用的 API 协议（返回数组）
+ * - Claude/Gemini 模型：只用 anthropic-messages
+ * - 其他模型只支持 openai：只用 openai-completions
+ * - 其他模型同时支持两个协议：返回两个，让各工具模块生成两条配置
+ */
+function resolveApiProtocols(id, endpoints) {
+  const hasAnthropic = endpoints.includes('anthropic');
+  const hasOpenai = endpoints.includes('openai') ||
+    endpoints.includes('openai-response') ||
+    endpoints.includes('openai-completion') ||
+    endpoints.includes('openai-completions');
+
+  // Claude 只用 Anthropic
+  if (id.startsWith('claude')) {
+    return ['anthropic-messages'];
+  }
+
+  // 只支持 openai
+  if (hasOpenai && !hasAnthropic) {
+    if (endpoints.includes('openai-response')) return ['openai-responses'];
+    return ['openai-completions'];
+  }
+
+  // 两个都支持 → 都返回
+  if (hasOpenai && hasAnthropic) {
+    const protocols = [];
+    if (endpoints.includes('openai-response')) {
+      protocols.push('openai-responses');
+    } else {
+      protocols.push('openai-completions');
+    }
+    protocols.push('anthropic-messages');
+    return protocols;
+  }
+
+  // 兜底
+  if (hasAnthropic) return ['anthropic-messages'];
+  return ['openai-completions'];
+}
+
+/**
+ * 从 pricing 页面获取公开模型 ID 集合
+ * 返回 null 表示获取失败，调用方应跳过过滤
+ */
+async function fetchPublicModelIds(apiKey) {
+  try {
+    const response = await fetch(`${API_CONFIG.baseUrl}/pricing`, {
+      headers: { 'Authorization': `Bearer ${apiKey}` },
+    });
+    if (!response.ok) return null;
+    const html = await response.text();
+    const ids = new Set();
+    for (const m of (html.match(/###\s+([^\n\r]+)/g) || [])) {
+      ids.add(m.replace(/^###\s+/, '').trim());
+    }
+    return ids.size > 0 ? ids : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 从 API 获取模型列表
+ */
+export async function fetchModels(apiKey) {
+  try {
+    const [response, publicIds] = await Promise.all([
+      fetch(`${API_CONFIG.baseUrl}/v1/models`, {
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      }),
+      fetchPublicModelIds(apiKey),
+    ]);
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    // 保存原始数据
+    API_CONFIG.rawModels = data.data || [];
+    
+    // 解析模型列表，根据 ID 和 supported_endpoint_types 分类
+    const models = { claude: [], gpt: [], gemini: [], other: [] };
+    
+    if (data.data && Array.isArray(data.data)) {
+      for (const model of data.data) {
+        const id = model.id;
+        // 跳过未在 pricing 页面公开的隐藏模型
+        if (publicIds && !publicIds.has(id)) continue;
+        // 跳过含 image 的模型（图像生成类，不支持对话）
+        if (id.toLowerCase().includes('image')) continue;
+        const endpoints = model.supported_endpoint_types || [];
+
+        // 根据模型 ID 和支持的 endpoint 类型判断可用协议（可能多个）
+        const apis = resolveApiProtocols(id, endpoints);
+
+        if (id.startsWith('gpt')) {
+          models.gpt.push({ id, name: id, apis, endpoints });
+        } else if (id.startsWith('claude')) {
+          models.claude.push({ id, name: id, apis, endpoints });
+        } else if (id.startsWith('gemini')) {
+          models.gemini.push({ id, name: id, apis, endpoints });
+        } else if (id.startsWith('glm')) {
+          models.other.push({ id, name: id, apis, endpoints });
+        } else {
+          models.other.push({ id, name: id, apis, endpoints });
+        }
+      }
+    }
+
+    // 缓存结果
+    API_CONFIG.models = models;
+    return models;
+  } catch (error) {
+    console.log(chalk.yellow(`⚠ 无法获取模型列表: ${error.message}`));
+    return { claude: [], gpt: [], gemini: [], other: [] };
+  }
+}
+
+/**
+ * 获取模型列表（优先使用缓存）
+ */
+export function getModels() {
+  return API_CONFIG.models || { claude: [], gpt: [], gemini: [], other: [] };
+}
+
+/**
+ * 获取原始模型数据
+ */
+export function getRawModels() {
+  return API_CONFIG.rawModels || [];
+}
+
+// 工具配置器映射
+const toolConfigurators = {
+  claude: configureClaudeCode,
+  openclaw: configureOpenClaw,
+  cursor: configureCursor,
+  cline: configureCline,
+  codex: configureCodex,
+  continue: configureContinue,
+  opencode: configureOpenCode,
+  droid: configureDroid,
+};
+
+// 工具信息
+const toolInfo = {
+  claude: {
+    name: 'Claude Code',
+    description: 'Anthropic 官方 CLI 工具（自动配置）',
+    configPath: '~/.claude/settings.json',
+  },
+  droid: {
+    name: 'Droid',
+    description: 'Factory 的 AI 编程工具（自动配置）',
+    configPath: '~/.factory/config.json',
+  },
+  openclaw: {
+    name: 'OpenClaw / Moltbot',
+    description: '多平台 AI 助手网关（自动配置）',
+    configPath: '~/.openclaw/openclaw.json',
+  },
+  opencode: {
+    name: 'OpenCode',
+    description: '终端 AI 编码助手（自动配置）',
+    configPath: '~/.config/opencode/opencode.json',
+  },
+  continue: {
+    name: 'Continue',
+    description: 'VS Code/JetBrains AI 插件（自动配置）',
+    configPath: '~/.continue/config.json',
+  },
+  codex: {
+    name: 'Codex CLI',
+    description: 'OpenAI Codex 命令行工具（自动配置）',
+    configPath: '~/.codex/config.toml',
+  },
+  cursor: {
+    name: 'Cursor',
+    description: 'AI 代码编辑器（需手动配置，需 Pro 订阅）',
+    configPath: 'Cursor Settings → Models',
+  },
+  cline: {
+    name: 'Cline',
+    description: 'VS Code AI 编程插件（需手动配置）',
+    configPath: 'Cline 插件设置',
+  },
+};
+
+/**
+ * 配置所有选中的工具
+ */
+export async function configureAll(apiKey, tools) {
+  const results = [];
+
+  for (const tool of tools) {
+    const configurator = toolConfigurators[tool];
+    if (configurator) {
+      try {
+        const result = await configurator(apiKey);
+        results.push({ tool: toolInfo[tool]?.name || tool, ...result });
+      } catch (error) {
+        results.push({
+          tool: toolInfo[tool]?.name || tool,
+          success: false,
+          message: error.message,
+        });
+      }
+    } else {
+      results.push({
+        tool,
+        success: false,
+        message: '暂不支持该工具',
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * 配置单个工具
+ */
+export async function configureTool(tool, apiKey) {
+  const configurator = toolConfigurators[tool];
+  if (!configurator) {
+    return { success: false, message: `不支持的工具: ${tool}` };
+  }
+
+  return await configurator(apiKey);
+}
+
+/**
+ * 列出支持的工具
+ */
+export function listTools() {
+  console.log(chalk.cyan('\n📋 支持的工具列表:\n'));
+  
+  for (const [key, info] of Object.entries(toolInfo)) {
+    console.log(chalk.green(`  ${key.padEnd(12)}`), chalk.white(info.name));
+    console.log(chalk.gray(`              ${info.description}`));
+    console.log(chalk.gray(`              配置路径: ${info.configPath}\n`));
+  }
+}
+
+/**
+ * 显示当前配置状态
+ */
+export async function showStatus() {
+  console.log(chalk.cyan('\n📊 配置状态:\n'));
+  
+  for (const [tool, info] of Object.entries(toolInfo)) {
+    const configurator = toolConfigurators[tool];
+    if (configurator && configurator.checkStatus) {
+      try {
+        const status = await configurator.checkStatus();
+        const icon = status.configured ? chalk.green('✓') : chalk.gray('○');
+        console.log(`  ${icon} ${info.name.padEnd(20)} ${status.message || ''}`);
+      } catch {
+        console.log(`  ${chalk.gray('○')} ${info.name.padEnd(20)} ${chalk.gray('未检测到')}`);
+      }
+    } else {
+      console.log(`  ${chalk.gray('?')} ${info.name.padEnd(20)} ${chalk.gray('状态检测暂不支持')}`);
+    }
+  }
+  console.log('');
+}
+
+/**
+ * 撤销配置
+ */
+export async function revokeKey(tool) {
+  const spinner = ora('正在撤销配置...').start();
+  
+  try {
+    if (tool) {
+      const configurator = toolConfigurators[tool];
+      if (configurator && configurator.revoke) {
+        await configurator.revoke();
+        spinner.succeed(`已撤销 ${toolInfo[tool]?.name || tool} 的配置`);
+      } else {
+        spinner.warn(`${tool} 暂不支持撤销操作`);
+      }
+    } else {
+      // 撤销所有
+      for (const [key, configurator] of Object.entries(toolConfigurators)) {
+        if (configurator.revoke) {
+          try {
+            await configurator.revoke();
+          } catch {
+            // 忽略单个工具的错误
+          }
+        }
+      }
+      spinner.succeed('已撤销所有配置');
+    }
+  } catch (error) {
+    spinner.fail(`撤销失败: ${error.message}`);
+  }
+}

package/src/tools/claude.js

@@ -0,0 +1,200 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { API_CONFIG, getModels } from '../index.js';
+
+/**
+ * 获取 Claude Code 配置路径
+ */
+function getClaudeConfigPaths() {
+  const home = os.homedir();
+  return {
+    // Claude Code 配置目录
+    configDir: path.join(home, '.claude'),
+    // 主配置文件 (环境变量)
+    settingsFile: path.join(home, '.claude', 'settings.json'),
+    // 登录状态文件
+    claudeJson: path.join(home, '.claude.json'),
+  };
+}
+
+/**
+ * 配置 Claude Code
+ * 使用官方推荐的 settings.json env 方式配置
+ */
+export async function configureClaudeCode(apiKey) {
+  const paths = getClaudeConfigPaths();
+  
+  try {
+    // 确保目录存在
+    await fs.ensureDir(paths.configDir);
+
+    // 1. 读取现有 settings.json（如果存在）
+    let settings = {};
+    if (await fs.pathExists(paths.settingsFile)) {
+      try {
+        const content = await fs.readFile(paths.settingsFile, 'utf-8');
+        settings = JSON.parse(content);
+      } catch {
+        settings = {};
+      }
+    }
+
+    // 2. 清理旧的 Duojie 配置（如果有）
+    // 保留用户其他配置，只更新 env 中的 Duojie 相关项
+    if (!settings.env) {
+      settings.env = {};
+    }
+
+    // 3. 获取可用的 Claude 模型
+    const models = getModels();
+    const claudeModels = models.claude || [];
+    
+    // 查找各类型模型（优先查找最新 kiro 版本）
+    let sonnetModel = null;
+    let opusModel = null;
+    
+    // 优先级：opus-4-6-kiro > opus-4-6 > opus+kiro > opus > 第一个opus
+    const opusKiro46 = claudeModels.find(m => m.id.includes('opus-4-6') && m.id.includes('kiro'));
+    const opus46 = claudeModels.find(m => m.id.includes('opus-4-6'));
+    const opusKiro = claudeModels.find(m => m.id.includes('opus') && m.id.includes('kiro'));
+    const opusAny = claudeModels.find(m => m.id.includes('opus'));
+    opusModel = opusKiro46?.id || opus46?.id || opusKiro?.id || opusAny?.id || null;
+    
+    // sonnet 模型
+    sonnetModel = claudeModels.find(m => m.id.includes('sonnet'))?.id || null;
+    
+    // 4. 设置 1314mc API 环境变量
+    settings.env.ANTHROPIC_API_KEY = apiKey;
+    settings.env.ANTHROPIC_BASE_URL = API_CONFIG.baseUrl;
+    settings.env.API_TIMEOUT_MS = "300000";
+    settings.env.ANTHROPIC_MAX_TOKENS = "16384";
+    settings.env.DISABLE_TELEMETRY = "1";
+    
+    // 配置各类型模型（不配置 haiku/fast 模型）
+    if (sonnetModel) {
+      settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL = sonnetModel;
+    }
+    if (opusModel) {
+      settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL = opusModel;
+    }
+    
+    // 默认主模型优先级：claude-sonnet-4-6 > opus > 其他 claude
+    const sonnet46 = claudeModels.find(m => m.id.includes('sonnet-4-6'))?.id || null;
+    const defaultModel = sonnet46 || opusModel || sonnetModel || claudeModels[0]?.id;
+    if (defaultModel) {
+      settings.model = defaultModel;
+    }
+    
+    // 标记为 Duojie 配置
+    settings._mc1314 = {
+      configured: true,
+      configuredAt: new Date().toISOString(),
+      models: {
+        default: defaultModel,
+        sonnet: sonnetModel,
+        opus: opusModel,
+      },
+    };
+
+    // 5. 写入 settings.json
+    await fs.writeJson(paths.settingsFile, settings, { spaces: 2 });
+
+    // 6. 创建/更新 .claude.json（跳过登录流程）
+    let claudeJson = {};
+    if (await fs.pathExists(paths.claudeJson)) {
+      try {
+        claudeJson = await fs.readJson(paths.claudeJson);
+      } catch {
+        claudeJson = {};
+      }
+    }
+    
+    claudeJson.hasCompletedOnboarding = true;
+    await fs.writeJson(paths.claudeJson, claudeJson, { spaces: 2 });
+
+    // 统计配置的模型数量
+    const configuredModels = [sonnetModel, opusModel].filter(Boolean).length;
+
+    return {
+      success: true,
+      message: `已配置 ${configuredModels} 个模型 → ${paths.settingsFile}`,
+      configPath: paths.settingsFile,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `配置失败: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * 检查 Claude Code 配置状态
+ */
+configureClaudeCode.checkStatus = async function() {
+  const paths = getClaudeConfigPaths();
+  
+  if (await fs.pathExists(paths.settingsFile)) {
+    try {
+      const settings = await fs.readJson(paths.settingsFile);
+      
+      // 检查是否有 Duojie 配置
+      if (settings._mc1314?.configured || 
+          settings.env?.ANTHROPIC_BASE_URL?.includes('duojie') ||
+          settings.env?.ANTHROPIC_BASE_URL?.includes('1314mc')) {
+        return {
+          configured: true,
+          message: '已配置 1314mc API',
+        };
+      } else if (settings.env?.ANTHROPIC_API_KEY || settings.env?.ANTHROPIC_AUTH_TOKEN) {
+        return {
+          configured: true,
+          message: '已配置（非 1314mc）',
+        };
+      }
+    } catch {
+      // ignore
+    }
+  }
+  
+  return { configured: false };
+};
+
+/**
+ * 撤销 Claude Code 配置
+ */
+configureClaudeCode.revoke = async function() {
+  const paths = getClaudeConfigPaths();
+  
+  if (await fs.pathExists(paths.settingsFile)) {
+    try {
+      const settings = await fs.readJson(paths.settingsFile);
+      
+      // 只删除 Duojie 相关的环境变量
+      if (settings.env) {
+        delete settings.env.ANTHROPIC_API_KEY;
+        delete settings.env.ANTHROPIC_AUTH_TOKEN;
+        delete settings.env.ANTHROPIC_BASE_URL;
+        delete settings.env.API_TIMEOUT_MS;
+        delete settings.env.ANTHROPIC_MAX_TOKENS;
+        delete settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+        delete settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+        
+        // 如果 env 为空，删除整个 env
+        if (Object.keys(settings.env).length === 0) {
+          delete settings.env;
+        }
+      }
+      
+      delete settings.model;
+      delete settings._mc1314;
+      
+      await fs.writeJson(paths.settingsFile, settings, { spaces: 2 });
+    } catch {
+      // ignore
+    }
+  }
+};
+
+export default configureClaudeCode;

package/src/tools/cline.js

@@ -0,0 +1,103 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { API_CONFIG } from '../index.js';
+
+/**
+ * 获取 Cline 配置路径 (VS Code 插件)
+ */
+function getClineConfigPaths() {
+  const home = os.homedir();
+  const platform = os.platform();
+  
+  let vscodeDir;
+  if (platform === 'win32') {
+    vscodeDir = path.join(process.env.APPDATA || home, 'Code', 'User');
+  } else if (platform === 'darwin') {
+    vscodeDir = path.join(home, 'Library', 'Application Support', 'Code', 'User');
+  } else {
+    vscodeDir = path.join(home, '.config', 'Code', 'User');
+  }
+  
+  return {
+    configDir: vscodeDir,
+    settingsFile: path.join(vscodeDir, 'settings.json'),
+    // Cline 全局存储
+    globalStorageDir: path.join(vscodeDir, 'globalStorage', 'saoudrizwan.claude-dev'),
+  };
+}
+
+/**
+ * 配置 Cline
+ * Cline 需要通过 UI 手动配置，这里输出配置信息
+ */
+export async function configureCline(apiKey) {
+  const baseUrl = API_CONFIG.baseUrl;
+  
+  // 生成配置说明
+  const instructions = `
+${chalk.yellow('Cline 需要在 VS Code 中手动配置:')}
+
+${chalk.cyan('步骤 1:')} 打开 VS Code，点击左侧 Cline 图标
+${chalk.cyan('步骤 2:')} 点击设置图标 (⚙️)
+${chalk.cyan('步骤 3:')} 选择 "Use your own API Key"
+${chalk.cyan('步骤 4:')} 填入以下配置:
+
+  ${chalk.green('API Provider:')}  OpenAI Compatible
+  ${chalk.green('Base URL:')}      ${baseUrl}
+  ${chalk.green('API Key:')}       ${apiKey}
+  ${chalk.green('Model:')}         选择 "Enter model ID" 并输入模型名称
+                   例如: gpt-5.4 或 claude-opus-4-6
+
+${chalk.cyan('步骤 5:')} 可选配置:
+  • ${chalk.green('Max Tokens:')} 16384 (推荐)
+  • Context Window Size: 200000
+  • 取消勾选 "Support Images"（如果模型不支持）
+
+${chalk.gray('提示: 配置完成后即可在 Cline 中使用 1314mc API')}
+`;
+
+  return {
+    success: true,
+    manual: true,
+    message: '需要手动配置',
+    instructions: instructions,
+    configInfo: {
+      provider: 'OpenAI Compatible',
+      baseUrl: baseUrl,
+      apiKey: apiKey,
+    }
+  };
+}
+
+/**
+ * 检查 Cline 配置状态
+ */
+configureCline.checkStatus = async function() {
+  const paths = getClineConfigPaths();
+  
+  // Cline 配置存储在插件的 globalStorage 中，不在 settings.json
+  // 这里只能检测插件是否安装
+  if (await fs.pathExists(paths.globalStorageDir)) {
+    return {
+      configured: true,
+      message: 'Cline 插件已安装（配置状态需在 VS Code 中查看）',
+    };
+  }
+  
+  return { 
+    configured: false,
+    message: 'Cline 插件未安装或未使用过',
+  };
+};
+
+/**
+ * 撤销 Cline 配置
+ */
+configureCline.revoke = async function() {
+  // Cline 配置在插件内部，无法通过文件操作撤销
+  console.log(chalk.yellow('Cline 配置需要在 VS Code 的 Cline 插件设置中手动清除'));
+};
+
+export default configureCline;