import { unrestricted } from '../../shared/contracts/execution-policy.mjs'; import fs from 'node:fs'; import path from 'node:path'; import { randomUUID } from 'node:crypto'; import { diagnoseEnvironment, nodeEnvironmentBinding, environmentHash as hash, environmentConflict as conflict, fileIdentity } from './environment-inspector.mjs'; import { assertEnvironmentsResolved, ENVIRONMENT_ACTIVE, environmentPlanSeal as planSeal } from '../../shared/contracts/environment.mjs'; import { assertChangeSetsResolved } from '../../shared/contracts/change-sets.mjs'; import { assertWorkspacesResolved, projectWorkspaceIdentity } from '../../shared/contracts/workspaces.mjs'; import { workerForSession } from '../../shared/contracts/workers.mjs'; import { assertMcpResolved } from '../tools/mcp-contract.mjs'; import { verifyWorkspaceProject } from '../workspaces/git-workspaces.mjs'; import { verifyEvaluationSources } from '../evaluation/provenance.mjs'; import { projectEnvironment } from '../process-environment.mjs'; import { runOwnedCommand } from '../owned-command.mjs'; import { readOwnedProcessTree } from '../owned-process-tree.mjs'; import { assertPreviewsResolved } from '../../shared/contracts/preview.mjs'; import { inspectProject } from '../project-inspector.mjs'; const at = () => new Date().toISOString(); export const publicEnvironmentDiagnostic = record => ({ ...record, node:record.node ? (({packages,...node})=>node)(record.node) : null }); export class EnvironmentManager { constructor(store,{runtimeDirectory=null,pythonExecutable=null,redact=String,projectBusy=()=>false,timeoutMs=300000,allowHttpLoopback=false}={}) { Object.assign(this,{store,runtimeDirectory,pythonExecutable,redact,projectBusy,timeoutMs,allowHttpLoopback}); this.active=new Map(); this.projects=new Map(); } isActive(sessionId) { return [...this.active.values()].some(value=>value.sessionId===sessionId); } projectActive(projectId) { return this.projects.has(projectId); } options() { return {runtimeDirectory:this.runtimeDirectory,pythonExecutable:this.pythonExecutable}; } artifact(session,runId,value,kind) { const artifact=this.store.artifactStore.write(session,this.store.owned('run',runId,session.id),typeof value==='string'?this.redact(value):JSON.parse(this.redact(JSON.stringify(value))),{kind}); this.store.core.artifact.set(artifact.id,artifact); return artifact; } async diagnose(session) { if (!session.taskId || !session.runId) throw conflict('先建立项目任务,再记录本任务的环境诊断。'); const taskId=session.taskId,runId=session.runId; await verifyWorkspaceProject(this.store,this.store.project(session.projectId)); const diagnostic=await diagnoseEnvironment(this.store.project(session.projectId),this.options()); if(taskId!==session.taskId||runId!==session.runId) throw conflict('诊断期间任务已切换,请重新诊断。'); const record={...diagnostic,id:randomUUID(),sessionId:session.id,taskId,runId,createdAt:at()}; const artifact=this.artifact(session,runId,record,'environment-diagnostic');record.artifactId=artifact.id;record.artifactSha256=artifact.sha256; this.store.putRecord('environment_diagnostic',session,record,'environment.diagnosed');return record; } idle(session,{exceptSessionId=null}={}) { assertPreviewsResolved(this.store,session.projectId,{includeReady:true}); assertEnvironmentsResolved(this.store,session.projectId); assertChangeSetsResolved(this.store,session.projectId,{includePrepared:true}); assertWorkspacesResolved(this.store,session.projectId,{includePrepared:true}); assertMcpResolved(this.store,session.projectId); if(this.projectActive(session.projectId)||this.projectBusy(session.projectId,exceptSessionId)) throw conflict('工程已有执行,请等待结束后准备依赖。'); if(session.changes.some(value=>['pending','conflict'].includes(value.status))) throw conflict('先处理待审查的工程改动,再准备依赖。'); const worker=workerForSession(this.store,session); if(worker && !worker.evaluation) throw conflict('受限协作的依赖请在独立工程准备完成后再创建协作。'); if(worker?.status==='completed') throw conflict('评测子成果已经封存,不能再次准备依赖。'); } registry(value='https://registry.npmjs.org/') { let url;try{url=new URL(value);}catch{throw conflict('注册源需要有效的HTTPS地址。');} const local=this.allowHttpLoopback && url.protocol==='http:' && ['127.0.0.1','localhost','[::1]'].includes(url.hostname); if((url.protocol!=='https:'&&!local)||url.username||url.password||url.search||url.hash||url.pathname!=='/') throw conflict('注册源只接受不含凭据、查询参数的HTTPS根地址。'); return url.href; } async plan(session,input={}, {source='user'}={}) { if(!input||Array.isArray(input)||Object.keys(input).some(key=>!['registry','scripts','offline'].includes(key))) throw conflict('依赖计划只接受注册源、生命周期脚本策略和离线选择。'); if(input.scripts!==undefined&&!['skip','allow'].includes(input.scripts)||input.offline!==undefined&&typeof input.offline!=='boolean') throw conflict('脚本策略或离线选项无效。'); this.idle(session,{exceptSessionId:source==='agent'?session.id:null}); await verifyEvaluationSources(this.store,session); const project=this.store.project(session.projectId); if(!project.workspace) throw conflict('依赖准备需要工作台管理的独立工作区。请先创建并打开独立工作区。'); const diagnostic=await this.diagnose(session), node=diagnostic.node; this.idle(session,{exceptSessionId:source==='agent'?session.id:null}); if(!node?.preparable) throw conflict(node?.issues?.join('\n')||'当前工程不支持自动准备npm依赖。'); if(node.installed.status==='unverified') throw conflict('当前依赖目录无法完整核验,请保留现场并处理链接或诊断范围问题。'); const registry=this.registry(input.registry),origin=new URL(registry).origin; if(node.packages.some(value=>value.source?.origin!==origin)) throw conflict('锁文件下载来源与所选注册源不同。请人工审查锁文件,系统不会静默改源。'); const scripts=input.scripts??'skip'; const id=randomUUID(),directory=path.join(this.store.directory,'environments','plans',id); fs.mkdirSync(directory,{recursive:true}); if(fs.realpathSync.native(directory)!==path.resolve(directory))throw conflict('环境配置目录经过链接,不能准备计划。'); const configFiles=['user.npmrc','global.npmrc'].map(name=>{const target=path.join(directory,name);fs.writeFileSync(target,'',{flag:'wx'});return fileIdentity(target);}); const cacheDirectory=path.join(this.store.directory,'environments','cache',project.id); const invocation={executable:node.runtime.node.path,args:[node.runtime.npm.path,'ci','--registry='+registry,'--ignore-scripts='+(scripts==='skip'), '--audit=false','--fund=false','--update-notifier=false','--include=dev','--include=optional','--strict-ssl=true', '--userconfig='+configFiles[0].path,'--globalconfig='+configFiles[1].path,'--cache='+cacheDirectory, '--fetch-retries=0','--fetch-timeout=60000','--offline='+(input.offline===true)]}; const plan={schemaVersion:1,id,sessionId:session.id,projectId:project.id,taskId:session.taskId,runId:session.runId,diagnosticId:diagnostic.id, root:project.root,workspace:projectWorkspaceIdentity(project),sourceFingerprint:diagnostic.sourceFingerprint,nodeIdentity:node.identity, dependencyInputs:node.dependencyInputs,registry,scripts,offline:input.offline===true,timeoutMs:unrestricted(this.store)?0:this.timeoutMs,invocation,configFiles,cacheDirectory, lifecycle:node.lifecycle,installScriptPackages:node.installScriptPackages,packageCount:node.packageCount,status:'planned',createdAt:at(),jobId:null}; plan.fingerprint=hash(planSeal(plan)); const artifact=this.artifact(session,plan.runId,planSeal(plan),'environment-plan');plan.contractArtifactId=artifact.id;plan.contractSha256=artifact.sha256; this.store.putRecord('environment_plan',session,plan,'environment.planned');return plan; } own(session,id,fingerprint) { const plan=this.store.owned('environment_plan',id,session.id); if(plan.taskId!==session.taskId||plan.runId!==session.runId||fingerprint!==plan.fingerprint||hash(planSeal(plan))!==plan.fingerprint)throw conflict('环境计划身份、任务或执行范围已变化,请重新准备计划。'); const artifact=this.store.owned('artifact',plan.contractArtifactId,session.id); if(artifact.kind!=='environment-plan'||artifact.sha256!==plan.contractSha256||this.store.artifactStore.read(artifact)!==this.redact(JSON.stringify(planSeal(plan))))throw conflict('原环境计划工件无法核对。'); return plan; } async verify(session,plan) { const project=this.store.project(session.projectId);await verifyWorkspaceProject(this.store,project);await verifyEvaluationSources(this.store,session); if(JSON.stringify(projectWorkspaceIdentity(project))!==JSON.stringify(plan.workspace))throw conflict('准备目标的工作区身份已变化。'); const node=nodeEnvironmentBinding(project,this.options()); if(!node||node.identity!==plan.nodeIdentity)throw conflict('声明、锁文件、运行时或当前依赖已变化,请重新准备计划。'); const inspection=await inspectProject(project); if(!inspection.scope.complete||inspection.sourceFingerprint!==plan.sourceFingerprint)throw conflict('工程来源在计划创建后变化,请重新准备。'); for(const original of plan.configFiles)if(JSON.stringify(fileIdentity(original.path))!==JSON.stringify(original))throw conflict('隔离npm配置已变化。'); return node; } async start(session,id,fingerprint,{approved=false,signal,source='user',approvalId=null}={}) { if(approved!==true)throw conflict('请核对固定依赖命令、下载来源和脚本策略后明确批准。'); this.idle(session,{exceptSessionId:source==='agent'?session.id:null}); const plan=this.own(session,id,fingerprint); if(plan.status!=='planned'||plan.jobId)throw conflict('这个依赖计划已经使用;原结果保留,不自动重放。重新执行需要新计划和审批。'); const controller=new AbortController(),job={id:randomUUID(),sessionId:session.id,projectId:session.projectId,taskId:plan.taskId,runId:plan.runId, planId:plan.id,planFingerprint:plan.fingerprint,dependencyInputs:plan.dependencyInputs,source,approvalId,status:'queued',createdAt:at(),startedAt:null,finishedAt:null, command:['node',...plan.invocation.args].join(' '),root:plan.root,process:null,requiresVerification:false,logExcerpt:'',result:null}; const active={sessionId:session.id,projectId:session.projectId,controller,promise:null}; this.active.set(job.id,active);this.projects.set(session.projectId,job.id); try { await this.verify(session,plan); this.own(session,id,fingerprint); if(signal?.aborted||controller.signal.aborted)throw conflict('环境准备在执行前已停止。'); if(!approvalId){const approval={id:randomUUID(),environmentPlanId:plan.id,taskId:plan.taskId,runId:plan.runId,projectId:plan.projectId, command:job.command,cwd:plan.root,reason:'核对不可变依赖计划后准备所属工作区',shell:'npm · 直接进程',status:'approved',createdAt:at(),decidedAt:at()};session.approvals.push(approval);job.approvalId=approval.id;} plan.status='consumed';plan.jobId=job.id; this.store.putRecord('environment_job',session,job,'environment.queued'); const combined=signal?AbortSignal.any([signal,controller.signal]):controller.signal; active.promise=this.execute(session,plan,job,combined).finally(()=>{this.active.delete(job.id);this.projects.delete(session.projectId);}); active.promise.catch(()=>{});return {job,promise:active.promise}; }catch(error){this.active.delete(job.id);this.projects.delete(session.projectId);throw error;} } async execute(session,plan,job,signal) { let dispatched=false,recorded=false; try { await this.verify(session,plan);signal.throwIfAborted(); fs.mkdirSync(plan.cacheDirectory,{recursive:true}); if(fs.realpathSync.native(plan.cacheDirectory)!==path.resolve(plan.cacheDirectory))throw conflict('npm缓存目录经过链接,准备已拒绝。'); job.status='running';job.startedAt=at();this.store.save(session,{type:'environment.running',detail:{jobId:job.id}}); let lastUpdate=0; const result=await runOwnedCommand(plan.invocation,{cwd:plan.root,signal,timeoutMs:plan.timeoutMs, env:projectEnvironment({CI:'1',NO_COLOR:'1',NPM_CONFIG_USERCONFIG:plan.configFiles[0].path,NPM_CONFIG_GLOBALCONFIG:plan.configFiles[1].path, NPM_CONFIG_CACHE:plan.cacheDirectory,NPM_CONFIG_REGISTRY:plan.registry,NPM_CONFIG_IGNORE_SCRIPTS:String(plan.scripts==='skip')}), onSpawn:info=>{dispatched=true;job.process={...info};this.store.save(session,{type:'environment.process',detail:{jobId:job.id}});}, onOutput:(stream,text)=>{job.logExcerpt=this.redact((job.logExcerpt+text).slice(-8000));if(Date.now()-lastUpdate>750){lastUpdate=Date.now();this.store.save(session,{type:'environment.output',detail:{jobId:job.id,stream}});}}}); const {stdout,stderr,...saved}=result; const log=this.artifact(session,job.runId,`$ ${job.command}\n\n[stdout]\n${stdout}\n\n[stderr]\n${stderr}`,'environment-log'); job.logArtifactId=log.id;job.logSha256=log.sha256;job.logExcerpt=this.redact((stdout+'\n'+stderr).slice(-8000));job.result=saved;job.process=result.process??job.process; recorded=true;job.status=result.status==='passed'?'prepared':result.status;job.requiresVerification=result.status==='unknown'; const after=await this.diagnose(session); const artifact=this.artifact(session,job.runId,after,'environment-result');job.environmentArtifactId=artifact.id;job.environmentSha256=artifact.sha256; job.after=nodeEnvironmentBinding(this.store.project(session.projectId),this.options()); if(after.sourceFingerprint!==plan.sourceFingerprint||job.after?.dependencyInputs!==plan.dependencyInputs){job.stale=true;if(job.status==='prepared')job.status='stale';} if(job.status==='prepared'&&job.after?.status!=='ready')job.status='unverified'; this.store.invalidateChecks(session.projectId,'工作区依赖准备已执行,旧检查环境需要重新核验。'); job.summary=job.status==='prepared'?'依赖命令完成,实际依赖字节已记录。请继续执行工程检查。':job.status==='cancelled'?'准备已停止,部分依赖和原日志保留。':job.status==='unknown'?'所属进程或执行结果未知,请核对原记录。':job.status==='stale'?'准备期间源码或锁文件已变化,原结果保留,请重新诊断。':'依赖准备未满足条件,请查看实际退出码和原日志。'; } catch(error) { job.status=dispatched&&!recorded?'unknown':signal.aborted?'cancelled':error.status===409?'stale':'failed'; job.requiresVerification=job.status==='unknown';job.summary=this.redact(error.message??String(error)); } finally {job.finishedAt=at();this.store.save(session,{type:'environment.finished',detail:{jobId:job.id,status:job.status}});} return job; } async reconcile(session,id,fingerprint) { const job=this.store.owned('environment_job',id,session.id); if(this.active.has(job.id)||ENVIRONMENT_ACTIVE.has(job.status)||!job.requiresVerification||job.reconciliation||fingerprint!==job.planFingerprint)throw conflict('只有原中断的未知准备记录可以核对。'); const observation=job.process?.pid?await readOwnedProcessTree(job.process):{supported:true,processes:[],note:'原记录未登记已启动进程'}; if(!observation.supported||observation.processes.length)throw conflict('原所属进程仍存在或无法核对;不会按历史PID杀进程。'); const diagnostic=await this.diagnose(session); const reconciliation={observedAt:at(),observation,diagnosticId:diagnostic.id,note:'已核对原进程结束并保留当前依赖现场;不补造原安装成功或重放命令。'}; const artifact=this.artifact(session,job.runId,reconciliation,'environment-reconciliation'); job.reconciliation={...reconciliation,artifactId:artifact.id,sha256:artifact.sha256};job.requiresVerification=false; this.store.save(session,{type:'environment.reconciled',detail:{jobId:job.id}});return job; } async stop(sessionId,id=null) { if(id)this.store.owned('environment_job',id,sessionId); const entries=[...this.active.entries()].filter(([key,value])=>value.sessionId===sessionId&&(!id||key===id)); for(const [key,value]of entries){value.controller.abort(new Error('用户停止依赖准备'));const job=this.store.core.environment_job.get(key);if(job){job.status='stopping';this.store.save(this.store.session(sessionId),{type:'environment.stopping',detail:{jobId:key}});}} await Promise.all(entries.map(([,value])=>value.promise)); } async stopAll(){await Promise.all([...new Set([...this.active.values()].map(value=>value.sessionId))].map(id=>this.stop(id)));} }