ccbot-cli 2.0.1 → 2.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 telagod
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/adapters/claude.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SETTINGS_TEMPLATE = {
+  $schema: 'https://json.schemastore.org/claude-code-settings.json',
+  env: {
+    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+  },
+  alwaysThinkingEnabled: true,
+  model: 'opus',
+  outputStyle: 'abyss-cultivator',
+  attribution: { commit: '', pr: '' },
+  permissions: {
+    allow: [
+      'Bash', 'LS', 'Read', 'Agent', 'Write', 'Edit', 'MultiEdit',
+      'Glob', 'Grep', 'WebFetch', 'WebSearch', 'TodoWrite',
+      'NotebookRead', 'NotebookEdit'
+    ]
+  }
+};
+
+const CCLINE_CMD = process.platform === 'win32' ? 'ccline' : '~/.claude/ccline/ccline';
+const CCLINE_STATUS_LINE = {
+  statusLine: {
+    type: 'command',
+    command: CCLINE_CMD,
+    padding: 0
+  }
+};
+
+function getClaudeCoreFiles() {
+  return [
+    { src: 'config/CLAUDE.md', dest: 'CLAUDE.md' },
+    { src: 'output-styles', dest: 'output-styles' },
+    { src: 'skills', dest: 'skills' },
+  ];
+}
+
+function detectClaudeAuth({
+  settings = {},
+  HOME,
+  env = process.env,
+  warn = () => {}
+}) {
+  const settingsEnv = settings.env || {};
+  if (settingsEnv.ANTHROPIC_BASE_URL && settingsEnv.ANTHROPIC_AUTH_TOKEN) {
+    return { type: 'custom', detail: settingsEnv.ANTHROPIC_BASE_URL };
+  }
+  if (env.ANTHROPIC_API_KEY) return { type: 'env', detail: 'ANTHROPIC_API_KEY' };
+  if (env.ANTHROPIC_BASE_URL && env.ANTHROPIC_AUTH_TOKEN) {
+    return { type: 'env-custom', detail: env.ANTHROPIC_BASE_URL };
+  }
+
+  const cred = path.join(HOME, '.claude', '.credentials.json');
+  if (fs.existsSync(cred)) {
+    try {
+      const cc = JSON.parse(fs.readFileSync(cred, 'utf8'));
+      if (cc.claudeAiOauth || cc.apiKey) return { type: 'login', detail: 'claude login' };
+    } catch (e) {
+      warn(`凭证文件损坏: ${cred}`);
+    }
+  }
+
+  return null;
+}
+
+async function configureCustomProvider(ctx, { ok }) {
+  const { confirm, input } = await import('@inquirer/prompts');
+  const doCfg = await confirm({ message: '配置自定义 provider?', default: false });
+  if (!doCfg) return;
+
+  if (!ctx.settings.env) ctx.settings.env = {};
+  const url = await input({ message: 'ANTHROPIC_BASE_URL:' });
+  const token = await input({ message: 'ANTHROPIC_AUTH_TOKEN:' });
+  if (url) ctx.settings.env.ANTHROPIC_BASE_URL = url;
+  if (token) ctx.settings.env.ANTHROPIC_AUTH_TOKEN = token;
+
+  fs.writeFileSync(ctx.settingsPath, JSON.stringify(ctx.settings, null, 2) + '\n');
+  ok('provider 已配置');
+}
+
+function mergeSettings(ctx, { deepMergeNew, printMergeLog, c, ok }) {
+  const log = [];
+  deepMergeNew(ctx.settings, SETTINGS_TEMPLATE, '', log);
+  printMergeLog(log, c);
+  fs.writeFileSync(ctx.settingsPath, JSON.stringify(ctx.settings, null, 2) + '\n');
+  ok('settings.json 合并完成');
+}
+
+async function postClaude({
+  ctx,
+  autoYes,
+  HOME,
+  PKG_ROOT,
+  step,
+  ok,
+  warn,
+  info,
+  c,
+  deepMergeNew,
+  printMergeLog,
+  installCcline
+}) {
+  step(2, 3, '认证检测');
+  const auth = detectClaudeAuth({ settings: ctx.settings, HOME, warn });
+  if (auth) {
+    ok(`${c.b(auth.type)} → ${auth.detail}`);
+  } else {
+    warn('未检测到 API 认证');
+    info(`支持: ${c.cyn('claude login')} | ${c.cyn('ANTHROPIC_API_KEY')} | ${c.cyn('自定义 provider')}`);
+    if (!autoYes) await configureCustomProvider(ctx, { ok });
+  }
+
+  step(3, 3, '可选配置');
+  if (autoYes) {
+    info('自动模式: 合并推荐配置');
+    mergeSettings(ctx, { deepMergeNew, printMergeLog, c, ok });
+    await installCcline(ctx, { HOME, PKG_ROOT, CCLINE_STATUS_LINE, ok, warn, info, c });
+    return;
+  }
+
+  const { checkbox } = await import('@inquirer/prompts');
+  const choices = await checkbox({
+    message: '选择要安装的配置 (空格选择, 回车确认)',
+    choices: [
+      { name: '精细合并推荐 settings.json (保留现有配置)', value: 'settings', checked: true },
+      { name: '安装 ccline 状态栏 (需要 Nerd Font)', value: 'ccline', checked: true },
+    ],
+  });
+
+  if (choices.includes('settings')) {
+    mergeSettings(ctx, { deepMergeNew, printMergeLog, c, ok });
+  }
+  if (choices.includes('ccline')) {
+    await installCcline(ctx, { HOME, PKG_ROOT, CCLINE_STATUS_LINE, ok, warn, info, c });
+  }
+}
+
+module.exports = {
+  SETTINGS_TEMPLATE,
+  CCLINE_STATUS_LINE,
+  getClaudeCoreFiles,
+  detectClaudeAuth,
+  configureCustomProvider,
+  mergeSettings,
+  postClaude,
+};

