easyai 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0e9e5abc64041d1ca3e0a9fb59a81aa3dcdd16edfdfa716069fa17a71df1f4b
-  data.tar.gz: b729e5453a287e1e7fb6908fba42bd4516e48800eafff811d4b0fea80bb83653
+  metadata.gz: 75408704158dabc22070ec012de28eaced8080bbfc7ebd4b45e5c0481bdfe071
+  data.tar.gz: 58b0d079f864fc04c3cb82690af5f0e904b0eef17a4737dc44fa83443a66bd56
 SHA512:
-  metadata.gz: f5fa95bca000bf57323f11026e5392b90fa71d22f606e77ddf49e87420afe1b128ef8313e3c51e6940bec15a177df3bc1ba7b81de532613c23cd394556a1c2f4
-  data.tar.gz: a4b24f06ec5dfa6ea7ed8a7476619eb580f4b606151e22a0921ad7a6760775e8ee5202e7832d7bfca2a8c470664e57daa0be0ac1944ca55d3b82e502a0c779de
+  metadata.gz: 1e6e34f8e8d716042ac88d690a82a4f38a5a1a61cc1cd8e7a5fc32f09f611233d6b48439fa1234c29dd392bb021b8a7f6b8138ea9c5022888382bcb59af8259f
+  data.tar.gz: 45990675aba9f65881fa41946539ea5cffb626c0e1adf1a48f2265deb18620125040436d391b581ce71c24f86d90c53ecdaf4f8eca1e13940f89dde8e6ed8aa4

data/CLAUDE.md

@@ -272,3 +272,13 @@ CLAide::Command
   - 输入用 `IO#noecho` 不回显
   - `--list` 输出做"前 4 + 后 4 + 长度"脱敏
 - 不得把 `~/.easyai/config.json` 上传到代码仓库或日志服务
+
+## Ruby Rules
+
+编写 Ruby 代码时参考以下规范：
+- 通用编码风格：`.claude/rules/ecc/common/coding-style.md`
+- Ruby 专项规范：`.claude/rules/ecc/ruby/` 目录（coding-style / testing / security / patterns / hooks）
+
+## 提交规范
+
+提交代码时参考 `.claude/rules/git-flow/git-flow.md` 中的规范。

data/lib/easyai/base/toml_sections.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module EasyAI
+  module Base
+    # 极简 TOML "段" 处理工具：只按 table 头切块，不解析具体值。
+    #
+    # 适用范围：codex ~/.codex/config.toml 这类结构简单的文件
+    # （顶层 key/value + 若干 [table] / [a.b] 段，无多行数组 / 复杂内联表）。
+    #
+    # 提供能力：
+    #   - split_sections  把文本切成有序的段（每段含 header + 原始行）
+    #   - reject_projects 过滤掉所有 [projects.*] 段，返回新文本
+    #   - merge           段级合并：override 覆盖 base 同名段，base 独有段保留
+    module TomlSections
+      module_function
+
+      PROJECT_HEADER_PREFIX = '[projects.'
+
+      Section = Struct.new(:header, :body, keyword_init: true)
+
+      # 判断一行是否是 table 头：去掉前导空白后以 '[' 开头（含 '[[' 数组表）
+      def header_line?(line)
+        line.lstrip.start_with?('[')
+      end
+
+      # 归一化 header（整行去空白），用于同名段比对
+      def header_key(line)
+        line.strip
+      end
+
+      def project_header?(header)
+        return false if header.nil?
+
+        header.start_with?(PROJECT_HEADER_PREFIX)
+      end
+
+      # 切段：返回 [Section, ...]。文件开头无 table 头的部分作为 header=nil 的前导段。
+      def split_sections(text)
+        sections = []
+        current = Section.new(header: nil, body: +'')
+
+        text.to_s.each_line do |line|
+          if header_line?(line)
+            sections << current unless empty_preamble?(current)
+            current = Section.new(header: header_key(line), body: +line.dup)
+          else
+            current.body << line
+          end
+        end
+        sections << current unless empty_preamble?(current)
+        sections
+      end
+
+      def reject_projects(text)
+        kept = split_sections(text).reject { |s| project_header?(s.header) }
+        render(kept)
+      end
+
+      # 段级合并，override 优先：
+      #   - override 出现的 header 覆盖 base 同名段
+      #   - base 独有 header（含 [projects.*]）保留，追加在 override 具名段之后
+      #   - 前导段（header=nil）：override 非空用 override，否则用 base
+      def merge(base_text, override_text)
+        base = split_sections(base_text)
+        override = split_sections(override_text)
+        override_keys = override.map(&:header).compact
+
+        result = []
+
+        over_pre = override.find { |s| s.header.nil? }
+        base_pre = base.find { |s| s.header.nil? }
+        preamble = over_pre && !over_pre.body.strip.empty? ? over_pre : base_pre
+        result << preamble if preamble
+
+        override.each { |s| result << s unless s.header.nil? }
+        base.each do |s|
+          next if s.header.nil?
+          next if override_keys.include?(s.header)
+
+          result << s
+        end
+
+        render(result)
+      end
+
+      # ----- private -----
+
+      def render(sections)
+        sections.map { |s| ensure_trailing_newline(s.body) }.join
+      end
+
+      def ensure_trailing_newline(body)
+        return body if body.empty? || body.end_with?("\n")
+
+        "#{body}\n"
+      end
+
+      def empty_preamble?(section)
+        section.header.nil? && section.body.empty?
+      end
+
+      private_class_method :render, :ensure_trailing_newline, :empty_preamble?
+    end
+  end
+end

data/lib/easyai/command/ai_tool_base.rb

@@ -48,11 +48,12 @@ module EasyAI
 
       def run
         cfg = resolve_config
+        @resolved_config = cfg # 供子类 pre_exec 读取当前生效的平台配置
         print_platform_env(cfg)
-        env = build_environment(cfg)
-        export_environment_variables(env)
+        @env = build_environment(cfg) # 存 ivar：pre_exec 可按需追加（如 codex 注入 CODEX_HOME）
+        export_environment_variables(@env)
         pre_exec
-        exec(env, exec_command, *@passthrough_args)
+        exec(@env, exec_command, *@passthrough_args)
       rescue Config::LocalConfig::NotFoundError => e
         print_error(e.message)
         puts "  请运行: #{'easyai setup'.yellow}"
@@ -95,12 +96,19 @@ module EasyAI
         {}
       end
 
-      # 子类可选重写：在 exec 启动子进程之前执行的钩子（如：写入子进程依赖的状态文件）。
+      # 子类可选重写：在 exec 启动子进程之前执行的钩子（如：写入子进程依赖的状态文件、
+      # 追加只对本次子进程生效的环境变量到 @env，如 codex 注入 CODEX_HOME）。
       # 默认 no-op；不应阻塞主流程，异常应降级为 warning。
       def pre_exec
         # no-op
       end
 
