lingyao-ai 0.2.0

package/README.md

@@ -0,0 +1,53 @@
+# lingyao-ai
+
+A customizable setup CLI that behaves like `npx leishen-ai`, with your own configuration.
+
+## Features
+
+- Configure Codex and/or Claude Code in one interactive flow.
+- Optional auto-install checks for `@openai/codex` and `@anthropic-ai/claude-code`.
+- Writes and backs up:
+  - `~/.claude/config.json`
+  - `~/.codex/config.toml`
+  - `~/.codex/auth.json`
+  - `~/.codex/.env`
+  - shell RC block (`.zshrc`, `.bashrc`, etc.)
+- On Windows, optionally patch VSCode ChatGPT extension model order.
+
+## 1) Customize your config
+
+Edit `project.config.json`:
+
+- `brand.*`: product name and shell marker.
+- `apiKey.*`: API key format and env variable name.
+- `endpoints.*`: your gateway domain and paths.
+- `cli.*`: min Node version, npm mirror, package names.
+- `claude.*` / `codex.*`: provider defaults and target files.
+- `codex.windowsVscodePatch.*`: Windows extension patch behavior.
+
+## 2) Run locally
+
+```bash
+cd /Users/espresso/Project/lingyao-ai
+node cli.js
+```
+
+Use a custom config file:
+
+```bash
+node cli.js --config /absolute/path/to/project.config.json
+```
+
+## 3) Publish and use with npx
+
+Package name is already set to `lingyao-ai`.
+
+```bash
+npm publish --access public
+```
+
+Then users can run:
+
+```bash
+npx lingyao-ai
+```

package/cli.js

