182 lines
17 KiB
JavaScript
182 lines
17 KiB
JavaScript
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)));}
|
|
}
|