+      # 子类可选重写：向平台选择列表注入的虚拟平台 { key => data }（如 codex 的 ChatGPT Subscribe）。
+      # 默认空；与 config.json 真实平台合并参与交互选择。
+      def extra_platforms
+        {}
+      end
+
       private
 
       # 从 remainder 中识别第一个以 .json 结尾且文件存在的位置参数作为本地覆盖入口
@@ -119,7 +127,9 @@ module EasyAI
           print_success("使用本地覆盖配置 #{@local_config_file}（工具：#{tool_name}）")
           cfg
         else
-          Config::LocalConfig.resolve_platform(tool: tool_name, platform: @platform, verbose: @verbose) do |name|
+          Config::LocalConfig.resolve_platform(
+            tool: tool_name, platform: @platform, verbose: @verbose, extra: extra_platforms
+          ) do |name|
             print_success("使用平台 #{name}（工具：#{tool_name}）")
           end
         end

data/lib/easyai/command/backup/claude.rb

@@ -27,20 +27,23 @@ module EasyAI
               $ easyai backup claude
         DESC
 
-        SOURCE_PATH = File.expand_path('~/.claude.json').freeze
-        BACKUP_DIR  = File.expand_path('~/.easyai/backup').freeze
-        BACKUP_PATH = File.join(BACKUP_DIR, '.claude.json').freeze
         EXCLUDED_KEYS = %w[projects].freeze
         KEYCHAIN_LABEL = 'Claude Code-credentials'.freeze
         KEYCHAIN_BACKUP_KEY = '_easyai_keychain'.freeze
 
+        # 注意：路径用方法动态 expand_path，避免常量在加载期冻结真实 HOME，
+        # 让 spec 切换 ENV['HOME'] 后定位失败（同 LocalConfig.config_path 的处理）
+        def source_path = File.expand_path('~/.claude.json')
+        def backup_dir  = File.expand_path('~/.easyai/backup')
+        def backup_path = File.join(backup_dir, '.claude.json')
+
         def validate!
           super
-          help! "源文件不存在: #{SOURCE_PATH}\n请先登录 Claude Code 后再备份。" unless File.exist?(SOURCE_PATH)
+          help! "源文件不存在: #{source_path}\n请先登录 Claude Code 后再备份。" unless File.exist?(source_path)
         end
 
         def run
-          source = read_json(SOURCE_PATH)
+          source = read_json(source_path)
           EXCLUDED_KEYS.each { |key| source.delete(key) }
 
           keychain_value = read_keychain_credential(KEYCHAIN_LABEL)
@@ -48,18 +51,31 @@ module EasyAI
             source[KEYCHAIN_BACKUP_KEY] = { KEYCHAIN_LABEL => keychain_value }
           end
 
-          target = File.exist?(BACKUP_PATH) ? read_json(BACKUP_PATH) : {}
+          target = File.exist?(backup_path) ? read_json(backup_path) : {}
           before_keys = target.keys
 
           merged = deep_merge(target, source)
 
-          FileUtils.mkdir_p(BACKUP_DIR)
-          File.write(BACKUP_PATH, JSON.pretty_generate(merged))
-          File.chmod(0o600, BACKUP_PATH) unless windows?
+          FileUtils.mkdir_p(backup_dir)
+          File.write(backup_path, JSON.pretty_generate(merged))
+          File.chmod(0o600, backup_path) unless windows?
 
           report(before_keys, source.keys, merged.keys, keychain_value)
         end
 
+        # 供 easyai claude 运行前调用：仅当备份不存在且源文件存在时自动备份一次。
+        # 返回是否执行了备份；任何异常降级为 warning，绝不阻塞启动。
+        def backup_if_absent
+          return false if File.exist?(backup_path)
+          return false unless File.exist?(source_path)
+
+          run
+          true
+        rescue StandardError => e
+          warn "  ⚠ 自动备份 Claude 登录信息失败（#{e.message}），继续启动"
+          false
+        end
+
         private
 
         def read_json(path)
@@ -100,8 +116,8 @@ module EasyAI
           kept    = before_keys - source_keys
 
           puts "✓ Claude 登录信息已备份"
-          puts "  源文件:   #{SOURCE_PATH}"
-          puts "  备份路径: #{BACKUP_PATH}"
+          puts "  源文件:   #{source_path}"
+          puts "  备份路径: #{backup_path}"
           puts "  排除字段: #{EXCLUDED_KEYS.join(', ')}"
           puts "  字段更新: 新增 #{added.size}，更新 #{updated.size}，保留目标独有 #{kept.size}（合计 #{after_keys.size}）"
           if keychain_value

data/lib/easyai/command/backup/codex.rb

