termdock 1.4.299 → 1.4.301

package/dist/server/agent/collaborationTaskStore.js

@@ -83,7 +83,7 @@ function validateSnapshot(task) {
             invalid();
         if (event.deliveryId !== undefined && !validId(event.deliveryId))
             invalid();
-        if (event.source !== undefined && !['system', 'user'].includes(event.source))
+        if (event.source !== undefined && !['system', 'user', 'integration'].includes(event.source))
             invalid();
         if (event.actor !== null)
             member(event.actor);
@@ -115,6 +115,9 @@ function validateSnapshot(task) {
 /** Atomic document writes keep decisions and their outgoing messages in one transaction. */
 export class CollaborationTaskStore {
     file;
+    listeners = new Set();
+    subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
+    snapshot() { return structuredClone(this.document.tasks); }
     document = { version: 1, tasks: [], outbox: [], requests: {} };
     constructor(file) {
         this.file = file;
@@ -129,9 +132,18 @@ export class CollaborationTaskStore {
                 throw error;
         }
     }
-    transaction(mutate) {
+    transaction(mutate, origin) {
         const next = structuredClone(this.document);
         const result = mutate(next);
+        if (origin) {
+            const previous = new Set(this.document.tasks.flatMap(t => t.events.map(e => e.id)));
+            for (const task of next.tasks)
+                for (const event of task.events)
+                    if (!previous.has(event.id) && event.actor === null && event.source !== 'system') {
+                        event.source = 'integration';
+                        event.origin = structuredClone(origin);
+                    }
+        }
         if (next.tasks.some(task => Buffer.byteLength(JSON.stringify(task)) > 512_000))
             throw new CollaborationError('TASK_HISTORY_LIMIT', '此任务记录达到 500 KiB，请建立后续任务并保留本任务为历史', 409);
         const serialized = JSON.stringify(next);
@@ -142,8 +154,18 @@ export class CollaborationTaskStore {
         writeFileSync(temporary, serialized, { mode: 0o600 });
         renameSync(temporary, this.file);
         this.document = next;
+        for (const listener of this.listeners) {
+            try {
+                listener();
+            }
+            catch { /* Durable sources allow the integration journal to retry. */ }
+        }
         return structuredClone(result);
     }
+    integrationRequestEvent(principalId, key, taskId) {
+        const request = this.document.requests[`integration:${principalId}:${key}`];
+        return request?.taskId === taskId ? structuredClone(this.document.tasks.find(t => t.id === taskId)?.events.find(e => e.id === request.eventId)) : undefined;
+    }
     get(taskId) { return structuredClone(this.document.tasks.find(t => t.id === taskId) ?? null); }
     owned(owner) { return structuredClone(this.document.tasks.filter(t => t.ownerServiceId === owner)); }
     children(taskId) {
@@ -166,7 +188,7 @@ export class CollaborationTaskStore {
                 attempts: current ? [{ ...current, report: current.report ? { ...current.report, summary: reportSummary, content: '', evidence: undefined } : undefined }] : [],
                 artifacts: [plan, result, ...task.artifacts.filter(a => a.kind === 'review' && a.reviewsArtifactId === result?.id)].filter((a) => !!a).map(a => ({ ...a, content: '', summary: (a.summary || (a.kind === 'result' && collaborationResultPresentation(a.content).condensed ? collaborationResultPresentation(a.content).summary : undefined))?.slice(0, 800), evidence: undefined })),
                 decisions: task.decisions.filter(d => d.status === 'pending').map(d => ({ ...d, question: d.question.slice(0, 512), options: [] })),
-                events: task.events.filter(e => ['revise', 'request-review'].includes(e.kind) && e.attemptId === task.activeAttemptId).slice(-4).map(e => ({ ...e, content: e.source === 'user' && e.kind === 'revise' ? e.content.slice(0, 512) : '' })) };
+                events: task.events.filter(e => ['revise', 'request-review'].includes(e.kind) && e.attemptId === task.activeAttemptId).slice(-4).map(e => ({ ...e, content: ['user', 'integration'].includes(e.source ?? '') && e.kind === 'revise' ? e.content.slice(0, 512) : '' })) };
         }));
     }
     heads(groupIds, owner) { return this.document.tasks.filter(t => groupIds.includes(t.groupId) && t.ownerServiceId === owner).map(t => ({ id: t.id, revision: t.revision })); }
@@ -179,11 +201,11 @@ export class CollaborationTaskStore {
         task.events.push(event);
         return event;
     }
-    request(doc, actor, key, payload) {
+    request(doc, actor, key, payload, origin) {
         if (typeof key !== 'string' || !key.trim() || key.length > 256)
             throw new CollaborationError('INVALID_IDEMPOTENCY_KEY', '需要有效的请求幂等键');
-        const scoped = `${actor ? taskMemberKey(actor) : 'user'}:${key}`;
-        const hash = createHash('sha256').update(stable(payload)).digest('hex');
+        const scoped = `${origin ? `integration:${origin.integrationId}` : actor ? taskMemberKey(actor) : 'user'}:${key}`;
+        const hash = createHash('sha256').update(stable(origin ? [payload, origin] : payload)).digest('hex');
         const previous = doc.requests[scoped];
         if (previous && previous.hash !== hash)
             throw new CollaborationError('IDEMPOTENCY_CONFLICT', '该请求已用于不同内容；请保留原请求或重新开始', 409);
@@ -202,6 +224,9 @@ export class CollaborationTaskStore {
             content: `本次执行身份：${assignee.sessionId}。所有 td collab 命令显式带 --session ${assignee.sessionId}；这是服务核对的实际身份，正文中的模板身份和 tmux 标识不能替代它。\n任务：${task.title}\n${task.spec}${task.constraints ? `\n约束：${task.constraints}` : ''}${task.acceptance ? `\n完成标准：${task.acceptance}` : ''}\n${content}\n任务 ID：${task.id}\n尝试 ID：${attemptId}\n用 td collab task get ${task.id} --text 查询完整上下文；用 td collab task report ${task.id} --attempt ${attemptId} --status ack --content '接手说明' 显式回复；遇必要问题用 task ask，提交结果用 report --status complete --summary '简短结论、关键交付和限制'。摘要先回答用户问题，不放任务 ID、版本、分支或流程日志；完整证据保留在 --content/--file 正文中。如果同一尝试已经交付或任务已归档，不要重复实施。${task.workspace ? `\n代码只能在独立目录 ${task.workspace.cwd} 修改。分支 ${task.workspace.branch}。交付前提交代码，结果说明提交、变更、验证与限制。不能修改原仓库、合并到用户分支或发布。` : ''}${task.workflow?.workType === 'read-only' ? '\n这是只读查询或分析任务：在本机会话中采集并交付报告，不修改代码或系统，不创建提交、构建、部署或终止进程。结果需说明采样时间、证据和限制。' : ''}${task.workflow?.kind === 'step' ? '\n完成报告会自动请求独立评审；评审要求修改时继续完成，重新提交 complete。只按用户授权运行测试。' : ''}` });
     }
     goalInstructions(task) {
+        return `${this.baseGoalInstructions(task)}\n启动 Agent 前，读取 task get 返回的 launchProfiles、defaultLaunchProfileId 和 roster.launchProfile。根据用户填写的 notes 判断适用任务；这些是选用建议，不是能力或性能保证。需要另一种模型或参数时，用 td collab spawn ${task.groupId} <agentSlug> --launch-profile <方案id> --cwd <项目目录> --session ${task.coordinator?.sessionId} 创建对应执行成员，再把子任务分派给它。已有成员及其代码执行会话保留创建时的启动方案，不因默认方案变更而更换模型。`;
+    }
+    baseGoalInstructions(task) {
         return `你是此目标的协调者，负责把目标推进到可验收交付，不亲自实施子任务。\n目标：${task.spec}\n约束：${task.constraints || '未补充'}\n完成标准：${task.acceptance || '满足用户目标，说明交付与限制'}\n任务 ID：${task.id}\n当前协调身份：${task.coordinator?.sessionId}；所有命令显式带 --session ${task.coordinator?.sessionId}，不使用 tmux 标识。\n用 td collab task get ${task.id} --json 读取 roster、子任务、完整记录和 revision。\n先报告 ack；拆分为可交付子任务，用 td collab task create --group ${task.groupId} --parent ${task.id} --title '标题' --content '完整要求' --assignee <roster里的成员sessionId> --acceptance '明确标准' --work-type read-only|code。先按目标明确分类：查询、检查、研究、分析用 read-only，复用现有执行成员会话，不创建 Git 目录；修改代码用 code，才创建独立目录。简单问题只建一个必要任务，不为了形式拆成采集、复述、汇总多份任务。子任务继承自动评审与协调者。依赖任务用 --depends-on id,id，服务在依赖评审通过后自动分派。保持分工合理，不根据终端输出推断谁有空。\n每次收到明确更新后读取最新记录，处理失败与交接。服务自动安排独立评审、返工和依赖接续；不要重复请求评审或催促正在等待回复的成员。必要的人类决策用 task ask --attempt <本轮id>；方案需要用户确认时提交 task plan，不把普通回复当授权。\n只有已交付代码任务实际包含相对 base 的提交变化时，才需创建 --work-type code --integration 的最终集成子任务，--depends-on 依赖全部代码实施任务；独立目录会包含依赖的提交。不得在原仓库自动合并或发布。\n结束本次协调用 td collab task coordinate ${task.id} --revision <最新版本> --content '已安排的工作和下一步'；有新事件服务会再次唤起你。所有子任务评审通过后报告 complete --summary '直接回答用户的简短结果和限制'；只读目标直接汇总已核对结果，不创建集成或重复汇总任务。正文保留证据、评审结论和限制，仅代码目标补充目录、分支和提交，等待用户最终验收。任何异常都要留下明确说明，不伪造完成或进度。`;
     }
     notifyCoordinator(doc, task, update) {
@@ -222,7 +247,7 @@ export class CollaborationTaskStore {
         doc.outbox.push({ id: id(), taskId: task.id, attemptId: attempt?.id ?? null, target: task.coordinator, kind: 'message', threadId: attempt?.threadId ?? task.id,
             content: `你被指定为任务「${task.title}」的协调者。\n目标：${task.spec}\n约束：${task.constraints || '未补充'}\n验收标准：${task.acceptance || '由用户决定'}\n任务 ID：${task.id}\n用 td collab task get ${task.id} --text 查看原始记录；用 task list --group ${task.groupId} 查看工作组。需要拆分时用 task create --group ${task.groupId} --parent ${task.id} --title '子任务标题' --content '任务内容'。分派前查询 revision，再用 task assign --revision；把必要的人类决策交给 task ask，不推断成员忙闲，不停止其他成员终端。` });
     }
-    create(owner, input, actor) {
+    create(owner, input, actor, origin) {
         const title = text(input.title, '标题', 640, true), spec = text(input.spec, '任务内容', 32_000, true);
         const constraints = text(input.constraints, '约束'), acceptance = text(input.acceptance, '完成标准');
         if (input.dependsOn !== undefined && (!Array.isArray(input.dependsOn) || input.dependsOn.length > 32 || input.dependsOn.some(v => typeof v !== 'string')))
@@ -242,7 +267,7 @@ export class CollaborationTaskStore {
             throw new CollaborationError('INVALID_REVIEWERS', '评审成员列表无效');
         input.reviewers?.forEach(member);
         return this.transaction(doc => {
-            const request = this.request(doc, actor, input.idempotencyKey, input);
+            const request = this.request(doc, actor, input.idempotencyKey, input, origin);
             if (request.previous)
                 return request.previous;
             if (doc.tasks.length >= 2000)
@@ -285,7 +310,7 @@ export class CollaborationTaskStore {
             const task = { id: id(), ownerServiceId: owner, groupId: input.groupId, title, spec, constraints, acceptance,
                 coordinator: parent?.workflow ? parent.coordinator : input.coordinator !== undefined ? input.coordinator : input.parentTaskId ? doc.tasks.find(t => t.id === input.parentTaskId)?.coordinator ?? actor : null,
                 parentTaskId: input.parentTaskId ?? null, dependsOn, createdAt: now, updatedAt: now, revision: 1,
-                status: 'open', activeAttemptId: null, attempts: [], decisions: [], artifacts: [], events: [], deliveries: [], ...(workflow ? { workflow } : {}) };
+                ...(origin ? { origin: structuredClone(origin) } : {}), status: 'open', activeAttemptId: null, attempts: [], decisions: [], artifacts: [], events: [], deliveries: [], ...(workflow ? { workflow } : {}) };
             this.event(task, 'created', actor, spec);
             if (parent?.constraints)
                 task.constraints = text([parent.constraints, constraints].filter(Boolean).join('\n'), '继承约束');
@@ -307,9 +332,9 @@ export class CollaborationTaskStore {
             this.touchParent(doc, task, '新子任务已创建');
             doc.requests[request.key] = { hash: request.hash, taskId: task.id };
             return task;
-        });
+        }, origin);
     }
-    apply(taskId, input, actor) {
+    apply(taskId, input, actor, origin) {
         const content = text(input.content, '内容');
         const summary = text(input.summary, '结果摘要', 2400);
         if (summary && (input.kind !== 'report' || input.status !== 'complete'))
@@ -322,23 +347,25 @@ export class CollaborationTaskStore {
             const task = doc.tasks.find(t => t.id === taskId);
             if (!task)
                 throw new CollaborationError('TASK_NOT_FOUND', '任务不存在或无权查看', 404);
-            const request = this.request(doc, actor, input.idempotencyKey, [taskId, input]);
+            const request = this.request(doc, actor, input.idempotencyKey, [taskId, input], origin);
             if (request.previous)
                 return request.previous;
+            if (origin && ['accept', 'approve-plan', 'report', 'ask', 'submit-plan', 'review', 'respond'].includes(input.kind))
+                throw new CollaborationError('INTEGRATION_OPERATION_DENIED', '此操作需要用户或原执行成员身份', 403);
             const coordination = actor === null || sameMember(actor, task.coordinator);
             if (['assign', 'coordinator', 'close', 'reopen', 'revise', 'request-review', 'coordinate', 'pause', 'resume', 'retry'].includes(input.kind) && !coordination)
                 throw new CollaborationError('TASK_PERMISSION_DENIED', '此操作需要用户或当前协调者', 403);
             if (['answer', 'accept', 'approve-plan'].includes(input.kind) && actor !== null)
                 throw new CollaborationError('USER_DECISION_REQUIRED', '回答、方案确认与验收需要用户操作', 403);
-            if (!['report', 'ask', 'submit-plan', 'review', 'comment', 'answer'].includes(input.kind) && input.expectedRevision !== task.revision)
+            if (!['report', 'ask', 'submit-plan', 'review', 'comment', 'respond', 'answer'].includes(input.kind) && input.expectedRevision !== task.revision)
                 throw new CollaborationError('TASK_CHANGED', '任务已更新，请查看最新记录后重试', 409);
             const userFollowup = actor === null && input.kind === 'revise' && !!content;
-            if (task.status !== 'open' && !['reopen', 'report'].includes(input.kind) && !(task.status === 'accepted' && userFollowup))
+            if (task.status !== 'open' && !['reopen', 'report'].includes(input.kind) && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
                 throw new CollaborationError('TASK_ARCHIVED', '任务已归档；需要继续时请重新打开', 409);
-            if (task.workflow && task.status !== 'open' && input.kind !== 'reopen' && !(task.status === 'accepted' && userFollowup))
+            if (task.workflow && task.status !== 'open' && input.kind !== 'reopen' && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
                 throw new CollaborationError('TASK_ARCHIVED', '自动协作的已完成版本不能追加执行报告，请先重新打开', 409);
             const root = task.workflow?.rootTaskId ? doc.tasks.find(t => t.id === task.workflow.rootTaskId) : undefined;
-            if (root && root.status !== 'open' && !(root.status === 'accepted' && userFollowup))
+            if (root && root.status !== 'open' && !(root.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
                 throw new CollaborationError('GOAL_ARCHIVED', '请先重新打开所属目标，再继续子任务', 409);
             if (userFollowup && task.status === 'accepted') {
                 task.status = 'open';
@@ -418,8 +445,26 @@ export class CollaborationTaskStore {
                 const event = this.event(task, 'report', actor, content, attempt.id);
                 event.reportStatus = input.status;
                 event.evidence = input.evidence;
-                if (input.status === 'complete')
-                    task.artifacts.push({ id: id(), attemptId: attempt.id, kind: 'result', content, ...(summary ? { summary } : {}), evidence: input.evidence, actor: actor, createdAt: event.createdAt });
+                if (input.status === 'complete' && attempt.id === task.activeAttemptId && task.status === 'accepted') {
+                    task.status = 'open';
+                    delete task.acceptedArtifactId;
+                    delete task.completionMode;
+                }
+                if (input.status === 'complete') {
+                    event.artifactId = id();
+                    task.artifacts.push({ id: event.artifactId, attemptId: attempt.id, kind: 'result', content, ...(summary ? { summary } : {}), evidence: input.evidence, actor: actor, createdAt: event.createdAt });
+                }
+            }
+            else if (input.kind === 'respond') {
+                const original = task.events.find(e => e.id === input.replyToEventId && e.kind === 'comment');
+                const originalAttempt = original && task.attempts.find(a => a.id === original.attemptId);
+                if (!original || !originalAttempt || originalAttempt.id !== input.attemptId || !sameMember(actor, originalAttempt.assignee))
+                    throw new CollaborationError('RESPONSE_PERMISSION_DENIED', '请由原追问对应的执行成员回复，并指定原事件和分派', 403);
+                if (!content)
+                    throw new CollaborationError('INVALID_RESPONSE', '答复不能为空');
+                const response = this.event(task, 'respond', actor, content, originalAttempt.id);
+                response.replyToEventId = original.id;
+                response.evidence = input.evidence;
             }
             else if (input.kind === 'ask') {
                 if (!content || input.options !== undefined && (!Array.isArray(input.options) || input.options.length > 8 || input.options.some(v => typeof v !== 'string' || !v.trim() || v.length > 500)))
@@ -439,7 +484,7 @@ export class CollaborationTaskStore {
                 this.event(task, 'answer', null, content, decision.attemptId);
                 const recipient = task.attempts.find(a => a.id === decision.attemptId);
                 doc.outbox.push({ id: id(), taskId: task.id, attemptId: recipient.id, target: recipient.assignee, kind: 'message', threadId: recipient.threadId,
-                    content: `任务「${task.title}」问题已回答\n问题：${decision.question}\n用户回答：${content}\n任务 ID：${task.id}\n尝试 ID：${recipient.id}` });
+                    content: `任务「${task.title}」问题已回答\n问题：${decision.question}\n${origin ? '外部接入回答' : '用户回答'}：${content}\n任务 ID：${task.id}\n尝试 ID：${recipient.id}` });
             }
             else if (input.kind === 'submit-plan' || input.kind === 'review') {
                 if (!content || !actor)
@@ -519,7 +564,7 @@ export class CollaborationTaskStore {
                     event.target = recipient.assignee;
                     event.deliveryId = id();
                     doc.outbox.push({ id: event.deliveryId, taskId: task.id, attemptId: recipient.id, target: recipient.assignee,
-                        kind: 'message', threadId: recipient.threadId, content: `任务「${task.title}」${input.kind === 'revise' ? actor === null ? '用户要求继续跟进' : '修改要求' : '补充反馈'}：\n${content}\n任务 ID：${task.id}\n尝试 ID：${recipient.id}${task.workflow?.kind === 'goal' ? `\n本轮继续沿用此目标和已交付证据，只推进新增要求。\n${this.goalInstructions(task)}` : '\n按这次要求继续当前分派，重新提交 complete 和摘要；新版本会重新独立评审。'}` });
+                        kind: 'message', threadId: recipient.threadId, replyToEventId: event.id, content: `任务「${task.title}」${input.kind === 'revise' ? actor === null ? origin ? '外部接入要求继续跟进' : '用户要求继续跟进' : '修改要求' : '补充反馈'}：\n${content}\n任务 ID：${task.id}\n尝试 ID：${recipient.id}${input.kind === 'comment' ? `\n这是纯咨询，保留当前结果与验收。请用 td collab --session ${recipient.assignee.sessionId} task respond ${task.id} --attempt ${recipient.id} --to-event ${event.id} --content '答复' 关联回复；只有明确提交新的交付物才用 complete。` : task.workflow?.kind === 'goal' ? `\n本轮继续沿用此目标和已交付证据，只推进新增要求。\n${this.goalInstructions(task)}` : '\n按这次要求继续当前分派，重新提交 complete 和摘要；新版本会重新独立评审。'}` });
                     if (task.workflow?.kind === 'goal' && task.coordination) {
                         task.coordination.notifiedSequence = event.sequence;
                         task.coordination.notifiedAt = Date.now();
@@ -584,21 +629,21 @@ export class CollaborationTaskStore {
             }
             else
                 throw new CollaborationError('INVALID_TASK_OPERATION', '不支持的任务操作');
-            if (['report', 'ask', 'answer', 'submit-plan', 'review', 'accept', 'revise', 'close', 'reopen'].includes(input.kind))
+            if (['report', 'respond', 'ask', 'answer', 'submit-plan', 'review', 'accept', 'revise', 'close', 'reopen'].includes(input.kind))
                 this.notifyCoordinator(doc, task, task.events.at(-1));
             if (task.events.length > 1000 || task.artifacts.length > 200 || task.attempts.length > 100)
                 throw new CollaborationError('TASK_HISTORY_LIMIT', '此任务历史达到上限，请建立后续任务并保留本任务为历史', 409);
             task.revision++;
             task.updatedAt = Math.max(Date.now(), task.updatedAt + 1);
-            if (task.workflow && input.kind !== 'coordinate')
+            if (task.workflow && !['coordinate', 'comment', 'respond'].includes(input.kind))
                 this.touchParent(doc, task, `${input.kind}${input.status ? ` / ${input.status}` : ''}：${content.slice(0, 1500)}`);
             if (task.workflow && ['blocked', 'failed'].includes(input.status ?? ''))
                 task.automationIssue = content.slice(0, 1000);
             if (task.workflow && input.kind === 'report' && ['ack', 'working', 'complete'].includes(input.status ?? ''))
                 delete task.automationIssue;
-            doc.requests[request.key] = { hash: request.hash, taskId };
+            doc.requests[request.key] = { hash: request.hash, taskId, eventId: task.events.at(-1)?.id };
             return task;
-        });
+        }, origin);
     }
     touchParent(doc, task, content) {
         const root = task.workflow?.rootTaskId ? doc.tasks.find(t => t.id === task.workflow.rootTaskId) : undefined;
@@ -717,7 +762,7 @@ export class CollaborationTaskStore {
                     this.touchParent(doc, task, '独立评审通过，后续依赖可以接续');
                 }
                 else if (action === 'review-feedback') {
-                    const boundary = task.events.filter(e => e.kind === 'revise' && e.source === 'user' && e.attemptId === task.activeAttemptId).at(-1)?.sequence ?? 0;
+                    const boundary = task.events.filter(e => e.kind === 'revise' && ['user', 'integration'].includes(e.source ?? '') && e.attemptId === task.activeAttemptId).at(-1)?.sequence ?? 0;
                     const rounds = task.events.filter(e => e.kind === 'revise' && e.actor === null && e.artifactId && e.attemptId === task.activeAttemptId && e.sequence > boundary).length;
                     const blocked = review.verdict === 'blocked' || rounds >= task.workflow.maxRevisions;
                     const event = this.event(task, blocked ? 'review-blocked' : 'revise', null, review.content);

package/dist/server/agent/collaborationTeam.js

@@ -6,10 +6,10 @@ export async function ensureTeam(options) {
     for (const role of labels) {
         const members = options.members();
         const reserved = members.find(member => member.role?.startsWith(role.split(' (')[0]));
-        if (reserved && (reserved.role !== role || reserved.cwd !== options.cwd)) {
-            throw new Error('本组已有自动配置的成员，请使用原 Agent 和目录，或在成员设置中移出后重新配置');
+        if (reserved && (reserved.role !== role || reserved.cwd !== options.cwd || (reserved.launchProfileKey ?? '') !== (options.launchProfileKey ?? ''))) {
+            throw new Error('本组已有自动配置的成员，请使用原 Agent、启动方案和目录，或在成员设置中移出后重新配置');
         }
-        const existing = reserved ?? members.find(member => !ids.includes(member.id) && member.agentSlug === options.agentSlug && member.cwd === options.cwd);
+        const existing = reserved ?? members.find(member => !ids.includes(member.id) && member.agentSlug === options.agentSlug && member.cwd === options.cwd && (member.launchProfileKey ?? '') === (options.launchProfileKey ?? ''));
         ids.push(existing?.id ?? await options.spawn(role));
     }
     return { coordinatorSessionId: ids[0], reviewerSessionIds: [ids[1]] };

package/dist/server/agent/integrationCli.js

@@ -0,0 +1,243 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import { INTEGRATION_PROTOCOL } from './integrationStore.js';
+import { integrationSocketPath } from './integrationServer.js';
+import { CollaborationError } from './collaborationProtocol.js';
+import { executeCollaborationCommand, duration } from './collaborationCli.js';
+import { getTermdockVersion } from '../utils/version.js';
+export const INTEGRATION_HELP = `td integration — local scoped integration administration
+  groups | list
+  create --file <policy.json> --credential-file <private-output.json>
+  update --file <policy.json> (same identity/group; preserves the credential)
+  revoke <principal-id>
+Credentials are saved as a private file and never printed. Workers set
+TERMDOCK_INTEGRATION_CREDENTIAL_FILE, then use td collab --principal <id> …
+Only the local administrator can provision/revoke grants. See docs/integrations.md.`;
+export function readIntegrationCredential(file, principalId) {
+    const info = fs.lstatSync(file);
+    if (!info.isFile() || info.size > 4096 || (info.mode & 0o077) || process.getuid && info.uid !== process.getuid())
+        throw new CollaborationError('INTEGRATION_CREDENTIAL_FILE_DENIED', 'Credential file must be owned by this user and private (0600)', 403);
+    const credential = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (credential.id !== principalId || !credential.token || credential.protocol !== INTEGRATION_PROTOCOL)
+        throw new CollaborationError('INTEGRATION_CREDENTIAL_MISMATCH', 'Credential identity/protocol does not match the requested principal', 403);
+    return credential;
+}
+function headers(credential, adminToken) {
+    return { 'Content-Type': 'application/json', 'x-termdock-integration-protocol': String(INTEGRATION_PROTOCOL),
+        'x-termdock-cli-version': getTermdockVersion(),
+        ...(credential ? { 'x-termdock-integration-id': credential.id, authorization: `Bearer ${credential.token}` } : {}),
+        ...(adminToken ? { 'x-termdock-local-token': adminToken } : {}) };
+}
+function request(socketPath, method, route, body, requestHeaders, timeout = 30000) {
+    return new Promise((resolve, reject) => {
+        const req = http.request({ socketPath, method, path: route, headers: requestHeaders }, res => {
+            let raw = '';
+            res.setEncoding('utf8');
+            res.on('data', chunk => { raw += chunk; if (raw.length > 4 * 1024 * 1024)
+                req.destroy(new Error('Integration response exceeds limit')); });
+            res.once('end', () => resolve({ statusCode: res.statusCode ?? 500, body: raw }));
+            res.once('error', reject);
+        });
+        req.setTimeout(timeout, () => req.destroy(new Error('Integration request timed out')));
+        req.once('error', reject);
+        req.end(body === undefined ? undefined : JSON.stringify(body));
+    });
+}
+function parsed(response) {
+    const result = JSON.parse(response.body);
+    if (response.statusCode >= 300)
+        throw new CollaborationError(result.code ?? 'INTEGRATION_REQUEST_FAILED', result.error ?? 'Integration request failed', response.statusCode);
+    return result;
+}
+export async function runIntegrationAdmin(argv, port, adminToken, write) {
+    let reserved;
+    try {
+        const action = argv[0] ?? 'help', options = {};
+        if (action === 'help' || action === '--help') {
+            write(INTEGRATION_HELP);
+            return 0;
+        }
+        for (let index = 1; index < argv.length; index += 2) {
+            const flag = argv[index];
+            if (!['--file', '--credential-file'].includes(flag) || !argv[index + 1] || options[flag])
+                throw new Error('Invalid integration arguments');
+            options[flag] = argv[index + 1];
+        }
+        const socketPath = integrationSocketPath(port);
+        if (action === 'groups' || action === 'list') {
+            if (argv.length !== 1)
+                throw new Error('Unexpected arguments');
+            write(JSON.stringify(parsed(await request(socketPath, 'GET', action === 'groups' ? '/admin/groups' : '/admin/principals', undefined, headers(undefined, adminToken)))));
+            return 0;
+        }
+        if (action === 'update') {
+            if (!options['--file'] || Object.keys(options).length !== 1)
+                throw new Error('update requires only --file');
+            const policy = JSON.parse(fs.readFileSync(options['--file'], 'utf8'));
+            const capabilities = parsed(await request(socketPath, 'GET', '/admin/capabilities', undefined, headers(undefined, adminToken)));
+            if (capabilities.integration_policy_update !== true || policy.launchProfiles?.some((profile) => profile.startupInput !== undefined) && capabilities.startup_input_conditions !== true)
+                throw new CollaborationError('STARTUP_INPUT_CONDITION_UNSUPPORTED', 'Running service does not support this policy update', 409);
+            write(JSON.stringify(parsed(await request(socketPath, 'POST', `/admin/principals/${encodeURIComponent(policy.id)}/policy`, policy, headers(undefined, adminToken)))));
+            return 0;
+        }
+        if (action === 'create') {
+            if (!options['--file'] || !options['--credential-file'] || Object.keys(options).length !== 2)
+                throw new Error('create requires --file and --credential-file');
+            const policy = JSON.parse(fs.readFileSync(options['--file'], 'utf8'));
+            if (policy.launchProfiles?.some((profile) => profile.startupInput !== undefined)) {
+                const capabilities = parsed(await request(socketPath, 'GET', '/admin/capabilities', undefined, headers(undefined, adminToken)));
+                if (capabilities.startup_input_conditions !== true)
+                    throw new CollaborationError('STARTUP_INPUT_CONDITION_UNSUPPORTED', 'Running service does not support startup input conditions', 409);
+            }
+            const destination = path.resolve(options['--credential-file']);
+            fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+            fs.closeSync(fs.openSync(destination, 'wx', 0o600));
+            reserved = destination;
+            const credential = parsed(await request(socketPath, 'POST', '/admin/principals', policy, headers(undefined, adminToken)));
+            fs.writeFileSync(reserved, JSON.stringify(credential), { mode: 0o600 });
+            write(JSON.stringify({ ok: true, id: credential.id, credential_file: reserved }));
+            reserved = undefined;
+            return 0;
+        }
+        throw new Error('Unknown integration operation');
+    }
+    catch (error) {
+        if (reserved)
+            fs.unlinkSync(reserved);
+        write(JSON.stringify({ ok: false, code: error instanceof CollaborationError ? error.code : 'INTEGRATION_ADMIN_ERROR', error: error instanceof CollaborationError ? error.message : 'Integration administration failed; inspect arguments and private file paths' }));
+        return 1;
+    }
+}
+export async function revokeIntegration(id, port, adminToken, write) {
+    try {
+        write(JSON.stringify(parsed(await request(integrationSocketPath(port), 'POST', `/admin/principals/${encodeURIComponent(id)}/revoke`, {}, headers(undefined, adminToken)))));
+        return 0;
+    }
+    catch (error) {
+        write(JSON.stringify({ ok: false, code: error instanceof CollaborationError ? error.code : 'INTEGRATION_ADMIN_ERROR', error: error instanceof CollaborationError ? error.message : 'Integration revocation failed' }));
+        return 1;
+    }
+}
+export async function runIntegrationCollab(command, port, io) {
+    try {
+        const principalId = String(command.options.principal), file = process.env.TERMDOCK_INTEGRATION_CREDENTIAL_FILE;
+        if (!file)
+            throw new CollaborationError('INTEGRATION_CREDENTIAL_REQUIRED', 'Set TERMDOCK_INTEGRATION_CREDENTIAL_FILE to a private credential file', 401);
+        const credential = readIntegrationCredential(file, principalId), socketPath = integrationSocketPath(port);
+        const capability = parsed(await request(socketPath, 'GET', '/capabilities', undefined, headers(credential)));
+        if (capability.integration_protocol !== INTEGRATION_PROTOCOL)
+            throw new CollaborationError('INCOMPATIBLE_INTEGRATION_PROTOCOL', 'CLI/service protocols are incompatible', 409);
+        if (command.action === 'capabilities') {
+            io.write(JSON.stringify({ ...capability, cli_version: getTermdockVersion() }));
+            return 0;
+        }
+        if (command.action === 'events') {
+            const consumer = String(command.options.consumer ?? 'default');
+            if (command.operation === 'ack') {
+                io.write(JSON.stringify(parsed(await request(socketPath, 'POST', '/events/ack', { consumer, cursor: command.target }, headers(credential)))));
+                return 0;
+            }
+            const params = new URLSearchParams({ consumer });
+            if (command.options.group)
+                params.set('group', String(command.options.group));
+            return subscribe(socketPath, `/events?${params}`, credential, command.options.timeout ? duration(String(command.options.timeout)) : undefined, io.write);
+        }
+        if (command.action === 'session') {
+            const route = command.operation === 'create' ? '/sessions' : `/sessions/${encodeURIComponent(command.target)}${command.operation === 'restore' ? '/restore' : ''}`;
+            const body = command.operation === 'create' ? { group_id: command.options.group, launch_profile: command.options['launch-profile'], cwd: command.options.cwd, idempotency_key: command.options['idempotency-key'] }
+                : command.operation === 'restore' ? { idempotency_key: command.options['idempotency-key'] } : undefined;
+            io.write(JSON.stringify(parsed(await request(socketPath, command.operation === 'get' ? 'GET' : 'POST', route, body, headers(credential)))));
+            return 0;
+        }
+        if (!['task', 'message', 'help'].includes(command.action) || command.action === 'message' && command.operation !== 'get')
+            throw new CollaborationError('INTEGRATION_OPERATION_DENIED', 'Command is not exposed to integration identities', 403);
+        return executeCollaborationCommand(command, {}, { ...io, request: async (method, endpoint, body, timeout) => {
+                const origin = { source: command.options.source, externalActor: command.options['external-actor'] ? JSON.parse(String(command.options['external-actor'])) : undefined,
+                    externalMessageId: command.options['external-message-id'], metadata: command.options.metadata ? JSON.parse(String(command.options.metadata)) : undefined };
+                return request(socketPath, method, endpoint.replace('/api/terminal/operations/orchestration', ''), body === undefined ? undefined : { ...body, origin }, headers(credential), timeout);
+            } });
+    }
+    catch (error) {
+        io.write(JSON.stringify({ ok: false, code: error instanceof CollaborationError ? error.code : 'INTEGRATION_CONNECTION_FAILED', error: error instanceof CollaborationError ? error.message : 'Local integration connection failed; credentials were not sent to a public service' }));
+        return 1;
+    }
+}
+async function subscribe(socketPath, route, credential, timeout, write) {
+    const deadline = timeout ? Date.now() + timeout : Infinity;
+    let backoff = 1000;
+    while (Date.now() < deadline) {
+        const outcome = await new Promise(resolve => {
+            let timer;
+            const req = http.request({ socketPath, method: 'GET', path: route, headers: headers(credential) }, res => {
+                res.setEncoding('utf8');
+                let pending = '', ended = false;
+                res.on('data', chunk => {
+                    pending += chunk;
+                    if (pending.length > 2 * 1024 * 1024) {
+                        ended = true;
+                        req.destroy();
+                        resolve('stop');
+                        return;
+                    }
+                    for (;;) {
+                        const newline = pending.indexOf('\n');
+                        if (newline < 0)
+                            break;
+                        const line = pending.slice(0, newline);
+                        pending = pending.slice(newline + 1);
+                        if (!line.trim())
+                            continue;
+                        let event;
+                        try {
+                            event = JSON.parse(line);
+                        }
+                        catch {
+                            write(JSON.stringify({ type: 'error', code: 'INVALID_EVENT_RESPONSE', retryable: false }));
+                            ended = true;
+                            req.destroy();
+                            resolve('stop');
+                            return;
+                        }
+                        write(line);
+                        if (event.type === 'error' && !event.retryable) {
+                            ended = true;
+                            req.destroy();
+                            resolve('stop');
+                        }
+                    }
+                });
+                res.once('end', () => {
+                    if ((res.statusCode ?? 500) >= 300 && pending) {
+                        try {
+                            const error = JSON.parse(pending);
+                            write(JSON.stringify(error));
+                        }
+                        catch {
+                            write(JSON.stringify({ type: 'error', code: 'INVALID_EVENT_RESPONSE', retryable: false }));
+                        }
+                        resolve((res.statusCode ?? 500) >= 500 ? 'retry' : 'stop');
+                    }
+                    else if (!ended)
+                        resolve('retry');
+                });
+                res.once('close', () => { if (!ended)
+                    resolve('retry'); });
+            });
+            req.once('error', () => resolve('retry'));
+            req.once('close', () => { if (timer)
+                clearTimeout(timer); });
+            if (Number.isFinite(deadline))
+                timer = setTimeout(() => { resolve('timeout'); req.destroy(); }, Math.max(1, deadline - Date.now()));
+            req.end();
+        });
+        if (outcome === 'stop')
+            return 1;
+        if (outcome === 'timeout')
+            return 0;
+        write(JSON.stringify({ type: 'connection', state: 'reconnecting', retry_in_ms: backoff }));
+        await new Promise(resolve => setTimeout(resolve, Math.min(backoff, Math.max(0, deadline - Date.now()))));
+        backoff = Math.min(backoff * 2, 30000);
+    }
+    return 0;
+}