236 lines
19 KiB
JavaScript
236 lines
19 KiB
JavaScript
import { unrestricted, ceiling } from '../../shared/contracts/execution-policy.mjs';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import http from 'node:http';
|
|
import { randomUUID, timingSafeEqual } from 'node:crypto';
|
|
import { DeepSeekAdapter } from './deepseek-adapter.mjs';
|
|
import { engineFileIdentity } from './deepseek-installation.mjs';
|
|
import { engineError } from '../../shared/contracts/engines.mjs';
|
|
import { isId } from '../../shared/contracts/execution.mjs';
|
|
import { readOwnedProcessTree } from '../owned-process-tree.mjs';
|
|
import { CONTROLLED_BRIDGE_PLUGIN } from './controlled-plugin.mjs';
|
|
import { assertControlledInstallation, controlledDigest, controlledPatch, controlledToolCatalogue, CONTROLLED_ENGINE_SCOPE } from './controlled-installation.mjs';
|
|
import { assertPurgeStrategy, PURGE_PROMPT_KIND, ORIGINAL_PURGE_KIND } from './purge-strategy.mjs';
|
|
import { OriginalPurgeRuntime } from './original-purge-runtime.mjs';
|
|
|
|
const allowedEnvironment = /^(path|pathext|systemroot|systemdrive|windir|comspec|temp|tmp|userprofile|appdata|localappdata|programfiles(?:\(x86\))?|homedrive|homepath)$/i;
|
|
const at = () => new Date().toISOString();
|
|
const equalSecret = (left, right) => typeof left === 'string' && Buffer.byteLength(left) === Buffer.byteLength(right)
|
|
&& timingSafeEqual(Buffer.from(left), Buffer.from(right));
|
|
|
|
export class ControlledDeepSeekSession extends DeepSeekAdapter {
|
|
constructor(installation, options = {}) {
|
|
super(installation, options); this.maximumFrameBytes = options.maximumFrameBytes ?? 4 * 1024 * 1024;
|
|
this.pending = new Set(); this.closed = false;
|
|
this.processTreeReader = options.processTreeReader ?? readOwnedProcessTree;
|
|
}
|
|
async open({ directory, cwd, owner, sdkSessionId, tools, config, strategy, signal, onModel, onTool, onState = () => {}, onNotification = () => {} }) {
|
|
for (const field of ['sessionId', 'projectId', 'taskId', 'runId', 'jobId']) if (!isId(owner?.[field])) throw engineError('受控引擎所属身份无效。', 400);
|
|
if (!isId(sdkSessionId) || typeof onModel !== 'function' || typeof onTool !== 'function') throw engineError('受控引擎回调或会话无效。', 400);
|
|
if (unrestricted(config)) { this.maximumFrameBytes = Infinity; this.timeoutMs = 0; }
|
|
signal?.throwIfAborted(); assertControlledInstallation(this.installation);
|
|
assertPurgeStrategy(strategy); this.strategy = structuredClone(strategy);
|
|
const catalogue = controlledToolCatalogue(tools), catalogueSha256 = controlledDigest(catalogue);
|
|
this.bridgeController = new AbortController();
|
|
const bridgeSignal = signal ? AbortSignal.any([signal, this.bridgeController.signal]) : this.bridgeController.signal;
|
|
this.owner = structuredClone(owner); this.sdkSessionId = sdkSessionId; this.signal = bridgeSignal; this.parentSignal = signal;
|
|
this.catalogueNames = new Set(catalogue.map(tool => tool.name)); this.callIds = new Set();
|
|
this.catalogueSha256 = catalogueSha256; this.config = structuredClone(config);
|
|
this.report = { schemaVersion: 1, scope: CONTROLLED_ENGINE_SCOPE, owner: this.owner, sdkSessionId,
|
|
installationSha256: this.installation.controlledSha256, startedAt: at(), responses: [], notifications: [], unownedNotifications: [],
|
|
rejectedServerRequests: [], bridgeRequests: [], cleanup: null, modelRequests: 0, toolRequests: 0 };
|
|
fs.mkdirSync(directory, { recursive: false });
|
|
const home = path.join(directory, 'home'), agents = path.join(directory, 'agents');
|
|
fs.mkdirSync(home); fs.mkdirSync(agents);
|
|
const nonce = randomUUID(), marker = path.join(directory, 'ready.json'), plugin = path.join(directory, 'bridge.mjs'), patch = path.join(directory, 'bridge.patch.json');
|
|
const authentication = 'Bearer ' + nonce;
|
|
this.guard = http.createServer((request, response) => {
|
|
const operation = this.handleBridge(request, response, { authentication, onModel, onTool, signal: bridgeSignal }).catch(error => {
|
|
if (!response.destroyed && !response.writableEnded) { response.writeHead(error.status ?? 409, { 'Content-Type': 'application/json', Connection: 'close' }); response.end(JSON.stringify({ error: error.message })); }
|
|
});
|
|
this.pending.add(operation); operation.finally(() => this.pending.delete(operation));
|
|
});
|
|
await new Promise((resolve, reject) => { this.guard.once('error', reject); this.guard.listen(0, '127.0.0.1', resolve); });
|
|
const pluginConfig = { owner: this.owner, sdkSessionId, tools: catalogue, catalogueSha256, nonce, marker,
|
|
llmModule: this.installation.llmModule, endpoint: 'http://127.0.0.1:' + this.guard.address().port,
|
|
maximumFrameBytes: unrestricted(config) ? null : this.maximumFrameBytes, model: config.model, capacityMode: config.capacityMode,
|
|
maxOutputTokens: config.capacityMode === 'passthrough' ? null : config.maxOutputTokens, contextLimit: config.capacityMode === 'passthrough' ? Number.MAX_SAFE_INTEGER : config.contextLimit,
|
|
...(strategy?.kind===PURGE_PROMPT_KIND ? { promptExperiment: { sha256: strategy.sha256, section: strategy.section } } : {}) };
|
|
fs.writeFileSync(plugin, CONTROLLED_BRIDGE_PLUGIN, { flag: 'wx' }); fs.writeFileSync(patch, JSON.stringify(controlledPatch(plugin, pluginConfig)), { flag: 'wx' });
|
|
this.report.launchInputs = { plugin: engineFileIdentity(plugin), patch: engineFileIdentity(patch), cwd: fs.realpathSync.native(cwd),
|
|
disabledPlugins: this.installation.disabledPlugins, catalogue, catalogueSha256 };
|
|
const env = {};
|
|
for (const name of Object.keys(process.env)) if (allowedEnvironment.test(name)) env[name] = process.env[name];
|
|
Object.assign(env, { DSH_HOME: home, DSH_AGENTS_HOME: agents, DSH_TELEMETRY_DISABLED: 'true' });
|
|
if (unrestricted(config)) { this.maximumFrameBytes = Infinity; this.timeoutMs = 0; }
|
|
signal?.throwIfAborted(); assertControlledInstallation(this.installation);
|
|
let launch={executable:this.installation.node.path,args:[this.installation.entry,'--profile',this.installation.profile,'--patch',patch],cwd,env};
|
|
if(strategy?.kind===ORIGINAL_PURGE_KIND){
|
|
this.originalPurge=new OriginalPurgeRuntime(strategy,directory);this.report.originalPurge=this.originalPurge.report;
|
|
launch=await this.originalPurge.prepare(launch,this.installation);this.report.launchInputs.patch=engineFileIdentity(patch);
|
|
}
|
|
this.client = this.clientFactory(launch,
|
|
{ timeoutMs: this.timeoutMs, maximumFrameBytes: this.maximumFrameBytes, cancellationMethod: null });
|
|
this.report.process = { pid: this.client.pid, connectionId: this.client.id, startedAt: this.client.startedAt, ownership: 'one-process-per-engine-run' };
|
|
onState('starting', this.report.process);
|
|
this.publishOwnership = () => onState('ownership', this.report.process);
|
|
try { await this.captureTree(); } catch (error) { this.report.process.treeObservationError = error.message; throw error; }
|
|
this.treeTimer = setInterval(() => {
|
|
if (this.closed || this.treePending) return;
|
|
this.treePending = this.captureTree().catch(error => {
|
|
this.report.process.treeObservationError = error.message; this.client.fail(error);
|
|
this.publishOwnership();
|
|
}).finally(() => { this.treePending = null; });
|
|
}, 1200); this.treeTimer.unref();
|
|
this.client.on('server-request', request => {
|
|
this.report.rejectedServerRequests.push({ id: request.id, method: request.method, parametersSha256: controlledDigest(request.params ?? {}) });
|
|
this.client.fail(engineError('原SDK反向请求未在受控契约中开放。'));
|
|
});
|
|
let notificationBytes = 0;
|
|
this.client.on('notification', value => {
|
|
notificationBytes += Buffer.byteLength(JSON.stringify(value));
|
|
if (!unrestricted(config) && (notificationBytes > 16 * 1024 * 1024 || this.report.notifications.length + this.report.unownedNotifications.length >= 8192)) {
|
|
this.client.fail(engineError('受控引擎事件超过接收范围。')); return;
|
|
}
|
|
if (!['session.event', 'session.status', 'subagent.started', 'subagent.finished'].includes(value.method)) {
|
|
this.client.fail(engineError('受控引擎返回未支持的通知。')); return;
|
|
}
|
|
if (value.params?.sessionId !== sdkSessionId) { this.report.unownedNotifications.push(value); return; }
|
|
this.report.notifications.push(value);
|
|
try { onNotification(value); } catch (error) { this.client.fail(error); }
|
|
});
|
|
this.report.readiness = await this.waitReady(marker, nonce, signal);
|
|
const ready = this.report.readiness;
|
|
if (controlledDigest(ready.owner) !== controlledDigest(this.owner) || ready.sdkSessionId !== sdkSessionId
|
|
|| ready.catalogueSha256 !== catalogueSha256 || controlledDigest(ready.catalogue) !== catalogueSha256
|
|
|| JSON.stringify(ready.providers) !== JSON.stringify(['agent-workbench'])
|
|
|| (ready.promptExperimentSha256 ?? null) !== (strategy?.kind===PURGE_PROMPT_KIND?strategy.sha256:null)) throw engineError('启动后工具、模型、实验提示或Run目录不符合封存契约。');
|
|
this.originalPurge?.verify({ready:true,pid:this.client.pid});
|
|
this.verifyLaunch(); onState('initializing', { readiness: ready });
|
|
const initialized = await this.request('initialize', { cwd, provider: 'agent-workbench', model: config.model,
|
|
...(config.capacityMode !== 'passthrough' ? { maxTokens: config.maxOutputTokens } : {}) });
|
|
if (controlledDigest(initialized.serverInfo) !== controlledDigest(this.installation.serverInfo)) throw engineError('受控SDK返回身份不符合固定发行。');
|
|
const working = await this.request('session/working-directory/get', { sessionId: sdkSessionId });
|
|
if (fs.realpathSync.native(working.cwd) !== fs.realpathSync.native(cwd)) throw engineError('原SDK工作目录不属于所封存的工作区。');
|
|
onState('ready', { serverInfo: initialized.serverInfo }); return this.report;
|
|
}
|
|
verifyLaunch() {
|
|
assertControlledInstallation(this.installation);
|
|
assertPurgeStrategy(this.strategy);
|
|
for (const input of [this.report.launchInputs.plugin, this.report.launchInputs.patch]) {
|
|
if (engineFileIdentity(input.path).sha256 !== input.sha256) throw engineError('所属叠加插件或启动输入发生变化。');
|
|
}
|
|
this.originalPurge?.verify();
|
|
}
|
|
async captureTree(publish = true) {
|
|
const info = this.report.process, tree = await this.processTreeReader(info);
|
|
if (tree.supported) {
|
|
if (tree.root) info.rootCreatedAt ??= tree.root.createdAt;
|
|
const known = new Map((info.descendants ?? []).map(value => [value.pid + ':' + value.createdAt, value]));
|
|
for (const value of tree.processes) if (value.pid !== info.pid) known.set(value.pid + ':' + value.createdAt, value);
|
|
info.descendants = [...known.values()].sort((left, right) => left.pid - right.pid);
|
|
info.treeRemainingPids = tree.processes.map(value => value.pid); info.treeObservedAt = at();
|
|
}
|
|
if (publish) this.publishOwnership?.(); return tree;
|
|
}
|
|
async handleBridge(request, response, { authentication, onModel, onTool, signal }) {
|
|
if (this.closed || this.client?.exited === true || signal?.aborted || request.method !== 'POST' || !['/model', '/tool'].includes(request.url)
|
|
|| request.headers.origin !== undefined || request.headers['content-type'] !== 'application/json'
|
|
|| !equalSecret(request.headers.authorization, authentication)) throw engineError('桥请求不属于当前受控Run。', 403);
|
|
const chunks = []; let size = 0;
|
|
for await (const chunk of request) { size += chunk.length; if (size > this.maximumFrameBytes) throw engineError('桥请求超过输入范围。', 413); chunks.push(chunk); }
|
|
const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
|
|
if (Object.keys(body).some(key => !['owner', 'sessionId', 'pid', 'data'].includes(key)) || body.pid !== this.client?.pid
|
|
|| body.sessionId !== this.sdkSessionId || controlledDigest(body.owner) !== controlledDigest(this.owner)) throw engineError('桥请求的进程或任务归属不一致。', 403);
|
|
signal?.throwIfAborted(); this.verifyLaunch();
|
|
const data = body.data;
|
|
if (!data || typeof data !== 'object' || Array.isArray(data)) throw engineError('桥调用正文必须是对象。', 400);
|
|
if (request.url === '/tool') {
|
|
if (Object.keys(data).some(key => !['callId', 'name', 'arguments'].includes(key))
|
|
|| typeof data.callId !== 'string' || !data.callId || data.callId.length > ceiling(this.config, 160) || !this.catalogueNames.has(data.name)
|
|
|| !data.arguments || typeof data.arguments !== 'object' || Array.isArray(data.arguments)) throw engineError('工具调用不符合原目录和参数契约。', 400);
|
|
if (this.callIds.has(data.callId)) throw engineError('原引擎工具调用ID已接收,不会重复执行。');
|
|
this.callIds.add(data.callId);
|
|
} else if (Object.keys(data).some(key => !['messages', 'system', 'tools', 'toolHistory', 'model', 'maxTokens'].includes(key))
|
|
|| data.model !== this.config.model || !Array.isArray(data.messages) || !Array.isArray(data.tools)
|
|
|| controlledDigest(controlledToolCatalogue(data.tools)) !== this.catalogueSha256
|
|
|| (this.config.capacityMode !== 'passthrough' && (!Number.isSafeInteger(data.maxTokens) || data.maxTokens < 1 || data.maxTokens > this.config.maxOutputTokens))) {
|
|
throw engineError('原引擎模型请求与封存的目录、模型或输出预算不一致。', 400);
|
|
}
|
|
const trace = { id: randomUUID(), route: request.url, requestSha256: controlledDigest(body), requestBytes: size, data: body.data, status: 'received', startedAt: at() };
|
|
if (this.report.bridgeRequests.length >= ceiling(this.config, 1024)) throw engineError('桥请求次数超过接收范围。');
|
|
this.report.bridgeRequests.push(trace);
|
|
const callback = request.url === '/model' ? onModel : onTool;
|
|
if (request.url === '/model') this.report.modelRequests++; else this.report.toolRequests++;
|
|
try {
|
|
const result = await callback(body.data, trace, signal);
|
|
trace.resultSha256 = controlledDigest(result); trace.status = 'completed'; trace.finishedAt = at();
|
|
if (this.closed || signal?.aborted) throw engineError('所属引擎已停止,迟到原结果只保留记录。');
|
|
response.writeHead(200, { 'Content-Type': 'application/json', Connection: 'close' }); response.end(JSON.stringify(result));
|
|
} catch (error) { trace.status = 'failed'; trace.error = error.message; trace.finishedAt = at(); throw error; }
|
|
}
|
|
async request(method, params = {}) {
|
|
this.signal?.throwIfAborted(); this.verifyLaunch();
|
|
const result = await this.client.request(method, params, { signal: this.signal,
|
|
...(method === 'session/wait' ? { timeoutMs: this.config.maxRunDurationMs === 0 ? 0 : this.config.maxRunDurationMs ?? 600000 } : {}) });
|
|
this.report.responses.push({ method, params, result, trace: structuredClone(this.client.trace.at(-1)) }); return result;
|
|
}
|
|
async prompt(content) {
|
|
if (typeof content !== 'string' || !content || Buffer.byteLength(content) > this.maximumFrameBytes / 2) throw engineError('受控引擎任务输入超出范围。', 400);
|
|
const receipt = await this.request('session/prompt', { sessionId: this.sdkSessionId, contentBlocks: [{ type: 'text', text: content }] });
|
|
if (typeof receipt.messageId !== 'string' || !receipt.messageId) throw engineError('SDK没有返回原入队收据。');
|
|
this.report.receipt = receipt; return receipt;
|
|
}
|
|
async wait() {
|
|
const result = await this.request('session/wait', { sessionId: this.sdkSessionId });
|
|
if (!result || Array.isArray(result) || Object.keys(result).length) throw engineError('SDK等待结果不符合原协议。');
|
|
const events = this.report.notifications.filter(value => value.method === 'session.event').map(value => value.params.event);
|
|
const receipt = events.findIndex(event => event?.type === 'agent/inbox/spliced'
|
|
&& event.data?.inserted?.some(value => value.id === this.report.receipt?.messageId));
|
|
if (receipt < 0) throw engineError('未观察到所属prompt收据,不能采纳引擎输出。');
|
|
const activity = events.slice(receipt), assistant = activity.findLast(event => event?.type === 'assistant/message');
|
|
if (!assistant || !Array.isArray(assistant.data?.message?.content)) throw engineError('所属活动没有完整assistant原消息。');
|
|
const ends = activity.filter(event => event?.type === 'turn/end');
|
|
this.report.activity = { receiptIndex: receipt, endEvents: ends };
|
|
if (ends.length !== 1 || ends[0].data?.reason?.kind !== 'completed') throw engineError('所属活动没有唯一的正常结束事件,原输出不能视为完成。');
|
|
this.report.finalText = assistant.data.message.content.filter(block => block.type === 'text').map(block => block.text).join('');
|
|
return this.report.finalText;
|
|
}
|
|
async close({ force = false } = {}) {
|
|
if (this.closePromise) return this.closePromise;
|
|
const interrupted = force || this.parentSignal?.aborted === true;
|
|
this.closed = true;
|
|
clearInterval(this.treeTimer);
|
|
this.bridgeController?.abort(new Error('所属引擎正在关闭。'));
|
|
return this.closePromise = (async () => {
|
|
let failure = null;
|
|
if (this.client) {
|
|
await this.treePending;
|
|
if (!interrupted && !this.client.exited) {
|
|
try { await this.client.request('shutdown', {}, { timeoutMs: 1000 }); } catch (error) { failure = error; }
|
|
}
|
|
try { this.report.cleanup = await this.client.close({ force: interrupted || !!failure }); } catch (error) { failure ??= error; }
|
|
try {
|
|
const tree = await this.captureTree(false);
|
|
this.report.cleanup ??= { rootExited: false };
|
|
this.report.cleanup.treeConfirmed = tree.supported ? tree.processes.length === 0 && !!this.report.process.rootCreatedAt
|
|
&& !this.report.process.treeObservationError : this.report.cleanup.rootExited;
|
|
this.report.cleanup.remainingProcesses = tree.processes;
|
|
} catch (error) {
|
|
failure ??= error; this.report.cleanup ??= { rootExited: false }; this.report.cleanup.treeConfirmed = false;
|
|
}
|
|
this.report.trace = this.client.trace; this.report.stderr = this.client.stderr;
|
|
}
|
|
if (this.guard) { this.guard.closeAllConnections(); await new Promise(resolve => this.guard.close(resolve)); }
|
|
await Promise.allSettled([...this.pending]);
|
|
if(this.originalPurge){try{this.originalPurge.verify();}catch(error){failure??=error;}finally{await this.originalPurge.close();}}
|
|
if (!interrupted && this.report.launchInputs) { try { this.verifyLaunch(); } catch (error) { failure ??= error; } }
|
|
if (!interrupted && this.report.cleanup?.exit?.code !== 0) failure ??= engineError('所属引擎未正常退出。');
|
|
this.report.finishedAt = at(); this.report.status = this.client && (!this.report.cleanup?.rootExited || !this.report.cleanup?.treeConfirmed)
|
|
? 'unknown' : failure ? 'failed' : interrupted ? 'cancelled' : 'closed';
|
|
if (failure) this.report.error = failure.message;
|
|
return this.report;
|
|
})();
|
|
}
|
|
}
|