Files
Agent-Workbench/src/core/engine-manager.mjs
T
2026-10-30 20:34:54 +08:00

151 lines
12 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import { randomUUID } from 'node:crypto';
import { DeepSeekAdapter } from './engines/deepseek-adapter.mjs';
import { resolveDeepSeekInstallation } from './engines/deepseek-installation.mjs';
import { assertMcpResolved } from './tools/mcp-contract.mjs';
import { ENGINE_ACTIVE, ENGINE_SCOPE, ENGINE_LIMITS, engineInput, engineReportContract, engineError } from '../shared/contracts/engines.mjs';
const at = () => new Date().toISOString();
export class EngineManager {
constructor(store, { appDirectory = process.cwd(), adapterFactory = installation => new DeepSeekAdapter(installation),
projectBusy = () => false, redact = value => String(value), directoryRoot = null } = {}) {
this.store = store; this.appDirectory = appDirectory; this.adapterFactory = adapterFactory;
this.projectBusy = projectBusy; this.redact = redact; this.directoryRoot = directoryRoot;
this.active = new Map(); this.projects = new Map();
}
availability(root) { return resolveDeepSeekInstallation(this.appDirectory, root); }
isActive(sessionId) { return [...this.active.values()].some(value => value.sessionId === sessionId); }
projectActive(projectId) { return this.projects.has(projectId); }
jobs(session) { return [...this.store.core.engine_job.values()].filter(value => value.sessionId === session.id).slice(-20); }
inputFor(session, job) {
this.store.owned('engine_job', job.id, session.id);
const input = this.store.owned('artifact', job.contractArtifactId, session.id);
if (input.kind !== 'engine-input' || input.taskId !== job.taskId || input.runId !== job.runId || input.sha256 !== job.contractSha256
|| this.store.artifactStore.read(input) !== JSON.stringify(engineInput(job))) throw engineError('引擎检查与封存的任务、安装或会话身份不一致。');
return input;
}
originalReport(session, job) {
this.inputFor(session, job);
const artifact = this.store.owned('artifact', job.reportArtifactId, session.id);
if (artifact.kind !== 'engine-report' || artifact.sha256 !== job.reportSha256 || artifact.taskId !== job.taskId || artifact.runId !== job.runId) throw engineError('引擎原记录不属于这次检查。');
const text = this.store.artifactStore.read(artifact);
if (text !== JSON.stringify(engineReportContract(job))) throw engineError('引擎原记录与当前封存状态不一致。');
return text;
}
summary(session, job) {
let verified = false, message = job.summary;
try {
if (job.reportArtifactId) { this.originalReport(session, job); verified = job.status === 'completed' && job.report?.status === 'verified' && job.verification?.verified === true; }
else this.inputFor(session, job);
} catch (error) { message = this.redact(error.message); }
return { engine_job_id: job.id, engine_id: job.engineId, task_id: job.taskId, run_id: job.runId,
engine_status: job.status === 'completed' && !verified ? 'unknown' : job.status, evidence_verified: verified,
installation_sha256: job.installation.identitySha256, package_version: job.installation.version, profile: job.installation.profile,
sdk_session_id: job.sdkSessionId, pid: job.pid ?? null, connection_id: job.connectionId ?? null,
report_artifact_id: job.reportArtifactId ?? null, report_sha256: job.reportSha256 ?? null,
model_requests: job.report?.modelRequests ?? null, provider_requests: 0,
requires_verification: job.requiresVerification || job.status === 'completed' && !verified,
message, scope: job.scope, limitations: ENGINE_LIMITS };
}
start(session, input = {}) {
assertMcpResolved(this.store, session.projectId);
if (!input || typeof input !== 'object' || Array.isArray(input) || Object.keys(input).some(key => !['root', 'retry', 'identitySha256'].includes(key))
|| input.retry !== undefined && typeof input.retry !== 'boolean'
|| input.identitySha256 !== undefined && (typeof input.identitySha256 !== 'string' || !/^[a-f0-9]{64}$/.test(input.identitySha256))) throw engineError('连接核验只接受本地安装目录、检测身份和明确的重新验证选项。', 400);
if (session.archived || this.projectActive(session.projectId) || this.projectBusy(session.projectId)) throw engineError('当前项目有任务、审批或检查在执行,请等待结束。');
const installation = this.availability(input.root);
if (installation.status !== 'available') throw engineError(installation.message, 409, 'ENGINE_UNAVAILABLE');
if (input.identitySha256 !== undefined && input.identitySha256 !== installation.identitySha256) throw engineError('引擎安装与刚才的检测结果不一致,请重新检测后再核验连接。', 409, 'ENGINE_INPUT_CHANGED');
const previous = this.jobs(session).filter(job => job.taskId === session.taskId && job.installation.root === installation.root).at(-1);
if (previous && previous.status !== 'completed' && !input.retry) throw engineError('此前连接检查没有完成,请查看原记录后明确选择重新验证。');
const id = randomUUID(), controller = new AbortController(), active = { sessionId: session.id, projectId: session.projectId, controller };
this.active.set(id, active); this.projects.set(session.projectId, id);
try {
if (!this.store.core.task.get(session.taskId)) {
const goal = '核对本地DeepSeek Harness的启动、SDK连接、会话目录与进程结束,保存原检查记录。';
const run = this.store.beginRun(session, goal, false, this.store.config);
run.engine = 'deepseek-sdk-probe'; run.origin = 'user-engine-check';
this.store.message(session, 'user', goal); session.providerMessages.push({ role: 'user', content: goal });
session.status = 'paused'; this.store.finishRun(session, run, 'engine_probe_ready');
if (session.title === '新任务') session.title = '外部引擎连接';
}
const run = this.store.owned('run', session.runId, session.id);
const base = path.resolve(this.directoryRoot ?? path.join(os.tmpdir(), 'AgentWorkbench-Engines'));
fs.mkdirSync(base, { recursive: true });
if (fs.lstatSync(base).isSymbolicLink()) throw engineError('所属引擎探针目录不能是链接。');
const directory = path.join(base, id);
if (fs.existsSync(directory)) throw engineError('引擎探针目录已存在,不能复用或覆盖。');
const job = { schemaVersion: 1, id, sessionId: session.id, projectId: session.projectId, taskId: run.taskId, runId: run.id,
engineId: 'deepseek-harness', scope: ENGINE_SCOPE, source: 'user', installation, sdkSessionId: randomUUID(), directory,
status: 'queued', startedAt: at(), finishedAt: null, requiresVerification: false, verification: null,
summary: '已登记本地安装和检查范围,尚未启动原程序。', report: null };
active.job = job;
const artifact = this.store.artifactStore.write(session, run, engineInput(job), { kind: 'engine-input' });
this.store.core.artifact.set(artifact.id, artifact); job.contractArtifactId = artifact.id; job.contractSha256 = artifact.sha256;
const event = this.store.event(session, { kind: 'engine', tool: 'deepseek-sdk-probe', label: '核验外部引擎连接', phase: 'queued',
input: { engineId: job.engineId, root: installation.root, version: installation.version, profile: installation.profile, modelRequestsAllowed: 0 } });
job.eventId = event.id; this.store.putRecord('engine_job', session, job, 'engine.queued');
active.promise = this.execute(session, run, job, active).finally(() => {
this.active.delete(id); if (this.projects.get(session.projectId) === id) this.projects.delete(session.projectId);
});
active.promise.catch(() => {}); return { job, promise: active.promise };
} catch (error) { this.active.delete(id); this.projects.delete(session.projectId); throw error; }
}
async execute(session, run, job, active) {
let report;
try {
this.inputFor(session, job);
active.adapter = this.adapterFactory(job.installation);
report = await active.adapter.probe({ directory: job.directory, sdkSessionId: job.sdkSessionId, signal: active.controller.signal,
onState: (status, detail) => {
if (active.controller.signal.aborted) return;
if (!['starting', 'initializing', 'checking'].includes(status)) throw engineError('引擎状态不符合检查契约。');
this.inputFor(session, job); job.status = status;
for (const field of ['pid', 'connectionId', 'readiness', 'serverInfo']) if (detail?.[field] !== undefined) job[field] = detail[field];
job.summary = status === 'starting' ? '原程序已启动,正在等待所属启动完成信号。' : status === 'initializing' ? '启动已完成,正在核对一次SDK初始化。' : 'SDK身份已返回,正在核对会话目录、错误与关闭。';
this.store.putRecord('engine_job', session, job, 'engine.' + status);
} });
this.inputFor(session, job);
if (report.status !== 'verified' || report.scope !== job.scope || report.sdkSessionId !== job.sdkSessionId
|| report.before?.identitySha256 !== job.installation.identitySha256 || report.after?.identitySha256 !== job.installation.identitySha256
|| report.process?.pid !== report.readiness?.pid || !report.cleanup?.rootExited || report.cleanup.exit?.code !== 0
|| report.modelRequests !== 0 || report.providerRequests !== 0 || report.responses?.length !== 6 || !report.workspace?.unchanged) throw engineError('引擎返回缺少完整的身份、原协议或关闭依据。');
job.status = 'completed'; job.summary = '连接通过,启动、协议返回、会话目录与进程结束均已核对。';
job.verification = { verified: true, installationSha256: job.installation.identitySha256, readySignal: 'appReady',
sdkSessionId: job.sdkSessionId, connectionId: report.process.connectionId, rootExited: true, modelRequests: 0 };
} catch (error) {
report = error.report ?? report ?? { schemaVersion: 1, scope: job.scope, sdkSessionId: job.sdkSessionId,
status: active.controller.signal.aborted ? 'cancelled' : 'failed', error: { code: error.code ?? 'ENGINE_CHECK_FAILED', message: this.redact(error.message) },
modelRequests: null, providerRequests: 0, responses: [], cleanup: null };
job.status = report.status === 'unknown' ? 'unknown' : active.controller.signal.aborted ? 'cancelled' : 'failed';
job.requiresVerification = job.status === 'unknown'; job.verification = null;
job.summary = this.redact(report.error?.message ?? error.message); job.error = { code: report.error?.code ?? error.code ?? 'ENGINE_CHECK_FAILED', message: job.summary };
}
job.report = report; job.finishedAt = at();
try {
const artifact = this.store.artifactStore.write(session, run, engineReportContract(job), { kind: 'engine-report' });
this.store.core.artifact.set(artifact.id, artifact); job.reportArtifactId = artifact.id; job.reportSha256 = artifact.sha256;
const event = session.events.find(value => value.id === job.eventId);
if (event) { event.phase = job.status; event.finishedAt = job.finishedAt; event.output = job.summary; }
this.store.putRecord('engine_job', session, job, 'engine.finished');
} catch (error) {
job.status = 'unknown'; job.verification = null; job.requiresVerification = true; job.summary = '引擎原结果没有完成封存,请核对所属原记录:' + this.redact(error.message);
this.store.putRecord('engine_job', session, job, 'engine.seal_failed');
}
return job;
}
async stop(sessionId) {
const active = [...this.active.values()].filter(value => value.sessionId === sessionId);
for (const value of active) {
if (ENGINE_ACTIVE.has(value.job.status)) value.job.status = 'stopping';
value.controller.abort(new Error('用户停止了所属外部引擎连接检查。'));
this.store.putRecord('engine_job', this.store.session(sessionId), value.job, 'engine.stopping');
}
await Promise.allSettled(active.map(value => value.promise));
}
async stopAll() { await Promise.all([...new Set([...this.active.values()].map(value => value.sessionId))].map(sessionId => this.stop(sessionId))); }
}