easyai 2.0.0 → 2.2.0

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
@@ -41,21 +42,21 @@ DESC
           'claude_official' => {
             label: 'Claude 官方',
             required_env: %w[ANTHROPIC_AUTH_TOKEN],
-            optional_env: {
+            fixed_env: {
               'ANTHROPIC_BASE_URL' => 'https://api.anthropic.com'
             }
           },
           'kimi' => {
             label: 'Kimi（Moonshot）',
             required_env: %w[ANTHROPIC_AUTH_TOKEN],
-            optional_env: {
+            fixed_env: {
               'ANTHROPIC_BASE_URL' => 'https://api.kimi.com/coding/'
             }
           },
           'deepseek' => {
             label: 'DeepSeek',
             required_env: %w[ANTHROPIC_AUTH_TOKEN],
-            optional_env: {
+            fixed_env: {
               'ANTHROPIC_BASE_URL' => 'https://api.deepseek.com/anthropic',
               'ANTHROPIC_MODEL' => 'deepseek-v4-pro[1m]',
               'ANTHROPIC_DEFAULT_OPUS_MODEL' => 'deepseek-v4-pro[1m]',
@@ -68,7 +69,7 @@ DESC
           'aliqwen' => {
             label: '阿里千问 Coding Plan（兼容 Anthropic 协议）',
             required_env: %w[ANTHROPIC_AUTH_TOKEN],
-            optional_env: {
+            fixed_env: {
               'ANTHROPIC_BASE_URL' => 'https://coding.dashscope.aliyuncs.com/apps/anthropic',
               'ANTHROPIC_MODEL' => 'qwen3.6-plus',
               'ANTHROPIC_DEFAULT_OPUS_MODEL' => 'qwen3.6-plus',
@@ -82,7 +83,7 @@ DESC
           'minimax' => {
             label: 'MiniMax（兼容 Anthropic 协议）',
             required_env: %w[ANTHROPIC_AUTH_TOKEN],
-            optional_env: {
+            fixed_env: {
               'ANTHROPIC_BASE_URL' => 'https://api.minimaxi.com/anthropic',
               'ANTHROPIC_MODEL' => 'MiniMax-M2.7-highspeed',
               'ANTHROPIC_DEFAULT_SONNET_MODEL' => 'MiniMax-M2.7-highspeed',
@@ -93,41 +94,49 @@ DESC
           'glm' => {
             label: 'GLM Coding Plan（bigmodel.cn）',
             required_env: %w[ANTHROPIC_AUTH_TOKEN],
-            optional_env: {
+            fixed_env: {
               'ANTHROPIC_BASE_URL' => 'https://open.bigmodel.cn/api/anthropic',
               'API_TIMEOUT_MS' => '3000000',
-              'ANTHROPIC_DEFAULT_OPUS_MODEL' => 'glm-5.1',
-              'ANTHROPIC_DEFAULT_SONNET_MODEL' => 'glm-5-turbo',
-              'ANTHROPIC_DEFAULT_HAIKU_MODEL' => 'glm-4.5-air'
+              'CLAUDE_CODE_AUTO_COMPACT_WINDOW' => '1000000',
+              'ANTHROPIC_DEFAULT_OPUS_MODEL' => 'glm-5.2[1m]',
+              'ANTHROPIC_DEFAULT_SONNET_MODEL' => 'glm-5.2[1m]',
+              'ANTHROPIC_DEFAULT_HAIKU_MODEL' => 'glm-4.7'
+            }
+          },
+          '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'
             }
-          }
-        },
-        'gemini' => {
-          'google_official' => {
-            label: 'Google 官方',
-            required_env: %w[GEMINI_API_KEY],
-            optional_env: {}
           }
         },
         '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 +146,7 @@ DESC
 
       def self.options
         [
-          ['--tool=NAME', '指定要配置的工具（claude / gemini / codex）'],
+          ['--tool=NAME', '指定要配置的工具（claude / codex）'],
           ['--add=PLATFORM', '在指定工具下追加或覆盖单个平台'],
           ['--remove=PLATFORM', '在指定工具下删除单个平台'],
           ['--list', '脱敏方式展示当前所有配置'],
@@ -192,7 +201,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 +220,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 +316,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 +407,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 +441,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,24 +502,47 @@ DESC
         end
       end
 
-      # 收集单个平台的 env / proxy 数据
+      # 返回某工具下「未被屏蔽」的内置平台模板 key（屏蔽清单见 LocalConfig::DISABLED_PLATFORMS）
+      def known_platform_keys(tool)
+        KNOWN_PLATFORMS[tool].keys.reject { |p| Config::LocalConfig.disabled_platform?(tool, p) }
+      end
+
+      # 收集单个平台的 env 数据（不再交互询问代理：setup 默认不配置 HTTP/HTTPS 代理，
+      # 如需代理请用 `easyai setup --edit` 手动向平台补 proxy 字段；runtime 与 --list 仍支持 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
 
-        proxy = ask_proxy
+        { 'env' => env }
+      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
 
-        data = { 'env' => env }
-        data['proxy'] = proxy unless proxy.empty?
-        data
+        { 'env' => {} }
       end
 
       def ask_required(key)
@@ -543,23 +581,6 @@ DESC
         value
       end
 
-      def ask_proxy
-        print '  是否配置 HTTP/HTTPS 代理？(y/N) > '
-        ans = read_line
-        return {} unless ans && ans.downcase.start_with?('y')
-
-        print '    HTTP_PROXY  (例如 http://127.0.0.1:7890): '
-        http = read_line
-        print '    HTTPS_PROXY (回车与 HTTP_PROXY 相同): '
-        https = read_line
-        https = http if https.nil? || https.empty?
-
-        proxy = {}
-        proxy['HTTP_PROXY'] = http unless http.nil? || http.empty?
-        proxy['HTTPS_PROXY'] = https unless https.nil? || https.empty?
-        proxy
-      end
-
       def read_line
         line = $stdin.gets
         raise Interrupt, '用户取消输入' if line.nil?