Files
vibemake-pcb-studio/codex_pcb/rpc.py
T
admin e7f19ff493
CI / typecheck + test + build (push) Has been cancelled
部署更改
2026-11-13 17:20:03 +08:00

147 lines
6.3 KiB
Python

"""JSON-RPC transport; native Codex owns reasoning, tools and conversation history."""
import asyncio
import json
import os
from pathlib import Path
from .config import AUTH_MODE, CODEX_BIN, CODEX_HOME, MODEL, EFFORT, PROVIDER
def api_key():
key = os.environ.get('OPENAI_API_KEY', '').strip()
if not key and os.environ.get('OPENAI_API_KEY_FILE'):
try:
with Path(os.environ['OPENAI_API_KEY_FILE']).expanduser().open() as stream:
key = stream.read(16385).strip()
except (OSError, UnicodeError):
raise ValueError('Cannot read OPENAI_API_KEY_FILE') from None
if not key:
raise ValueError('PCB_CODEX_AUTH=apikey requires OPENAI_API_KEY or OPENAI_API_KEY_FILE')
if len(key) > 16384 or any(c.isspace() for c in key):
raise ValueError('OpenAI API key must be a single non-empty value')
return key
def process_config(production):
if AUTH_MODE not in {'apikey', 'chatgpt'}:
raise ValueError('PCB_CODEX_AUTH must be apikey or chatgpt')
config = {
'model': MODEL, 'model_provider': PROVIDER, 'model_reasoning_effort': EFFORT,
'approval_policy': 'never', 'web_search': 'live',
'sandbox_mode': 'workspace-write' if production else 'read-only',
'features.shell_tool': production, 'features.multi_agent': False,
'sandbox_workspace_write.network_access': True,
'sandbox_workspace_write.exclude_slash_tmp': True,
'sandbox_workspace_write.exclude_tmpdir_env_var': True,
'shell_environment_policy.ignore_default_excludes': False,
}
env = dict(os.environ, CODEX_HOME=str(CODEX_HOME))
for key in ('OPENAI_API_KEY', 'OPENAI_API_KEY_FILE', 'OPENAI_BASE_URL',
'DEEPSEEK_API_KEY', 'CODEX_API_KEY'):
env.pop(key, None)
if AUTH_MODE == 'apikey':
env['OPENAI_API_KEY'] = api_key()
prefix = 'model_providers.' + PROVIDER + '.'
config.update({
prefix + 'name': 'VibeMake OpenAI API',
prefix + 'base_url': 'https://api.openai.com/v1',
prefix + 'wire_api': 'responses',
prefix + 'env_key': 'OPENAI_API_KEY',
prefix + 'requires_openai_auth': False,
})
args = [CODEX_BIN, 'app-server', '--listen', 'stdio://']
for key, value in config.items():
args += ['-c', key + '=' + json.dumps(value)]
return args, env
class AppServer:
def __init__(self, directory, production, handler):
self.directory, self.production, self.handler = directory, production, handler
self.pending, self.requests, self.counter = {}, set(), 0
self.events = asyncio.Queue()
self.proc = None
self.reader = None
self.err = None
async def __aenter__(self):
args, env = process_config(self.production)
CODEX_HOME.mkdir(parents=True, exist_ok=True, mode=0o700)
self.err = (self.directory / 'codex-stderr.log').open('ab')
try:
self.proc = await asyncio.create_subprocess_exec(*args, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=self.err, env=env, cwd=self.directory, limit=64*1024*1024)
self.reader = asyncio.create_task(self._read())
await self.call('initialize', {'clientInfo': {'name':'vibemake_persistent_pcb','title':'VibeMake Persistent PCB','version':'1.0.0'}, 'capabilities':{'experimentalApi':True}})
await self.send({'method':'initialized'})
except BaseException:
await self.__aexit__()
raise
return self
async def send(self, message):
if self.proc.returncode is not None:
raise ConnectionError('Codex process exited')
self.proc.stdin.write((json.dumps(message, ensure_ascii=False)+'\n').encode())
await self.proc.stdin.drain()
async def call(self, method, params, timeout=90):
self.counter += 1
n = self.counter
future = asyncio.get_running_loop().create_future()
self.pending[n] = future
try:
await self.send({'id':n,'method':method,'params':params})
return await asyncio.wait_for(future, timeout)
finally:
self.pending.pop(n, None)
async def answer(self, msg):
try:
result = await self.handler(msg['method'], msg.get('params',{}))
await self.send({'id':msg['id'],'result':result})
except asyncio.CancelledError:
raise
except Exception as e:
await self.send({'id':msg['id'],'error':{'code':-32000,'message':str(e)}})
async def _read(self):
try:
while line := await self.proc.stdout.readline():
msg = json.loads(line)
if 'method' in msg and 'id' in msg:
job = asyncio.create_task(self.answer(msg))
self.requests.add(job)
job.add_done_callback(self.requests.discard)
elif 'method' in msg:
await self.events.put(msg)
elif msg.get('id') in self.pending:
future = self.pending[msg['id']]
if not future.done():
if 'error' in msg:
future.set_exception(RuntimeError(json.dumps(msg['error'],ensure_ascii=False)))
else:
future.set_result(msg.get('result'))
except Exception as e:
await self.events.put({'method':'transport/error','params':{'message':str(e)}})
finally:
for future in list(self.pending.values()):
if not future.done():
future.set_exception(ConnectionError('Codex transport ended'))
await self.events.put({'method':'transport/closed','params':{}})
async def __aexit__(self, *args):
for job in self.requests:
job.cancel()
await asyncio.gather(*self.requests, return_exceptions=True)
if self.proc and self.proc.returncode is None:
self.proc.terminate()
try:
await asyncio.wait_for(self.proc.wait(),10)
except asyncio.TimeoutError:
self.proc.kill()
await self.proc.wait()
if self.reader:
self.reader.cancel()
await asyncio.gather(self.reader,return_exceptions=True)
if self.err:
self.err.close()