Spaces:
Sleeping
Sleeping
Download src/apps/workbench/engine.py from dellweb3/VibeCoding: direct link, hf CLI and curl.
- Browser
- Download file 44.2 kB
-
https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/apps/workbench/engine.py
- Command line
-
hf download hf://spaces/dellweb3/VibeCoding/src/apps/workbench/engine.py
-
curl -L -o engine.py https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/apps/workbench/engine.py
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))) | |
| 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() | |