@@ -0,0 +1,871 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const readline = require('readline')
+const { spawnSync } = require('child_process')
+
+const DEFAULT_CONFIG_PATH = path.join(__dirname, 'project.config.json')
+
+function exitGracefully() {
+  console.log('\nCancelled.')
+  process.exit(0)
+}
+
+process.on('SIGINT', exitGracefully)
+
+function showHelp() {
+  console.log(`
+Usage:
+  node cli.js [--config /abs/path/to/project.config.json]
+
+Options:
+  -c, --config   Use a custom configuration file.
+  -h, --help     Show help.
+`)
+}
+
+function parseArgs(argv) {
+  let configPath = DEFAULT_CONFIG_PATH
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '-h' || arg === '--help') {
+      showHelp()
+      process.exit(0)
+    }
+    if (arg === '-c' || arg === '--config') {
+      const next = argv[i + 1]
+      if (!next) {
+        throw new Error('Missing value for --config')
+      }
+      configPath = path.resolve(next)
+      i += 1
+    }
+  }
+  return { configPath }
+}
+
+function loadConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`)
+  }
+  const raw = fs.readFileSync(configPath, 'utf8')
+  const cfg = JSON.parse(raw)
+  validateConfig(cfg)
+  return cfg
+}
+
+function validateConfig(cfg) {
+  const required = [
+    ['brand.name', cfg?.brand?.name],
+    ['brand.shellMarker', cfg?.brand?.shellMarker],
+    ['apiKey.regex', cfg?.apiKey?.regex],
+    ['apiKey.example', cfg?.apiKey?.example],
+    ['apiKey.envKey', cfg?.apiKey?.envKey],
+    ['endpoints.baseOrigin', cfg?.endpoints?.baseOrigin],
+    ['endpoints.claudePath', cfg?.endpoints?.claudePath],
+    ['endpoints.codexPath', cfg?.endpoints?.codexPath],
+    ['cli.packages.codex', cfg?.cli?.packages?.codex],
+    ['cli.packages.claude', cfg?.cli?.packages?.claude],
+    ['claude.configPath', cfg?.claude?.configPath],
+    ['claude.primaryApiKey', cfg?.claude?.primaryApiKey],
+    ['claude.baseUrlEnvKey', cfg?.claude?.baseUrlEnvKey],
+    ['claude.authTokenEnvKey', cfg?.claude?.authTokenEnvKey],
+    ['codex.configDir', cfg?.codex?.configDir],
+    ['codex.providerName', cfg?.codex?.providerName],
+    ['codex.defaultModel', cfg?.codex?.defaultModel],
+    ['codex.reasoningEffort', cfg?.codex?.reasoningEffort],
+    ['codex.wireApi', cfg?.codex?.wireApi]
+  ]
+
+  const missing = required.filter(([, value]) => !value).map(([key]) => key)
+  if (missing.length > 0) {
+    throw new Error(`Config missing required fields: ${missing.join(', ')}`)
+  }
+
+  try {
+    new RegExp(cfg.apiKey.regex)
+  } catch (error) {
+    throw new Error(`Invalid apiKey.regex: ${error.message}`)
+  }
+}
+
+function joinUrl(base, subPath) {
+  const left = String(base || '').replace(/\/+$/, '')
+  const right = String(subPath || '').replace(/^\/+/, '')
+  return right ? `${left}/${right}` : left
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true })
+  }
+}
+
+function backupFileIfExists(filePath, suffix = '.bak') {
+  if (!fs.existsSync(filePath)) return null
+  const backupPath = `${filePath}${suffix}`
+  if (!fs.existsSync(backupPath)) {
+    fs.copyFileSync(filePath, backupPath)
+  }
+  return backupPath
+}
+
+function writeJson(filePath, data) {
+  ensureDir(path.dirname(filePath))
+  const backupPath = backupFileIfExists(filePath)
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8')
+  return { filePath, backupPath }
+}
+
+function writeText(filePath, content) {
+  ensureDir(path.dirname(filePath))
+  const backupPath = backupFileIfExists(filePath)
+  fs.writeFileSync(filePath, content, 'utf8')
+  return { filePath, backupPath }
+}
+
+function upsertDotenvFile(filePath, envVars) {
+  ensureDir(path.dirname(filePath))
+  const backupPath = backupFileIfExists(filePath)
+  const content = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : ''
+  const lines = content.split(/\r?\n/)
+  const remaining = new Set(Object.keys(envVars))
+
+  const updatedLines = lines.map((line) => {
+    const trimmed = String(line || '').trim()
+    if (!trimmed || trimmed.startsWith('#')) return line
+
+    const eqIdx = String(line).indexOf('=')
+    if (eqIdx === -1) return line
+
+    const key = String(line)
+      .slice(0, eqIdx)
+      .trim()
+    if (!Object.prototype.hasOwnProperty.call(envVars, key)) return line
+
+    remaining.delete(key)
+    return `${key}=${envVars[key]}`
+  })
+
+  for (const key of remaining) {
+    updatedLines.push(`${key}=${envVars[key]}`)
+  }
+
+  fs.writeFileSync(filePath, updatedLines.join('\n'), 'utf8')
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(filePath, 0o600)
+    } catch (_) {
+      // Ignore chmod failure.
+    }
+  }
+
+  return { filePath, backupPath }
+}
+
+function detectShellRcFiles() {
+  if (process.platform === 'win32') return []
+
+  const home = os.homedir()
+  const shell = String(process.env.SHELL || '').toLowerCase()
+  const priority = shell.includes('zsh')
+    ? ['.zshrc', '.zprofile']
+    : shell.includes('bash')
+      ? ['.bashrc', '.bash_profile']
+      : ['.zshrc', '.bashrc']
+
+  const defaults = ['.bashrc', '.bash_profile', '.profile', '.zshrc', '.zprofile']
+  const ordered = [...priority, ...defaults]
+  const seen = new Set()
+  const rcFiles = []
+
+  for (const fileName of ordered) {
+    if (seen.has(fileName)) continue
+    seen.add(fileName)
+    rcFiles.push(path.join(home, fileName))
+  }
+
+  return rcFiles
+}
+
+function updateRcFile(rcPath, envVars, marker) {
+  if (!rcPath || Object.keys(envVars).length === 0) return null
+
+  const startMarker = `# >>> ${marker}`
+  const endMarker = `# <<< ${marker}`
+  const content = fs.existsSync(rcPath) ? fs.readFileSync(rcPath, 'utf8') : ''
+  const lines = content.split(/\r?\n/)
+  const startIdx = lines.findIndex((line) => line.trim() === startMarker)
+  const endIdx = lines.findIndex((line) => line.trim() === endMarker)
+
+  if (startIdx !== -1 && endIdx !== -1 && endIdx >= startIdx) {
+    lines.splice(startIdx, endIdx - startIdx + 1)
+  }
+
+  const block = [startMarker]
+  for (const [key, value] of Object.entries(envVars)) {
+    block.push(`export ${key}="${value}"`)
+  }
+  block.push(endMarker, '')
+
+  const trimmed = lines.join('\n').trimEnd()
+  const finalContent = trimmed ? `${trimmed}\n\n${block.join('\n')}` : block.join('\n')
+  fs.writeFileSync(rcPath, finalContent, 'utf8')
+  return rcPath
+}
+
+function configureWindowsEnv(envVars) {
+  for (const [key, value] of Object.entries(envVars)) {
+    try {
+      spawnSync('setx', [key, String(value)], { stdio: 'ignore' })
+    } catch (_) {
+      // Best-effort only.
+    }
+  }
+}
+
+function askLine(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(String(answer || '').trim())
+    })
+  })
+}
+
+async function askYesNo(question, initialYes = true) {
+  const yesHint = initialYes ? 'Y/n' : 'y/N'
+  while (true) {
+    const answer = (await askLine(`${question} [${yesHint}]: `)).toLowerCase()
+    if (!answer) return initialYes
+    if (['y', 'yes'].includes(answer)) return true
+    if (['n', 'no'].includes(answer)) return false
+    console.log('Please type y or n.')
+  }
+}
+
+async function promptApiKey(apiKeyRegex, example) {
+  while (true) {
+    const key = await askLine(`Input API key (${example}): `)
+    if (apiKeyRegex.test(key)) return key
+    console.log('Invalid API key format. Try again.')
+  }
+}
+
+async function promptTargets() {
+  while (true) {
+    console.log('\nSelect target:')
+    console.log('1) Codex')
+    console.log('2) Claude Code')
+    console.log('3) Codex + Claude Code')
+    console.log('q) Quit')
+
+    const answer = (await askLine('Choice: ')).toLowerCase()
+    if (answer === '1') return ['codex']
+    if (answer === '2') return ['claude']
+    if (answer === '3') return ['codex', 'claude']
+    if (['q', 'quit', 'exit'].includes(answer)) process.exit(0)
+
+    console.log('Invalid choice.')
+  }
+}
+
+function getNodeMajorVersion() {
+  const raw = (process.versions && process.versions.node) || '0.0.0'
+  const major = Number.parseInt(String(raw).split('.')[0], 10)
+  return Number.isFinite(major) ? major : 0
+}
+
+function ensureMinimumNodeVersion(minMajor) {
+  const required = Number.isFinite(Number(minMajor)) ? Number(minMajor) : 16
+  const current = getNodeMajorVersion()
+  if (current > 0 && current < required) {
+    console.log(`Node.js ${required}+ required. Current: ${process.versions.node}`)
+    return false
+  }
+  return true
+}
+
+function findExecutableInPath(binName) {
+  const rawPath = process.env.PATH || ''
+  if (!rawPath) return null
+
+  const dirs = rawPath.split(path.delimiter).filter(Boolean)
+  const exts =
+    process.platform === 'win32'
+      ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+      : ['']
+
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const fullPath =
+        process.platform === 'win32' ? path.join(dir, `${binName}${ext}`) : path.join(dir, binName)
+      try {
+        if (fs.existsSync(fullPath)) return fullPath
+      } catch (_) {
+        // Ignore path entries that cannot be read.
+      }
+    }
+  }
+
+  return null
+}
+
+function runCommandText(command, args) {
+  let result
+  try {
+    result = spawnSync(command, args, { encoding: 'utf8' })
+  } catch (error) {
+    return { ok: false, error, stdout: '', stderr: '' }
+  }
+
+  const stdout = String(result.stdout || '')
+  const stderr = String(result.stderr || '')
+  if (result.error) {
+    return { ok: false, error: result.error, stdout, stderr }
+  }
+
+  if (result.status === 0) {
+    return { ok: true, text: stdout.trim(), stdout, stderr }
+  }
+
+  return { ok: false, status: result.status, stdout, stderr }
+}
+
+function detectCli(binName, versionArgs, npmPackageName) {
+  const executablePath = findExecutableInPath(binName)
+  if (executablePath) {
+    const versionResult = runCommandText(binName, versionArgs)
+    if (versionResult.ok) {
+      const version = versionResult.text ? versionResult.text.split('\n')[0].trim() : null
+      return {
+        state: 'ready',
+        executablePath,
+        version
+      }
+    }
+
+    return {
+      state: 'exists_but_failed',
+      executablePath,
+      stdout: versionResult.stdout,
+      stderr: versionResult.stderr
+    }
+  }
+
+  if (findExecutableInPath('npm')) {
+    const listResult = runCommandText('npm', ['ls', '-g', '--depth=0', npmPackageName])
+    if (listResult.ok) {
+      return { state: 'installed_not_on_path' }
+    }
+  }
+
+  return { state: 'not_installed' }
+}
+
+function showMirrorHint(pkgName, registry) {
+  if (!pkgName || !registry) return
+  console.log(`Hint: if install is slow, try:`)
+  console.log(`npm install -g ${pkgName} --registry=${registry}`)
+}
+
+function showInstallTroubleshoot(result) {
+  const out = `${String(result?.stdout || '')}\n${String(result?.stderr || '')}`
+  if (/EACCES|permission denied/i.test(out)) {
+    console.log('Install failed: permission issue.')
+    return
+  }
+  if (/ETARGET|E404|404 Not Found/i.test(out)) {
+    console.log('Install failed: npm registry may be out of sync.')
+    return
+  }
+  if (/ECONNRESET|ETIMEDOUT|ENOTFOUND|network/i.test(out)) {
+    console.log('Install failed: network problem detected.')
+    return
+  }
+  if (/unsupported engine|notsup|engine/i.test(out)) {
+    console.log('Install failed: Node.js version may be too low.')
+    return
+  }
+  console.log('Install failed. Check npm logs for details.')
+}
+
+function installGlobalPackage(pkgName) {
+  const result = spawnSync('npm', ['install', '-g', pkgName], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8'
+  })
+
+  if (result.error) {
+    return {
+      ok: false,
+      error: result.error,
+      stdout: '',
+      stderr: ''
+    }
+  }
+
+  if (result.status === 0) {
+    return {
+      ok: true,
+      status: 0,
+      stdout: String(result.stdout || ''),
+      stderr: String(result.stderr || '')
+    }
+  }
+
+  return {
+    ok: false,
+    status: result.status,
+    stdout: String(result.stdout || ''),
+    stderr: String(result.stderr || '')
+  }
+}
+
+async function ensureCliInstalled(options) {
+  const {
+    label,
+    binName,
+    versionArgs,
+    npmPackageName,
+    mirrorRegistry,
+    minNodeMajorForInstall
+  } = options
+
+  const detected = detectCli(binName, versionArgs, npmPackageName)
+  if (detected.state === 'ready') {
+    const ver = detected.version ? ` (${detected.version})` : ''
+    console.log(`${label} already detected${ver}.`)
+    return true
+  }
+
+  if (
+    Number.isFinite(Number(minNodeMajorForInstall)) &&
+    getNodeMajorVersion() < Number(minNodeMajorForInstall)
+  ) {
+    console.log(
+      `${label} auto install skipped: Node.js ${minNodeMajorForInstall}+ recommended. Current: ${process.versions.node}`
+    )
+    return false
+  }
+
+  if (!findExecutableInPath('npm')) {
+    console.log('npm command not found. Install Node.js/npm first.')
+    return false
+  }
+
+  if (detected.state === 'installed_not_on_path') {
+    console.log(`${label} package is installed globally, but command is not on PATH.`)
+    return false
+  }
+
+  if (detected.state === 'exists_but_failed') {
+    console.log(`${label} command exists but failed to run.`)
+    const details = String(detected.stderr || detected.stdout || '').trim()
+    if (details) {
+      console.log(details.split('\n').slice(0, 6).join('\n'))
+    }
+  }
+
+  const shouldInstall = await askYesNo(`Run npm install -g ${npmPackageName} now?`, true)
+  if (!shouldInstall) {
+    showMirrorHint(npmPackageName, mirrorRegistry)
+    return false
+  }
+
+  showMirrorHint(npmPackageName, mirrorRegistry)
+  const installResult = installGlobalPackage(npmPackageName)
+  if (!installResult.ok) {
+    showInstallTroubleshoot(installResult)
+    return false
+  }
+
+  const after = detectCli(binName, versionArgs, npmPackageName)
+  if (after.state === 'ready') {
+    const ver = after.version ? ` (${after.version})` : ''
+    console.log(`${label} installed successfully${ver}.`)
+    return true
+  }
+
+  console.log(`${label} installed, but command still not found on PATH.`)
+  return false
+}
+
+function escapeRegExp(str) {
+  return String(str).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function parseExtensionSemver(name, extensionPrefix) {
+  const safePrefix = escapeRegExp(extensionPrefix)
+  const regex = new RegExp(`^${safePrefix}(\\d+)\\.(\\d+)\\.(\\d+)(?:[-.].*)?$`, 'i')
+  const match = String(name || '').trim().match(regex)
+  if (!match) return null
+  return [Number(match[1]), Number(match[2]), Number(match[3])]
+}
+
+function compareSemverTupleDesc(left, right) {
+  const l = Array.isArray(left) ? left : []
+  const r = Array.isArray(right) ? right : []
+  const max = Math.max(l.length, r.length, 0)
+  for (let i = 0; i < max; i += 1) {
+    const lv = Number.isFinite(l[i]) ? l[i] : -1
+    const rv = Number.isFinite(r[i]) ? r[i] : -1
+    if (lv > rv) return -1
+    if (lv < rv) return 1
+  }
+  return 0
+}
+
+function listWindowsVscodeAssets(windowsPatchCfg) {
+  const home = os.homedir()
+  const extensionPrefix = String(windowsPatchCfg?.extensionPrefix || 'openai.chatgpt-')
+  const userDirs = Array.isArray(windowsPatchCfg?.userDirs)
+    ? windowsPatchCfg.userDirs
+    : ['.vscode', '.vscode-insiders']
+
+  const candidates = []
+
+  for (const userDir of userDirs) {
+    const extensionsRoot = path.join(home, String(userDir), 'extensions')
+    if (!fs.existsSync(extensionsRoot)) continue
+
+    let entries = []
+    try {
+      entries = fs.readdirSync(extensionsRoot, { withFileTypes: true })
+    } catch (_) {
+      continue
+    }
+
+    for (const entry of entries) {
+      if (!entry?.isDirectory?.()) continue
+      if (!String(entry.name).startsWith(extensionPrefix)) continue
+
+      const extensionDir = path.join(extensionsRoot, entry.name)
+      const assetsDir = path.join(extensionDir, 'webview', 'assets')
+      if (!fs.existsSync(assetsDir)) continue
+
+      let assetEntries = []
+      try {
+        assetEntries = fs.readdirSync(assetsDir, { withFileTypes: true })
+      } catch (_) {
+        continue
+      }
+
+      for (const assetEntry of assetEntries) {
+        if (!assetEntry?.isFile?.()) continue
+        if (!/^index-.*\.js$/i.test(String(assetEntry.name))) continue
+
+        const filePath = path.join(assetsDir, assetEntry.name)
+        let mtimeMs = 0
+        try {
+          mtimeMs = Number(fs.statSync(filePath)?.mtimeMs || 0)
+        } catch (_) {
+          mtimeMs = 0
+        }
+
+        candidates.push({
+          filePath,
+          extensionName: entry.name,
+          version: parseExtensionSemver(entry.name, extensionPrefix),
+          mtimeMs
+        })
+      }
+    }
+  }
+
+  candidates.sort((a, b) => {
+    const versionCmp = compareSemverTupleDesc(a.version, b.version)
+    if (versionCmp !== 0) return versionCmp
+    if (a.mtimeMs > b.mtimeMs) return -1
+    if (a.mtimeMs < b.mtimeMs) return 1
+    return 0
+  })
+
+  return candidates
+}
+
+function extractQuotedModels(expression) {
+  const models = []
+  const regex = /["']([^"']+)["']/g
+  let match = regex.exec(expression)
+  while (match) {
+    models.push(match[1])
+    match = regex.exec(expression)
+  }
+  return models
+}
+
+function patchDefaultModelOrder(content, targetModel) {
+  const match = /DEFAULT_MODEL_ORDER\s*=\s*\[([\s\S]*?)\]/.exec(content)
+  if (!match) return { status: 'marker_not_found' }
+
+  const originalModels = extractQuotedModels(match[1])
+  if (originalModels.length === 0) return { status: 'parse_failed' }
+
+  const nextModels = [targetModel, ...originalModels.filter((m) => m !== targetModel)]
+  const alreadyUpToDate =
+    originalModels.length === nextModels.length &&
+    originalModels.every((model, idx) => model === nextModels[idx])
+
+  if (alreadyUpToDate) {
+    return { status: 'already', models: originalModels }
+  }
+
+  const replacement = `DEFAULT_MODEL_ORDER=[${nextModels
+    .map((model) => JSON.stringify(model))
+    .join(',')}]`
+
+  const start = match.index
+  const end = start + match[0].length
+  const updatedContent = `${content.slice(0, start)}${replacement}${content.slice(end)}`
+  const verify = /DEFAULT_MODEL_ORDER\s*=\s*\[([\s\S]*?)\]/.exec(updatedContent)
+  if (!verify) return { status: 'verify_failed' }
+
+  const verifyModels = extractQuotedModels(verify[1])
+  if (verifyModels[0] !== targetModel) return { status: 'verify_failed' }
+
+  return { status: 'patched', content: updatedContent, models: verifyModels }
+}
+
+function patchWindowsVscodeDefaultModel(targetModel, windowsPatchCfg) {
+  if (process.platform !== 'win32') return { status: 'not_windows' }
+
+  const candidates = listWindowsVscodeAssets(windowsPatchCfg)
+  if (candidates.length === 0) return { status: 'assets_not_found' }
+
+  let parseFailed = 0
+  for (const candidate of candidates) {
+    let content = ''
+    try {
+      content = fs.readFileSync(candidate.filePath, 'utf8')
+    } catch (_) {
+      continue
+    }
+
+    const result = patchDefaultModelOrder(content, targetModel)
+    if (result.status === 'marker_not_found' || result.status === 'parse_failed') {
+      parseFailed += 1
+      continue
+    }
+
+    if (result.status === 'already') {
+      return {
+        status: 'already',
+        filePath: candidate.filePath,
+        extensionName: candidate.extensionName
+      }
+    }
+
+    if (result.status !== 'patched') {
+      continue
+    }
+
+    const backupPath = backupFileIfExists(candidate.filePath, '.backup')
+    fs.writeFileSync(candidate.filePath, result.content, 'utf8')
+
+    return {
+      status: 'patched',
+      filePath: candidate.filePath,
+      backupPath,
+      extensionName: candidate.extensionName
+    }
+  }
+
+  if (parseFailed > 0) return { status: 'pattern_not_supported' }
+  return { status: 'assets_not_found' }
+}
+
+function tomlString(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+}
+
+function renderCodexToml(cfg) {
+  const codexBaseUrl = joinUrl(cfg.endpoints.baseOrigin, cfg.endpoints.codexPath)
+  const provider = cfg.codex.providerName
+  const migrations = Object.entries(cfg.codex.modelMigrations || {})
+  const migrationSection =
+    migrations.length === 0
+      ? ''
+      : `\n[notice.model_migrations]\n${migrations
+          .map(([from, to]) => `"${tomlString(from)}" = "${tomlString(to)}"`)
+          .join('\n')}\n`
+
+  const envInstructionLine = cfg?.codex?.envKeyInstructions
+    ? `\nenv_key_instructions = "${tomlString(cfg.codex.envKeyInstructions)}"`
+    : ''
+
+  return `model_provider = "${tomlString(provider)}"
+model = "${tomlString(cfg.codex.defaultModel)}"
+model_reasoning_effort = "${tomlString(cfg.codex.reasoningEffort)}"
+disable_response_storage = true
+preferred_auth_method = "apikey"
+
+[model_providers.${provider}]
+name = "${tomlString(provider)}"
+base_url = "${tomlString(codexBaseUrl)}"
+wire_api = "${tomlString(cfg.codex.wireApi)}"
+requires_openai_auth = ${cfg.codex.requiresOpenAIAuth ? 'true' : 'false'}
+env_key = "${tomlString(cfg.apiKey.envKey)}"${envInstructionLine}${migrationSection}`
+}
+
+function configureClaude(cfg, apiKey) {
+  const home = os.homedir()
+  const claudeConfigPath = path.join(home, cfg.claude.configPath)
+  const info = writeJson(claudeConfigPath, { primaryApiKey: cfg.claude.primaryApiKey })
+  const claudeBaseUrl = joinUrl(cfg.endpoints.baseOrigin, cfg.endpoints.claudePath)
+
+  return {
+    env: {
+      [cfg.claude.baseUrlEnvKey]: claudeBaseUrl,
+      [cfg.claude.authTokenEnvKey]: apiKey
+    },
+    files: [
+      {
+        label: 'Claude config',
+        path: info.filePath,
+        backupPath: info.backupPath
+      }
+    ]
+  }
+}
+
+function configureCodex(cfg, apiKey) {
+  const home = os.homedir()
+  const codexDir = path.join(home, cfg.codex.configDir)
+  const tomlPath = path.join(codexDir, 'config.toml')
+  const authPath = path.join(codexDir, 'auth.json')
+  const envPath = path.join(codexDir, '.env')
+
+  const tomlInfo = writeText(tomlPath, renderCodexToml(cfg))
+  const authInfo = writeJson(authPath, cfg.codex.authJson || { OPENAI_API_KEY: null })
+  const envInfo = upsertDotenvFile(envPath, { [cfg.apiKey.envKey]: apiKey })
+
+  return {
+    env: {
+      [cfg.apiKey.envKey]: apiKey
+    },
+    files: [
+      { label: 'Codex config.toml', path: tomlInfo.filePath, backupPath: tomlInfo.backupPath },
+      { label: 'Codex auth.json', path: authInfo.filePath, backupPath: authInfo.backupPath },
+      { label: 'Codex .env', path: envInfo.filePath, backupPath: envInfo.backupPath }
+    ]
+  }
+}
+
+function printSummary(fileSummaries) {
+  console.log('\nCompleted changes:')
+  for (const item of fileSummaries) {
+    console.log(`- ${item.label}: ${item.path}`)
+    console.log(`  backup: ${item.backupPath || 'none (new file)'}`)
+  }
+}
+
+async function main() {
+  const { configPath } = parseArgs(process.argv.slice(2))
+  const cfg = loadConfig(configPath)
+
+  if (!ensureMinimumNodeVersion(cfg?.cli?.minNodeMajor)) {
+    process.exit(1)
+  }
+
+  console.log(`\n${cfg.brand.name}`)
+  console.log(`Config file: ${configPath}`)
+  console.log(`Base origin: ${cfg.endpoints.baseOrigin}`)
+
+  const apiKeyRegex = new RegExp(cfg.apiKey.regex)
+  const apiKey = await promptApiKey(apiKeyRegex, cfg.apiKey.example)
+  const targets = await promptTargets()
+
+  const npmMirrorRegistry = cfg?.cli?.npmMirrorRegistry || ''
+  const codexPackage = cfg.cli.packages.codex
+  const claudePackage = cfg.cli.packages.claude
+
+  if (targets.includes('codex')) {
+    await ensureCliInstalled({
+      label: 'Codex CLI',
+      binName: 'codex',
+      versionArgs: ['--version'],
+      npmPackageName: codexPackage,
+      mirrorRegistry: npmMirrorRegistry,
+      minNodeMajorForInstall: cfg?.cli?.codexMinNodeMajor
+    })
+  }
+
+  if (targets.includes('claude')) {
+    await ensureCliInstalled({
+      label: 'Claude CLI',
+      binName: 'claude',
+      versionArgs: ['--version'],
+      npmPackageName: claudePackage,
+      mirrorRegistry: npmMirrorRegistry,
+      minNodeMajorForInstall: cfg?.cli?.minNodeMajor
+    })
+  }
+
+  let envVars = {}
+  const fileSummaries = []
+
+  if (targets.includes('claude')) {
+    const result = configureClaude(cfg, apiKey)
+    envVars = { ...envVars, ...result.env }
+    fileSummaries.push(...result.files)
+  }
+
+  if (targets.includes('codex')) {
+    const result = configureCodex(cfg, apiKey)
+    envVars = { ...envVars, ...result.env }
+    fileSummaries.push(...result.files)
+
+    const windowsPatchCfg = cfg?.codex?.windowsVscodePatch
+    if (process.platform === 'win32' && windowsPatchCfg?.enabled) {
+      const shouldPatch = await askYesNo(
+        `Patch VSCode ChatGPT default model to ${cfg.codex.defaultModel}?`,
+        true
+      )
+
+      if (shouldPatch) {
+        const patchResult = patchWindowsVscodeDefaultModel(cfg.codex.defaultModel, windowsPatchCfg)
+        if (patchResult.status === 'patched') {
+          console.log(`VSCode model order patched: ${patchResult.filePath}`)
+          fileSummaries.push({
+            label: 'VSCode model order',
+            path: patchResult.filePath,
+            backupPath: patchResult.backupPath || null
+          })
+        } else if (patchResult.status === 'already') {
+          console.log(`VSCode model order already up to date: ${patchResult.filePath}`)
+        } else if (patchResult.status === 'assets_not_found') {
+          console.log('VSCode ChatGPT asset file not found, patch skipped.')
+        } else if (patchResult.status === 'pattern_not_supported') {
+          console.log('VSCode asset found but pattern not supported, patch skipped.')
+        }
+      }
+    }
+  }
+
+  if (process.platform === 'win32') {
+    configureWindowsEnv(envVars)
+    console.log('Environment variables were written with setx. Open a new terminal to apply.')
+  } else {
+    const updatedRcFiles = detectShellRcFiles()
+      .map((rcPath) => updateRcFile(rcPath, envVars, cfg.brand.shellMarker))
+      .filter(Boolean)
+
+    if (updatedRcFiles.length > 0) {
+      console.log('\nUpdated shell rc files:')
+      updatedRcFiles.forEach((filePath) => console.log(`- ${filePath}`))
+    }
+  }
+
+  printSummary(fileSummaries)
+}
+
+main().catch((error) => {
+  console.error(`Failed: ${error.message}`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "lingyao-ai",
+  "version": "0.2.0",
+  "description": "Lingyao setup CLI for Codex and Claude Code.",
+  "type": "commonjs",
+  "bin": {
+    "lingyao-ai": "cli.js",
+    "lingyao": "cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js",
+    "lint": "node --check cli.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}

package/project.config.json

@@ -0,0 +1,53 @@
+{
+  "brand": {
+    "name": "Lingyao AI",
+    "shellMarker": "lingyao-ai"
+  },
+  "apiKey": {
+    "regex": "^cr_[0-9a-f]{64}$",
+    "example": "cr_<64_hex>",
+    "envKey": "CRS_OAI_KEY"
+  },
+  "endpoints": {
+    "baseOrigin": "https://claude.chiddns.com",
+    "claudePath": "/",
+    "codexPath": "/v1"
+  },
+  "cli": {
+    "minNodeMajor": 16,
+    "codexMinNodeMajor": 18,
+    "npmMirrorRegistry": "https://registry.npmmirror.com",
+    "packages": {
+      "codex": "@openai/codex",
+      "claude": "@anthropic-ai/claude-code"
+    }
+  },
+  "claude": {
+    "configPath": ".claude/config.json",
+    "primaryApiKey": "custom-provider",
+    "baseUrlEnvKey": "ANTHROPIC_BASE_URL",
+    "authTokenEnvKey": "ANTHROPIC_AUTH_TOKEN"
+  },
+  "codex": {
+    "configDir": ".codex",
+    "providerName": "custom-provider",
+    "defaultModel": "gpt-5.4",
+    "reasoningEffort": "xhigh",
+    "wireApi": "responses",
+    "requiresOpenAIAuth": true,
+    "authJson": {
+      "OPENAI_API_KEY": null
+    },
+    "modelMigrations": {
+      "gpt-5.4": "gpt-5.4"
+    },
+    "windowsVscodePatch": {
+      "enabled": true,
+      "extensionPrefix": "openai.chatgpt-",
+      "userDirs": [
+        ".vscode",
+        ".vscode-insiders"
+      ]
+    }
+  }
+}