package/bin/adapters/codex.js

@@ -0,0 +1,439 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const CODEX_DEFAULTS = {
+  approvalPolicy: 'on-request',
+  sandboxMode: 'workspace-write',
+  featureFlag: 'multi_agent',
+};
+
+const LEGACY_FEATURES = {
+  removed: [
+    'search_tool',
+    'request_rule',
+    'experimental_windows_sandbox',
+    'elevated_windows_sandbox',
+    'remote_models',
+    'collaboration_modes',
+    'steer',
+  ],
+  deprecated: [
+    'web_search_request',
+    'web_search_cached',
+  ],
+};
+
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function isTableHeader(line) {
+  return /^\s*\[[^\]]+\]\s*$/.test(line);
+}
+
+function isProjectTableHeader(line) {
+  return /^\s*\[projects\."[^"]+"\]\s*$/.test(line);
+}
+
+function isAssignmentForKey(line, key) {
+  const re = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`);
+  return re.test(line);
+}
+
+function hasRootKey(content, key) {
+  const lines = content.split(/\r?\n/);
+  let inRoot = true;
+
+  for (const line of lines) {
+    if (isTableHeader(line)) {
+      inRoot = false;
+      continue;
+    }
+    if (inRoot && isAssignmentForKey(line, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function readRootStringKey(content, key) {
+  const lines = content.split(/\r?\n/);
+  const re = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"`);
+  let inRoot = true;
+
+  for (const line of lines) {
+    if (isTableHeader(line)) {
+      inRoot = false;
+      continue;
+    }
+    if (!inRoot) continue;
+    const m = line.match(re);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+function hasSection(content, sectionName) {
+  const re = new RegExp(`^\\s*\\[${escapeRegExp(sectionName)}\\]\\s*$`, 'm');
+  return re.test(content);
+}
+
+function hasKeyInSection(content, sectionName, key) {
+  const lines = content.split(/\r?\n/);
+  const sectionRe = new RegExp(`^\\s*\\[${escapeRegExp(sectionName)}\\]\\s*$`);
+  const anySectionRe = /^\s*\[[^\]]+\]\s*$/;
+  const keyRe = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`);
+  let inSection = false;
+
+  for (const line of lines) {
+    if (sectionRe.test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && anySectionRe.test(line)) {
+      return false;
+    }
+    if (inSection && keyRe.test(line)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function appendLine(content, line, eol) {
+  if (!content) return `${line}${eol}`;
+  const normalized = content.endsWith('\n') ? content : `${content}${eol}`;
+  return `${normalized}${line}${eol}`;
+}
+
+function insertRootLine(content, line, eol) {
+  if (!content) return `${line}${eol}`;
+  const lines = content.split(/\r?\n/);
+  const firstSection = lines.findIndex((l) => isTableHeader(l));
+  const idx = firstSection === -1 ? lines.length : firstSection;
+  lines.splice(idx, 0, line);
+  return lines.join(eol);
+}
+
+function ensureRootKey(content, key, valueLiteral, eol) {
+  if (hasRootKey(content, key)) return { merged: content, added: false };
+  return { merged: insertRootLine(content, `${key} = ${valueLiteral}`, eol), added: true };
+}
+
+function insertLineAfterSectionHeader(content, sectionName, line, eol) {
+  const lines = content.split(/\r?\n/);
+  const sectionRe = new RegExp(`^\\s*\\[${escapeRegExp(sectionName)}\\]\\s*$`);
+  const idx = lines.findIndex((l) => sectionRe.test(l));
+  if (idx === -1) return appendLine(content, line, eol);
+  lines.splice(idx + 1, 0, line);
+  return lines.join(eol);
+}
+
+function ensureKeyInSection(content, sectionName, key, valueLiteral, eol) {
+  let merged = content;
+  let added = false;
+
+  if (!hasSection(merged, sectionName)) {
+    merged = appendLine(merged, `[${sectionName}]`, eol);
+    merged = appendLine(merged, `${key} = ${valueLiteral}`, eol);
+    added = true;
+  } else if (!hasKeyInSection(merged, sectionName, key)) {
+    merged = insertLineAfterSectionHeader(merged, sectionName, `${key} = ${valueLiteral}`, eol);
+    added = true;
+  }
+
+  return { merged, added };
+}
+
+function parseTomlBooleanAssignment(line) {
+  const m = line.match(/=\s*(true|false)\b/i);
+  if (!m) return null;
+  return m[1].toLowerCase() === 'true';
+}
+
+function removeKeyAssignmentsInNonRootSections(content, key) {
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const lines = content.split(/\r?\n/);
+  const kept = [];
+  let inRoot = true;
+  let removed = false;
+
+  for (const line of lines) {
+    if (isTableHeader(line)) {
+      inRoot = false;
+      kept.push(line);
+      continue;
+    }
+    if (!inRoot && isAssignmentForKey(line, key)) {
+      removed = true;
+      continue;
+    }
+    kept.push(line);
+  }
+
+  return { merged: kept.join(eol), removed };
+}
+
+function removeProjectTrustSectionsForFullAccess(content) {
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const sandboxMode = readRootStringKey(content, 'sandbox_mode');
+  if (sandboxMode !== 'danger-full-access') {
+    return { merged: content, removed: false };
+  }
+
+  const lines = content.split(/\r?\n/);
+  const kept = [];
+  let inProjectSection = false;
+  let removed = false;
+
+  for (const line of lines) {
+    if (isTableHeader(line)) {
+      if (isProjectTableHeader(line)) {
+        inProjectSection = true;
+        removed = true;
+        continue;
+      }
+      inProjectSection = false;
+      kept.push(line);
+      continue;
+    }
+    if (inProjectSection) continue;
+    kept.push(line);
+  }
+
+  return { merged: kept.join(eol), removed };
+}
+
+function removeFeatureFlagsFromFeaturesSection(content, featureNames) {
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const lines = content.split(/\r?\n/);
+  const sectionRe = /^\s*\[features\]\s*$/;
+  const anySectionRe = /^\s*\[[^\]]+\]\s*$/;
+  const assignRe = /^\s*([A-Za-z0-9_.-]+)\s*=/;
+  const featureSet = new Set(featureNames);
+  const removedEntries = [];
+
+  let inFeatures = false;
+  const kept = [];
+
+  for (const line of lines) {
+    if (sectionRe.test(line)) {
+      inFeatures = true;
+      kept.push(line);
+      continue;
+    }
+    if (inFeatures && anySectionRe.test(line)) {
+      inFeatures = false;
+      kept.push(line);
+      continue;
+    }
+    if (inFeatures) {
+      const m = line.match(assignRe);
+      if (m && featureSet.has(m[1])) {
+        removedEntries.push({ key: m[1], enabled: parseTomlBooleanAssignment(line) });
+        continue;
+      }
+    }
+    kept.push(line);
+  }
+
+  return { merged: kept.join(eol), removedEntries };
+}
+
+function uniq(values) {
+  return [...new Set(values)];
+}
+
+function cleanupLegacyCodexConfig(content) {
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const toRemove = [...LEGACY_FEATURES.removed, ...LEGACY_FEATURES.deprecated];
+  const { merged: pruned, removedEntries } = removeFeatureFlagsFromFeaturesSection(content, toRemove);
+  let merged = pruned;
+  const removed = uniq(removedEntries.map((x) => x.key));
+  const migrated = [];
+
+  const deprecatedRemoved = removedEntries.filter((x) => LEGACY_FEATURES.deprecated.includes(x.key));
+  if (deprecatedRemoved.length > 0) {
+    const shouldEnableWebSearch = deprecatedRemoved.some((x) => x.enabled !== false);
+    const { merged: withTools, added } = ensureKeyInSection(
+      merged,
+      'tools',
+      'web_search',
+      shouldEnableWebSearch ? 'true' : 'false',
+      eol
+    );
+    merged = withTools;
+    if (added) migrated.push(`tools.web_search=${shouldEnableWebSearch ? 'true' : 'false'}`);
+  }
+
+  return { merged, removed, migrated };
+}
+
+function mergeCodexConfigDefaults(content) {
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  let merged = content;
+  const added = [];
+
+  const rootKeys = [
+    'approval_policy',
+    'sandbox_mode',
+    'model_reasoning_effort',
+    'disable_response_storage',
+    'personality',
+  ];
+
+  for (const key of rootKeys) {
+    const cleaned = removeKeyAssignmentsInNonRootSections(merged, key);
+    merged = cleaned.merged;
+  }
+
+  const approval = ensureRootKey(merged, 'approval_policy', `"${CODEX_DEFAULTS.approvalPolicy}"`, eol);
+  merged = approval.merged;
+  if (approval.added) {
+    added.push('approval_policy');
+  }
+
+  const sandbox = ensureRootKey(merged, 'sandbox_mode', `"${CODEX_DEFAULTS.sandboxMode}"`, eol);
+  merged = sandbox.merged;
+  if (sandbox.added) {
+    added.push('sandbox_mode');
+  }
+
+  if (!hasSection(merged, 'features')) {
+    merged = appendLine(merged, '[features]', eol);
+    merged = appendLine(merged, `${CODEX_DEFAULTS.featureFlag} = true`, eol);
+    added.push('features.multi_agent');
+  } else if (!hasKeyInSection(merged, 'features', CODEX_DEFAULTS.featureFlag)) {
+    merged = insertLineAfterSectionHeader(merged, 'features', `${CODEX_DEFAULTS.featureFlag} = true`, eol);
+    added.push('features.multi_agent');
+  }
+
+  return { merged, added };
+}
+
+function patchCodexConfig(cfgPath) {
+  const raw = fs.readFileSync(cfgPath, 'utf8');
+  const { merged: cleaned, removed, migrated } = cleanupLegacyCodexConfig(raw);
+  const { merged: mergedDefaults, added } = mergeCodexConfigDefaults(cleaned);
+  const { merged, removed: removedProjectTrust } = removeProjectTrustSectionsForFullAccess(mergedDefaults);
+  const removedAll = removedProjectTrust ? [...removed, 'projects.*.trust_level'] : removed;
+
+  if (merged !== raw) fs.writeFileSync(cfgPath, merged);
+  return { added, removed: removedAll, migrated };
+}
+
+function patchCodexConfigDefaults(cfgPath) {
+  return patchCodexConfig(cfgPath).added;
+}
+
+function patchAndReportCodexDefaults({ cfgPath, ok, warn }) {
+  try {
+    const { added, removed, migrated } = patchCodexConfig(cfgPath);
+    const changes = [];
+    if (added.length > 0) changes.push(`补全默认项: ${added.join(', ')}`);
+    if (removed.length > 0) changes.push(`清理过时项: ${removed.join(', ')}`);
+    if (migrated.length > 0) changes.push(`迁移配置: ${migrated.join(', ')}`);
+    if (changes.length > 0) ok(`config.toml 已存在，${changes.join('；')}`);
+    else ok('config.toml 已存在');
+  } catch (e) {
+    warn(`config.toml 读取失败，跳过补全: ${e.message}`);
+  }
+}
+
+function detectCodexAuth({
+  HOME,
+  env = process.env,
+  warn = () => {}
+}) {
+  if (env.OPENAI_API_KEY) return { type: 'env', detail: 'OPENAI_API_KEY' };
+
+  const auth = path.join(HOME, '.codex', 'auth.json');
+  if (fs.existsSync(auth)) {
+    try {
+      const a = JSON.parse(fs.readFileSync(auth, 'utf8'));
+      if (a.token || a.api_key) return { type: 'login', detail: 'codex login' };
+    } catch (e) {
+      warn(`凭证文件损坏: ${auth}`);
+    }
+  }
+
+  const cfg = path.join(HOME, '.codex', 'config.toml');
+  if (fs.existsSync(cfg) && fs.readFileSync(cfg, 'utf8').includes('base_url')) {
+    return { type: 'custom', detail: 'config.toml' };
+  }
+
+  return null;
+}
+
+function getCodexCoreFiles() {
+  return [
+    { src: 'config/AGENTS.md', dest: 'AGENTS.md' },
+    { src: 'skills', dest: 'skills' },
+  ];
+}
+
+async function postCodex({
+  autoYes,
+  HOME,
+  PKG_ROOT,
+  step,
+  ok,
+  warn,
+  info,
+  c
+}) {
+  const { confirm } = await import('@inquirer/prompts');
+  const cfgPath = path.join(HOME, '.codex', 'config.toml');
+  const exists = fs.existsSync(cfgPath);
+
+  step(2, 3, '认证检测');
+  const auth = detectCodexAuth({ HOME, warn });
+  if (auth) {
+    ok(`${c.b(auth.type)} → ${auth.detail}`);
+  } else {
+    warn('未检测到 API 认证');
+    info(`支持: ${c.cyn('codex login')} | ${c.cyn('OPENAI_API_KEY')} | ${c.cyn('自定义 provider')}`);
+  }
+
+  step(3, 3, '可选配置');
+  if (autoYes) {
+    if (!exists) {
+      const src = path.join(PKG_ROOT, 'config', 'codex-config.example.toml');
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, cfgPath);
+        ok('写入: ~/.codex/config.toml (模板)');
+        warn('请编辑 base_url 和 model');
+      }
+    } else {
+      patchAndReportCodexDefaults({ cfgPath, ok, warn });
+    }
+    return;
+  }
+
+  if (!exists) {
+    warn('未检测到 ~/.codex/config.toml');
+    const doWrite = await confirm({ message: '写入推荐 config.toml (含自定义 provider 模板)?', default: true });
+    if (doWrite) {
+      const src = path.join(PKG_ROOT, 'config', 'codex-config.example.toml');
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, cfgPath);
+        ok('写入: ~/.codex/config.toml');
+        warn('请编辑 base_url 和 model');
+      }
+    }
+  } else {
+    patchAndReportCodexDefaults({ cfgPath, ok, warn });
+  }
+}
+
+module.exports = {
+  cleanupLegacyCodexConfig,
+  mergeCodexConfigDefaults,
+  patchCodexConfig,
+  patchCodexConfigDefaults,
+  detectCodexAuth,
+  getCodexCoreFiles,
+  postCodex,
+};