179 lines
10 KiB
Python
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
|