VibeCoding / src /apps /workbench /engine.py
dellweb3's picture
sol6.1 ERP稳定版本
115b94d verified
Raw History Blame Contribute Delete
44.2 kB
"""Local composition, durable work queue and artifact export for three shared workflows."""
import io
import hashlib
import json
import queue
import threading
import time
import zipfile
from pathlib import Path
from src.adapters.indexes.knowledge_sqlite import SqliteKnowledgeRepository
from src.adapters.persistence.local_identity import LocalIdentity
from src.adapters.persistence.skill_sqlite import SqliteSkillRepository
from src.adapters.persistence.runtime_sqlite import RuntimeStore
from src.adapters.persistence.artifact_sqlite import SqliteArtifactRepository
from src.adapters.sandbox.qemu import QemuSandbox
from src.adapters.sandbox.preview import PreviewSession
from src.modules.execution.scenarios import erp, wms, equipment, calculator, pdf, webapp, erp_orders, business_app
from src.modules.skill.application.service import SkillService
from src.modules.skill.packs.examples import all_examples, framework_candidate, example_draft
from src.modules.skill.domain.models import SkillError, digest, canonical
from src.modules.knowledge.application.catalog import KnowledgeCatalog
from src.modules.knowledge.erp_assistant import ERPAssistant
from src.modules.harness.policy import Harness
from src.modules.llm_gateway.service import LLMGateway
from src.modules.orchestrator.service import AgentRuntime, REPAIRABLE
from src.modules.artifact_catalog.service import ArtifactCatalog
from src.modules.governance.local_validation import LocalValidation
from src.apps.workbench.conversation import Conversations
from src.apps.workbench.java_skills import JavaSkills
from src.apps.workbench.erp_flow import ERPFlow
from src.apps.workbench.development import brief, timeline, progress
ROOT = Path(__file__).resolve().parents[3]
SCENARIOS = {
'erp':dict(name='ERP 采购报价',project='erp-demo',skill='erp-java-development',module=erp,
requirement='实现 ERP 采购报价 Java Web 服务:BigDecimal 金额计算、审批阈值、输入校验和部门隔离。遵循 runtime_contract。'),
'wms':dict(name='WMS 库存流水',project='wms-demo',skill='wms-java-development',module=wms,
requirement='实现 WMS Java 库存服务:原子出入库、请求幂等、库存非负和输入边界。遵循 runtime_contract。重复查询参数必须返回400,不能用Map覆盖重复值。只输出紧凑的App.java,控制在160行以内,不生成README,避免响应截断。'),
'equipment':dict(name='设备工单与巡检',project='equipment-demo',skill='equipment-ops-java-development',module=equipment,
requirement='实现设备运维 Java 服务:工单状态机、非法转换拒绝、严格日期和巡检周期。遵循 runtime_contract。必须import com.sun.net.httpserver.HttpServer和HttpExchange;HttpHandler仅允许IOException,辅助方法不要throws Exception,日期和数值异常捕获后返回400。重复查询参数必须拒绝,已知路径先检查method再鉴权。只输出紧凑的App.java,控制在160行以内,不生成README,避免响应截断。'),
'calculator':dict(name='网页计算器',project='calculator-demo',skill='calculator-java-development',module=calculator,requirement=brief('calculator')),
'pdf':dict(name='PDF读取与解析',project='pdf-demo',skill='pdf-java-development',module=pdf,requirement=brief('pdf')),
'webapp':dict(name='网页应用开发',project='webapp-demo',skill=webapp.SKILL,module=webapp,requirement=brief('webapp')),
'erp-orders':dict(name='ERP 采购订单清单',project='erp-demo',skill=erp_orders.SKILL,module=erp_orders,requirement=brief('erp-orders')),
'business-app':dict(name='Java 业务应用开发',project='erp-demo',skill=business_app.SKILL,module=business_app,requirement=brief('business-app'))}
SCENARIOS['erp']['requirement']=brief('erp',SCENARIOS['erp']['requirement'])
class LocalWorkbench:
resource_limits=None # Older frozen/test compositions retain their original policy.
budget_policy=None
def __init__(self, root, providers=(), *, start_worker=True, recover_incomplete=True, sandbox_capacity=3,resource_limited=False,resource_limits=None):
from src.modules.governance.resource_limits import configured
self.resource_limits=configured(resource_limits) if resource_limited else None
self.budget_policy=None if resource_limited else {'mode':'unlimited-usage-v1'}
self.root=Path(root); self.root.mkdir(parents=True,exist_ok=True)
self.identity=LocalIdentity(self.root/'identity.sqlite'); self.identity.seed_projects()
self.author=self.identity.actor('local-example-builder')
self.conversations=Conversations(self.identity,providers,recover_incomplete=recover_incomplete)
self.conversations.resource_limited=bool(self.resource_limits)
self.store=RuntimeStore(self.root/'runtime.sqlite')
self.initialize_jobs(recover_incomplete=recover_incomplete)
self.java_skills=JavaSkills(self)
self.knowledge=KnowledgeCatalog(SqliteKnowledgeRepository(ROOT/'.local/platform/knowledge.sqlite'))
self.skills=SkillService(SqliteSkillRepository(self.root/'skills.sqlite'),self.knowledge.resolve,self.identity.project_access)
self.skills.bootstrap(self.author)
if any(getattr(provider,'routing_version',None) for provider in providers):
from src.modules.skill.atomic_registry.catalog import routing_operations, code_review_operation
existing={row['key'] for row in self.skills.catalog(self.author,'operation')}
for operation in [*routing_operations(),code_review_operation()]:
if operation.operation_id+'@'+operation.version not in existing:self.skills.add_operation(self.author,operation)
vm_root=ROOT/'.local/tools/vm'
manifest_path=next((vm_root/name for name in ('manifest-v8.json','manifest-v7.json','manifest-v6.json','manifest-v5.json','manifest-v4.json','manifest-v3.json','manifest-v2.json','manifest.json') if (vm_root/name).is_file()),vm_root/'manifest.json')
manifest=json.loads(manifest_path.read_text())
image='zkcoding-qemu@sha256:'+digest(manifest)
profile=framework_candidate().model_copy(update={'state':'approved','evidence_refs':['local-toolchain:'+image,'user-authorized-local-validation']})
if not self.skills.catalog(self.author,'framework'): self.skills.add_framework(self.author,profile)
pdf_profile=pdf.framework_candidate().model_copy(update={'state':'approved','evidence_refs':['local-toolchain:'+image,'user-requested-pdf-development']})
if pdf_profile.profile_id+'@'+pdf_profile.version not in {row['key'] for row in self.skills.catalog(self.author,'framework')}:
self.skills.add_framework(self.author,pdf_profile)
web_profile=framework_candidate().model_copy(update={
'profile_id':webapp.PROFILE,'allowed_paths':['src/main/','website/'],
'state':'approved','evidence_refs':['local-toolchain:'+image,'user-authorized-local-validation']})
if web_profile.profile_id+'@'+web_profile.version not in {row['key'] for row in self.skills.catalog(self.author,'framework')}:
self.skills.add_framework(self.author,web_profile)
business_profile=framework_candidate().model_copy(update={
'profile_id':business_app.PROFILE,'allowed_paths':['src/main/','website/'],
'state':'approved','evidence_refs':['local-toolchain:'+image,'user-authorized-local-validation']})
if business_profile.profile_id+'@'+business_profile.version not in {row['key'] for row in self.skills.catalog(self.author,'framework')}:
self.skills.add_framework(self.author,business_profile)
revisions={c['collection_id']:c['revision'] for c in self.knowledge.collections(self.author)}
drafts={d['key'] for d in self.skills.drafts(self.author)}
self.runtimes={}
extra=[example_draft('calculator-java-development','网页计算器Java开发','web-development','精确表达式解析与网页交互',revisions),
example_draft('pdf-java-development','PDF读取与解析Java开发','java-integration','上传PDF与逐页文本提取',revisions),
example_draft(webapp.SKILL,'网页应用开发','web-development','根据每次需求生成独立交互页面',revisions),
example_draft(erp_orders.SKILL,'ERP采购订单清单Java开发','erp','文件模拟订单、查询、入库、退货与付款',revisions),
example_draft(business_app.SKILL,'需求驱动Java业务应用','erp','技术框架固定,业务由当前需求决定',revisions)]
pdf_draft=extra[1].model_dump()
pdf_draft['framework_ref']=pdf_profile.profile_id+'@'+pdf_profile.version
for edge in pdf_draft['graph']['resource_edges']:
if edge['kind']=='framework':edge['resource']=pdf_profile.profile_id
extra[1]=type(extra[1]).model_validate(pdf_draft)
web_draft=extra[2].model_dump()
web_draft['framework_ref']=web_profile.profile_id+'@'+web_profile.version
for edge in web_draft['graph']['resource_edges']:
if edge['kind']=='framework':edge['resource']=web_profile.profile_id
extra[2]=type(extra[2]).model_validate(web_draft)
business_draft=extra[4].model_dump()
business_draft['framework_ref']=business_profile.profile_id+'@'+business_profile.version
for edge in business_draft['graph']['resource_edges']:
if edge['kind']=='framework':edge['resource']=business_profile.profile_id
extra[4]=type(extra[4]).model_validate(business_draft)
for key,draft in zip(SCENARIOS,[*all_examples(revisions),*extra]):
spec=SCENARIOS[key]
if draft.skill_id not in drafts: self.skills.save_draft(self.author,draft.model_copy(update={'project_id':spec['project']}))
if any(getattr(provider,'routing_version',None) for provider in providers):
from src.modules.skill.domain.models import Draft,Budget
current=self.skills.read_draft(self.author,draft.skill_id)
# Only migrate the built-in author's default budget. Published snapshots
# and user-edited limits are immutable and never silently expanded.
expanded=Budget(max_model_calls=6,max_tokens=120000,max_repairs=2).model_dump()
if (current['body']['owner_id']==self.author.user_id and current['body']['last_editor_id']==self.author.user_id
and current['body']['budget'] in [Budget().model_dump(),expanded]
and any(node.get('operation_ref')=='AO05@0.1.0' for node in current['body']['graph']['nodes'])):
updated={k:v for k,v in current['body'].items() if k not in {'owner_id','last_editor_id'}}
updated=json.loads(json.dumps(updated))
updated['budget']=expanded
for node in updated['graph']['nodes']:
if node.get('operation_ref')=='AO05@0.1.0':node['operation_ref']='AO05@0.2.0'
self.skills.save_draft(self.author,Draft.model_validate(updated),current['revision'])
current=self.skills.read_draft(self.author,draft.skill_id)
if (current['body']['owner_id']==self.author.user_id and current['body']['last_editor_id']==self.author.user_id
and any((n.get('operation_ref') or '').startswith('AO13@') for n in current['body']['graph']['nodes'])):
from src.modules.skill.packs.code_review import without_code_review
body={k:v for k,v in current['body'].items() if k not in {'owner_id','last_editor_id'}}
try: updated=without_code_review(body)
except ValueError: pass # Preserve nonstandard graphs rather than rewriting them.
else: self.skills.save_draft(self.author,updated,current['revision'])
config=spec['module'].scenario(image)
sandbox=QemuSandbox(self.root/'sandboxes'/key,config,executable=str(ROOT/'.local/tools/qemu/qemu-system-x86_64.exe'),image_root=ROOT/'.local/tools/vm')
sandbox.event_sink=lambda rid,status,detail:self.store.stage_event(rid,'sandbox_recovery',status,detail)
self.runtimes[key]=AgentRuntime(self.store,self.skills,self.knowledge,LLMGateway(self.store,providers),
Harness(enabled=True,allow_qemu=True),sandbox,artifacts=ArtifactCatalog(SqliteArtifactRepository(self.root/'artifacts.sqlite')))
self.erp=ERPAssistant(self.root/'erp-demo.sqlite',self.identity.project_access)
self.business=ERPFlow(self.identity,self.root/'business-knowledge.sqlite')
self.queue=queue.Queue(maxsize=10); self.lock=threading.RLock(); self.preview=None; self.preview_owner=None
from src.apps.workbench.agent_sandboxes import AgentSandboxPool
self.preview_pool=AgentSandboxPool(self,sandbox_capacity)
self.stopped=threading.Event(); self.busy=False
for scenario,folder in [('erp','erp-procurement'),('wms','wms-inventory'),('equipment','equipment-maintenance'),('calculator','calculator-web'),('pdf','pdf-parser'),('business-app','inventory-erp')]:
seed=ROOT/'examples'/folder/'validation-evidence.json'
if seed.exists():
evidence=json.loads(seed.read_text(encoding='utf-8'))
self.save_example(scenario,evidence['manifest']['run_id'],evidence,replace=False)
historical=ROOT/'.local/live-java/run-dca11b3cebda4a16a090a468bec33cf1/evidence.json'
if historical.exists():
evidence=json.loads(historical.read_text(encoding='utf-8'))
self.save_example('erp','run-dca11b3cebda4a16a090a468bec33cf1',evidence,replace=False)
if start_worker: threading.Thread(target=self.worker,daemon=True).start()
def initialize_jobs(self, *, recover_incomplete=True):
with self.store.connect() as db:
db.executescript('''
CREATE TABLE IF NOT EXISTS web_jobs(id TEXT PRIMARY KEY,owner TEXT,scenario TEXT,request_key TEXT,request_digest TEXT,state TEXT,evidence TEXT,error TEXT,UNIQUE(owner,request_key));
CREATE TABLE IF NOT EXISTS web_examples(scenario TEXT PRIMARY KEY,run_id TEXT,evidence TEXT);
CREATE TABLE IF NOT EXISTS web_job_links(previous_run TEXT NOT NULL,new_run TEXT PRIMARY KEY,owner TEXT NOT NULL);
CREATE TABLE IF NOT EXISTS web_job_recovery(run_id TEXT PRIMARY KEY,root_run TEXT NOT NULL,attempt INTEGER NOT NULL,error TEXT);
''')
if recover_incomplete:
db.execute("UPDATE web_jobs SET state='unknown',error='SERVER_RESTART_RESULT_UNKNOWN' WHERE state IN ('queued','working')")
def spec(self,actor,scenario):
if scenario not in SCENARIOS: raise SkillError('SCENARIO_NOT_FOUND','场景不存在。',404)
self.identity.project_access(actor,SCENARIOS[scenario]['project'])
return SCENARIOS[scenario]
def skill_library(self,actor):
"""The three product Skills, each bound to the exact draft used by submit."""
result=[]
for scenario,icon in [('business-app','business'),('webapp','web'),('pdf','pdf')]:
try:spec=self.spec(actor,scenario)
except SkillError as exc:
if exc.status in {403,404}:continue
raise
doc=self.skills.read_draft(self.author,spec['skill'])
result.append(dict(id=scenario,skill_id=doc['key'],name=doc['body']['name'],
description=doc['body']['description'],icon=icon,project_id=spec['project'],
revision=doc['revision'],digest=doc['digest'],requirement=spec['requirement'],
framework_ref=doc['body']['framework_ref'],node_count=len(doc['body']['graph']['nodes']),
scope='local-validation',budget=doc['body']['budget']))
return result
def submit(self,actor,scenario,requirement,key,skill_id=None,*,recovery_of=None,auto_recover=False,model=None,workflow_revision=None,workflow_id=None,workflow_inputs=None,acknowledge_new_cost=False,scope_baseline=None):
if scenario=='erp-orders' and not recovery_of:
# Preserve idempotent reads of historical procurement runs before redirecting new work.
with self.store.connect() as db:
old=db.execute('SELECT * FROM web_jobs WHERE owner=? AND request_key=?',(actor.user_id,key)).fetchone()
if old and old['scenario']=='erp-orders':
fingerprint=digest({'scenario':'erp-orders','requirement':requirement,'skill_id':skill_id,
**({'auto_recover':True} if auto_recover else {}),**({'model':model} if model not in (None,'auto') else {})})
if old['request_digest']!=fingerprint:raise SkillError('IDEMPOTENCY_CONFLICT','同一请求键对应不同需求。',409)
return self.job(actor,old['id'])
if skill_id:raise SkillError('LEGACY_BUSINESS_TEMPLATE','采购订单源码只适用于旧实例,请选择需求驱动 Java 业务应用。',409)
scenario='business-app'
spec=self.spec(actor,scenario)
if self.resource_limits:auto_recover=False
if scope_baseline:
raise SkillError('SCOPE_ADMISSION_REMOVED','范围裁剪已撤回,请直接提交完整原需求。',409)
if scope_baseline and scenario!='business-app':raise SkillError('SCOPE_SCENARIO_INVALID','范围基线仅用于业务开发。',409)
if workflow_id:
self.skills.require(actor, {'admin', 'skill_manager'})
workflow=self.skills.read_draft(actor,workflow_id)
body=workflow['body']
if (body.get('execution_profile_ref') or workflow_id)!=spec['skill'] or body.get('project_id')!=spec['project']:
raise SkillError('WORKFLOW_PROFILE_MISMATCH','工作流与批准的场景、项目不匹配。',409)
base=self.skills.read_draft(self.author,spec['skill'])['body']
if body['framework_ref']!=base['framework_ref']:
raise SkillError('WORKFLOW_PROFILE_MISMATCH','不能通过草稿更换场景执行框架。',409)
baseline=None;recovery_diagnostics=None;preserved_design=None
if scope_baseline and scope_baseline.get('base_run'):
previous=self.job(actor,scope_baseline['base_run'])
old_run=self.store.get(scope_baseline['base_run'])
if (old_run['owner_id']!=actor.user_id or previous['scenario']!=scenario or previous['status'] not in {'verified','failed','cancelled'}
or any(c['state'] in {'unknown','reserved'} for c in previous['model_calls'])):
raise SkillError('SCOPE_BASELINE_UNCERTAIN','原任务未确定,不能通过新范围重放。',409)
if previous.get('source'):
baseline=self.runtimes[scenario].harness.files({'files':previous['source']['files']},old_run['snapshot']['framework'])
if recovery_of and skill_id:raise SkillError('RECOVERY_SOURCE_CONFLICT','修复任务只能选择一个明确源码基线。',409)
if recovery_of:
prior=self.job(actor,recovery_of)
original=self.store.get(recovery_of)
if self.resource_limits or original['request'].get('resource_limits'):
raise SkillError('RECOVERY_BUDGET_APPROVAL_REQUIRED','受限模式不另开续修预算;请在原任务批准本次限额调整,或确认新的业务阶段。',409)
if original['owner_id']!=actor.user_id:raise SkillError('RUN_NOT_FOUND','原任务不存在或不可见。',404)
if prior['scenario']!=scenario or prior['status'] not in {'failed','unknown','cancelled'}:
raise SkillError('RECOVERY_TARGET_INVALID','仅可为同场景的已终止任务建立明确授权的新任务。',409)
if scenario=='business-app' and requirement!=original['request']['requirement']:
raise SkillError('RECOVERY_REQUIREMENT_CHANGED','需求已变化,请新建业务任务,避免沿用旧页面。',409)
if prior['status']=='unknown' and not acknowledge_new_cost:
raise SkillError('NEW_CALL_CONFIRMATION_REQUIRED','这是独立新任务,可能新增费用;须明确确认,原未知结果和预留保持不变。',409)
if model is None:model=original['request'].get('selected_model')
if (prior['status']=='failed' and prior.get('source')
and all(call['state'] in {'settled','rejected'} for call in prior['model_calls'])):
baseline=self.runtimes[scenario].harness.files({'files':prior['source']['files']},original['snapshot']['framework'])
recovery_diagnostics=self.runtimes[scenario].repair_diagnostics(original)
if scenario=='business-app' and recovery_diagnostics:
from src.modules.llm_gateway.service import Design
preserved_design=Design.model_validate(AgentRuntime._operation_output(original,'AO04')['design']).model_dump()
if skill_id:
skill=self.java_skills.get(actor,skill_id)
if skill['scenario']!=scenario: raise SkillError('SKILL_SCENARIO_MISMATCH','技能与场景不符。',409)
baseline=skill['evidence']['manifest']['source']
self.runtimes[scenario].harness.files({'files':baseline['files']},skill['evidence']['manifest']['snapshot']['framework'])
if not isinstance(key,str) or not 8<=len(key)<=128: raise SkillError('INVALID_IDEMPOTENCY_KEY','需要有效请求键。')
from src.modules.llm_gateway.routing import selected_provider
runtime=self.runtimes[scenario]
selected=selected_provider(runtime.llm.providers,model,['design','diagnose','code','repair'])
selected_model=selected.model if selected else None
fingerprint=digest({'scenario':scenario,'requirement':requirement,'skill_id':skill_id,**({'scope_baseline':scope_baseline} if scope_baseline else {}),**({'recovery_of':recovery_of} if recovery_of else {}),**({'auto_recover':True} if auto_recover else {}),**({'model':selected_model} if selected_model else {}),**({'workflow_revision':workflow_revision} if workflow_revision else {}),**({'workflow_id':workflow_id,'workflow_inputs':workflow_inputs} if workflow_id else {})})
with self.lock:
with self.store.connect() as db:
old=db.execute('SELECT * FROM web_jobs WHERE owner=? AND request_key=?',(actor.user_id,key)).fetchone()
if old:
if old['request_digest']!=fingerprint: raise SkillError('IDEMPOTENCY_CONFLICT','同一请求键对应不同需求。',409)
return self.job(actor,old['id'])
if self.queue.full(): raise SkillError('QUEUE_FULL','队列已满,请稍后再提交。',429)
runtime.sandbox.preflight()
if not runtime.llm.providers: raise SkillError('MODEL_NOT_CONFIGURED','模型尚未配置。',503)
auth='local-web-delegation-v1:'+actor.user_id
release=self.skills.stage_local_validation(self.author,workflow_id or spec['skill'],auth,validation_owner=actor.user_id,
**({'expected_revision':workflow_revision} if workflow_revision else {}))
run=runtime.create(actor,dict(release_ref=release['key'],project_id=spec['project'],source_digest=baseline['source_digest'] if baseline else digest({}),
baseline=baseline,generated_skill_id=skill_id,
**({'workflow_inputs':workflow_inputs} if workflow_id else {}),
**({'recovery_policy':{'version':'bounded-continuation-v1','max_continuations':1,'authorization':'explicit-request-auto_recover'}} if auto_recover else {}),
requirement=requirement,**({'budget_policy':self.budget_policy} if self.budget_policy else {}),**({'scope_baseline':scope_baseline} if scope_baseline else {}),**({'recovery_of':recovery_of} if recovery_of else {}),
**({'resource_limits':self.resource_limits} if self.resource_limits else {}),
**({'new_call_authorization':'explicit-user-confirmation'} if acknowledge_new_cost else {}),
**({'selected_model':selected_model} if selected_model else {}),
**({'recovery_diagnostics':recovery_diagnostics,'baseline_origin':'unverified-failed-candidate'} if recovery_diagnostics else {}),
**({'preserved_design':preserved_design,'design_source_run':recovery_of} if preserved_design else {}),
query=((workflow_inputs or {}).get('query') or (requirement[:120] if scenario in {'webapp','business-app'} else
{'erp':'purchase order BigDecimal','erp-orders':'purchase order file inventory payment','wms':'stock idempotency','equipment':'maintenance state machine','calculator':'BigDecimal expression parser','pdf':'PDFBox text extraction'}[scenario]))),key)
with self.store.connect() as db:
db.execute('INSERT INTO web_jobs VALUES(?,?,?,?,?,?,?,?)',(run['id'],actor.user_id,scenario,key,fingerprint,'queued',None,None))
if recovery_of:db.execute('INSERT INTO web_job_links VALUES(?,?,?)',(recovery_of,run['id'],actor.user_id))
if auto_recover:db.execute('INSERT INTO web_job_recovery VALUES(?,?,0,NULL)',(run['id'],run['id']))
self.queue.put_nowait(run['id'])
return self.job(actor,run['id'])
def auto_recover(self,actor,run_id):
"""One explicitly opted-in continuation; never replay unknown/charged calls."""
if self.resource_limits or self.store.get(run_id)['request'].get('resource_limits'):return None
with self.lock:
with self.store.connect() as db:
policy=db.execute('SELECT * FROM web_job_recovery WHERE run_id=?',(run_id,)).fetchone()
if not policy or policy['attempt'] != 0:return None
run=self.store.get(run_id)
if run['owner_id'] != actor.user_id:return None
calls=self.store.calls(run_id)
if (run['status']!='failed' or run['error'] not in REPAIRABLE or run.get('cancel_requested')
or not calls or any(c['state'] not in {'settled','rejected'} for c in calls)):
return None
old=self.job(actor,run_id)
# Any already linked recovery, including an explicit user action, wins.
if old['followups']:return old['followups'][0]['id']
try:
next_job=self.submit(actor,old['scenario'],old['requirement'],
'automatic-recovery-v1:'+run_id,recovery_of=run_id)
with self.store.connect() as db:
db.execute('INSERT OR IGNORE INTO web_job_recovery VALUES(?,?,1,NULL)',(next_job['id'],policy['root_run']))
self.store.stage_event(run_id,'recovery','scheduled','原任务保留;已依据失败源码与真实诊断创建一次自动恢复:'+next_job['id'])
return next_job['id']
except SkillError as exc:
# A scheduling refusal does not turn a known failure into unknown.
with self.store.connect() as db:db.execute('UPDATE web_job_recovery SET error=? WHERE run_id=?',(exc.code,run_id))
return None
except Exception:
with self.store.connect() as db:db.execute("UPDATE web_job_recovery SET error='AUTO_RECOVERY_SCHEDULING_FAILED' WHERE run_id=?",(run_id,))
return None
def worker(self):
while not self.stopped.is_set():
try: run_id=self.queue.get(timeout=.5)
except queue.Empty: continue
self.process(run_id)
self.queue.task_done()
def process(self,run_id):
# A queued job must never evict another user's active preview lease.
while not self.stopped.is_set():
with self.lock:
if not self.preview or self.preview.status not in {'starting','ready'}:
self.busy=True
break
with self.store.connect() as db:
waiting=db.execute('SELECT scenario FROM web_jobs WHERE id=?',(run_id,)).fetchone()
if waiting and self.store.get(run_id)['status']=='cancelled':
with self.store.connect() as db: db.execute("UPDATE web_jobs SET state='cancelled' WHERE id=?",(run_id,))
return
self.stopped.wait(.25)
if self.stopped.is_set(): return
try:
with self.store.connect() as db:
row=dict(db.execute('SELECT * FROM web_jobs WHERE id=?',(run_id,)).fetchone())
db.execute("UPDATE web_jobs SET state='working' WHERE id=?",(run_id,))
runtime=self.runtimes[row['scenario']]
for _ in range(30):
actor=self.identity.actor(row['owner'])
self.spec(actor,row['scenario'])
run=runtime.get(actor,run_id)
if run['status'] in {'waiting_budget','waiting_limit'}:
with self.store.connect() as db:db.execute('UPDATE web_jobs SET state=?,error=? WHERE id=?',(run['status'],run['error'],run_id))
return
if run['status']=='waiting_approval' and run['pending_approval']['scope']=='acceptance':
evidence=runtime.validation_evidence(actor,run_id)
with self.store.connect() as db: db.execute("UPDATE web_jobs SET state='verified',evidence=?,error=NULL WHERE id=?",(canonical(evidence),run_id))
if actor.user_id=='local-example-builder': self.save_example(row['scenario'],run_id,evidence)
elif not run['request'].get('resource_limits') and hasattr(self,'preview_pool') and row['scenario'] in {'erp','erp-orders','business-app','calculator','pdf'}:
try:self.preview_pool.start(actor,'run',run_id,prewarm=True)
except Exception:self.store.stage_event(run_id,'preview-prewarm','skipped','后台预热未完成,仍可手动打开预览。')
return
if run['status'] in {'failed','unknown','cancelled','succeeded'}:
with self.store.connect() as db: db.execute('UPDATE web_jobs SET state=?,error=? WHERE id=?',(run['status'],run['error'],run_id))
if run['status']=='failed':self.auto_recover(actor,run_id)
return
LocalValidation(runtime,actor,'local-web-delegation-v1:'+actor.user_id).step(run_id)
raise SkillError('WORKER_STEP_LIMIT','任务推进步数超限。')
except Exception as exc:
code=exc.code if isinstance(exc,SkillError) else 'WORKER_RESULT_UNKNOWN'
self.store.diagnostic(run_id,'workbench',code,exc)
with self.store.connect() as db: db.execute("UPDATE web_jobs SET state='unknown',error=? WHERE id=?",(code,run_id))
finally: self.busy=False
def job(self,actor,run_id):
with self.store.connect() as db:
row=db.execute('SELECT * FROM web_jobs WHERE id=?',(run_id,)).fetchone()
if not row: raise SkillError('RUN_NOT_FOUND','任务不存在。',404)
run=self.runtimes[row['scenario']].get(actor,run_id)
with self.store.connect() as db:
followups=[dict(r) for r in db.execute('SELECT j.id,j.state AS status FROM web_job_links l JOIN web_jobs j ON j.id=l.new_run WHERE l.previous_run=? AND l.owner=? ORDER BY j.rowid DESC',(run_id,run['owner_id']))]
try:source=AgentRuntime._operation_output(run,'AO06')['source']
except (KeyError,StopIteration):source=None
events=self.store.stages(run_id)
design=next((v['design'].get('summary','') for v in run.get('outputs',{}).values() if isinstance(v,dict) and isinstance(v.get('design'),dict)), '')
from src.apps.workbench.project_files import project_info
with self.store.connect() as db:policy=db.execute('SELECT * FROM web_job_recovery WHERE run_id=?',(run_id,)).fetchone()
recovery=dict(root_run=policy['root_run'],attempt=policy['attempt'],max_continuations=1,
next_run_id=followups[0]['id'] if followups else None,error=policy['error']) if policy else None
calls=self.store.calls(run_id)
settled=sum(c['charged'] or 0 for c in calls)
held=sum(c['reservation'] for c in calls if c['charged'] is None)
usage={'settled_tokens':settled,'reserved_tokens':held,
'remaining_tokens':max(0,run['budget']['max_tokens']-settled-held),'token_limit':run['budget']['max_tokens'],
'overdraft_tokens':max(0,settled+held-run['budget']['max_tokens']),
'calls':len(calls),'call_limit':run['budget']['max_model_calls'],
'unknown_calls':sum(c['state']=='unknown' for c in calls),
'pending_calls':sum(c['state']=='reserved' for c in calls),'currency_cost':None}
if run['request'].get('budget_policy',{}).get('mode')=='unlimited-usage-v1':
usage.update(token_limit=None,call_limit=None,remaining_tokens=None,overdraft_tokens=0)
return dict(id=run_id,scenario=row['scenario'],requirement=run['request']['requirement'],scope_baseline=run['request'].get('scope_baseline'),model=run['request'].get('selected_model') or 'auto',status=row['state'],runtime_status=run['status'],
revision=run['revision'],effective_budget=run['budget'],budget_policy=run['request'].get('budget_policy'),
error=row['error'] or run['error'],cursor=run['cursor'],stages=run['release']['execution_order'],repairs=run['repairs'],
failure_category=run.get('failure_details',{}).get('failure_category'),
failure_details=run.get('failure_details',{}),budget_checks=run.get('budget_checks',[]),
budget_request=run.get('budget_request'),limit_request=run.get('limit_request'),resource_limits=run['request'].get('resource_limits'),budget_authorizations=run.get('budget_authorizations',[]),simulation=run.get('simulation',False),simulation_kind=run.get('simulation_kind'),
workflow=dict(skill_id=run['release']['skill_id'],name=run['release']['draft']['name'],
revision=run['release'].get('draft_revision'),digest=run['release'].get('draft_digest'),
instructions=run['release']['draft'].get('instructions',''),release_ref=run['request']['release_ref']),
model_calls=calls,usage=usage,created_at=run['created_at'],source=source,
diagnostics=run.get('diagnostics'),diagnostic_events=self.store.diagnostics(run_id),evidence=self.checked_json(row['evidence']) if row['evidence'] else None,
timeline=timeline(self.store,run,events),progress=progress(run,row['state'],events,time.time()),
design_summary=design,project=project_info(self,actor,run_id),
failure_analysis=run.get('failure_analysis'),
code_review=run.get('outputs',{}).get('code_review',{}).get('review'),
artifacts_available=bool(source),human_acceptance=False,
recovery_of=run['request'].get('recovery_of'),followups=followups,auto_recovery=recovery)
def jobs(self,actor):
with self.store.connect() as db: ids=[r['id'] for r in db.execute('SELECT id FROM web_jobs ORDER BY rowid DESC LIMIT 100')]
result=[]
for rid in ids:
try:
job=self.job(actor,rid); job.pop('source'); job.pop('evidence'); job.pop('diagnostics'); job.pop('diagnostic_events',None); result.append(job)
except SkillError as exc:
if exc.status!=404: raise
return result
def save_example(self,scenario,run_id,evidence,*,replace=True):
self.check_evidence(evidence)
body=evidence['manifest']; source=body['source']
if (digest(source['files'])!=source['source_digest'] or body['status']!='verified_pending_user_acceptance'
or not body['test']['passed'] or not body['preview']['passed']):
raise SkillError('EXAMPLE_EVIDENCE_INVALID','实例证据无效。')
for section in ['candidate','test','preview']:
if body[section]['source_digest']!=source['source_digest']: raise SkillError('EXAMPLE_EVIDENCE_INVALID','实例摘要不一致。')
with self.store.connect() as db:
verb='REPLACE' if replace else 'IGNORE'
db.execute('INSERT OR '+verb+' INTO web_examples VALUES(?,?,?)',(scenario,run_id,canonical(evidence)))
@staticmethod
def check_evidence(evidence):
body=evidence['manifest']
if digest(body)!=evidence['digest'] or digest(body['source']['files'])!=body['source']['source_digest']:
raise SkillError('ARTIFACT_DIGEST_MISMATCH','源码或验证证据摘要不符。',409)
def checked_json(self,value):
evidence=json.loads(value);self.check_evidence(evidence);return evidence
def examples(self,actor):
with self.store.connect() as db: rows=[dict(r) for r in db.execute('SELECT * FROM web_examples')]
results=[]
for row in rows:
try: self.spec(actor,row['scenario'])
except SkillError: continue
row['evidence']=json.loads(row['evidence']); self.check_evidence(row['evidence']); results.append(row)
return results
def evidence(self,actor,kind,reference):
if kind=='skill':
skill=self.java_skills.get(actor,reference)
return skill['scenario'],skill['run_id'],skill['evidence']
if kind=='example':
self.spec(actor,reference)
for row in self.examples(actor):
if row['scenario']==reference: return row['scenario'],row['run_id'],row['evidence']
elif kind=='run':
row=self.job(actor,reference)
if row['evidence']: return row['scenario'],reference,row['evidence']
raise SkillError('VALIDATION_INCOMPLETE','尚无技术通过证据。',409)
def export(self,actor,kind,reference):
scenario,run_id,evidence=self.evidence(actor,kind,reference)
body=evidence['manifest']; source=body['source']
self.check_evidence(evidence)
self.runtimes[scenario].harness.files({'files':source['files']},body['snapshot']['framework'])
manifest={'run_id':run_id,'scenario':scenario,'source_digest':source['source_digest'],'candidate':body['candidate'],
'evidence_digest':evidence['digest'],
'provenance':{key:body[key] for key in ('repair_origin','continuation_origin','documentation_provenance') if key in body},
'test':body['test'],'preview':body['preview'],'model_calls':body['model_calls'],'config_version':'local-web-v1',
'human_acceptance':False,'target_environment':'pending-user-selection','deployment_approved':False,
'approval_target':digest({'source':source['source_digest'],'candidate':body['candidate'],'config':'local-web-v1'}),
'rollback':'Retain the previous source, image digest and configuration; stop the new instance before restoring the approved previous bundle.'}
stream=io.BytesIO()
with zipfile.ZipFile(stream,'w',zipfile.ZIP_DEFLATED) as archive:
from src.apps.workbench.deliverables import get_delivery
delivery=get_delivery(self,actor,kind,reference)
entries={file['path']:file['content'].encode('utf-8') for file in delivery['files']}
entries['evidence/validation.json']=json.dumps(evidence,ensure_ascii=False,indent=2).encode('utf-8')
if scenario=='pdf':entries['samples/two-page.pdf']=pdf.sample_pdf()
for path,content in entries.items():archive.writestr(path,content)
archive.writestr('delivery-manifest.json',json.dumps({'source_digest':source['source_digest'],
'origins':{file['path']:file['origin'] for file in delivery['files']},
'files':{path:hashlib.sha256(content).hexdigest() for path,content in entries.items()}},indent=2))
archive.writestr('validation-manifest.json',json.dumps(manifest,ensure_ascii=False,indent=2))
archive.writestr('acceptance-checklist.txt','Verify source/image/config digest; map identity and project ACL; inject target secrets separately; test target isolation and readiness; obtain human approval; retain previous approved bundle for rollback.\nNo target deployment was performed.\n')
return stream.getvalue()
def start_preview(self,actor,kind,reference):
if hasattr(self,'preview_pool'):return self.preview_pool.start(actor,kind,reference)
scenario,_,evidence=self.evidence(actor,kind,reference)
runtime=self.runtimes[scenario]; source=evidence['manifest']['source']
runtime.harness.files({'files':source['files']},evidence['manifest']['snapshot']['framework'])
with self.lock:
if self.busy or not self.queue.empty(): raise SkillError('SANDBOX_CAPACITY_EXCEEDED','编程任务正在运行,请稍后启动预览。',409)
if self.preview and self.preview.status in {'starting','ready'}:
if self.preview_owner!=actor.user_id: raise SkillError('SANDBOX_CAPACITY_EXCEEDED','另一成员正在使用预览。',409)
if self.preview_kind==kind and self.preview_reference==reference and self.preview.source['source_digest']==source['source_digest']:
return self.preview_state(actor)
self.preview.close()
self.preview=PreviewSession(runtime.sandbox,source); self.preview_owner=actor.user_id; self.preview_scenario=scenario
self.preview_kind,self.preview_reference=kind,reference
threading.Thread(target=self.preview.start,daemon=True).start()
return self.preview_state(actor)
def close_preview(self,actor,preview_id=None):
if hasattr(self,'preview_pool'):return self.preview_pool.close(actor,preview_id)
with self.lock:
self.preview_state(actor)
self.preview.close()
def request_preview(self,actor,method,path,token,body=None,preview_id=None):
if hasattr(self,'preview_pool'):return self.preview_pool.request(actor,preview_id,method,path,token,body)
with self.lock:
self.preview_state(actor)
return self.preview.request(method,path,token,**({'body':body} if body is not None else {}))
def preview_state(self,actor,preview_id=None):
if hasattr(self,'preview_pool'):return self.preview_pool.state(actor,preview_id)
if not self.preview or self.preview_owner!=actor.user_id: raise SkillError('PREVIEW_NOT_FOUND','预览不存在。',404)
self.spec(actor,self.preview_scenario)
return dict(id=self.preview.id,scenario=self.preview_scenario,status=self.preview.status,error=self.preview.error,
expires_at=self.preview.expires,receipt=self.preview.receipt,kind=getattr(self,'preview_kind',None),reference=getattr(self,'preview_reference',None),
progress=self.preview.progress() if hasattr(self.preview,'progress') else None,
url=getattr(self,'preview_origin','')+'/preview-site/?lease='+self.preview.id if self.preview.status=='ready' else None)
def shutdown(self):
self.stopped.set()
for runtime in self.runtimes.values():
close = getattr(runtime.sandbox.command, 'close', None)
if close: close()
if hasattr(self,'preview_pool'):self.preview_pool.shutdown()
if self.preview: self.preview.close()