@@ -0,0 +1,206 @@
+require 'json'
+require 'fileutils'
+require_relative '../../base/toml_sections'
+require_relative '../../base/system_info'
+
+module EasyAI
+  class Command
+    class Backup
+      class Codex < Backup
+        self.summary = '备份 Codex 登录信息'
+        self.description = <<-DESC
+          把 ~/.codex/auth.json（登录凭证）+ ~/.codex/config.toml（去除 [projects.*] 授信段）
+          合并存进单个文件 ~/.easyai/backup/.codex.json，便于跨机器迁移或灾难恢复。
+
+          特点:
+
+              * 单文件存储：auth 与 config.toml 文本一并放进 .codex.json 的 auth / config_toml 字段
+
+              * auth 字段级深度 merge：源字段覆盖/新增到备份，备份独有字段保留
+
+              * config.toml 排除 [projects.*]：本地按项目授信的段不进备份，其余段段级 merge（源覆盖）
+
+              * 安全权限：备份文件 chmod 600（仅当前用户可读写）
+
+          使用示例:
+
+              $ easyai backup codex
+        DESC
+
+        AUTH_KEY   = 'auth'.freeze
+        CONFIG_KEY = 'config_toml'.freeze
+
+        # 注意：路径用方法动态 expand_path，避免常量在加载期冻结真实 HOME，
+        # 让 spec 切换 ENV['HOME'] 后定位失败（同 LocalConfig.config_path 的处理）
+        def auth_source   = File.expand_path('~/.codex/auth.json')
+        def config_source = File.expand_path('~/.codex/config.toml')
+        def backup_dir    = File.expand_path('~/.easyai/backup')
+        def backup_path   = File.join(backup_dir, '.codex.json')
+
+        def validate!
+          super
+          ensure_file_credentials_supported!
+          help! "源文件不存在: #{auth_source}\n请先登录 Codex 后再备份。" unless File.exist?(auth_source)
+        end
+
+        def run
+          ensure_file_credentials_supported!
+          unless official_token_present?
+            puts '⚠ 未在 ~/.codex/auth.json 检测到 ChatGPT 官方登录 token（OAuth），跳过备份。'
+            puts '  如需备份，请先运行 codex 完成 ChatGPT 订阅账户登录后重试。'
+            return
+          end
+
+          perform_backup
+        end
+
+        # 供 easyai setup 选择 ChatGPT Subscribe 时复用：仅当存在官方 token 才更新备份，
+        # 效果等同 easyai backup codex。返回是否实际执行了备份。
+        def backup_if_official
+          return false unless official_token_present?
+
+          perform_backup
+          true
+        end
+
+        # 供 easyai codex 运行前调用：仅当备份不存在、源文件存在且含官方 token 时自动备份一次。
+        # 返回是否执行了备份；任何异常降级为 warning，绝不阻塞启动。
+        def backup_if_absent
+          return false if File.exist?(backup_path)
+          return false unless File.exist?(auth_source)
+          # keyring 模式下凭证不在文件里，自动备份会一路触发 help! → 每次启动刷屏；此处静默跳过
+          return false if File.exist?(config_source) && keyring_credentials_store?(File.read(config_source))
+          # 只备份真正的 ChatGPT 官方登录态；EasyAI 给 longcat/deepseek 写的纯 API Key auth.json 不在此列
+          return false unless official_token_present?
+
+          perform_backup
+          true
+        rescue StandardError => e
+          warn "  ⚠ 自动备份 Codex 登录信息失败（#{e.message}），继续启动"
+          false
+        end
+
+        # 备份文件 .codex.json 中是否含 ChatGPT 官方 OAuth token，
+        # 供 easyai codex 运行时决定是否提供 ChatGPT Subscribe 选项。
+        def backup_has_official_token?
+          return false unless File.exist?(backup_path)
+
+          oauth_token?(read_json(backup_path)[AUTH_KEY])
+        rescue StandardError
+          false
+        end
+
+        private
+
+        def perform_backup
+          FileUtils.mkdir_p(backup_dir)
+          existing = File.exist?(backup_path) ? read_json(backup_path) : {}
+
+          auth_summary = merge_auth(existing)
+          config_summary = merge_config(existing)
+
+          File.write(backup_path, JSON.pretty_generate(existing))
+          File.chmod(0o600, backup_path) unless windows?
+
+          report(auth_summary, config_summary)
+        end
+
+        # 检测 ~/.codex/auth.json 是否为 ChatGPT 官方登录（OAuth）。
+        def official_token_present?
+          return false unless File.exist?(auth_source)
+
+          oauth_token?(read_json(auth_source))
+        rescue StandardError
+          false
+        end
+
+        # auth hash 是否带 ChatGPT OAuth 凭证：含非空 tokens 段，或 auth_mode == "chatgpt"。
+        # 仅有第三方 OPENAI_API_KEY 不算。
+        def oauth_token?(auth)
+          return false unless auth.is_a?(Hash)
+
+          tokens = auth['tokens']
+          has_oauth = tokens.is_a?(Hash) && tokens.values.any? { |v| !v.to_s.strip.empty? }
+          has_oauth || auth['auth_mode'].to_s == 'chatgpt'
+        end
+
+        def ensure_file_credentials_supported!
+          return unless File.exist?(config_source)
+
+          return unless keyring_credentials_store?(File.read(config_source))
+
+          help! <<~MSG
+            当前 Codex 配置 cli_auth_credentials_store = "keyring"，凭证存储在系统钥匙串中。
+            easyai backup codex 目前只支持 file/auth.json 凭证备份，请先改用 file 存储或手动备份系统钥匙串凭证。
+          MSG
+        end
+
+        def keyring_credentials_store?(toml_text)
+          toml_text.to_s.each_line.any? do |line|
+            line.match?(/^\s*cli_auth_credentials_store\s*=\s*["']keyring["']\s*(?:#.*)?$/)
+          end
+        end
+
+        # 把 ~/.codex/auth.json 深度 merge 进 existing[AUTH_KEY]，返回统计
+        def merge_auth(existing)
+          source = read_json(auth_source)
+          target = existing[AUTH_KEY].is_a?(Hash) ? existing[AUTH_KEY] : {}
+          before = target.keys
+          existing[AUTH_KEY] = deep_merge(target, source)
+
+          {
+            added: (source.keys - before).size,
+            updated: (source.keys & before).size,
+            kept: (before - source.keys).size,
+            total: existing[AUTH_KEY].keys.size
+          }
+        end
+
+        # 把 config.toml（去 projects）段级 merge 进 existing[CONFIG_KEY]，返回统计
+        def merge_config(existing)
+          return nil unless File.exist?(config_source)
+
+          raw = File.read(config_source)
+          excluded = Base::TomlSections.split_sections(raw)
+                                       .count { |s| Base::TomlSections.project_header?(s.header) }
+          filtered = Base::TomlSections.reject_projects(raw)
+          base = existing[CONFIG_KEY].is_a?(String) ? existing[CONFIG_KEY] : ''
+          existing[CONFIG_KEY] = Base::TomlSections.merge(base, filtered)
+
+          { excluded_projects: excluded }
+        end
+
+        def read_json(path)
+          JSON.parse(File.read(path))
+        rescue JSON::ParserError => e
+          raise "解析 JSON 失败 (#{path}): #{e.message}"
+        end
+
+        def deep_merge(target, source)
+          target.merge(source) do |_key, old_val, new_val|
+            if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+              deep_merge(old_val, new_val)
+            else
+              new_val
+            end
+          end
+        end
+
+        def report(auth, config)
+          puts "✓ Codex 登录信息已备份"
+          puts "  备份文件: #{backup_path}"
+          puts "  auth:        新增 #{auth[:added]}，更新 #{auth[:updated]}，保留备份独有 #{auth[:kept]}（合计 #{auth[:total]}）"
+          if config
+            puts "  config.toml: 已备份（排除 #{config[:excluded_projects]} 个 [projects.*] 授信段）"
+          else
+            puts "  config.toml: 源文件不存在，跳过"
+          end
+        end
+
+        def windows?
+          Base::SystemInfo.windows?
+        end
+      end
+    end
+  end
+end

data/lib/easyai/command/backup.rb

@@ -8,10 +8,12 @@ module EasyAI
         可用命令:
 
             * claude - 备份 Claude Code 登录信息
+            * codex  - 备份 Codex 登录信息
 
         使用示例:
 
             $ easyai backup claude    # 备份 ~/.claude.json（去除 projects）到 ~/.easyai/backup/.claude.json
+            $ easyai backup codex     # 备份 ~/.codex/auth.json + config.toml（去除 [projects.*]）到 ~/.easyai/backup/.codex.json
       DESC
 
       self.abstract_command = true
@@ -21,3 +23,4 @@ end
 
 # 加载子命令
 require_relative 'backup/claude'
+require_relative 'backup/codex'

data/lib/easyai/command/claude.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'fileutils'
 require 'open3'
 require_relative 'ai_tool_base'
+require_relative 'backup'
 
 module EasyAI
   class Command
@@ -57,6 +58,8 @@ DESC
       # 会清掉 OAuth 状态。EasyAI 设计前提是统一走 ANTHROPIC_AUTH_TOKEN 环境变量路径，OAuth 登录
       # 态由 `easyai backup claude` / `easyai restore claude` 显式管理。
       def pre_exec
+        # 方案 A：清理 OAuth 残留前先兜底备份，确保首次运行可恢复（仅当备份缺失时触发）
+        Backup::Claude.new(CLAide::ARGV.new([])).backup_if_absent
         reset_claude_state_to_token_mode
         delete_keychain_credential(KEYCHAIN_LABEL)
       end

data/lib/easyai/command/clean.rb

@@ -9,18 +9,17 @@ module EasyAI
     # 清理 AI CLI 自身在本地产生的缓存与配置目录。
     #
     # 设计要点（详见 docs/设计文档.md §2.6）：
-    #   - 仅清理三家 AI CLI（claude / gemini / codex）的缓存路径
+    #   - 仅清理两家 AI CLI（claude / codex）的缓存路径
     #   - 不会触碰 ~/.easyai/config.json（重置 EasyAI 自身配置请用 easyai setup --reset）
     #   - --force 跳过确认；--dry-run 仅打印
     #   - 删除时遇到 Errno::EACCES 继续删余下项；最终如有失败项以退出码 1 退出
     class Clean < Command
       self.summary = '清理 AI CLI 自身缓存（不影响 EasyAI 配置）'
       self.description = <<-DESC
-清理 claude / gemini / codex 各自在本地产生的缓存目录与配置文件。
+清理 claude / codex 各自在本地产生的缓存目录与配置文件。
 
 支持范围：
     * claude → ~/.claude、~/.claude.json、~/.config/claude
-    * gemini → ~/.gemini、~/.config/gemini
     * codex  → ~/.codex、~/.config/codex
     * all    → 上述全部
 
@@ -37,12 +36,11 @@ module EasyAI
     $ easyai setup --reset
 DESC
 
-      VALID_TOOLS = %w[claude gemini codex all].freeze
+      VALID_TOOLS = %w[claude codex all].freeze
 
       # AI CLI 自身的缓存路径表（不含 ~/.easyai/config.json）
       CACHE_PATHS = {
         'claude' => %w[~/.claude ~/.claude.json ~/.config/claude],
-        'gemini' => %w[~/.gemini ~/.config/gemini],
         'codex'  => %w[~/.codex ~/.config/codex]
       }.freeze
 

data/lib/easyai/command/codex.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'fileutils'
 require_relative 'ai_tool_base'
+require_relative 'backup'
+require_relative 'restore'
+require_relative '../base/system_info'
 
 module EasyAI
   class Command
@@ -34,6 +39,231 @@ DESC
       def install_hint
         '未找到 codex CLI。请安装：npm install -g @openai/codex'
       end
+
+      # 部分第三方端点无法只靠环境变量接入 Codex：需要在 <profile>.config.toml
+      # 写自定义 model_provider（model / wire_api 等无法用环境变量表达）。
+      #   · LongCat 用 Responses API（wire_api=responses），文档：https://longcat.chat/platform/docs/zh/Codex.html
+      #   · DeepSeek：codex 已移除 wire_api="chat"（2026-02-01），只认 responses；故此处也写 responses。
+      #     注意：实测 https://api.deepseek.com/v1/responses 返回 404（DeepSeek 仅实现 /chat/completions），
+      #     该 profile 能加载但运行时可能 404，待 DeepSeek 支持 Responses API 或在前面加协议转换代理。
+      #
+      # 实现策略（凭证隔离 + 配置共享）：按 base_url 标记匹配 → 给该平台分配独立的
+      # CODEX_HOME（~/.easyai/codex-home/<profile>），把 auth.json + profile layer 作为
+      # 真实文件写进去，其余（config.toml / prompts / sessions …）软链回 ~/.codex 共享；
+      # 再注入 CODEX_HOME + --profile。这样各平台 auth.json 物理隔离——可同时开多个终端跑
+      # 不同平台互不覆盖（如 LongCat 与 ChatGPT 官方并行），而用户的全局 config.toml 仍共享。
+      # 官方 / ChatGPT Subscribe 不走此路径，继续用默认 ~/.codex。新增端点只需往本表追加一项。
+      PROFILE_SPECS = [
+        {
+          profile: 'longcat',
+          marker: 'api.longcat.chat',
+          toml: <<~TOML
+            model_provider = "codex"
+            model = "LongCat-2.0"
+            disable_response_storage = true
+            web_search = "disabled"
+            model_reasoning_effort = "high"
+            model_supports_reasoning_summaries = true
+
+            [model_providers.codex]
+            name = "codex"
+            base_url = "https://api.longcat.chat/openai/v1"
+            wire_api = "responses"
+            requires_openai_auth = true
+          TOML
+        },
+        {
+          profile: 'deepseek',
+          marker: 'api.deepseek.com',
+          toml: <<~TOML
+            model_provider = "deepseek"
+            model = "deepseek-v4-pro"
+            disable_response_storage = true
+            web_search = "disabled"
+            model_reasoning_effort = "high"
+            model_supports_reasoning_summaries = true
+
+            [model_providers.deepseek]
+            name = "deepseek"
+            base_url = "https://api.deepseek.com/v1"
+            wire_api = "responses"
+            requires_openai_auth = true
+          TOML
+        }
+      ].freeze
+
+      # ChatGPT Subscribe 虚拟平台标记（写入虚拟平台 data，runtime 据此还原官方 token）
+      CHATGPT_SUBSCRIBE_MARKER = 'chatgpt_subscribe'
+
+      # 存在含官方 token 的备份时，向 codex 平台选择列表注入「ChatGPT Subscribe」虚拟项。
+      # 复用 openai_official 这个 key（PLATFORM_DISPLAY_NAMES 已映射为「ChatGPT Subscribe」），
+      # 选中后用备份里的官方 OAuth token 还原 auth.json，再原生启动 codex。
+      def extra_platforms
+        return {} unless Backup::Codex.new(CLAide::ARGV.new([])).backup_has_official_token?
+
+        { 'openai_official' => { 'env' => {}, CHATGPT_SUBSCRIBE_MARKER => true } }
+      end
+
+      def pre_exec
+        # 方案 A：运行前兜底备份 Codex 登录信息（仅当备份缺失时触发），确保可恢复
+        Backup::Codex.new(CLAide::ARGV.new([])).backup_if_absent
+
+        # ChatGPT Subscribe：从备份还原官方 OAuth token 后原生启动，不走 provider profile
+        if chatgpt_subscribe_selected?
+          restore_chatgpt_subscribe
+          return
+        end
+
+        # 命中自定义 provider：写独立 profile layer + 注入 --profile，不污染 config.toml
+        spec = matched_profile_spec
+        apply_profile(spec) if spec
+      end
+
+      private
+
+      def chatgpt_subscribe_selected?
+        @resolved_config.is_a?(Hash) && @resolved_config[CHATGPT_SUBSCRIBE_MARKER]
+      end
+
+      # 用备份里的官方 token 还原 auth.json（仅 auth，不动 config.toml）。异常降级为 warning。
+      def restore_chatgpt_subscribe
+        restored = Restore::Codex.new(CLAide::ARGV.new([])).restore_auth_only
+        if restored
+          puts '  ✓ 已从备份恢复 ChatGPT 官方登录信息（~/.codex/auth.json）'
+        else
+          warn '  ⚠ 备份中未找到可恢复的官方登录信息'
+        end
+      rescue StandardError => e
+        warn "  ⚠ 恢复 ChatGPT 官方登录失败（#{e.message}），继续启动"
+      end
+
+      # 按当前生效平台的 OPENAI_BASE_URL 匹配 profile 规格；未命中返回 nil
+      def matched_profile_spec
+        env = @resolved_config.is_a?(Hash) ? @resolved_config['env'] : nil
+        base_url = env.is_a?(Hash) ? (env['OPENAI_BASE_URL'] || env['openai_base_url']) : nil
+        return nil if base_url.to_s.empty?
+
+        PROFILE_SPECS.find { |spec| base_url.to_s.include?(spec[:marker]) }
+      end
+
+      # 默认 CODEX_HOME 与隔离 home 根目录
+      DEFAULT_CODEX_HOME = '~/.codex'
+      ISOLATED_HOME_ROOT = '~/.easyai/codex-home'
+
+      # 给命中平台分配独立 CODEX_HOME：软链共享 ~/.codex 下的配置 → 写真实 auth.json + profile
+      # layer → 注入 CODEX_HOME + --profile。异常降级为 warning，不阻塞 exec。
+      #
+      # 前置校验：这些第三方端点必须用 OPENAI_API_KEY；缺 key 则整体跳过隔离（不注入 CODEX_HOME /
+      # --profile），避免"隔离目录没有 auth.json 却打印成功、codex 启动找不到凭证"的误导态。
+      def apply_profile(spec)
+        key = platform_api_key
+        if key.to_s.empty?
+          warn "  ⚠ 平台缺少 OPENAI_API_KEY，跳过 CODEX_HOME 隔离，按默认 ~/.codex 启动"
+          return
+        end
+
+        home = isolated_home_for(spec[:profile])
+        link_shared_home(File.expand_path(DEFAULT_CODEX_HOME), home)
+        write_layer(spec, home)
+        write_clean_auth_json(home, key)
+        inject_codex_home(home)
+        ensure_profile_arg(spec[:profile])
+        puts "  ✓ 使用隔离的 CODEX_HOME：#{home}（auth.json 独立，config.toml 等已链接共享）"
+      rescue StandardError => e
+        warn "  ⚠ 应用 Codex provider profile（#{spec[:profile]}）失败（#{e.message}），继续启动"
+      end
+
+      def platform_api_key
+        return nil unless @resolved_config.is_a?(Hash)
+
+        @resolved_config.dig('env', 'OPENAI_API_KEY')
+      end
+
+      def isolated_home_for(profile)
+        File.expand_path("#{ISOLATED_HOME_ROOT}/#{profile}")
+      end
+
+      # 隔离目录内必须"各自独立"的真实文件名：不参与软链共享（否则会写穿污染 ~/.codex）
+      def isolation_names
+        ['auth.json', *PROFILE_SPECS.map { |s| "#{s[:profile]}.config.toml" }]
+      end
+
+      # 把 src(~/.codex) 下除隔离文件外的条目，逐个共享进隔离 home（config.toml / prompts /
+      # sessions … 共享）。dest 由本工具独占，重复运行幂等；src 不存在则仅建目录。
+      #
+      # 跨平台策略：非 Windows 用软链（运行时实时共享，codex 写 [projects.*] 授信能回写 ~/.codex）；
+      # Windows 上 File.symlink 常因缺 SeCreateSymbolicLinkPrivilege 抛错，退而用复制——每次启动
+      # 重跑本方法幂等覆盖，等于"启动时刻同步"共享配置，规避软链权限限制。
+      def link_shared_home(src, dest)
+        FileUtils.mkdir_p(dest)
+        File.chmod(0o700, dest) unless Base::SystemInfo.windows?
+        return unless File.directory?(src)
+
+        Dir.each_child(src) do |name|
+          next if isolation_names.include?(name)
+
+          share_entry(File.join(dest, name), File.join(src, name))
+        end
+      end
+
+      def share_entry(dest_path, src_path)
+        if Base::SystemInfo.windows?
+          refresh_copy(dest_path, src_path)
+        else
+          refresh_symlink(dest_path, src_path)
+        end
+      end
+
+      # 幂等地把 link_path 指向 target。已是正确软链则跳过；旧软链先删；已是真实文件则不动。
+      def refresh_symlink(link_path, target)
+        if File.symlink?(link_path)
+          return if File.readlink(link_path) == target
+
+          File.delete(link_path)
+        elsif File.exist?(link_path)
+          return
+        end
+        File.symlink(target, link_path)
+      end
+
+      # Windows 复制共享：整体覆盖复制（dest 由本工具独占，天然幂等）。src 为目录则递归复制。
+      def refresh_copy(dest_path, src_path)
+        FileUtils.rm_rf(dest_path)
+        FileUtils.cp_r(src_path, dest_path)
+      end
+
+      # 把 CODEX_HOME 追加到本次子进程 env（@env 由基类 run 赋值，exec 时透传给子进程）。
+      # 只改 @env、不碰全局 ENV：exec 已显式传 @env，污染当前进程 ENV 既多余又会泄漏到测试。
+      def inject_codex_home(home)
+        @env['CODEX_HOME'] = home if @env.is_a?(Hash)
+      end
+
+      def write_layer(spec, home)
+        path = File.join(home, "#{spec[:profile]}.config.toml")
+        write_real_file(path, spec[:toml])
+      end
+
+      # 写入纯净的 auth.json：只保留 OPENAI_API_KEY，清除 auth_mode / tokens / last_refresh
+      # 等 ChatGPT OAuth 残留，避免 Codex 优先走 OAuth 而忽略 API Key（这些端点必须用 API Key）。
+      # 整文件覆盖，写进隔离 home，本工具独占写主权，无需深度 merge。key 由 apply_profile 预校验非空。
+      def write_clean_auth_json(home, key)
+        write_real_file(File.join(home, 'auth.json'), JSON.pretty_generate({ 'OPENAI_API_KEY' => key }))
+      end
+
+      # 写真实文件到隔离 home：若同名位置残留软链先删（防止写穿到共享 ~/.codex），再整文件覆盖 + 600
+      def write_real_file(path, content)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.delete(path) if File.symlink?(path)
+        File.write(path, content)
+        File.chmod(0o600, path) unless Base::SystemInfo.windows?
+      end
+
+      # 注入 --profile <profile>；用户已显式指定 profile（--profile[=x] / -p）时不覆盖
+      def ensure_profile_arg(profile)
+        return if @passthrough_args.any? { |a| a == '--profile' || a == '-p' || a.start_with?('--profile=') }
+
+        @passthrough_args.unshift('--profile', profile)
+      end
     end
   end
 end

data/lib/easyai/command/restore/codex.rb

@@ -0,0 +1,165 @@
+require 'json'
+require 'fileutils'
+require_relative '../../base/toml_sections'
+require_relative '../../base/system_info'
+
+module EasyAI
+  class Command
+    class Restore
+      class Codex < Restore
+        self.summary = '恢复 Codex 登录信息'
+        self.description = <<-DESC
+          把 easyai backup codex 生成的 ~/.easyai/backup/.codex.json 合并回 ~/.codex/。
+
+          特点:
+
+              * auth 字段级深度 merge：备份字段覆盖/新增，目标独有字段保留
+
+              * config.toml 段级 merge：备份段（不含 [projects.*]）覆盖/新增回目标，
+                目标本地的 [projects.*] 授信段及其他独有段原样保留
+
+              * 安全权限：恢复后的文件仍 chmod 600
+
+          使用示例:
+
+              $ easyai restore codex
+        DESC
+
+        AUTH_KEY   = 'auth'.freeze
+        CONFIG_KEY = 'config_toml'.freeze
+
+        # 注意：路径用方法动态 expand_path，避免常量在加载期冻结真实 HOME
+        def auth_target   = File.expand_path('~/.codex/auth.json')
+        def config_target = File.expand_path('~/.codex/config.toml')
+        def codex_dir     = File.expand_path('~/.codex')
+        def backup_path   = File.expand_path('~/.easyai/backup/.codex.json')
+
+        def validate!
+          super
+          help! "备份文件不存在: #{backup_path}\n请先运行 easyai backup codex 创建备份。" unless File.exist?(backup_path)
+          ensure_file_credentials_supported!
+        end
+
+        def run
+          FileUtils.mkdir_p(codex_dir)
+          backup = read_json(backup_path)
+          ensure_file_credentials_supported!(backup)
+
+          auth_summary = restore_auth(backup[AUTH_KEY])
+          config_summary = restore_config(backup[CONFIG_KEY])
+
+          report(auth_summary, config_summary)
+        end
+
+        # 仅还原 auth.json（供 easyai codex 选择 ChatGPT Subscribe 时取回官方 token），
+        # 不触碰 config.toml。返回是否实际还原。异常由调用方处理。
+        def restore_auth_only
+          return false unless File.exist?(backup_path)
+
+          auth = read_json(backup_path)[AUTH_KEY]
+          return false unless auth.is_a?(Hash) && !auth.empty?
+
+          FileUtils.mkdir_p(codex_dir)
+          restore_auth(auth)
+          true
+        end
+
+        private
+
+        def ensure_file_credentials_supported!(backup = nil)
+          backup ||= read_json(backup_path)
+          if keyring_credentials_store?(backup[CONFIG_KEY])
+            help! <<~MSG
+              备份中的 Codex 配置 cli_auth_credentials_store = "keyring"，凭证原本存储在系统钥匙串中。
+              easyai restore codex 目前只支持 file/auth.json 凭证还原，无法自动恢复 keyring 凭证。
+            MSG
+          end
+
+          return unless File.exist?(config_target)
+          return unless keyring_credentials_store?(File.read(config_target))
+
+          help! <<~MSG
+            当前 Codex 配置 cli_auth_credentials_store = "keyring"，Codex 将从系统钥匙串读取凭证。
+            easyai restore codex 目前只支持 file/auth.json 凭证还原，请先改用 file 存储或手动恢复系统钥匙串凭证。
+          MSG
+        end
+
+        def keyring_credentials_store?(toml_text)
+          toml_text.to_s.each_line.any? do |line|
+            line.match?(/^\s*cli_auth_credentials_store\s*=\s*["']keyring["']\s*(?:#.*)?$/)
+          end
+        end
+
+        def restore_auth(source)
+          source = {} unless source.is_a?(Hash)
+          target = File.exist?(auth_target) ? read_json(auth_target) : {}
+          before = target.keys
+          merged = deep_merge(target, source)
+
+          # 冲突消解：OAuth 模式（有 tokens）与 API Key 模式互斥。
+          # 备份中含 tokens 说明当时走的是 ChatGPT OAuth，恢复时必须清除 OPENAI_API_KEY，
+          # 否则 Codex 可能优先用 API Key 请求 OpenAI 官方 API 而忽略 OAuth token。
+          if merged.is_a?(Hash) && merged.key?('tokens')
+            merged.delete('OPENAI_API_KEY')
+          end
+
+          File.write(auth_target, JSON.pretty_generate(merged))
+          File.chmod(0o600, auth_target) unless windows?
+
+          {
+            added: (source.keys - before).size,
+            updated: (source.keys & before).size,
+            kept: (before - source.keys).size,
+            total: merged.keys.size
+          }
+        end
+
+        def restore_config(backup_text)
+          return nil unless backup_text.is_a?(String) && !backup_text.empty?
+
+          target_text = File.exist?(config_target) ? File.read(config_target) : ''
+          kept_projects = Base::TomlSections.split_sections(target_text)
+                                            .count { |s| Base::TomlSections.project_header?(s.header) }
+          # base=目标（保留其 projects 等独有段），override=备份（非 projects 段覆盖）
+          merged = Base::TomlSections.merge(target_text, backup_text)
+
+          File.write(config_target, merged)
+          File.chmod(0o600, config_target) unless windows?
+
+          { kept_projects: kept_projects }
+        end
+
+        def read_json(path)
+          JSON.parse(File.read(path))
+        rescue JSON::ParserError => e
+          raise "解析 JSON 失败 (#{path}): #{e.message}"
+        end
+
+        def deep_merge(target, source)
+          target.merge(source) do |_key, old_val, new_val|
+            if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+              deep_merge(old_val, new_val)
+            else
+              new_val
+            end
+          end
+        end
+
+        def report(auth, config)
+          puts "✓ Codex 登录信息已恢复"
+          puts "  目标目录: #{codex_dir}"
+          puts "  auth:        新增 #{auth[:added]}，更新 #{auth[:updated]}，保留目标独有 #{auth[:kept]}（合计 #{auth[:total]}）"
+          if config
+            puts "  config.toml: 已恢复（保留本地 #{config[:kept_projects]} 个 [projects.*] 授信段）"
+          else
+            puts "  config.toml: 备份中不含，跳过"
+          end
+        end
+
+        def windows?
+          Base::SystemInfo.windows?
+        end
+      end
+    end
+  end
+end

data/lib/easyai/command/restore.rb

@@ -9,10 +9,12 @@ module EasyAI
         可用命令:
 
             * claude - 恢复 Claude Code 登录信息
+            * codex  - 恢复 Codex 登录信息
 
         使用示例:
 
             $ easyai restore claude    # 把 ~/.easyai/backup/.claude.json 深度 merge 回 ~/.claude.json
+            $ easyai restore codex     # 把 ~/.easyai/backup/.codex.json 合并回 ~/.codex/（保留本地 [projects.*]）
       DESC
 
       self.abstract_command = true
@@ -22,3 +24,4 @@ end
 
 # 加载子命令
 require_relative 'restore/claude'
+require_relative 'restore/codex'

data/lib/easyai/command/setup.rb

@@ -6,6 +6,7 @@ require 'colored2'
 require_relative '../command'
 require_relative '../config/local_config'
 require_relative '../base/secret_masker'
+require_relative 'backup'
 
 module EasyAI
   class Command
@@ -100,34 +101,41 @@ DESC
               'ANTHROPIC_DEFAULT_SONNET_MODEL' => 'glm-5-turbo',
               'ANTHROPIC_DEFAULT_HAIKU_MODEL' => 'glm-4.5-air'
             }
-          }
-        },
-        'gemini' => {
-          'google_official' => {
-            label: 'Google 官方',
-            required_env: %w[GEMINI_API_KEY],
-            optional_env: {}
+          },
+          'longcat' => {
+            label: 'LongCat（美团，兼容 Anthropic 协议）',
+            required_env: %w[ANTHROPIC_AUTH_TOKEN],
+            fixed_env: {
+              'ANTHROPIC_BASE_URL' => 'https://api.longcat.chat/anthropic',
+              'ANTHROPIC_MODEL' => 'LongCat-2.0',
+              'ANTHROPIC_SMALL_FAST_MODEL' => 'LongCat-2.0',
+              'ANTHROPIC_DEFAULT_SONNET_MODEL' => 'LongCat-2.0',
+              'ANTHROPIC_DEFAULT_OPUS_MODEL' => 'LongCat-2.0',
+              'CLAUDE_CODE_MAX_OUTPUT_TOKENS' => '131072',
+              'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC' => '1'
+            }
           }
         },
         'codex' => {
           'openai_official' => {
-            label: 'OpenAI 官方',
-            required_env: %w[OPENAI_API_KEY],
-            optional_env: {
-              'OPENAI_BASE_URL' => 'https://api.openai.com/v1'
-            }
-          },
-          'azure_openai' => {
-            label: 'Azure OpenAI',
-            required_env: %w[AZURE_OPENAI_API_KEY AZURE_OPENAI_ENDPOINT],
-            optional_env: {}
+            label: 'ChatGPT Subscribe（使用 ChatGPT 订阅账户授权信息）',
+            # 不录入 API Key：直接复用 ~/.codex 的 ChatGPT OAuth 登录态，
+            # 配置动作 = 等同 easyai backup codex（仅当存在官方 token 时更新备份）
+            chatgpt_subscribe: true
           },
           'deepseek' => {
-            label: 'DeepSeek（兼容 OpenAI 协议）',
+            label: 'DeepSeek（兼容 OpenAI 协议，codex 自动写 responses provider profile）',
             required_env: %w[OPENAI_API_KEY],
-            optional_env: {
+            fixed_env: {
               'OPENAI_BASE_URL' => 'https://api.deepseek.com/v1'
             }
+          },
+          'longcat' => {
+            label: 'LongCat（美团，兼容 OpenAI 协议）',
+            required_env: %w[OPENAI_API_KEY],
+            fixed_env: {
+              'OPENAI_BASE_URL' => 'https://api.longcat.chat/openai/v1'
+            }
           }
         }
       }.freeze
@@ -137,7 +145,7 @@ DESC
 
       def self.options
         [
-          ['--tool=NAME', '指定要配置的工具（claude / gemini / codex）'],
+          ['--tool=NAME', '指定要配置的工具（claude / codex）'],
           ['--add=PLATFORM', '在指定工具下追加或覆盖单个平台'],
           ['--remove=PLATFORM', '在指定工具下删除单个平台'],
           ['--list', '脱敏方式展示当前所有配置'],
@@ -192,7 +200,7 @@ DESC
         puts "schema 版本：#{cfg['version']}"
 
         printed_any = false
-        %w[claude gemini codex].each do |tool|
+        %w[claude codex].each do |tool|
           tool_cfg = cfg[tool]
           next unless tool_cfg.is_a?(Hash)
 
@@ -211,7 +219,7 @@ DESC
         # 列出未列入三家但用户自定义的工具键
         cfg.each do |key, value|
           next if key == 'version'
-          next if %w[claude gemini codex].include?(key)
+          next if %w[claude codex].include?(key)
           next unless value.is_a?(Hash) && value['platforms'].is_a?(Hash)
 
           printed_any = true
@@ -307,11 +315,17 @@ DESC
 
         unless tool_known.key?(@add)
           print_error("未知平台：#{@add}（不在 KNOWN_PLATFORMS[#{@tool}] 中）")
-          puts "  可用平台：#{tool_known.keys.join(', ')}"
+          puts "  可用平台：#{known_platform_keys(@tool).join(', ')}"
           puts '  提示：如确需新增自定义平台，可使用 --edit 手工编辑 config.json'
           exit 1
         end
 
+        if Config::LocalConfig.disabled_platform?(@tool, @add)
+          print_error("平台 #{@add} 已被屏蔽（暂不可用）")
+          puts "  可用平台：#{known_platform_keys(@tool).join(', ')}"
+          exit 1
+        end
+
         existing = Config::LocalConfig.available_platforms(@tool).include?(@add)
         if existing
           print_status('覆盖', "#{@tool} / #{@add}（已存在，将覆盖原有数据）")
@@ -392,7 +406,7 @@ DESC
         tools.each do |tool|
           puts
           puts "[#{tool}]".green.bold
-          available = KNOWN_PLATFORMS[tool].keys
+          available = known_platform_keys(tool)
           chosen = select_multi(
             "  请选择 #{tool} 下要配置的平台（逗号分隔多个序号，回车默认全部）",
             available, allow_all_default: true
@@ -426,7 +440,7 @@ DESC
         end
 
         tools.each do |tool|
-          available_known = KNOWN_PLATFORMS[tool].keys
+          available_known = known_platform_keys(tool)
           puts
           puts "[#{tool}]".green.bold
           chosen = select_multi(
@@ -487,15 +501,27 @@ DESC
         end
       end
 
+      # 返回某工具下「未被屏蔽」的内置平台模板 key（屏蔽清单见 LocalConfig::DISABLED_PLATFORMS）
+      def known_platform_keys(tool)
+        KNOWN_PLATFORMS[tool].keys.reject { |p| Config::LocalConfig.disabled_platform?(tool, p) }
+      end
+
       # 收集单个平台的 env / proxy 数据
       def collect_platform_data(tool, platform)
         spec = KNOWN_PLATFORMS.dig(tool, platform) || {}
+        return collect_chatgpt_subscribe_data if spec[:chatgpt_subscribe]
+
         env = {}
 
         Array(spec[:required_env]).each do |key|
           env[key] = ask_required(key)
         end
 
+        (spec[:fixed_env] || {}).each do |key, value|
+          env[key] = value.to_s
+          print_status('默认', "#{key} = #{value}")
+        end
+
         (spec[:optional_env] || {}).each do |key, default|
           env[key] = ask_optional(key, default)
         end
@@ -507,6 +533,20 @@ DESC
         data
       end
 
+      # ChatGPT Subscribe：不录入 API Key，直接复用 ~/.codex 的 ChatGPT OAuth 登录态。
+      # 配置动作等同 easyai backup codex —— 仅当 auth.json 存在官方 token 时才更新备份。
+      # 平台数据本身为空 env（runtime 直接用原生 auth.json 启动 codex）。
+      def collect_chatgpt_subscribe_data
+        backup = Command::Backup::Codex.new(CLAide::ARGV.new([]))
+        if backup.backup_if_official
+          print_success('已备份当前 ChatGPT 官方登录信息（~/.codex/auth.json → ~/.easyai/backup/.codex.json）')
+        else
+          print_warning('未检测到 ChatGPT 官方登录 token，已跳过备份。请先运行 codex 完成 ChatGPT 登录后再配置。')
+        end
+
+        { 'env' => {} }
+      end
+
       def ask_required(key)
         loop do
           if sensitive_key?(key)

data/lib/easyai/config/local_config.rb

@@ -62,13 +62,27 @@ module EasyAI
         'deepseek' => 'DeepSeek',
         'glm' => 'GLM（Coding Plan）',
         'kimi' => 'Kimi',
-        'minimax' => 'MiniMax'
+        'longcat' => 'LongCat（美团）',
+        'minimax' => 'MiniMax',
+        'openai_official' => 'ChatGPT Subscribe'
       }.freeze
 
       def platform_display_name(key)
         PLATFORM_DISPLAY_NAMES.fetch(key, key)
       end
 
+      # 已屏蔽的平台：保留模板与 config 数据，仅暂不对外提供（setup 不列出、runtime 不可选）。
+      # codex/deepseek：新版 codex 移除了 wire_api="chat"，而 DeepSeek 暂无 Responses API
+      # （/responses 实测 404），接入即失败，故先屏蔽。待 DeepSeek 支持 Responses 或接入协议
+      # 转换代理后，从本表删除该项即可恢复（profile 模板与 KNOWN_PLATFORMS 条目均未删除）。
+      DISABLED_PLATFORMS = {
+        'codex' => %w[deepseek]
+      }.freeze
+
+      def disabled_platform?(tool, platform)
+        Array(DISABLED_PLATFORMS[tool]).include?(platform)
+      end
+
       def available_platforms(tool)
         return [] unless exists?
 
@@ -81,16 +95,31 @@ module EasyAI
 
       # 解析平台配置。选定平台后会 yield 平台名（如果给了 block），
       # 让上层（AIToolBase）负责打印 UI 提示，保持 LocalConfig 的输出最小化。
-      def resolve_platform(tool:, platform: nil, verbose: false)
+      # extra：调用方注入的虚拟平台 { key => data }（如 codex 的 ChatGPT Subscribe），
+      # 与 config.json 中真实平台合并参与选择；选中虚拟平台时返回其 data。
+      def resolve_platform(tool:, platform: nil, verbose: false, extra: {})
         cfg = load
         tool_cfg = cfg[tool]
         platforms = tool_cfg.is_a?(Hash) ? tool_cfg['platforms'] : nil
-        if !platforms.is_a?(Hash) || platforms.empty?
+        platforms = {} unless platforms.is_a?(Hash)
+        extra = {} unless extra.is_a?(Hash)
+
+        # 显式指定了已屏蔽平台：直接拒绝（extra 虚拟平台不受屏蔽影响）
+        if platform && !platform.empty? && disabled_platform?(tool, platform) && !extra.key?(platform)
+          raise PlatformNotFoundError, "工具 #{tool} 的平台 #{platform} 已被屏蔽（暂不可用）"
+        end
+
+        # 屏蔽清单中的真实平台不参与选择（保留 config 数据，仅隐藏）
+        visible = platforms.reject { |name, _| disabled_platform?(tool, name) }
+        # 数据层：extra（虚拟平台，如 ChatGPT Subscribe）覆盖同名真实平台，保留其 marker
+        merged = visible.merge(extra)
+        if merged.empty?
           raise ToolNotConfiguredError,
                 "工具 #{tool} 未配置任何平台，请运行 easyai setup --tool=#{tool}"
         end
 
-        available = platforms.keys
+        # 顺序层：extra 虚拟平台始终排在选择列表最前（如【ChatGPT Subscribe】恒为第一项）
+        available = extra.keys + (visible.keys - extra.keys)
         selected =
           if platform && !platform.empty?
             unless available.include?(platform)
@@ -107,8 +136,8 @@ module EasyAI
             interactive_select(tool, available)
           end
 
-        yield(platform_display_name(selected)) if block_given?
-        platforms[selected]
+        yield(platform_display_name(selected), selected) if block_given?
+        merged[selected]
       end
 
       def upsert_platform(tool, platform, data)

data/lib/easyai/version.rb

@@ -1,3 +1,3 @@
 module EasyAI
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

data/lib/easyai.rb

@@ -3,7 +3,6 @@ require 'easyai/config/local_config'
 require 'easyai/command'
 require 'easyai/command/ai_tool_base'
 require 'easyai/command/claude'
-require 'easyai/command/gemini'
 require 'easyai/command/codex'
 require 'easyai/command/utils'
 require 'easyai/command/clean'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easyai
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Wade
@@ -114,18 +114,20 @@ files:
 - lib/easyai/base/file_crypto.rb
 - lib/easyai/base/secret_masker.rb
 - lib/easyai/base/system_info.rb
+- lib/easyai/base/toml_sections.rb
 - lib/easyai/base/update_notifier.rb
 - lib/easyai/base/version_checker.rb
 - lib/easyai/command.rb
 - lib/easyai/command/ai_tool_base.rb
 - lib/easyai/command/backup.rb
 - lib/easyai/command/backup/claude.rb
+- lib/easyai/command/backup/codex.rb
 - lib/easyai/command/claude.rb
 - lib/easyai/command/clean.rb
 - lib/easyai/command/codex.rb
-- lib/easyai/command/gemini.rb
 - lib/easyai/command/restore.rb
 - lib/easyai/command/restore/claude.rb
+- lib/easyai/command/restore/codex.rb
 - lib/easyai/command/setup.rb
 - lib/easyai/command/update.rb
 - lib/easyai/command/utils.rb
@@ -151,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.11
 specification_version: 4
 summary: Claude / Gemini / Codex 三家 AI CLI 的本地化统一入口
 test_files: []

data/lib/easyai/command/gemini.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'ai_tool_base'
-
-module EasyAI
-  class Command
-    class Gemini < AIToolBase
-      self.summary = '启动 Gemini 命令行（多平台支持）'
-      self.description = <<-DESC
-启动 Google Gemini CLI，从 ~/.easyai/config.json 读取平台配置，并将凭证 / 代理仅注入子进程。
-
-使用示例：
-
-    $ easyai gemini                       # 多平台时进入交互选择
-    $ easyai gemini --platform=google_official
-    $ easyai gemini ./adhoc.json          # 用一次性 JSON 覆盖（单平台扁平 schema）
-    $ easyai gemini -- --help             # 透传参数给 gemini CLI
-DESC
-
-      self.arguments = [
-        CLAide::Argument.new('CONFIG.json', false),
-        CLAide::Argument.new('ARGS', false, true)
-      ]
-
-      def tool_name
-        'gemini'
-      end
-
-      def exec_command
-        'gemini'
-      end
-
-      def install_hint
-        '未找到 gemini CLI。请安装：npm install -g @google/gemini-cli'
-      end
-    end
-  end
-end