termdock 1.4.294 → 1.4.296

package/dist/server/agent/collaborationRoutes.js

@@ -151,6 +151,10 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
     };
     router.get('/capabilities', run((_req, res) => {
         res.json({ protocol_version: 2, limits: COLLAB_LIMITS,
+            task_workflow: { version: 2, command: 'td collab task', single_authority: true, explicit_reports: true,
+                managed_goals: true, automatic_review: true, dependency_dispatch: true, isolated_worktrees: true, encrypted_commit_transfer: true,
+                durable_questions: true, user_acceptance: true, versioned_artifacts: true, independent_reviews: true,
+                task_reply: 'Replies to task-linked user messages are stored in the task; status=stored is not a terminal delivery receipt' },
             routing: { background_recovery: true, explicit_rebind: Boolean(rebind), fixed_tmux_pane: true },
             statuses: ['pending', 'delivered', 'failed', 'expired'], queued_status: 'pending',
             semantics: { delivered: 'written to terminal; no application acknowledgement implied',
@@ -201,8 +205,20 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
     }));
     router.post('/reply', run(async (req, res, sessionId) => {
         const original = ownMessage(String(req.body.messageId ?? ''), sessionId, true);
-        if (!original.fromSessionId)
-            throw new CollaborationError('NO_REPLY_TARGET', 'User messages have no agent reply target');
+        if (!original.fromSessionId) {
+            const link = original.metadata?.termdockTask;
+            if (link?.taskId && req.app.locals.collaborationTasks) {
+                const extras = extrasFromBody(req.body);
+                const status = extras.task?.status ?? (extras.responseKind === 'ack' ? 'ack' : extras.responseKind === 'result' ? 'complete' : extras.responseKind === 'progress' ? 'working' : null);
+                const task = await req.app.locals.collaborationTasks.apply(link.taskId, {
+                    kind: status ? 'report' : 'comment', status: status ?? undefined, attemptId: link.attemptId,
+                    content: req.body.content, evidence: extras.task?.evidence, idempotencyKey: extras.idempotencyKey,
+                }, req.app.locals.collaborationService.taskMember(sessionId));
+                res.json({ ok: true, status: 'stored', task_recorded: true, task_id: task.id, task_revision: task.revision });
+                return;
+            }
+            throw new CollaborationError('NO_REPLY_TARGET', '该消息没有成员回复目标；任务请使用 td collab task report 或 task comment');
+        }
         const messages = store.send({ ...extrasFromBody(req.body), groupId: original.groupId, fromSessionId: sessionId,
             toSessionIds: [original.fromSessionId], kind: 'reply', content: typeof req.body.content === 'string' ? req.body.content : '',
             replyTo: original.id, threadId: original.threadId });

package/dist/server/agent/collaborationService.js

@@ -89,6 +89,34 @@ export class CollaborationService {
         this.persist();
     }
     descriptor() { return { ...this.options.node(), ...(this.document.origin ? { origin: this.document.origin } : {}) }; }
+    taskMember(sessionId) {
+        const parsed = address(sessionId);
+        if (!parsed)
+            return { serviceId: this.options.node().serviceId, sessionId };
+        const peer = this.document.peers.find(node => node.origin === parsed.origin);
+        if (!peer)
+            throw new CollaborationError('TASK_PEER_UNAVAILABLE', '成员所在服务尚未配对', 409);
+        return { serviceId: peer.serviceId, sessionId: parsed.id };
+    }
+    taskSession(member) {
+        if (member.serviceId === this.options.node().serviceId)
+            return member.sessionId;
+        const peer = this.document.peers.find(node => node.serviceId === member.serviceId);
+        if (!peer)
+            throw new CollaborationError('TASK_PEER_UNAVAILABLE', '任务所在服务尚未配对', 409);
+        return remoteSession(peer.origin, member.sessionId);
+    }
+    async requestTasks(serviceId, payload) {
+        const peer = this.document.peers.find(node => node.serviceId === serviceId);
+        if (!peer)
+            throw new CollaborationError('TASK_PEER_UNAVAILABLE', '任务来源服务未连接，记录已保留', 409);
+        const result = await (await this.client(peer)).request({ type: 'collaboration-service', action: 'tasks', ...payload });
+        if (result.taskError) {
+            const error = result.taskError;
+            throw new CollaborationError(error.code, error.message, error.status);
+        }
+        return result;
+    }
     /** Called through the existing authenticated administrator connection. No
      * client key is copied; only pinned public service descriptors are persisted. */
     connectKnown(origin, nodes) {
@@ -260,6 +288,18 @@ export class CollaborationService {
             return { ok: true };
         if (packet.action === 'directory')
             return this.snapshot(peer);
+        if (packet.action === 'tasks' && this.options.tasks) {
+            try {
+                return Promise.resolve(this.options.tasks.receive(peer, packet)).catch(error => ({ taskError: {
+                        code: error instanceof CollaborationError ? error.code : 'TASK_ERROR', message: error instanceof Error ? error.message : String(error),
+                        status: error instanceof CollaborationError ? error.httpStatus : 400
+                    } }));
+            }
+            catch (error) {
+                return { taskError: { code: error instanceof CollaborationError ? error.code : 'TASK_ERROR',
+                        message: error instanceof Error ? error.message : String(error), status: error instanceof CollaborationError ? error.httpStatus : 400 } };
+            }
+        }
         if (packet.action === 'group') {
             const canonical = packet.group;
             if (!canonical?.sessionIds?.some(id => address(id)?.origin === peer.origin) && !this.document.replicas?.[canonical?.id]?.includes(peer.origin))
@@ -281,7 +321,7 @@ export class CollaborationService {
             .filter(group => scope === undefined || group.sessionIds.every(id => address(id) ? true : scope.includes(id)))
             .map(group => mapGroup(group, id => address(id) ? id : remoteSession(origin, id)));
         return { sessions: scope === undefined ? sessions : sessions.filter(session => scope.includes(session.sessionId)),
-            groups, nodes: scope === undefined ? this.nodes() : [this.node(), peer] };
+            groups, taskHeads: this.options.tasks?.heads(groups.map(g => g.id)) ?? [], nodes: scope === undefined ? this.nodes() : [this.node(), peer] };
     }
     merge(canonical, nodes, source) {
         if (!canonical || typeof canonical.id !== 'string' || !canonical.id.startsWith('cross-') || !Array.isArray(canonical.sessionIds)
@@ -377,6 +417,8 @@ export class CollaborationService {
                 this.observations.set(peer.serviceId, { sessions, checkedAt: Date.now() });
                 for (const group of data.groups)
                     this.merge(group, data.nodes, peer);
+                if (Array.isArray(data.taskHeads))
+                    await this.options.tasks?.sync(peer, data.taskHeads);
                 for (const group of this.options.store.federationSnapshot().groups.filter(g => g.federated && (g.sessionIds.some(id => address(id)?.origin === peer.origin) || this.document.replicas?.[g.id]?.includes(peer.origin)))) {
                     const scope = this.effectiveScope(peer.serviceId);
                     // Never push a group to a scoped peer if it involves other local sessions.

package/dist/server/agent/collaborationTaskBundles.js

@@ -0,0 +1,121 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { mkdir, open, readFile, writeFile, rename, stat, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+const exec = promisify(execFile), chunkSize = 256 * 1024, maxBytes = 128 * 1024 * 1024;
+const directory = path.join(os.homedir(), '.termdock', 'task-bundles');
+const preparing = new Map();
+const git = async (cwd, args) => (await exec('git', ['-C', cwd, ...args], { timeout: 60_000, maxBuffer: 1024 * 1024,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } })).stdout.trim();
+async function digestFile(file) {
+    const digest = createHash('sha256');
+    for await (const chunk of createReadStream(file))
+        digest.update(chunk);
+    return digest.digest('hex');
+}
+function acceptedCommit(task) {
+    const artifact = task.artifacts.find(a => a.id === task.acceptedArtifactId && a.kind === 'result');
+    const commit = artifact?.evidence?.commit;
+    if (task.status !== 'accepted' || !artifact || !task.workspace || !commit || !/^[a-f0-9]{40,64}$/.test(commit)
+        || !/^[a-f0-9]{40,64}$/.test(task.workspace.base) || !/^[a-f0-9]{32}$/.test(artifact.id))
+        throw new Error('依赖没有已评审的代码提交');
+    return { artifact, commit, base: task.workspace.base, workspace: task.workspace };
+}
+async function prepareBundle(task) {
+    const { artifact, commit, base, workspace } = acceptedCommit(task);
+    const existing = preparing.get(artifact.id);
+    if (existing)
+        return existing;
+    const operation = (async () => {
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const file = path.join(directory, `${artifact.id}.bundle`), metadataFile = `${file}.json`;
+        try {
+            const metadata = JSON.parse(await readFile(metadataFile, 'utf8'));
+            if (metadata.commit === commit && metadata.base === base && metadata.bytes === (await stat(file)).size)
+                return metadata;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        // Export the reviewed commit, even if the task branch has since moved.
+        const ref = `refs/termdock/exports/${artifact.id}`;
+        await git(workspace.cwd, ['update-ref', ref, commit]);
+        const temporary = `${file}.${process.pid}.tmp`;
+        if (commit === base)
+            throw new Error('依赖未产生代码提交，无需传输；请检查项目基线是否一致');
+        try {
+            await git(workspace.cwd, ['bundle', 'create', temporary, ref, `^${base}`]);
+            const bytes = (await stat(temporary)).size;
+            if (bytes > maxBytes)
+                throw new Error('依赖提交包超过 128 MiB，请通过仓库远端同步后继续');
+            const metadata = { bytes, digest: await digestFile(temporary), commit, base, ref };
+            await rename(temporary, file);
+            await writeFile(`${metadataFile}.${process.pid}.tmp`, JSON.stringify(metadata), { mode: 0o600 });
+            await rename(`${metadataFile}.${process.pid}.tmp`, metadataFile);
+            return metadata;
+        }
+        finally {
+            await unlink(temporary).catch(() => { });
+        }
+    })().finally(() => preparing.delete(artifact.id));
+    preparing.set(artifact.id, operation);
+    return operation;
+}
+/** Chunks travel on the existing Noise RPC. No HTTP upload or repository credentials are introduced. */
+export async function taskBundleChunk(task, offset) {
+    if (!Number.isSafeInteger(offset) || Number(offset) < 0 || Number(offset) % chunkSize !== 0)
+        throw new Error('提交包偏移无效');
+    const metadata = await prepareBundle(task);
+    if (Number(offset) >= metadata.bytes)
+        throw new Error('提交包偏移超出范围');
+    const artifact = acceptedCommit(task).artifact;
+    const file = await open(path.join(directory, `${artifact.id}.bundle`), 'r');
+    try {
+        const buffer = Buffer.alloc(Math.min(chunkSize, metadata.bytes - Number(offset)));
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, Number(offset));
+        return { ...metadata, offset, data: buffer.subarray(0, bytesRead).toString('base64') };
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function importTaskDependency(current, dependency, repository, peers, localRead) {
+    const expected = acceptedCommit(dependency);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const temporary = path.join(directory, `${expected.artifact.id}.incoming.${current.id}.${process.pid}.tmp`);
+    const file = await open(temporary, 'w', 0o600);
+    let offset = 0, digest = '', total = Infinity, ref = '';
+    try {
+        do {
+            const response = current.ownerServiceId === peers.descriptor().serviceId ? await localRead(current.id, dependency.id, offset)
+                : await peers.requestTasks(current.ownerServiceId, { op: 'dependency-bundle', taskId: current.id, dependencyId: dependency.id, offset });
+            const chunk = response.chunk;
+            if (!chunk || chunk.offset !== offset || chunk.commit !== expected.commit || chunk.base !== expected.base
+                || !Number.isSafeInteger(chunk.bytes) || chunk.bytes < 1 || chunk.bytes > maxBytes || typeof chunk.digest !== 'string' || !/^[a-f0-9]{64}$/.test(chunk.digest)
+                || chunk.ref !== `refs/termdock/exports/${expected.artifact.id}` || typeof chunk.data !== 'string' || chunk.data.length > 350_000
+                || digest && digest !== chunk.digest || offset && total !== chunk.bytes)
+                throw new Error('依赖提交包校验信息无效');
+            digest = chunk.digest;
+            total = chunk.bytes;
+            ref = chunk.ref;
+            const bytes = Buffer.from(chunk.data, 'base64');
+            if (!bytes.length || bytes.length > chunkSize || offset + bytes.length > total)
+                throw new Error('依赖提交包分片无效');
+            await file.write(bytes, 0, bytes.length, offset);
+            offset += bytes.length;
+        } while (offset < total);
+        await file.close();
+        if (await digestFile(temporary) !== digest)
+            throw new Error('依赖提交包摘要不匹配，保留任务等待重试');
+        await git(repository, ['bundle', 'verify', temporary]);
+        await git(repository, ['fetch', '--no-tags', temporary, ref]);
+    }
+    finally {
+        await file.close().catch(() => { });
+        await unlink(temporary).catch(() => { });
+    }
+}

package/dist/server/agent/collaborationTaskCli.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+export async function executeTaskCommand(command, request, io) {
+    const o = command.options, operation = command.operation;
+    const bodyOptions = ['content', 'file', 'stdin', 'idempotency-key'];
+    const allowed = {
+        list: ['group'], get: [], create: [...bodyOptions, 'group', 'title', 'constraints', 'acceptance', 'assignee', 'coordinator', 'parent', 'depends-on', 'managed', 'reviewers', 'shared-directory', 'integration'],
+        assign: [...bodyOptions, 'assignee', 'revision'], report: [...bodyOptions, 'attempt', 'status', 'evidence'], ask: [...bodyOptions, 'attempt', 'options'],
+        plan: [...bodyOptions, 'attempt', 'evidence'], review: [...bodyOptions, 'artifact', 'evidence', 'verdict'], comment: bodyOptions,
+        'request-review': [...bodyOptions, 'artifact', 'assignee', 'revision'],
+        revise: [...bodyOptions, 'revision'], close: [...bodyOptions, 'revision'], reopen: [...bodyOptions, 'revision'],
+        coordinate: [...bodyOptions, 'revision'], pause: [...bodyOptions, 'revision'], resume: [...bodyOptions, 'revision'], retry: [...bodyOptions, 'revision'],
+    };
+    for (const flag of Object.keys(o))
+        if (![...allowed[operation], 'session', 'json', 'jsonl', 'text', 'help'].includes(flag))
+            throw new Error(`--${flag} is not supported by task ${operation}`);
+    if (operation === 'list')
+        return request('GET', `/tasks${o.group ? `?group=${encodeURIComponent(String(o.group))}` : ''}`);
+    if (operation === 'get')
+        return request('GET', `/tasks/${encodeURIComponent(command.target)}`);
+    const contentSources = [o.content, o.file, o.stdin].filter(Boolean).length;
+    if (contentSources > 1)
+        throw new Error('Choose --content, --file or --stdin');
+    const content = o.file ? fs.readFileSync(String(o.file), 'utf8') : o.stdin ? await io.stdin?.() : o.content;
+    if (!['assign', 'close', 'reopen', 'request-review', 'pause', 'resume', 'retry'].includes(operation) && (typeof content !== 'string' || !content.trim()))
+        throw new Error('This task operation requires --content, --file or --stdin');
+    const idempotencyKey = String(o['idempotency-key'] ?? randomUUID());
+    const expectedRevision = o.revision === undefined ? undefined : Number(o.revision);
+    if (expectedRevision !== undefined && (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1))
+        throw new Error('--revision must be a positive integer');
+    if (['assign', 'revise', 'close', 'reopen', 'request-review', 'coordinate', 'pause', 'resume', 'retry'].includes(operation) && expectedRevision === undefined)
+        throw new Error('Read task get first, then supply --revision to avoid overwriting another decision');
+    if (['assign', 'request-review'].includes(operation) && !o.assignee)
+        throw new Error('This task operation requires --assignee');
+    if (['report', 'ask', 'plan'].includes(operation) && !o.attempt)
+        throw new Error('Use --attempt from the dispatch message; never guess the current attempt');
+    if (operation === 'create') {
+        if (!o.title || !o.group)
+            throw new Error('task create requires --title and --group');
+        return request('POST', '/tasks', { input: { idempotencyKey, groupId: o.group, title: o.title, spec: content,
+                constraints: o.constraints, acceptance: o.acceptance, assigneeSessionId: o.assignee, coordinatorSessionId: o.coordinator,
+                parentTaskId: o.parent, dependsOn: o['depends-on'] ? String(o['depends-on']).split(',').filter(Boolean) : undefined,
+                integration: o.integration === true, managed: o.managed === true, isolated: o['shared-directory'] !== true,
+                reviewerSessionIds: o.reviewers ? String(o.reviewers).split(',').filter(Boolean) : undefined } });
+    }
+    const options = o.options ? JSON.parse(String(o.options)) : undefined;
+    if (options !== undefined && (!Array.isArray(options) || options.some(v => typeof v !== 'string')))
+        throw new Error('--options must be a JSON array of strings');
+    return request('POST', `/tasks/${encodeURIComponent(command.target)}`, { input: {
+            kind: operation === 'plan' ? 'submit-plan' : operation, idempotencyKey, expectedRevision, content,
+            assigneeSessionId: o.assignee, attemptId: o.attempt, status: o.status, artifactId: o.artifact, options, verdict: o.verdict,
+            evidence: o.evidence ? JSON.parse(String(o.evidence)) : undefined,
+        } });
+}

package/dist/server/agent/collaborationTaskRoutes.js

@@ -0,0 +1,58 @@
+import { Router } from 'express';
+import { CollaborationError } from './collaborationProtocol.js';
+import { assertPeerRegistrationAuthority } from './collaborationPeerTransport.js';
+export function collaborationTaskRoutes(options) {
+    const router = Router();
+    const groupId = (value) => {
+        const resolved = options.store.resolveGroupId(value);
+        if (resolved.status !== 'ok')
+            throw new CollaborationError(resolved.status === 'ambiguous' ? 'GROUP_ID_AMBIGUOUS' : 'TASK_GROUP_NOT_FOUND', '请使用存在且唯一的协作组 ID', resolved.status === 'ambiguous' ? 409 : 404);
+        return resolved.id;
+    };
+    const context = (req) => {
+        const tasks = req.app.locals.collaborationTasks;
+        const peers = req.app.locals.collaborationService;
+        if (!tasks || !peers)
+            throw new CollaborationError('TASK_SERVICE_STARTING', '任务服务正在启动，请稍后重试', 503);
+        if (!options.agent) {
+            try {
+                assertPeerRegistrationAuthority(req);
+            }
+            catch {
+                throw new CollaborationError('TASK_PERMISSION_DENIED', '当前连接无权处理协作任务', 403);
+            }
+            return { tasks, peers, actor: null };
+        }
+        const sessionId = options.resolveSession((req.method === 'GET' ? req.query : req.body) ?? {});
+        if (!sessionId || sessionId.startsWith('remote:'))
+            throw new CollaborationError('SESSION_NOT_FOUND', '请在 Termdock 管理的本机会话内使用任务命令', 404);
+        return { tasks, peers, actor: peers.taskMember(sessionId) };
+    };
+    const run = (handler) => async (req, res) => {
+        try {
+            res.json(await handler(req, context(req)));
+        }
+        catch (error) {
+            res.status(error instanceof CollaborationError ? error.httpStatus : 400).json({ ok: false,
+                code: error instanceof CollaborationError ? error.code : 'TASK_ERROR', error: error instanceof Error ? error.message : String(error) });
+        }
+    };
+    router.get('/', run((req, { tasks, actor }) => {
+        const requested = typeof req.query.group === 'string' ? groupId(req.query.group) : null;
+        const groups = requested ? [requested] : actor ? options.store.groupsForSession(actor.sessionId).map(g => g.id) : options.store.list().map(g => g.id);
+        return { tasks: groups.flatMap(id => tasks.list(id, actor)) };
+    }));
+    router.get('/:taskId', run(async (req, { tasks, actor }) => ({ task: await tasks.get(req.params.taskId, actor) })));
+    const input = (req, peers) => {
+        const body = req.body?.input;
+        if (!body || typeof body !== 'object' || Array.isArray(body))
+            throw new CollaborationError('INVALID_TASK', '需要任务内容');
+        if (body.reviewerSessionIds !== undefined && (!Array.isArray(body.reviewerSessionIds) || body.reviewerSessionIds.length > 32 || body.reviewerSessionIds.some((v) => typeof v !== 'string')))
+            throw new CollaborationError('INVALID_REVIEWERS', '执行成员列表无效');
+        return { ...body, ...(body.reviewerSessionIds ? { reviewers: body.reviewerSessionIds.map((id) => peers.taskMember(id)) } : {}), ...(typeof body.groupId === 'string' ? { groupId: groupId(body.groupId) } : {}), ...(body.assigneeSessionId ? { assignee: peers.taskMember(String(body.assigneeSessionId)) } : {}),
+            ...(body.coordinatorSessionId !== undefined ? { coordinator: body.coordinatorSessionId ? peers.taskMember(String(body.coordinatorSessionId)) : null } : {}) };
+    };
+    router.post('/', run(async (req, { tasks, peers, actor }) => ({ task: await tasks.create(input(req, peers), actor) })));
+    router.post('/:taskId', run(async (req, { tasks, peers, actor }) => ({ task: await tasks.apply(req.params.taskId, input(req, peers), actor) })));
+    return router;
+}