130 lines
12 KiB
JavaScript
130 lines
12 KiB
JavaScript
import { createHash } from 'node:crypto';
|
|
import { isId, accountedTokens, emptyUsage } from './execution.mjs';
|
|
import { selectedEngineInput } from './engine-execution.mjs';
|
|
|
|
export const WORKER_TOOLS = new Set(['diagnose_environment','plan_environment','prepare_environment','inspect_session', 'inspect_project', 'index_project', 'query_code', 'read_artifact',
|
|
'list_files', 'read_file', 'search_files', 'propose_file', 'propose_patch', 'prepare_change_set', 'plan_checks', 'run_checks']);
|
|
export const COLLABORATION_ACTIVE = new Set(['preparing', 'starting', 'running', 'stopping', 'collecting', 'merge_preparing', 'reconciling']);
|
|
export const COLLABORATION_CLOSED = new Set(['completed', 'discarded', 'resolved_external']);
|
|
export const workerConflict = message => Object.assign(new Error(message), { status: 409 });
|
|
export const workerHash = value => createHash('sha256').update(typeof value === 'string' || Buffer.isBuffer(value) ? value : JSON.stringify(value)).digest('hex');
|
|
|
|
export function workerPath(value) {
|
|
if (typeof value !== 'string' || !value || value.length > 240 || /[\\:\x00-\x1f*?"<>|]/.test(value)
|
|
|| value.startsWith('/') || value.endsWith('/') || value.split('/').some(part => !part || part === '.' || part === '..'
|
|
|| /[. ]$/.test(part) || /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part))) throw workerConflict('子任务范围需要明确的项目相对文件或目录,不能使用通配符、别名或上级路径。');
|
|
if (value.split('/').some(part => /^(?:\.git|node_modules|dist|dist-server|\.qa|\.awb-.+|\.env.*|credentials.*|secrets?.*)$/i.test(part))) throw workerConflict('子任务修改范围不能包含内部目录、依赖或凭据。');
|
|
return value;
|
|
}
|
|
export const workerPathKey = value => value.toLowerCase();
|
|
export const pathInWorkerScope = (value, paths) => paths.some(scope => workerPathKey(value) === workerPathKey(scope) || workerPathKey(value).startsWith(workerPathKey(scope) + '/'));
|
|
|
|
function bounded(value, fallback, minimum, maximum, label) {
|
|
const result = value === undefined ? fallback : value;
|
|
if (!Number.isSafeInteger(result) || result < minimum || result > maximum) throw workerConflict(label + '超出允许范围。');
|
|
return result;
|
|
}
|
|
const text = (value, maximum, label) => {
|
|
if (typeof value !== 'string' || !value.trim() || value.length > maximum || !value.isWellFormed() || /[\x00-\x08\x0b\x0c\x0e-\x1f]/.test(value)) throw workerConflict(label + '不能为空或超过长度范围。');
|
|
return value.trim();
|
|
};
|
|
|
|
export function collaborationInput(input, config) {
|
|
if (!input || Array.isArray(input) || Object.keys(input).some(key => !['goal', 'budget', 'children', 'engine'].includes(key))) throw workerConflict('协作只接受父目标、预算、子任务和已检测的引擎。');
|
|
const engine = input.engine === undefined ? null : selectedEngineInput(input.engine);
|
|
if (!Array.isArray(input.children) || input.children.length !== (engine ? 1 : 2)) throw workerConflict(engine ? '受控引擎计划需要一个所属子工程。' : '本阶段需要两个受限子任务。');
|
|
const raw = input.budget ?? {};
|
|
if (!raw || typeof raw !== 'object' || Array.isArray(raw) || Object.keys(raw).some(key => !['maxTokens', 'maxSteps', 'maxToolCalls', 'maxDurationMs'].includes(key))) throw workerConflict('协作预算字段无效。');
|
|
const tokenMaximum = Math.min(config.maxTaskTokens ?? 1000000, config.maxRunTokens ?? 200000);
|
|
const budget = {
|
|
maxTokens: bounded(raw.maxTokens, tokenMaximum, 1000, tokenMaximum, '总token预算'),
|
|
maxSteps: bounded(raw.maxSteps, Math.min(200, (config.maxSteps ?? 12) * 2), 2, 200, '总请求步数'),
|
|
maxToolCalls: bounded(raw.maxToolCalls, 96, 2, 512, '总工具次数'),
|
|
maxDurationMs: bounded(raw.maxDurationMs, config.maxRunDurationMs ?? 600000, 1000, Math.min(3600000, config.maxRunDurationMs ?? 600000), '总时限'),
|
|
};
|
|
const children = input.children.map((item, index) => {
|
|
if (!item || typeof item !== 'object' || Array.isArray(item) || Object.keys(item).some(key => !['label', 'goal', 'paths', 'budget'].includes(key))) throw workerConflict('子任务字段无效。');
|
|
if (!Array.isArray(item.paths) || !item.paths.length || item.paths.length > 16) throw workerConflict('每个子任务需要1到16个修改范围。');
|
|
const paths = item.paths.map(workerPath).sort();
|
|
if (new Set(paths.map(workerPathKey)).size !== paths.length) throw workerConflict('子任务范围不能重复。');
|
|
const part = item.budget ?? {};
|
|
if (!part || Array.isArray(part) || Object.keys(part).some(key => !['maxTokens', 'maxSteps', 'maxToolCalls'].includes(key))) throw workerConflict('子预算字段无效。');
|
|
const allocate = key => engine ? budget[key] : index === 0 ? Math.floor(budget[key] / 2) : budget[key] - Math.floor(budget[key] / 2);
|
|
return { label: text(item.label, 64, '子任务名称'), goal: text(item.goal, 8000, '子目标'), paths,
|
|
budget: Object.fromEntries(['maxTokens', 'maxSteps', 'maxToolCalls'].map(key => [key, bounded(part[key], allocate(key), key === 'maxTokens' ? 500 : 1, budget[key], key)])) };
|
|
});
|
|
for (const key of ['maxTokens', 'maxSteps', 'maxToolCalls']) if (children.reduce((sum, child) => sum + child.budget[key], 0) > budget[key]) throw workerConflict('子任务预算之和不能超过父预算:' + key);
|
|
return { goal: text(input.goal, 20000, '父目标'), budget, children, ...(engine ? { engine } : {}) };
|
|
}
|
|
|
|
export function collaborationSeal(group) {
|
|
return { schemaVersion: 1, id: group.id, projectId: group.projectId, sessionId: group.sessionId, taskId: group.taskId, runId: group.runId,
|
|
goal: group.goal, budget: group.budget, model: group.model, config: group.config, source: group.source, children: group.children,
|
|
...(group.evaluation ? { evaluation: group.evaluation } : {}) };
|
|
}
|
|
export function workerSeal(worker) {
|
|
return { schemaVersion: 1, id: worker.id, collaborationId: worker.collaborationId, parentProjectId: worker.parentProjectId,
|
|
parentSessionId: worker.parentSessionId, parentTaskId: worker.parentTaskId, parentRunId: worker.parentRunId,
|
|
projectId: worker.projectId, sessionId: worker.sessionId, taskId: worker.taskId, workspaceId: worker.workspaceId,
|
|
label: worker.label, goal: worker.goal, paths: worker.paths, budget: worker.budget, model: worker.model, baseCommit: worker.baseCommit,
|
|
baselineArtifactId: worker.baselineArtifactId, baselineSha256: worker.baselineSha256, baselineRunId: worker.baselineRunId,
|
|
...(worker.engine ? { engine: worker.engine } : {}), ...(worker.evaluation ? { evaluation: worker.evaluation } : {}) };
|
|
}
|
|
export function workerForProject(store, projectId) {
|
|
return [...(store.core.worker?.values() ?? [])].find(value => value.projectId === projectId) ?? null;
|
|
}
|
|
export function workerForSession(store, session) {
|
|
const worker = workerForProject(store, session.projectId);
|
|
if (!worker) return null;
|
|
if (worker.sessionId !== session.id || worker.taskId !== session.taskId || workerHash(workerSeal(worker)) !== worker.fingerprint) throw workerConflict('隔离项目只允许原受限子任务操作,身份或范围已变化。');
|
|
const group = store.core.collaboration.get(worker.collaborationId);
|
|
const definition = group?.children.find(child => child.id === worker.id);
|
|
if (!group || workerHash(collaborationSeal(group)) !== group.fingerprint || !definition
|
|
|| definition.taskId !== worker.taskId || definition.projectId !== worker.projectId || definition.sessionId !== worker.sessionId
|
|
|| definition.workspaceId !== worker.workspaceId || JSON.stringify(definition.paths) !== JSON.stringify(worker.paths)
|
|
|| JSON.stringify(definition.budget) !== JSON.stringify(worker.budget) || definition.goal !== worker.goal
|
|
|| JSON.stringify(group.model) !== JSON.stringify(worker.model)
|
|
|| JSON.stringify(definition.engine) !== JSON.stringify(worker.engine)
|
|
|| JSON.stringify(definition.evaluation) !== JSON.stringify(worker.evaluation)) throw workerConflict('子任务与父任务的封存分工不一致。');
|
|
const task = store.core.task.get(worker.taskId);
|
|
if (!task || task.goal !== worker.goal || task.workerId !== worker.id || task.budget.maxTokens !== worker.budget.maxTokens) throw workerConflict('子任务目标、身份或累计预算已变化。');
|
|
const original = store.owned('artifact', worker.contractArtifactId, session.id);
|
|
if (original.kind !== 'worker-contract' || original.taskId !== worker.taskId || original.sha256 !== worker.contractSha256
|
|
|| store.artifactStore.read(original) !== JSON.stringify(workerSeal(worker))) throw workerConflict('受限子任务契约与原工件不一致。');
|
|
const plan = store.owned('artifact', group.planArtifactId, group.sessionId);
|
|
if (plan.kind !== 'collaboration-plan' || plan.taskId !== group.taskId || plan.sha256 !== group.planSha256
|
|
|| store.artifactStore.read(plan) !== JSON.stringify(collaborationSeal(group))) throw workerConflict('父任务分工与原封存工件不一致。');
|
|
return worker;
|
|
}
|
|
export function assertWorkerWriteScope(store, session, value, { readOnly = false } = {}) {
|
|
const worker = workerForSession(store, session);
|
|
if (!worker) return;
|
|
const portable = workerPath(value);
|
|
if (!readOnly && worker.evaluation && store.core.evaluation?.get(worker.evaluation.batchId)?.samples.some(sample => sample.id === worker.evaluation.sampleId && sample.report)) throw workerConflict('评测样本已封存,不能再修改候选。');
|
|
if (worker.evaluation && (worker.evaluation.role === 'original' || !worker.paths.some(path => workerPathKey(path) === workerPathKey(portable)))) throw workerConflict('原版仅供固定检查;候选只能修改封存的明确源码文件。');
|
|
if (!pathInWorkerScope(portable, worker.paths)) throw workerConflict('文件超出子任务的固定修改范围:' + portable);
|
|
if (!readOnly && ['unknown', 'completed', 'resolved_external'].includes(worker.status)) throw workerConflict('子任务已封存或结果待核对,不能修改原成果。');
|
|
}
|
|
export function assertWorkerTool(store, session, tool, args) {
|
|
const worker = workerForSession(store, session);
|
|
if (!worker) return;
|
|
if (!WORKER_TOOLS.has(tool)) throw workerConflict('受限子任务不开放这个工具:' + tool);
|
|
if (tool === 'propose_file' || tool === 'propose_patch') assertWorkerWriteScope(store, session, args.path);
|
|
}
|
|
export function assertWorkersResolved(store, projectId, { recoveryTaskId = null } = {}) {
|
|
const group = [...(store.core.collaboration?.values() ?? [])].find(value => value.requiresVerification
|
|
&& (value.projectId === projectId || value.children.some(child => child.projectId === projectId))
|
|
&& !(recoveryTaskId && (value.projectId === projectId && value.taskId === recoveryTaskId
|
|
|| value.children.some(child => child.projectId === projectId && child.taskId === recoveryTaskId))));
|
|
const worker = workerForProject(store, projectId);
|
|
if (group || worker?.requiresVerification && worker.taskId !== recoveryTaskId) throw workerConflict('协作执行结果待核对,请返回父任务查看原输入和现场,不会自动重放。');
|
|
}
|
|
export function workerUsage(store, worker) {
|
|
const task = store.core.task.get(worker.taskId), runs = [...store.core.run.values()].filter(run => run.taskId === worker.taskId);
|
|
return { ...emptyUsage(), ...task?.usage, accountedTokens: accountedTokens(task?.usage),
|
|
steps: runs.reduce((sum, run) => sum + run.steps, 0), toolCalls: runs.reduce((sum, run) => sum + run.toolCalls, 0) };
|
|
}
|
|
export function assertWorkerIds(value) {
|
|
for (const field of ['id', 'workspaceId', 'projectId', 'sessionId', 'taskId']) if (!isId(value[field])) throw workerConflict('子任务预分配身份无效。');
|
|
}
|