termdock 1.4.295 → 1.4.296

package/dist/server/agent/collaborationTaskTypes.js

@@ -0,0 +1 @@
+export function taskMemberKey(member) { return `${member.serviceId}:${member.sessionId}`; }

package/dist/server/agent/collaborationTaskWorkspace.js

@@ -0,0 +1,100 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, readFile, writeFile, rename, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+const exec = promisify(execFile);
+const git = async (cwd, args) => (await exec('git', ['-C', cwd, ...args], {
+    timeout: 30_000, maxBuffer: 2 * 1024 * 1024,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_MERGE_AUTOEDIT: 'no' },
+})).stdout.trim();
+const home = path.join(os.homedir(), '.termdock', 'task-workspaces');
+/** Only committed code enters task worktrees; the user's checkout is never reset, cleaned or merged. */
+export async function prepareTaskWorkspace(task, sourceCwd, dependencies, importCommit) {
+    if (!/^[a-f0-9]{32}$/.test(task.id))
+        throw new Error('任务标识无效');
+    const generation = task.events.filter(e => e.kind === 'scheduled').at(-1)?.id;
+    if (!generation || !/^[a-f0-9]{32}$/.test(generation))
+        throw new Error('缺少执行目录准备记录');
+    const repository = await git(sourceCwd, ['rev-parse', '--show-toplevel']);
+    const rootId = task.workflow?.rootTaskId ?? task.id;
+    const goalDir = path.join(home, rootId);
+    await mkdir(goalDir, { recursive: true, mode: 0o700 });
+    // Pin a base per repository and goal. A moved user HEAD cannot change later tasks' starting point.
+    const { createHash } = await import('node:crypto');
+    const common = await realpath(path.resolve(repository, await git(repository, ['rev-parse', '--git-common-dir'])));
+    const baseFile = path.join(goalDir, `${createHash('sha256').update(common).digest('hex').slice(0, 16)}.base`);
+    let base;
+    try {
+        base = (await readFile(baseFile, 'utf8')).trim();
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        base = await git(repository, ['rev-parse', 'HEAD']);
+        try {
+            await writeFile(baseFile, base, { flag: 'wx', mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            base = (await readFile(baseFile, 'utf8')).trim();
+        }
+    }
+    if (!/^[a-f0-9]{40,64}$/.test(base))
+        throw new Error('目标基线无效');
+    const cwd = path.join(goalDir, `${task.id}-${generation.slice(0, 8)}`);
+    const branch = `termdock/task/${task.id}-${generation.slice(0, 8)}`;
+    try {
+        await readFile(path.join(cwd, '.git'), 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        await git(repository, ['worktree', 'add', '-b', branch, cwd, base]);
+    }
+    if (await git(cwd, ['rev-parse', '--show-toplevel']) !== cwd || await git(cwd, ['branch', '--show-current']) !== branch)
+        throw new Error('独立目录与任务分支不匹配，保留现场等待处理');
+    const readyFile = path.join(goalDir, `${task.id}-${generation.slice(0, 8)}.ready`);
+    let ready = false;
+    try {
+        ready = (await readFile(readyFile, 'utf8')) === generation;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    if (!ready) {
+        // A failed merge is deliberately left in this task's worktree for a member to resolve.
+        if (await git(cwd, ['status', '--porcelain']))
+            throw new Error(`依赖集成需要处理，现场保留在 ${cwd}；请协调者安排解决冲突后继续`);
+        for (const dependency of dependencies) {
+            const artifact = dependency.artifacts.find(a => a.id === dependency.acceptedArtifactId);
+            const commit = artifact?.evidence?.commit;
+            if (!commit || !/^[a-f0-9]{40,64}$/.test(commit))
+                throw new Error(`依赖「${dependency.title}」缺少已评审提交，请补充交付`);
+            try {
+                await git(cwd, ['cat-file', '-e', `${commit}^{commit}`]);
+            }
+            catch {
+                if (!importCommit)
+                    throw new Error(`依赖「${dependency.title}」的提交在此仓库不可用，请协调者先同步提交`);
+                await importCommit(dependency, cwd);
+                await git(cwd, ['cat-file', '-e', `${commit}^{commit}`]);
+            }
+            await git(cwd, ['-c', 'user.name=Termdock', '-c', 'user.email=tasks@termdock.local', 'merge', '--no-edit', commit]);
+        }
+        const temp = `${readyFile}.${process.pid}.tmp`;
+        await writeFile(temp, generation, { mode: 0o600 });
+        await rename(temp, readyFile);
+    }
+    return { cwd, repository, branch, base };
+}
+export async function captureTaskCommit(workspace) {
+    if (!(await realpath(workspace.cwd)).startsWith(`${await realpath(home)}${path.sep}`) || await git(workspace.cwd, ['branch', '--show-current']) !== workspace.branch)
+        throw new Error('交付目录与任务分支不匹配');
+    if (await git(workspace.cwd, ['status', '--porcelain']))
+        throw new Error('独立目录还有未提交改动，请先提交再报告完成；不会自动暂存或提交');
+    const commit = await git(workspace.cwd, ['rev-parse', 'HEAD']);
+    return { commit, branch: workspace.branch, cwd: workspace.cwd, base: workspace.base };
+}

package/dist/server/entry.js

@@ -1,7 +1,8 @@
 import { CollaborationService } from './agent/collaborationService.js';
 import { X509Certificate } from 'node:crypto';
 import { CollaborationPeerTransport, connectCollaborationRpc } from './agent/collaborationPeerTransport.js';
-import { collaborationStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions } from './routes/terminal.js';
+import { collaborationStore, collaborationTaskStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions, prepareCollaborationTaskWorker } from './routes/terminal.js';
+import { CollaborationTaskService } from './agent/collaborationTaskService.js';
 import { setPushTargetPeerId } from './notifications/pushService.js';
 import { desktopDirectTargets } from './federation/desktopTargets.js';
 import { createOpenAccessRouter } from './federation/openAccess.js';
@@ -616,11 +617,20 @@ export function startServer(options = {}) {
         collaborationService = new CollaborationService({ file: path.join(homedir(), '.termdock', 'federation', 'collaboration-services.json'),
             store: collaborationStore, transport: collaborationTransport, node: () => app.locals.collaborationNode,
             sessions: collaborationDirectorySessions, reverse: reverseCollaboration, connect: connectPeer,
+            tasks: {
+                receive: (peer, packet) => app.locals.collaborationTasks.receive(peer, packet),
+                heads: ids => app.locals.collaborationTasks?.heads(ids) ?? [],
+                sync: (peer, heads) => app.locals.collaborationTasks.sync(peer, heads),
+            },
             deviceScope: device => runtime.store.listEffective({ subjectId: device, serviceId: runtime.serviceId })
                 .filter(grant => grant.scope.kind === 'sessions' && grant.actions.includes('session.input'))
                 .flatMap(grant => grant.scope.kind === 'sessions' ? grant.scope.sessionIds : []),
             pairConnect: peer => connectCollaborationRpc(runtime.identity, peer) });
         app.locals.collaborationService = collaborationService;
+        const collaborationTasks = new CollaborationTaskService(collaborationTaskStore, collaborationStore, collaborationService, deliverPeerCollaboration, (task, template, dependencies) => prepareCollaborationTaskWorker(task, template, dependencies, collaborationService, (taskId, dependencyId, offset) => collaborationTasks.dependencyChunk(taskId, dependencyId, offset)));
+        app.locals.collaborationTasks = collaborationTasks;
+        collaborationTasks.start();
+        server.once('close', () => collaborationTasks.close());
         collaborationService.start();
         server.once('close', () => collaborationService?.close());
         collaborationTransport.start();

package/dist/server/federation/runtime.js

@@ -297,7 +297,12 @@ export async function createFederationRuntime(app, directory, handlers, options
                     else if (packet.type === 'collaboration-service') {
                         if (!options.collaborationService)
                             throw new Error('COLLABORATION_UPGRADE_REQUIRED');
-                        send({ type: 'result', id: packet.id, ...options.collaborationService(subjectId, packet) });
+                        // Task preparation may use the same channel for a directory request; do not block its reader.
+                        void Promise.resolve(options.collaborationService(subjectId, packet)).then(result => send({ type: 'result', id: packet.id, ...result }))
+                            .catch(error => { try {
+                            send({ type: 'error', id: packet.id, error: error instanceof Error ? error.message : 'REQUEST_FAILED' });
+                        }
+                        catch { /* Connection closed. */ } });
                     }
                     else if (packet.type === 'collaboration-scoped-peer') {
                         if (!options.registerScopedCollaborationPeer)

package/dist/server/routes/terminal.js

@@ -69,10 +69,15 @@ import { TermdockAutoUpdateManager } from '../utils/autoUpdate.js';
 import { AUTO_TITLE_LONG_RUNNING_DELAY_MS, AUTO_TITLE_MIN_CONTEXT_CHARS, cleanTerminalContext, generateAgentTitle, hasSubstantiveAutoTitleContext, isLongRunningAutoTitleTurnEligible, isNewAgentSessionId, isAutoTitleReevaluationDue, shouldReplaceAutoTitle, } from '../agent/autoTitle.js';
 import { getTitleNamerCatalog, invalidateTitleNamerCatalog, probePluginTitleNamer } from '../agent/titleNamerCatalog.js';
 import { RenderedTerminalContext } from '../agent/renderedTerminalContext.js';
+import { CollaborationTaskStore } from '../agent/collaborationTaskStore.js';
+import { collaborationTaskRoutes } from '../agent/collaborationTaskRoutes.js';
+import { prepareTaskWorkspace } from '../agent/collaborationTaskWorkspace.js';
+import { importTaskDependency } from '../agent/collaborationTaskBundles.js';
 const router = express.Router();
 const execFileAsync = promisify(execFile);
 const TERMDOCK_DIR = `${os.homedir()}/.termdock`;
 const automationStore = new AutomationStore(`${TERMDOCK_DIR}/automations.json`);
+export const collaborationTaskStore = new CollaborationTaskStore(`${TERMDOCK_DIR}/collaboration-tasks.json`);
 export const collaborationStore = new CollaborationStore(`${TERMDOCK_DIR}/collaboration-groups.json`);
 const collaborationRouting = new CollaborationRoutingStore(`${TERMDOCK_DIR}/collaboration-routing.json`);
 const collaborationDeliveryWorker = new CollaborationDeliveryWorker({
@@ -1387,10 +1392,13 @@ function orchestrationSessionSnapshot(record) {
     const backendId = binding?.backendSessionId ?? record.backendSessionId;
     const backend = backendId ? terminalSessions.get(backendId) : null;
     const route = collaborationDeliveryWorker.state(record.sessionId);
+    // A live terminal backend is observable even before the delivery worker has
+    // inspected this session. It does not prove a pinned Agent target is writable.
+    const terminalConnected = Boolean(backend);
     const slug = binding?.pane?.agentSlug ?? binding?.agentSlug ?? record.agentResume?.slug;
     const agent = slug ? agentBySlug(slug) : backend?.agent;
     return {
-        ...collaborationStore.sessionFacts(record.sessionId, route.state === 'ready'),
+        ...collaborationStore.sessionFacts(record.sessionId, terminalConnected || route.state === 'ready' || route.state === 'shell'),
         last_terminal_output_at: backend?.lastOutputAt || null,
         activity_observed_at: backend ? Date.now() : null,
         activity_source: backend ? 'terminal_output' : 'unavailable',
@@ -1404,7 +1412,7 @@ function orchestrationSessionSnapshot(record) {
         name: record.name,
         cwd: backend?.cwd ?? record.cwd ?? '',
         agent: agent ? { slug: agent.slug, displayName: agent.displayName } : null,
-        status: route.state,
+        status: route.state === 'unchecked' && terminalConnected ? 'terminal-connected' : route.state,
         capability: agent
             ? [agent.displayName, ...(agent.capabilities ?? []), backend?.activeProgram?.command || record.activeProgram || 'Agent 会话'].join(' · ')
             : (backend?.activeProgram?.command || record.activeProgram || 'Shell 终端'),
@@ -1779,6 +1787,60 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     }, 300).unref?.();
     return { group: updatedGroup, session: orchestrationSessionSnapshot(globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId)) };
 }
+const preparingTaskWorkers = new Map();
+/** Dedicated persistent terminals leave existing member sessions and the user's checkout untouched. */
+export function prepareCollaborationTaskWorker(task, template, dependencies, service, readDependency) {
+    const key = `${task.id}:${task.events.filter(e => e.kind === 'scheduled').at(-1)?.id}`;
+    const pending = preparingTaskWorkers.get(key);
+    if (pending)
+        return pending;
+    const operation = (async () => {
+        const source = globalSessionState.sessions.find(s => s.sessionId === template.sessionId);
+        if (!source || template.serviceId !== service.descriptor().serviceId)
+            throw new Error('执行成员当前不可用，请协调者重新分派');
+        const snapshot = orchestrationSessionSnapshot(source);
+        const slug = snapshot.agent?.slug ?? source.agentResume?.slug;
+        const launcher = (await listDetectedAgentLaunchers()).find(a => a.slug === slug);
+        if (!launcher || !source.cwd)
+            throw new Error('独立代码任务需要有项目目录的 Agent 成员，请选择可用成员');
+        const workspace = await prepareTaskWorkspace(task, source.cwd, dependencies, (dependency, repository) => importTaskDependency(task, dependency, repository, service, readDependency));
+        await pathValidator.allowSessionCwd(workspace.cwd);
+        const existing = globalSessionState.sessions.find(s => s.cwd === workspace.cwd);
+        const req = {};
+        const opened = await openInventorySession(req, { preferredFrontendSessionId: existing?.sessionId,
+            name: `执行 ${task.title.slice(0, 70)}`, customName: true, mode: 'tmux', cwd: workspace.cwd });
+        const record = globalSessionState.sessions.find(s => s.sessionId === opened.session.sessionId);
+        const backend = terminalSessions.get(opened.terminalSession.sessionId);
+        if (!backend)
+            throw new Error('独立执行终端创建失败，目录已保留');
+        const currentAgent = orchestrationSessionSnapshot(record).agent;
+        const launchFile = path.join(path.dirname(workspace.cwd), `${path.basename(workspace.cwd)}.worker.json`);
+        let launch = null;
+        try {
+            launch = JSON.parse(await fs.promises.readFile(launchFile, 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (!currentAgent && (!launch || launch.backendId !== opened.terminalSession.sessionId)) {
+            // Persist before typing: a retry must never type the launcher into a newly booted Agent's prompt.
+            const temporary = `${launchFile}.${process.pid}.tmp`;
+            await fs.promises.writeFile(temporary, JSON.stringify({ sessionId: record.sessionId, backendId: opened.terminalSession.sessionId }), { mode: 0o600 });
+            await fs.promises.rename(temporary, launchFile);
+            writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: launcher.command })}\r`);
+        }
+        const group = collaborationStore.getGroup(task.groupId);
+        if (!group || group.deleted)
+            throw new Error('协作组已删除，执行目录已保留');
+        if (!group.sessionIds.includes(record.sessionId))
+            await service.save({ id: group.id, name: group.name,
+                sessionIds: [...group.sessionIds, record.sessionId], expectedUpdatedAt: group.updatedAt });
+        return { sessionId: record.sessionId, workspace };
+    })().finally(() => preparingTaskWorkers.delete(key));
+    preparingTaskWorkers.set(key, operation);
+    return operation;
+}
 function getTmuxBinary() {
     if (process.env.TMUX_BIN)
         return process.env.TMUX_BIN;
@@ -5631,6 +5693,8 @@ export function collaborationLocalActivity() {
     });
 }
 export function deliverPeerCollaboration(sessionId) { void tryDeliverCollaborationInbox(sessionId); }
+router.use('/operations/collaboration-tasks', collaborationTaskRoutes({ agent: false, store: collaborationStore, resolveSession: resolveFrontendSessionId }));
+router.use('/operations/orchestration/tasks', collaborationTaskRoutes({ agent: true, store: collaborationStore, resolveSession: resolveFrontendSessionId }));
 router.use('/operations', collaborationGroupRoutes({ store: collaborationStore,
     sessions: () => globalSessionState.sessions.map(orchestrationSessionSnapshot),
     save: (req, input) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.295",
+  "version": "1.4.296",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.295",
+  "version": "1.4.296",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-+FK03eSUIISxxpGNQTlYLuAcpuytFuT+tiLAMYVhwl4=",
-  "serverBundleHash": "sha256-iYtS9ldvYzDUfLm6SANDq/7AB44OIdxy6W8a0qifjnA=",
-  "clientBundleHash": "sha256-0e7BcPx6z10Icj/9eD88DchjikmrZqCXJ+wgQ8d7lkw=",
+  "serverBundleHash": "sha256-Pey0kqNnGCviQazz2xMk+31zDfktp4wJFI/DN3CSzlc=",
+  "clientBundleHash": "sha256-xcl62Qc4opdlNYlyLKM+cu84NJTYyVxT/ezTJbkE9Ic=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }