Files

179 lines
10 KiB
Python

"""Native EasyEDA transport and independent delivery checks; no design algorithms."""
import asyncio
import base64
import fcntl
import json
import os
import time
import uuid
import tempfile
from .config import EDA_BIN
from pathlib import Path
from .storage import ROOT, workspace, task_dir, inside, save, write, event, digest
from .native_policy import guarded_script, validate_export_name
from .native_helpers import HELPERS_JS
from .checks import evaluate_verification
EDA_LOCK = asyncio.Lock()
async def cli(args, code=None, timeout=210, *, binary=None, directory=None, environment=None):
env = dict(os.environ if environment is None else environment)
env.setdefault('DISPLAY', ':0')
env.setdefault('XDG_RUNTIME_DIR', f'/run/user/{os.getuid()}')
for key in ('OPENAI_API_KEY', 'OPENAI_API_KEY_FILE', 'DEEPSEEK_API_KEY', 'DEEPSEEK_API_KEY_FILE', 'ARK_API_KEY', 'ARK_API_KEY_FILE', 'DOUBAO_API_KEY', 'DOUBAO_API_KEY_FILE', 'CODEX_API_KEY', 'CODEX_API_KEY_FILE'):
env.pop(key, None)
if not env.get('XAUTHORITY'):
auth = list(Path(f'/run/user/{os.getuid()}').glob('.mutter-Xwaylandauth.*'))
if auth:
env['XAUTHORITY'] = str(auth[0])
# Electron may leave a resident activation window/helper with inherited
# output handles. Pipes then never reach EOF even after the CLI exits.
# Private files let us wait for the actual command and retain its JSON error.
with tempfile.TemporaryFile() as stdout, tempfile.TemporaryFile() as stderr:
p = await asyncio.create_subprocess_exec(binary or EDA_BIN, *args, '--no-sandbox',
stdin=asyncio.subprocess.PIPE if code is not None else asyncio.subprocess.DEVNULL,
stdout=stdout, stderr=stderr, env=env, cwd=directory or ROOT)
try:
await asyncio.wait_for(p.communicate(code.encode() if code is not None else None), timeout)
except (asyncio.TimeoutError, asyncio.CancelledError):
try:
p.kill()
except ProcessLookupError:
pass
await p.communicate()
raise RuntimeError('EDA command outcome unknown; inspect live state before retrying mutations')
stdout.seek(0)
stderr.seek(0)
out, err = stdout.read(), stderr.read()
try:
result = json.loads(out)
except ValueError:
raise RuntimeError('EDA returned non-JSON: '+err.decode(errors='replace')[-1500:]) from None
if not isinstance(result, dict) or p.returncode or result.get('ok') is not True:
raise RuntimeError('EDA native error: '+json.dumps(result,ensure_ascii=False)[:6000])
return result.get('value')
async def host_lock(timeout=240):
path = Path.home()/'.local/state/ai-pcb-eda/locks/host.lock'
path.parent.mkdir(parents=True,exist_ok=True)
fd = path.open('a+')
started = time.monotonic()
while True:
try:
fcntl.flock(fd,fcntl.LOCK_EX|fcntl.LOCK_NB)
return fd
except BlockingIOError:
if time.monotonic()-started > timeout:
fd.close()
raise RuntimeError('EDA host occupied by another task; no mutation executed')
await asyncio.sleep(1)
async def execute(t, code, label='EDA script'):
if not t.get('approval') or t['state'] != 'running':
raise PermissionError('EDA is unavailable until the latest proposal is approved')
async with EDA_LOCK:
fd = await host_lock()
try:
if not t.get('eda_session'):
opened = await cli(['open','--headless','true'],timeout=90)
t['eda_session'] = opened['sessionId']
event(t,'eda.session',{'session_id':t['eda_session']})
elif t.get('check_eda_session'):
sessions = await cli(['session','list'])
if not any(s.get('sessionId') == t['eda_session'] and s.get('status') == 'alive' for s in sessions):
raise RuntimeError('Owned EDA session disappeared; reopen your saved native project through a new task session before continuing')
t.pop('check_eda_session',None)
n = t.get('eda_calls',0)+1
t['eda_calls'] = n
prefix = workspace(t)/'evidence'/f'eda-{n:05d}'
prefix.parent.mkdir(parents=True,exist_ok=True)
prefix.with_suffix('.js').write_text(code)
event(t,'eda.started',{'call':n,'label':label})
transfer_key='pcb_export_'+uuid.uuid4().hex
wrapper = 'const __transferKey='+json.dumps(transfer_key)+';\n'+r'''const __files=[];
globalThis.__pcbBackendTransfers ??= Object.create(null);
globalThis.__pcbBackendTransfers[__transferKey]=[];
const pcb_export=async(file,name)=>{
if(/\.(dsn|ses)$/i.test(name))throw Error('easyeda-native-v1: DSN/SES routing exchange exports are disabled');
if(!file || typeof file.arrayBuffer!=='function')throw Error('Native export returned no File/Blob');
const index=__files.length;
globalThis.__pcbBackendTransfers[__transferKey].push(file);
__files.push({name,bytes:file.size,index});return {name,bytes:file.size};
};
const __result=await (async()=>{
''' + guarded_script(HELPERS_JS+'\n'+code) + '\n})(); return {result:__result,files:__files};'
try:
value = await cli(['invoke','--session',t['eda_session'],'--ext-uuid','eda','--code-file','-','--timeout','180000'],wrapper)
files = []
for item in value.get('files',[]):
validate_export_name(item['name'])
dst=inside(workspace(t)/'artifacts',item['name'])
dst.parent.mkdir(parents=True,exist_ok=True)
partial=dst.with_name(dst.name+'.'+transfer_key+'.partial')
try:
with partial.open('wb') as output:
for offset in range(0,item['bytes'],1024*1024):
chunk_code=f'''const f=globalThis.__pcbBackendTransfers?.[{json.dumps(transfer_key)}]?.[{int(item['index'])}];
if(!f || f.size!=={int(item['bytes'])})throw Error('Native export handle expired; retry export without editing the board');
const blob=f.slice({offset},{offset+1024*1024});
const base64=await new Promise((resolve,reject)=>{{const r=new FileReader();r.onload=()=>resolve(String(r.result).split(',')[1]);r.onerror=reject;r.readAsDataURL(blob);}});
return {{base64}};'''
chunk=await cli(['invoke','--session',t['eda_session'],'--ext-uuid','eda','--code-file','-','--timeout','30000'],chunk_code,timeout=40)
data=base64.b64decode(chunk['base64'],validate=True)
if len(data)!=min(1024*1024,item['bytes']-offset):raise ValueError('Truncated native export chunk')
output.write(data)
partial.replace(dst)
finally:
partial.unlink(missing_ok=True)
files.append({'path':str(dst),'bytes':dst.stat().st_size,'sha256':digest(dst.read_bytes())})
result = {'result':value.get('result'),'exports':files}
write(prefix.with_suffix('.json'),result)
event(t,'eda.completed',{'call':n,'label':label,'files':files})
return result
except Exception as e:
write(prefix.with_suffix('.json'),{'error':str(e),'mutation_outcome':'inspect before retry'})
event(t,'eda.error',{'call':n,'message':str(e)})
raise
finally:
try:
await cli(['invoke','--session',t['eda_session'],'--ext-uuid','eda','--code-file','-','--timeout','10000'], 'delete globalThis.__pcbBackendTransfers?.['+json.dumps(transfer_key)+'];return true;', timeout=15)
except Exception:
pass
finally:
fcntl.flock(fd,fcntl.LOCK_UN)
fd.close()
async def verify_native(t, schematic_id, pcb_id, *, require_pass=True):
code = f'''const resolved=await pcb_resolve({json.dumps(schematic_id)}, {json.dumps(pcb_id)});
const allParts=new Set(), allErrors=new Map(); let schPassed=true;
for(const page of resolved.schematic.page) {{
await pcb_focus(page.uuid);
if(await eda.sch_Document.save()===false)throw Error('Schematic save failed');
for(const part of await eda.sch_PrimitiveComponent.getAll('part'))allParts.add(page.uuid+':'+part.getState_PrimitiveId());
const ok=await eda.sch_Drc.check(true,false,false); if(typeof ok!=='boolean')throw Error('Invalid schematic check response');
schPassed=schPassed && ok;
const rows=await eda.sch_Drc.check(true,false,true); if(!Array.isArray(rows))throw Error('Missing schematic diagnostics');
for(const row of rows)allErrors.set(JSON.stringify(row),row);
}}
const schNet=await eda.sch_ManufactureData.getNetlistFile('verification');
if(!schNet)throw Error('Schematic netlist export missing');
await pcb_export(schNet,'verification-schematic.net');
await pcb_focus(resolved.pcb.uuid);
if(await eda.pcb_Document.save()===false)throw Error('PCB save failed');
const components=await eda.pcb_PrimitiveComponent.getAll();
const pcbPassed=await eda.pcb_Drc.check(true,false,false);
const pcbErrors=await eda.pcb_Drc.check(true,false,true);
const pcbNet=await eda.pcb_ManufactureData.getNetlistFile('verification');
if(!pcbNet)throw Error('PCB netlist export missing');
await pcb_export(pcbNet,'verification-pcb.net');
return {{schPassed,pcbPassed,schematicParts:allParts.size,pcbParts:components.length,
schErrors:[...allErrors.values()],pcbErrors,schematic_id:resolved.schematic.uuid,
schematic_pages:resolved.schematic.page.map(p=>p.uuid),pcb_id:resolved.pcb.uuid}};'''
evidence=await execute(t,code,'Native error/warning verification across all schematic pages and PCB')
result=evaluate_verification(evidence['result'])
evidence['result']=result
write(task_dir(t['id'])/'native-verification.json',evidence)
if require_pass and not result['accepted']:
raise ValueError('Native errors block delivery: '+json.dumps(result['blockingErrors'],ensure_ascii=False)[:16000])
return result