agent-tower 0.4.15 → 0.4.16-beta.3

package/dist/services/workspace.service.js

@@ -1,21 +1,75 @@
 import { prisma } from '../utils/index.js';
 import { WorkspaceStatus, TaskStatus, SessionStatus, SessionPurpose } from '../types/index.js';
 import { WorktreeManager } from '../git/worktree.manager.js';
-import { execGit } from '../git/git-cli.js';
+import { execGit, MergeConflictError } from '../git/git-cli.js';
 import { NotFoundError, ServiceError } from '../errors.js';
 import { getSessionManager, getEventBus } from '../core/container.js';
 import { copyProjectFiles } from './copy-files.service.js';
+import { defaultTeamLockService } from './team-lock.service.js';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
+import { randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import { ensureProjectIsMutable } from './project-guards.js';
 const DEFAULT_IDLE_THRESHOLD_HOURS = 24;
+const WORKSPACE_READY_RETRY_COUNT = 20;
+const WORKSPACE_READY_RETRY_DELAY_MS = 50;
 const execAsync = promisify(exec);
 /** 过滤条件：只返回用户可见的 CHAT session */
 const visibleSessionsFilter = { where: { purpose: { not: SessionPurpose.COMMIT_MSG } } };
+const activeSessionStatuses = [SessionStatus.PENDING, SessionStatus.RUNNING];
+const finalChildWorkspaceStatuses = [WorkspaceStatus.MERGED, WorkspaceStatus.ABANDONED];
+function normalizeCreateOptions(input) {
+    if (typeof input === 'string') {
+        return {
+            branchName: input,
+            branchNamePrefix: '',
+            startPoint: null,
+            parentWorkspaceId: null,
+            ownerMemberId: null,
+            reuseInactive: true,
+        };
+    }
+    return {
+        branchName: input?.branchName ?? '',
+        branchNamePrefix: input?.branchNamePrefix ?? '',
+        startPoint: input?.startPoint ?? null,
+        parentWorkspaceId: input?.parentWorkspaceId ?? null,
+        ownerMemberId: input?.ownerMemberId ?? null,
+        reuseInactive: input?.reuseInactive ?? true,
+    };
+}
+function isUniqueConstraintError(error) {
+    return typeof error === 'object'
+        && error !== null
+        && 'code' in error
+        && error.code === 'P2002';
+}
+function branchFromOptions(workspaceId, options) {
+    if (options.branchName) {
+        return options.branchName;
+    }
+    if (options.branchNamePrefix) {
+        return `${options.branchNamePrefix}/${workspaceId.slice(0, 8)}`;
+    }
+    return `at/${workspaceId.slice(0, 8)}`;
+}
+function teamRunBranchPrefix(teamRunId) {
+    return `at/team/${teamRunId.slice(0, 8)}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 export class WorkspaceService {
+    lockService;
+    static mainWorkspaceClaims = new Map();
+    static dedicatedWorkspaceClaims = new Map();
     sessionService = getSessionManager();
     eventBus = getEventBus();
+    constructor(lockService = defaultTeamLockService) {
+        this.lockService = lockService;
+    }
     getBaseBranch(workspace) {
         return workspace.baseBranch || workspace.task.project.mainBranch;
     }
@@ -50,7 +104,8 @@ export class WorkspaceService {
      * - 创建后自动将关联 Task 状态改为 IN_PROGRESS
      * - 失败时回滚已创建的数据库记录
      */
-    async create(taskId, branchName) {
+    async create(taskId, branchNameOrOptions) {
+        const options = normalizeCreateOptions(branchNameOrOptions);
         const task = await prisma.task.findUnique({
             where: { id: taskId },
             include: { project: true },
@@ -61,34 +116,29 @@ export class WorkspaceService {
         ensureProjectIsMutable(task.project, 'create workspaces');
         const worktreeManager = new WorktreeManager(task.project.repoPath);
         // 查找可复用的 MERGED 或 HIBERNATED workspace
-        if (!branchName) {
+        if (!options.branchName && options.reuseInactive) {
             const reusableWorkspace = await prisma.workspace.findFirst({
                 where: {
                     taskId,
+                    parentWorkspaceId: options.parentWorkspaceId,
+                    ownerMemberId: options.ownerMemberId,
                     status: { in: [WorkspaceStatus.MERGED, WorkspaceStatus.HIBERNATED] },
                 },
                 orderBy: { updatedAt: 'desc' },
             });
             if (reusableWorkspace) {
-                const worktreePath = await worktreeManager.ensureWorktreeExists(reusableWorkspace.branchName);
-                this.runCopyFiles(task.project.repoPath, worktreePath, task.project.copyFiles);
-                this.fireSetupScript(reusableWorkspace.id, taskId, worktreePath, task.project.setupScript);
-                const updated = await prisma.workspace.update({
-                    where: { id: reusableWorkspace.id },
-                    data: {
-                        status: WorkspaceStatus.ACTIVE,
-                        worktreePath,
-                        hibernatedAt: null,
-                    },
-                    include: { sessions: true, task: { include: { project: true } } },
+                return this.restoreInactiveWorkspace({
+                    ...reusableWorkspace,
+                    task: { ...task, project: task.project },
                 });
-                return updated;
             }
         }
         // 先在数据库创建记录以获取 ID（用于生成默认分支名）
         const workspace = await prisma.workspace.create({
             data: {
                 taskId,
+                parentWorkspaceId: options.parentWorkspaceId,
+                ownerMemberId: options.ownerMemberId,
                 branchName: '', // 占位，稍后更新
                 worktreePath: '', // 占位，稍后更新
                 status: WorkspaceStatus.ACTIVE,
@@ -96,18 +146,21 @@ export class WorkspaceService {
         });
         try {
             // 生成分支名：用户指定 or 自动生成 at/{shortId}
-            const branch = branchName || `at/${workspace.id.slice(0, 8)}`;
+            const branch = branchFromOptions(workspace.id, options);
             // 空仓库（无任何 commit）无法创建 worktree，提前报错
-            let baseBranch = null;
-            try {
-                const currentBranch = (await execGit(task.project.repoPath, ['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
-                baseBranch = currentBranch && currentBranch !== 'HEAD' ? currentBranch : null;
-            }
-            catch {
-                throw new Error('仓库尚无任何提交记录，无法创建 Workspace。请重新编辑项目以触发自动初始化，或手动执行 git commit。');
+            const startPoint = options.startPoint || null;
+            let baseBranch = startPoint;
+            if (!startPoint) {
+                try {
+                    const currentBranch = (await execGit(task.project.repoPath, ['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+                    baseBranch = currentBranch && currentBranch !== 'HEAD' ? currentBranch : null;
+                }
+                catch {
+                    throw new Error('仓库尚无任何提交记录，无法创建 Workspace。请重新编辑项目以触发自动初始化，或手动执行 git commit。');
+                }
             }
             // WorktreeManager.create 内部已做分支名合法性校验和重复检查
-            const worktreePath = await worktreeManager.create(branch);
+            const worktreePath = await worktreeManager.create(branch, startPoint ?? undefined);
             // worktree 创建后：复制文件 + 异步执行 setup 脚本（fire-and-forget）
             this.runCopyFiles(task.project.repoPath, worktreePath, task.project.copyFiles);
             this.fireSetupScript(workspace.id, taskId, worktreePath, task.project.setupScript);
@@ -127,6 +180,201 @@ export class WorkspaceService {
             throw err;
         }
     }
+    async getOrCreateMainWorkspace(teamRunId) {
+        const existingClaim = WorkspaceService.mainWorkspaceClaims.get(teamRunId);
+        if (existingClaim) {
+            return existingClaim;
+        }
+        const claim = this.findOrCreateMainWorkspace(teamRunId);
+        WorkspaceService.mainWorkspaceClaims.set(teamRunId, claim);
+        try {
+            return await claim;
+        }
+        finally {
+            if (WorkspaceService.mainWorkspaceClaims.get(teamRunId) === claim) {
+                WorkspaceService.mainWorkspaceClaims.delete(teamRunId);
+            }
+        }
+    }
+    async getOrCreateDedicatedWorkspace(teamRunId, memberId) {
+        const mainWorkspace = await this.getOrCreateMainWorkspace(teamRunId);
+        const claimKey = `${mainWorkspace.id}:${memberId}`;
+        const existingClaim = WorkspaceService.dedicatedWorkspaceClaims.get(claimKey);
+        if (existingClaim) {
+            return existingClaim;
+        }
+        const claim = this.findOrCreateDedicatedWorkspace(teamRunId, memberId, mainWorkspace);
+        WorkspaceService.dedicatedWorkspaceClaims.set(claimKey, claim);
+        try {
+            return await claim;
+        }
+        finally {
+            if (WorkspaceService.dedicatedWorkspaceClaims.get(claimKey) === claim) {
+                WorkspaceService.dedicatedWorkspaceClaims.delete(claimKey);
+            }
+        }
+    }
+    async findOrCreateMainWorkspace(teamRunId) {
+        const teamRun = await prisma.teamRun.findUnique({
+            where: { id: teamRunId },
+            include: {
+                task: { include: { project: true } },
+                mainWorkspace: { include: { task: { include: { project: true } } } },
+            },
+        });
+        if (!teamRun) {
+            throw new NotFoundError('TeamRun', teamRunId);
+        }
+        ensureProjectIsMutable(teamRun.task.project, 'create workspaces');
+        if (teamRun.mainWorkspace
+            && teamRun.mainWorkspace.taskId === teamRun.taskId
+            && teamRun.mainWorkspace.parentWorkspaceId == null
+            && teamRun.mainWorkspace.ownerMemberId == null
+            && teamRun.mainWorkspace.status === WorkspaceStatus.ACTIVE) {
+            return this.ensureActiveWorkspaceWorktree(teamRun.mainWorkspace);
+        }
+        const activeRoot = await prisma.workspace.findFirst({
+            where: {
+                taskId: teamRun.taskId,
+                parentWorkspaceId: null,
+                ownerMemberId: null,
+                status: WorkspaceStatus.ACTIVE,
+            },
+            orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
+            include: { task: { include: { project: true } } },
+        });
+        if (activeRoot) {
+            await prisma.teamRun.update({
+                where: { id: teamRun.id },
+                data: { mainWorkspaceId: activeRoot.id },
+            });
+            return this.ensureActiveWorkspaceWorktree(activeRoot);
+        }
+        const workspace = await this.create(teamRun.taskId, {
+            branchNamePrefix: `${teamRunBranchPrefix(teamRun.id)}/main`,
+            parentWorkspaceId: null,
+            ownerMemberId: null,
+            reuseInactive: false,
+        });
+        await prisma.teamRun.update({
+            where: { id: teamRun.id },
+            data: { mainWorkspaceId: workspace.id },
+        });
+        return workspace;
+    }
+    async findOrCreateDedicatedWorkspace(teamRunId, memberId, mainWorkspace) {
+        const teamRun = await prisma.teamRun.findUnique({
+            where: { id: teamRunId },
+            include: { task: { include: { project: true } } },
+        });
+        if (!teamRun) {
+            throw new NotFoundError('TeamRun', teamRunId);
+        }
+        const member = await prisma.teamMember.findFirst({
+            where: { id: memberId, teamRunId },
+            select: { id: true },
+        });
+        if (!member) {
+            throw new NotFoundError('TeamMember', memberId);
+        }
+        ensureProjectIsMutable(teamRun.task.project, 'create workspaces');
+        const existing = await this.findDedicatedWorkspace(mainWorkspace.id, memberId);
+        if (existing) {
+            return this.activateDedicatedWorkspace(existing);
+        }
+        try {
+            return await this.create(teamRun.taskId, {
+                branchNamePrefix: `${teamRunBranchPrefix(teamRun.id)}/member-${memberId.slice(0, 8)}`,
+                startPoint: mainWorkspace.branchName,
+                parentWorkspaceId: mainWorkspace.id,
+                ownerMemberId: memberId,
+                reuseInactive: false,
+            });
+        }
+        catch (error) {
+            if (!isUniqueConstraintError(error)) {
+                throw error;
+            }
+            const raced = await this.findDedicatedWorkspace(mainWorkspace.id, memberId);
+            if (!raced) {
+                throw error;
+            }
+            return this.activateDedicatedWorkspace(await this.waitForWorkspaceReady(raced));
+        }
+    }
+    async findDedicatedWorkspace(mainWorkspaceId, memberId) {
+        return prisma.workspace.findFirst({
+            where: {
+                parentWorkspaceId: mainWorkspaceId,
+                ownerMemberId: memberId,
+            },
+            include: { task: { include: { project: true } } },
+        });
+    }
+    async activateDedicatedWorkspace(workspace) {
+        if (!workspace.branchName) {
+            workspace = await this.waitForWorkspaceReady(workspace);
+        }
+        if (workspace.status === WorkspaceStatus.ACTIVE) {
+            return this.ensureActiveWorkspaceWorktree(workspace);
+        }
+        if (workspace.status === WorkspaceStatus.HIBERNATED) {
+            return this.restoreInactiveWorkspace(workspace);
+        }
+        throw new ServiceError(`Cannot reuse dedicated workspace in ${workspace.status} status`, 'DEDICATED_WORKSPACE_UNAVAILABLE', 409);
+    }
+    async waitForWorkspaceReady(workspace) {
+        if (workspace.branchName) {
+            return workspace;
+        }
+        for (let attempt = 0; attempt < WORKSPACE_READY_RETRY_COUNT; attempt++) {
+            await sleep(WORKSPACE_READY_RETRY_DELAY_MS);
+            const reloaded = await prisma.workspace.findUnique({
+                where: { id: workspace.id },
+                include: { task: { include: { project: true } } },
+            });
+            if (!reloaded) {
+                break;
+            }
+            if (reloaded.branchName) {
+                return reloaded;
+            }
+        }
+        throw new ServiceError(`Workspace ${workspace.id} is still initializing`, 'WORKSPACE_INITIALIZING', 409);
+    }
+    async ensureActiveWorkspaceWorktree(workspace) {
+        if (!workspace.branchName) {
+            workspace = await this.waitForWorkspaceReady(workspace);
+        }
+        if (workspace.worktreePath) {
+            const gitFileExists = await fs
+                .access(path.join(workspace.worktreePath, '.git'))
+                .then(() => true)
+                .catch(() => false);
+            if (gitFileExists) {
+                return prisma.workspace.findUniqueOrThrow({
+                    where: { id: workspace.id },
+                    include: { sessions: visibleSessionsFilter, task: { include: { project: true } } },
+                });
+            }
+        }
+        return this.restoreInactiveWorkspace(workspace);
+    }
+    async restoreInactiveWorkspace(workspace) {
+        const worktreeManager = new WorktreeManager(workspace.task.project.repoPath);
+        const worktreePath = await worktreeManager.ensureWorktreeExists(workspace.branchName);
+        this.runCopyFiles(workspace.task.project.repoPath, worktreePath, workspace.task.project.copyFiles);
+        this.fireSetupScript(workspace.id, workspace.taskId, worktreePath, workspace.task.project.setupScript);
+        return prisma.workspace.update({
+            where: { id: workspace.id },
+            data: {
+                status: WorkspaceStatus.ACTIVE,
+                worktreePath,
+                hibernatedAt: null,
+            },
+            include: { sessions: visibleSessionsFilter, task: { include: { project: true } } },
+        });
+    }
     // ── Delete ───────────────────────────────────────────────────────────────────
     /**
      * 删除 Workspace
@@ -229,57 +477,150 @@ export class WorkspaceService {
         const worktreeManager = new WorktreeManager(workspace.task.project.repoPath);
         await worktreeManager.abortOperation(workspace.worktreePath);
     }
-    // ── Merge (squash) ──────────────────────────────────────────────────────────
-    /**
-     * 合并 Workspace 到主分支（squash merge）
-     *
-     * @param commitMessage - 可选的自定义 commit message
-     * @returns squash commit 的 SHA
-     */
-    async merge(id, commitMessage) {
-        const totalStart = performance.now();
-        const step = (label, start) => console.log(`[WorkspaceService.merge] ${label}: ${(performance.now() - start).toFixed(0)}ms`);
-        let t = performance.now();
+    async merge(id, commitMessageOrOptions) {
+        const options = typeof commitMessageOrOptions === 'string'
+            ? { commitMessage: commitMessageOrOptions }
+            : (commitMessageOrOptions ?? {});
         const workspace = await prisma.workspace.findUnique({
             where: { id },
-            include: { task: { include: { project: true } } },
+            include: { task: { include: { project: true, teamRun: true } } },
         });
-        step('db findUnique', t);
         if (!workspace) {
             throw new NotFoundError('Workspace', id);
         }
         ensureProjectIsMutable(workspace.task.project, 'merge workspaces');
-        // 优先使用传入的 commitMessage，其次使用 AI 生成的缓存
-        const message = commitMessage || workspace.commitMessage || undefined;
-        t = performance.now();
+        return this.withProjectMergeLock(workspace.task.projectId, options.lockOwnerId, () => this.mergeWithLock(workspace, options.commitMessage));
+    }
+    async mergeWithLock(workspace, commitMessage) {
+        if (workspace.status !== WorkspaceStatus.ACTIVE) {
+            throw new ServiceError(`Cannot merge workspace in ${workspace.status} status`, 'INVALID_WORKSPACE_STATE', 400);
+        }
+        if (workspace.parentWorkspaceId) {
+            return this.mergeChildIntoParent(workspace, commitMessage);
+        }
+        return this.mergeRootWorkspaceToMain(workspace, commitMessage);
+    }
+    async mergeChildIntoParent(workspace, commitMessage) {
+        const parentWorkspace = await prisma.workspace.findUnique({
+            where: { id: workspace.parentWorkspaceId ?? '' },
+            include: { task: { include: { project: true } } },
+        });
+        if (!parentWorkspace) {
+            throw new NotFoundError('Workspace', workspace.parentWorkspaceId ?? '');
+        }
+        if (parentWorkspace.taskId !== workspace.taskId || parentWorkspace.ownerMemberId != null) {
+            throw new ServiceError('Dedicated child workspace parent is not a valid TeamRun main workspace', 'INVALID_PARENT_WORKSPACE', 400);
+        }
+        if (parentWorkspace.status !== WorkspaceStatus.ACTIVE) {
+            throw new ServiceError(`Cannot merge into parent workspace in ${parentWorkspace.status} status`, 'INVALID_PARENT_WORKSPACE_STATE', 409);
+        }
+        await this.assertNoActiveWriteSessions(parentWorkspace.id);
+        const worktreeManager = new WorktreeManager(workspace.task.project.repoPath);
+        let sha;
+        try {
+            ({ sha } = await worktreeManager.mergeIntoWorktree(workspace.worktreePath, parentWorkspace.worktreePath, { commitMessage: commitMessage || workspace.commitMessage || undefined }));
+        }
+        catch (error) {
+            if (error instanceof MergeConflictError) {
+                error.sourceWorkspaceId = workspace.id;
+                error.targetWorkspaceId = parentWorkspace.id;
+                error.sourceWorktreePath ??= workspace.worktreePath;
+                error.targetWorktreePath ??= parentWorkspace.worktreePath;
+                error.sourceBranch ??= workspace.branchName;
+                error.targetBranch ??= parentWorkspace.branchName;
+            }
+            throw error;
+        }
+        await prisma.workspace.update({
+            where: { id: workspace.id },
+            data: { status: WorkspaceStatus.MERGED },
+        });
+        return sha;
+    }
+    async mergeRootWorkspaceToMain(workspace, commitMessage) {
+        await this.assertTeamRunFinalMergeAllowed(workspace);
         const worktreeManager = new WorktreeManager(workspace.task.project.repoPath);
-        const { sha } = await worktreeManager.merge(workspace.worktreePath, this.getBaseBranch(workspace), message ? { commitMessage: message } : undefined);
-        step('worktreeManager.merge', t);
-        // 更新 workspace：标记 MERGED，保留 worktreePath 供 cleanup() 后续清理物理目录
-        t = performance.now();
+        let sha;
+        const targetBranch = this.getBaseBranch(workspace);
+        try {
+            ({ sha } = await worktreeManager.merge(workspace.worktreePath, targetBranch, { commitMessage: commitMessage || workspace.commitMessage || undefined }));
+        }
+        catch (error) {
+            if (error instanceof MergeConflictError) {
+                error.sourceWorkspaceId = workspace.id;
+                error.sourceWorktreePath ??= workspace.worktreePath;
+                error.sourceBranch ??= workspace.branchName;
+                error.targetBranch ??= targetBranch;
+            }
+            throw error;
+        }
         await prisma.workspace.update({
-            where: { id },
+            where: { id: workspace.id },
             data: { status: WorkspaceStatus.MERGED },
         });
-        step('db update workspace', t);
-        // Task 推进到 DONE
         const advanceableStatuses = [TaskStatus.IN_PROGRESS, TaskStatus.IN_REVIEW];
         if (advanceableStatuses.includes(workspace.task.status)) {
-            t = performance.now();
             await prisma.task.update({
                 where: { id: workspace.task.id },
                 data: { status: TaskStatus.DONE },
             });
-            step('db update task', t);
             this.eventBus.emit('task:updated', {
                 taskId: workspace.task.id,
                 projectId: workspace.task.projectId,
                 status: TaskStatus.DONE,
             });
         }
-        console.log(`[WorkspaceService.merge] TOTAL: ${(performance.now() - totalStart).toFixed(0)}ms`);
         return sha;
     }
+    async assertTeamRunFinalMergeAllowed(workspace) {
+        const teamRun = workspace.task.teamRun;
+        if (!teamRun) {
+            return;
+        }
+        if (teamRun.mainWorkspaceId !== workspace.id) {
+            throw new ServiceError('Only the bound TeamRun main workspace can be merged into the project main branch', 'TEAM_RUN_NON_MAIN_WORKSPACE_FINAL_MERGE_FORBIDDEN', 409);
+        }
+        const blockingChildren = await prisma.workspace.findMany({
+            where: {
+                parentWorkspaceId: workspace.id,
+                status: { notIn: finalChildWorkspaceStatuses },
+            },
+            select: { id: true, status: true },
+            orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
+        });
+        if (blockingChildren.length > 0) {
+            throw new ServiceError('Cannot merge TeamRun main workspace before all dedicated child workspaces are merged or abandoned', 'TEAM_RUN_CHILD_WORKSPACES_NOT_FINAL', 409);
+        }
+    }
+    async assertNoActiveWriteSessions(workspaceId) {
+        const activeSession = await prisma.session.findFirst({
+            where: {
+                workspaceId,
+                status: { in: activeSessionStatuses },
+                purpose: SessionPurpose.CHAT,
+            },
+            select: { id: true },
+        });
+        if (activeSession) {
+            throw new ServiceError('Cannot merge into parent workspace while it has an active write session', 'PARENT_WORKSPACE_HAS_ACTIVE_SESSION', 409);
+        }
+    }
+    async withProjectMergeLock(projectId, requestedOwnerId, fn) {
+        const lockKey = `project:${projectId}:merge`;
+        const ownerId = requestedOwnerId ?? `workspace-merge:${randomUUID()}`;
+        const alreadyHeldByOwner = this.lockService.isHeldBy(ownerId, lockKey);
+        if (!alreadyHeldByOwner && !this.lockService.acquire(ownerId, [lockKey])) {
+            throw new ServiceError('Another workspace merge is already running for this project', 'PROJECT_MERGE_LOCKED', 409);
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            if (!alreadyHeldByOwner) {
+                this.lockService.release(ownerId, [lockKey]);
+            }
+        }
+    }
     // ── Archive ──────────────────────────────────────────────────────────────────
     /**
      * 归档 Workspace（标记状态为 ABANDONED）
@@ -475,7 +816,11 @@ export class WorkspaceService {
                 const worktreeManager = new WorktreeManager(workspace.task.project.repoPath);
                 // 清理残留 worktree（如果还存在）
                 if (workspace.worktreePath) {
-                    await worktreeManager.remove(workspace.worktreePath);
+                    const removeResult = await worktreeManager.remove(workspace.worktreePath);
+                    if (removeResult.status === 'unregistered') {
+                        console.warn(`[WorkspaceService] cleanup: workspace ${workspace.id} path is unregistered or unsafe to remove: ${removeResult.path}`);
+                        continue;
+                    }
                 }
                 // Task 已 DONE，branch 不再需要，删除
                 if (workspace.branchName) {