codex-mode 0.1.0a7__py3-none-any.whl

codex_mode/engine.py

@@ -0,0 +1,487 @@
+"""Switch Codex request routing while retaining one history and ChatGPT login."""
+import base64
+import socket
+import struct
+import contextlib
+import datetime
+import fcntl
+import hashlib
+import json
+import os
+from pathlib import Path
+import queue
+import re
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import tomllib
+import tomlkit
+from . import __version__
+
+VERSION = __version__
+VERBOSE = False
+PAUSED_GOALS = []
+
+def color(text,kind='info',stream=None):
+    stream=stream or sys.stdout
+    if stream.isatty() and 'NO_COLOR' not in os.environ and os.environ.get('TERM')!='dumb':
+        return '\033['+{'info':'36','ok':'32','warn':'33','error':'31'}[kind]+'m'+text+'\033[0m'
+    return text
+
+def say(text,kind='info',detail=False):
+    if not detail or VERBOSE:print(color(text,kind),flush=True)
+
+def error_text(error):
+    raw=str(error) or type(error).__name__
+    messages={
+        'App-server refused thread/goal/get':'无法查询 goal 状态；可加 --force 强制关闭旧服务后切换。',
+        'Force mode requires Linux pidfd support.':'当前 Python 不支持安全强制终止，请使用带 pidfd 支持的系统 Python。',
+        'Forced service shutdown failed; configuration unchanged.':'强制关闭失败，配置未切换。',
+        'Cancelled; no tasks interrupted and configuration unchanged.':'已取消，任务和配置均未更改。',
+        'Confirmation requires an interactive terminal; no tasks interrupted.':'请在交互终端中确认；尚未中断任务。',
+        'App-server did not exit gracefully; configuration unchanged. Paused goals remain paused. No force-kill was used.':'服务退出超时，未切换，也未强杀。已暂停的 goal 保持暂停。',
+        'Interruption timed out; configuration unchanged. No force-kill was used.':'任务停止超时，未切换，也未强杀。',
+        'Another login or switch operation is running; finish it first.':'已有登录或切换操作正在运行，请等待完成。',
+        'ChatGPT login missing. Run codex-mode login first; existing mode remains unchanged.':'未登录 ChatGPT，请先运行 codex-mode login。',
+        'A new active goal appeared during confirmation; retry.':'确认期间出现新 goal，已取消切换，请重试。',
+        'A new turn started during confirmation; retry. No new turn interrupted.':'确认期间出现新任务，已取消切换，未中断新任务。',
+        'A goal was activated during interruption; switching aborted.':'goal 被重新启用，已取消切换。',
+        'Tasks changed before service shutdown; switching aborted.':'任务状态发生变化，已取消切换。',
+        'App-server connections changed; retry.':'Desktop 连接发生变化，请断开后重试。',
+        'Configuration changed concurrently; retry without overwriting it.':'配置被其他进程修改，未覆盖，请重试。',
+    }
+    text=messages.get(raw,raw)
+    if VERBOSE and text!=raw:text+='\n  '+raw
+    return text
+API_URL = ''
+CHAT_URL = 'https://chatgpt.com/backend-api/codex'
+BIN = 'codex'
+ALIASES = ['direct']
+HEALTH_URL = None
+
+def atomic(path, data):
+    path = Path(path)
+    fd, name = tempfile.mkstemp(prefix=path.name+'.new-', dir=path.parent)
+    try:
+        os.fchmod(fd, 0o600)
+        with os.fdopen(fd, 'wb') as f:
+            f.write(data if isinstance(data, bytes) else data.encode())
+            f.flush(); os.fsync(f.fileno())
+        os.replace(name, path)
+    finally:
+        if os.path.exists(name): os.unlink(name)
+
+def read_auth(path):
+    try:
+        value=json.loads(path.read_text())
+        if not isinstance(value,dict):raise ValueError('Invalid JSON object in '+path.name)
+        return value
+    except FileNotFoundError: return {}
+
+def chat_auth(a):
+    tokens=a.get('tokens') or {}
+    return isinstance(tokens,dict) and bool(tokens.get('access_token')) and a.get('auth_mode') != 'apikey'
+
+def key_for(root):
+    settings=read_auth(root/'codex-mode.json')
+    name=settings.get('key_env')
+    if name:
+        key=os.environ.get(name,'').strip()
+        if not key:raise RuntimeError('Missing API key environment variable: '+name)
+        return key
+    a = read_auth(root/'auth-profiles/sub2api.auth.json')
+    key = a.get('OPENAI_API_KEY')
+    if not isinstance(key, str) or not key.strip(): raise RuntimeError('Saved sub2api key is missing; setup required.')
+    return key.strip()
+
+def codex_env(root):
+    env = os.environ.copy(); env['CODEX_HOME'] = str(root)
+    for k in ('OPENAI_API_KEY', 'OPENAI_BASE_URL', 'CODEX_API_KEY', 'CODEX_ACCESS_TOKEN'):
+        env.pop(k, None)
+    return env
+
+def render(text, root, mode):
+    document=tomlkit.parse(text)
+    settings=read_auth(root/'codex-mode.json')
+    model=settings.get('chatgpt_model' if mode=='chatgpt' else 'api_model')
+    if model:document['model']=model
+    document['model_provider']='direct'
+    document['cli_auth_credentials_store']='file'
+    document.pop('forced_login_method',None)
+    providers=document.setdefault('model_providers',tomlkit.table())
+    for provider in ALIASES:
+        p=tomlkit.table()
+        p.update({'name':mode+' (shared history)','base_url':CHAT_URL if mode=='chatgpt' else API_URL,
+                  'wire_api':'responses','supports_websockets':False})
+        if mode=='chatgpt':p['requires_openai_auth']=True
+        else:
+            # Use the installed Python interpreter, not an executable source file.
+            p['auth']={'command':sys.executable,'args':['-m','codex_mode','--state-dir',str(root),'_key'],
+                       'refresh_interval_ms':0,'timeout_ms':5000}
+        providers[provider]=p
+    out=tomlkit.dumps(document)
+    parsed=tomllib.loads(out)
+    assert parsed['model_provider']=='direct'
+    assert parsed['model_providers']['direct']['base_url']==(CHAT_URL if mode=='chatgpt' else API_URL)
+    return out
+
+def processes(root):
+    if sys.platform!='linux':raise RuntimeError('The first release supports Linux only.')
+    found=[]
+    for p in Path('/proc').iterdir():
+        if not p.name.isdigit():continue
+        try:
+            if p.stat().st_uid!=os.getuid():continue
+            argv=(p/'cmdline').read_bytes().decode().split('\0')
+            if 'app-server' not in argv:continue
+            env=dict(v.split('=',1) for v in (p/'environ').read_bytes().decode().split('\0') if '=' in v)
+            used=Path(env.get('CODEX_HOME',str(Path.home()/'.codex'))).resolve()
+            if used!=root:continue
+            exe=(p/'exe').resolve()
+            if exe.name!='codex':continue
+            found.append({'pid':int(p.name),'proxy':'proxy' in argv,'listen':'--listen' in argv,'exe':str(exe),'start':(p/'stat').read_text().split()[21]})
+        except (OSError,ValueError):continue
+    return found
+
+class RpcError(RuntimeError):
+    def __init__(self,method,error):
+        super().__init__('App-server refused '+method)
+        self.method=method;self.code=error.get('code');self.message=error.get('message','')
+
+class Probe:
+    """JSON RPC through the Desktop Unix WebSocket control socket."""
+    def __init__(self,root,proxy=True):
+        self.n=0;self.buf=b'';self.deadline=None
+        self.sock=socket.socket(socket.AF_UNIX,socket.SOCK_STREAM)
+        self.sock.settimeout(12)
+        try:
+            self.sock.connect(str(root/'app-server-control/app-server-control.sock'))
+            key=base64.b64encode(os.urandom(16)).decode()
+            self.sock.sendall(('GET / HTTP/1.1\r\nHost: localhost\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: '+key+'\r\nSec-WebSocket-Version: 13\r\n\r\n').encode())
+            header=b''
+            while b'\r\n\r\n' not in header:
+                part=self.sock.recv(4096)
+                if not part:raise RuntimeError('Control socket closed during handshake.')
+                header+=part
+                if len(header)>65536:raise RuntimeError('Oversized control handshake.')
+            header,self.buf=header.split(b'\r\n\r\n',1)
+            rows=header.decode().split('\r\n')
+            headers=dict((k.lower().strip(),v.strip()) for k,v in (r.split(':',1) for r in rows[1:]))
+            accept=base64.b64encode(hashlib.sha1((key+'258EAFA5-E914-47DA-95CA-C5AB0DC85B11').encode()).digest()).decode()
+            if rows[0].split()[1]!='101' or headers.get('sec-websocket-accept')!=accept:
+                raise RuntimeError('Invalid control socket handshake.')
+            self.call('initialize',{'clientInfo':{'name':'codex_mode','title':'Codex mode manager','version':VERSION},'capabilities':{'experimentalApi':True}})
+            self.send(1,b'{"method":"initialized"}')
+        except BaseException:
+            self.sock.close();raise
+    def send(self,opcode,data):
+        size=len(data);mask=os.urandom(4)
+        length=bytes([0x80|size]) if size<126 else bytes([254])+struct.pack('!H',size) if size<65536 else bytes([255])+struct.pack('!Q',size)
+        self.sock.sendall(bytes([0x80|opcode])+length+mask+bytes(b^mask[i%4] for i,b in enumerate(data)))
+    def exact(self,size,until):
+        while len(self.buf)<size:
+            remaining=until-time.monotonic()
+            if remaining<=0:raise RuntimeError('App-server status timeout.')
+            self.sock.settimeout(remaining)
+            part=self.sock.recv(min(65536,size-len(self.buf)))
+            if not part:raise RuntimeError('Control socket disconnected.')
+            self.buf+=part
+        result,self.buf=self.buf[:size],self.buf[size:]
+        return result
+    def receive(self,until):
+        parts=[];total=0
+        while True:
+            a,b=self.exact(2,until);opcode=a&15;size=b&127
+            if size==126:size=struct.unpack('!H',self.exact(2,until))[0]
+            elif size==127:size=struct.unpack('!Q',self.exact(8,until))[0]
+            if size>16*1024*1024 or b&128 or a&0x70:raise RuntimeError('Invalid control socket frame.')
+            data=self.exact(size,until)
+            if opcode==8:raise RuntimeError('App-server closed status connection.')
+            if opcode==9:self.send(10,data);continue
+            if opcode==10:continue
+            if opcode not in (0,1):raise RuntimeError('Unexpected control socket frame.')
+            parts.append(data);total+=size
+            if total>16*1024*1024:raise RuntimeError('Oversized control message.')
+            if a&128:return json.loads(b''.join(parts))
+    def call(self,method,params):
+        self.n+=1;ident=self.n
+        self.send(1,json.dumps({'id':ident,'method':method,'params':params}).encode())
+        until=min(time.monotonic()+12,self.deadline or float('inf'))
+        while time.monotonic()<until:
+            msg=self.receive(until)
+            if msg.get('id')!=ident:continue
+            if 'error' in msg:raise RpcError(method,msg['error'])
+            return msg['result']
+        raise RuntimeError('App-server status timeout.')
+    def close(self):
+        with contextlib.suppress(OSError):self.send(8,b'')
+        self.sock.close()
+
+def snapshot(rpc):
+    """Bounded, metadata-only reads: never load large conversation bodies."""
+    result=[];cursor=None;seen=set()
+    while True:
+        page=rpc.call('thread/loaded/list',{'cursor':cursor})
+        for tid in page['data']:
+            thread=rpc.call('thread/read',{'threadId':tid,'includeTurns':False})['thread']
+            goal=rpc.call('thread/goal/get',{'threadId':tid}).get('goal')
+            state=thread.get('status',{}).get('type')
+            if state not in ('idle','notLoaded','active','systemError'):
+                raise RuntimeError('Unknown task status; configuration unchanged.')
+            try:
+                turns=rpc.call('thread/turns/list',{'threadId':tid,'limit':1,'sortDirection':'desc','itemsView':'notLoaded'})['data']
+            except RpcError as error:
+                expected='thread '+tid+' is not materialized yet; thread/turns/list is unavailable before first user message'
+                if state in ('idle','notLoaded') and error.code==-32600 and error.message==expected:
+                    turns=[]
+                else:raise
+            turn=turns[0] if turns else {}
+            terminals=rpc.call('thread/backgroundTerminals/list',{'threadId':tid})
+            if terminals['data'] or terminals.get('nextCursor'):
+                raise RuntimeError('Task '+tid+' has background terminals. Inspect/stop them manually before switching; they will not be killed automatically.')
+            if state=='active' and turn.get('status')!='inProgress':
+                raise RuntimeError('Active task '+tid+' has no identifiable running turn; refusing to stop its service.')
+            if state=='systemError' and turn.get('status') not in ('failed','interrupted','completed'):
+                raise RuntimeError('Cannot verify errored task '+tid+' is stopped.')
+            result.append({'id':tid,'name':thread.get('name') or tid,'state':state,
+                           'turn':turn.get('id'),'turn_status':turn.get('status'),
+                           'goal_status':goal.get('status') if goal else None})
+        cursor=page.get('nextCursor')
+        if not cursor:return result
+        if cursor in seen:raise RuntimeError('Repeated task-list cursor; refusing to switch.')
+        seen.add(cursor)
+
+def active_tasks(tasks):
+    return [t for t in tasks if t['state']=='active' or t['turn_status']=='inProgress']
+
+def confirm_switch(tasks,has_proxy):
+    say('切换前需要处理：','warn')
+    for t in tasks:
+        if t in active_tasks(tasks) or t['state']=='systemError' or t.get('goal_status')=='active':
+            label={'active':'运行中','systemError':'异常','idle':'空闲','notLoaded':'未加载'}.get(t['state'],t['state'])
+            if t.get('goal_status')=='active':label+=' · goal 将暂停'
+            name=str(t['name']);name=name if VERBOSE or len(name)<=60 else name[:59]+'…'
+            say('  '+json.dumps(name,ensure_ascii=False)+'  '+label,'warn')
+            say('    ID: '+t['id'],'info',detail=True)
+    if has_proxy:say('  Desktop 连接将断开。','warn')
+    say('保留聊天、目标和代码改动；切换后手动继续。期间请勿重连。')
+    if not sys.stdin.isatty():raise RuntimeError('Confirmation requires an interactive terminal; no tasks interrupted.')
+    if input(color('继续切换？[y/N] ','warn')).strip().lower() not in ('y','yes'):
+        raise RuntimeError('Cancelled; no tasks interrupted and configuration unchanged.')
+
+def quiesce(rpc,tasks,has_proxy,disconnect_idle=False):
+    running=active_tasks(tasks)
+    errors={t['id'] for t in tasks if t['state']=='systemError'}
+    goals={t['id'] for t in tasks if t.get('goal_status')=='active'}
+    if running or errors or goals or (has_proxy and not disconnect_idle):confirm_switch(tasks,has_proxy)
+    approved={(t['id'],t['turn']) for t in running}
+    # Re-read after the human prompt; never interrupt a newly started turn.
+    fresh=snapshot(rpc)
+    if any(t.get('goal_status')=='active' and t['id'] not in goals for t in fresh):
+        raise RuntimeError('A new active goal appeared during confirmation; retry.')
+    if any((t['id'],t['turn']) not in approved for t in active_tasks(fresh)):
+        raise RuntimeError('A new turn started during confirmation; retry. No new turn interrupted.')
+    rpc.deadline=time.monotonic()+45
+    try:
+        if goals or active_tasks(fresh):say('处理中：'+('暂停 goal / ' if goals else '')+'停止任务…')
+        for t in fresh:
+            if t['id'] in goals and t.get('goal_status')=='active':
+                # Omit objective and tokenBudget to preserve accumulated usage and budget.
+                result=rpc.call('thread/goal/set',{'threadId':t['id'],'status':'paused'})
+                if (result.get('goal') or {}).get('status')!='paused':
+                    raise RuntimeError('Goal pause not confirmed; refusing to stop the service.')
+                PAUSED_GOALS.append(t['id'])
+                say('  goal 已暂停：'+t['id'],detail=True)
+        if goals:
+            fresh=snapshot(rpc)
+            if any(t.get('goal_status')=='active' for t in fresh):
+                raise RuntimeError('A goal is still active; switching aborted.')
+            if any((t['id'],t['turn']) not in approved for t in active_tasks(fresh)):
+                raise RuntimeError('A new turn started while pausing goals; retry. Paused goals remain paused.')
+        for t in active_tasks(fresh):
+            rpc.call('turn/interrupt',{'threadId':t['id'],'turnId':t['turn']})
+            say('  已请求中断：'+t['id'],detail=True)
+        while True:
+            current=snapshot(rpc)
+            if any(t.get('goal_status')=='active' for t in current):
+                raise RuntimeError('A goal was activated during interruption; switching aborted.')
+            if any((t['id'],t['turn']) not in approved for t in active_tasks(current)):
+                raise RuntimeError('A new turn started while waiting; switching aborted.')
+            if not active_tasks(current):
+                by_id={t['id']:t for t in current}
+                # A disappeared task cannot provide positive completion confirmation.
+                if any(tid not in by_id or by_id[tid]['turn']!=turn or by_id[tid]['turn_status'] not in ('interrupted','completed','failed') for tid,turn in approved):
+                    raise RuntimeError('Cannot confirm interrupted turns were persisted; switching aborted.')
+                if any(t['state']=='systemError' and t['id'] not in errors and (t['id'],t['turn']) not in approved for t in current):
+                    raise RuntimeError('A new task error appeared; retry after inspection.')
+                return current
+            if time.monotonic()>=rpc.deadline:raise RuntimeError('Interruption timed out; configuration unchanged. No force-kill was used.')
+            time.sleep(.25)
+    finally:rpc.deadline=None
+
+def force_stop(root):
+    targets=processes(root)
+    if not targets:return
+    say('将关闭 '+str(len(targets))+' 个 Codex 进程；未保存输出可能丢失。','warn')
+    for p in targets:
+        say('  PID '+str(p['pid'])+' · '+('Desktop 代理' if p['proxy'] else 'Codex 服务'),'warn',detail=True)
+    say('聊天和代码保留；goal 不会暂停，外部进程可能继续运行。','warn')
+    if not sys.stdin.isatty():raise RuntimeError('Confirmation requires an interactive terminal; no tasks interrupted.')
+    if input(color('强制切换？[y/N] ','warn')).strip().lower() not in ('y','yes'):
+        raise RuntimeError('Cancelled; no tasks interrupted and configuration unchanged.')
+    original={(p['pid'],p['start'],p['exe']) for p in targets}
+    def remaining():
+        current=processes(root)
+        if any((p['pid'],p['start'],p['exe']) not in original for p in current):
+            raise RuntimeError('App-server connections changed; retry.')
+        return current
+    def send(p,sig):
+        # A pidfd pins the exact process across PID reuse; recheck scope before signaling.
+        if not hasattr(os,'pidfd_open') or not hasattr(signal,'pidfd_send_signal'):
+            raise RuntimeError('Force mode requires Linux pidfd support.')
+        try:fd=os.pidfd_open(p['pid'])
+        except ProcessLookupError:return
+        try:
+            if not any((q['pid'],q['start'],q['exe'])==(p['pid'],p['start'],p['exe']) for q in remaining()):return
+            signal.pidfd_send_signal(fd,sig)
+        except ProcessLookupError:pass
+        finally:os.close(fd)
+    say('停止旧服务…')
+    for p in sorted(remaining(),key=lambda p:not p['proxy']):send(p,signal.SIGTERM)
+    deadline=time.monotonic()+5
+    while remaining() and time.monotonic()<deadline:time.sleep(.1)
+    pending=remaining()
+    if pending:
+        say('服务未退出，执行强制终止…','warn')
+        for p in pending:send(p,signal.SIGKILL)
+        deadline=time.monotonic()+5
+        while remaining() and time.monotonic()<deadline:time.sleep(.1)
+    if remaining():raise RuntimeError('Forced service shutdown failed; configuration unchanged.')
+
+def ensure_idle(root,disconnect_idle=False,allow_interrupt=False):
+    running=processes(root)
+    listeners=[p for p in running if p['listen']]
+    if running and (len(listeners)!=1 or any(not p['proxy'] and not p['listen'] for p in running)):
+        raise RuntimeError('Cannot verify all app-server processes; configuration unchanged.')
+    if listeners:
+        rpc=None
+        try:
+            rpc=Probe(root,proxy=True)
+            if allow_interrupt:
+                tasks=quiesce(rpc,snapshot(rpc),any(p['proxy'] for p in running),disconnect_idle)
+                # Repeat the metadata check immediately before any service termination.
+                final=snapshot(rpc)
+                if active_tasks(final) or any(t.get('goal_status')=='active' for t in final) or {(t['id'],t['turn'],t['turn_status']) for t in final}!={(t['id'],t['turn'],t['turn_status']) for t in tasks}:
+                    raise RuntimeError('Tasks changed before service shutdown; switching aborted.')
+            else:
+                self_check_idle(rpc)
+                self_check_idle(rpc)
+            current=processes(root)
+            if {(p['pid'],p['start']) for p in current}!={(p['pid'],p['start']) for p in running}:
+                raise RuntimeError('App-server connections changed; retry.')
+            if any(p['proxy'] for p in current) and not (disconnect_idle or allow_interrupt):
+                raise RuntimeError('All tasks are idle, but a Desktop proxy remains. Retry with --disconnect-idle to disconnect it safely before switching.')
+            for p in sorted(current,key=lambda p:not p['proxy']):
+                proc=Path('/proc')/str(p['pid'])
+                try:
+                    if (proc/'stat').read_text().split()[21]!=p['start']:raise RuntimeError('App-server process changed; retry.')
+                    os.kill(p['pid'],signal.SIGTERM)
+                except FileNotFoundError:pass
+        except (queue.Empty,BrokenPipeError):raise RuntimeError('Cannot verify app-server is idle; no configuration changed.')
+        finally:
+            if rpc:rpc.close()
+        say('等待旧服务退出…',detail=True)
+        deadline=time.monotonic()+30
+        while processes(root) and time.monotonic()<deadline:time.sleep(.1)
+        if processes(root):raise RuntimeError('旧服务未退出；配置未改动。可用 --force 重试。')
+
+def self_check_idle(rpc):
+            ids=[];cursor=None
+            while True:
+                page=rpc.call('thread/loaded/list',{'cursor':cursor})
+                ids.extend(page['data']);cursor=page.get('nextCursor')
+                if not cursor:break
+            blocked=[]
+            for tid in ids:
+                thread=rpc.call('thread/read',{'threadId':tid,'includeTurns':False})['thread']
+                status=thread.get('status',{}).get('type')
+                if status not in ('idle','notLoaded'):
+                    blocked.append(str(thread.get('name') or tid)+' ['+tid+'] ('+str(status)+')')
+            if blocked:raise RuntimeError('仍有非空闲会话：'+ '; '.join(blocked)+'。请先手动停止会话及 goal，或使用 --force。')
+
+def status(root):
+    c=tomllib.loads((root/'config.toml').read_text());provider=c.get('model_provider','openai');p=c.get('model_providers',{}).get(provider,{})
+    if not VERBOSE:
+        endpoint=p.get('base_url')
+        mode='ChatGPT' if endpoint==CHAT_URL else 'API' if API_URL and endpoint==API_URL else provider+'（未托管）'
+        say('codex-mode '+VERSION+'  |  当前配置：'+mode)
+        chat=chat_auth(read_auth(root/'auth.json')) or chat_auth(read_auth(root/'auth-profiles/chatgpt.auth.json'))
+        try:key_for(root);api=True
+        except RuntimeError:api=False
+        say('凭据：ChatGPT '+('已就绪' if chat else '未登录')+' / API '+('已就绪' if api else '缺失'))
+        running=processes(root)
+        say('服务：'+('运行中（现有进程沿用启动配置）' if running else '未运行'))
+        return
+    print('codex-mode',VERSION)
+    print('State directory:',root)
+    print('Configured provider:',provider)
+    print('Configured endpoint:',p.get('base_url','built-in OpenAI'))
+    print('Mode:', 'chatgpt' if p.get('base_url')==CHAT_URL else 'api' if API_URL and p.get('base_url')==API_URL else 'unmanaged')
+    print('ChatGPT login:', 'available' if chat_auth(read_auth(root/'auth.json')) else 'saved; activate by switching' if chat_auth(read_auth(root/'auth-profiles/chatgpt.auth.json')) else 'missing: run codex-mode login')
+    try:key_for(root);print('API credential: available (not displayed)')
+    except RuntimeError:print('API credential: missing')
+    for p in processes(root):print('Running:',p['pid'],'Desktop proxy' if p['proxy'] else 'app-server',p['exe'])
+    print('Active processes retain their startup settings until reconnected.')
+
+def switch(root,mode,disconnect_idle=False,force=False):
+    PAUSED_GOALS.clear()
+    say('切换到 '+('ChatGPT' if mode=='chatgpt' else 'API')+' · 检查中…')
+    profile=root/'auth-profiles';profile.mkdir(mode=0o700,exist_ok=True)
+    if mode=='sub2api':
+        if not API_URL:raise RuntimeError('API endpoint is not configured. Run codex-mode init --api-url URL.')
+        key_for(root)
+        if HEALTH_URL:
+            import urllib.request
+            try:
+                with urllib.request.urlopen(HEALTH_URL,timeout=5) as response:
+                    if response.status!=200:raise RuntimeError('API health check failed.')
+            except OSError:raise RuntimeError('API health check failed; inspect the configured endpoint.')
+    auth=read_auth(root/'auth.json');saved=read_auth(profile/'chatgpt.auth.json')
+    if mode=='chatgpt' and not chat_auth(auth) and not chat_auth(saved):raise RuntimeError('ChatGPT login missing. Run codex-mode login first; existing mode remains unchanged.')
+    original=(root/'config.toml').read_text();new=render(original,root,mode)
+    if force:force_stop(root)
+    else:ensure_idle(root,disconnect_idle=disconnect_idle,allow_interrupt=False)
+    # OAuth tokens may have refreshed while waiting; preserve the latest credentials.
+    auth=read_auth(root/'auth.json');saved=read_auth(profile/'chatgpt.auth.json')
+    if (root/'config.toml').read_text()!=original:
+        raise RuntimeError('Configuration changed concurrently; retry without overwriting it.')
+    backup=root/'mode-backups'/datetime.datetime.now().strftime('%Y%m%d-%H%M%S-%f');backup.mkdir(parents=True,mode=0o700)
+    for n in ('config.toml','auth.json'):
+        if (root/n).exists():shutil.copy2(root/n,backup/n);os.chmod(backup/n,0o600)
+    try:
+        if mode=='chatgpt' and not chat_auth(auth):atomic(root/'auth.json',json.dumps(saved))
+        atomic(root/'config.toml',new)
+        if chat_auth(read_auth(root/'auth.json')):atomic(profile/'chatgpt.auth.json',(root/'auth.json').read_bytes())
+    except BaseException:
+        for n in ('config.toml','auth.json'):
+            if (backup/n).exists():atomic(root/n,(backup/n).read_bytes())
+        raise
+    say('✓ 已切换到 '+('ChatGPT' if mode=='chatgpt' else 'API')+'，聊天记录保留。','ok')
+    say('重连 Desktop 后，在原聊天继续。')
+    say('备份：'+str(backup),detail=True)
+
+def login(root):
+    profile=root/'auth-profiles';profile.mkdir(mode=0o700,exist_ok=True)
+    staging=Path(tempfile.mkdtemp(prefix='chatgpt-login-',dir=profile))
+    atomic(staging/'config.toml','model_provider = "openai"\ncli_auth_credentials_store = "file"\n')
+    try:
+        result=subprocess.run([BIN,'login','--device-auth'],env=codex_env(staging))
+        if result.returncode:raise RuntimeError('Login did not complete; current auth unchanged.')
+        data=read_auth(staging/'auth.json')
+        if not chat_auth(data):raise RuntimeError('Expected a ChatGPT login.')
+        atomic(profile/'chatgpt.auth.json',json.dumps(data))
+        say('✓ ChatGPT 登录已保存。运行 codex-mode chatgpt 切换。','ok')
+    finally:shutil.rmtree(staging)