@yancyyu/openhermit 1.6.41 → 1.6.43

package/src/main/services/teams-mvp/TaskDispatchService.test.ts

@@ -0,0 +1,305 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { TaskDispatchService } from './TaskDispatchService';
+
+import type { CollabTask, CollabTaskStatus, DispatchMeta } from '@shared/types/team';
+import type { Task, TaskStatus, TeamManifest, TeamWorkspaceService } from './TeamWorkspaceService';
+import type { CollaborationBoardService } from './CollaborationBoardService';
+
+class FakeCollabBoard {
+  tasks = new Map<string, CollabTask>();
+
+  addTask(task: CollabTask): CollabTask {
+    if (this.tasks.has(task.dispatchId)) return this.tasks.get(task.dispatchId)!;
+    this.tasks.set(task.dispatchId, { ...task, version: task.version ?? 1 });
+    return this.tasks.get(task.dispatchId)!;
+  }
+
+  getTask(dispatchId: string): CollabTask | undefined {
+    return this.tasks.get(dispatchId);
+  }
+
+  transition(input: {
+    dispatchId: string;
+    expected: CollabTaskStatus | CollabTaskStatus[];
+    next: CollabTaskStatus;
+    extra?: Partial<CollabTask>;
+  }): CollabTask {
+    const task = this.tasks.get(input.dispatchId);
+    if (!task) throw new Error(`missing task: ${input.dispatchId}`);
+    const expected = Array.isArray(input.expected) ? input.expected : [input.expected];
+    if (!expected.includes(task.status)) {
+      throw new Error(`bad transition: ${task.status} -> ${input.next}`);
+    }
+    const next = {
+      ...task,
+      ...input.extra,
+      status: input.next,
+      version: (task.version ?? 1) + 1,
+      updatedAt: new Date().toISOString(),
+    };
+    this.tasks.set(input.dispatchId, next);
+    return next;
+  }
+
+  getBoard(): CollabTask[] {
+    return Array.from(this.tasks.values());
+  }
+
+  getEvents(): [] {
+    return [];
+  }
+
+  setRedis(): void {
+    // no-op
+  }
+}
+
+class FakeWorkspace {
+  manifests = new Map<string, TeamManifest>();
+  tasks = new Map<string, Task[]>();
+  messages: { teamSlug: string; content: string }[] = [];
+  nextTaskId = 1;
+
+  constructor(teamSlugs: string[]) {
+    for (const slug of teamSlugs) {
+      this.manifests.set(slug, {
+        schemaVersion: 2,
+        slug,
+        displayName: slug,
+        bindProject: slug,
+        harness: 'claudecode',
+        workDir: `/tmp/${slug}`,
+        collaboration: true,
+        rootPath: `/tmp/${slug}`,
+        createdAt: '2026-06-11T00:00:00.000Z',
+      });
+      this.tasks.set(slug, []);
+    }
+  }
+
+  async listTeams(): Promise<TeamManifest[]> {
+    return Array.from(this.manifests.values());
+  }
+
+  async readTeamManifest(teamSlug: string): Promise<TeamManifest> {
+    const manifest = this.manifests.get(teamSlug);
+    if (!manifest) throw new Error(`missing team: ${teamSlug}`);
+    return manifest;
+  }
+
+  async readTasks(teamSlug: string): Promise<Task[]> {
+    return this.tasks.get(teamSlug) ?? [];
+  }
+
+  async createTask(
+    teamSlug: string,
+    payload: {
+      title: string;
+      description?: string;
+      assignee?: string | null;
+      status?: TaskStatus;
+      dispatchMeta?: DispatchMeta;
+    }
+  ): Promise<Task> {
+    const now = new Date().toISOString();
+    const task: Task = {
+      id: `task-${this.nextTaskId++}`,
+      teamSlug,
+      title: payload.title,
+      description: payload.description ?? '',
+      status: payload.status ?? 'todo',
+      assignee: payload.assignee ?? null,
+      result: null,
+      createdAt: now,
+      updatedAt: now,
+      order: this.tasks.get(teamSlug)?.length ?? 0,
+      dispatchMeta: payload.dispatchMeta,
+    };
+    this.tasks.set(teamSlug, [...(this.tasks.get(teamSlug) ?? []), task]);
+    return task;
+  }
+
+  async patchTask(teamSlug: string, taskId: string, patch: Partial<Task>): Promise<Task> {
+    const tasks = this.tasks.get(teamSlug) ?? [];
+    const index = tasks.findIndex((task) => task.id === taskId);
+    if (index < 0) throw new Error(`missing task: ${taskId}`);
+    const next = { ...tasks[index], ...patch, id: taskId, teamSlug } as Task;
+    tasks[index] = next;
+    return next;
+  }
+
+  async appendMessage(teamSlug: string, msg: { content: string }): Promise<unknown> {
+    this.messages.push({ teamSlug, content: msg.content });
+    return { id: `msg-${this.messages.length}` };
+  }
+}
+
+function createService() {
+  const workspace = new FakeWorkspace(['origin', 'target']);
+  const collabBoard = new FakeCollabBoard();
+  const service = new TaskDispatchService(
+    workspace as unknown as TeamWorkspaceService,
+    collabBoard as unknown as CollaborationBoardService
+  );
+  return { service, workspace, collabBoard };
+}
+
+describe('TaskDispatchService local dispatch start gate', () => {
+  it('queues a local cross-team dispatch in TODO without starting runtime execution', async () => {
+    const { service, workspace, collabBoard } = createService();
+    const onRuntimeStart = vi.fn();
+    service.onRuntimeStart = onRuntimeStart;
+
+    const result = await service.dispatchTask(
+      'origin',
+      { subject: 'Fix external order state', description: 'Do not auto-start.' },
+      'target',
+      { dispatchId: 'dispatch-1' }
+    );
+
+    expect(result.status).toBe('received');
+    expect(result.message).toContain('waiting for manual start');
+    expect(onRuntimeStart).not.toHaveBeenCalled();
+
+    const targetTasks = await workspace.readTasks('target');
+    expect(targetTasks).toHaveLength(1);
+    expect(targetTasks[0]).toMatchObject({
+      status: 'todo',
+      dispatchMeta: {
+        dispatchId: 'dispatch-1',
+        originTeam: 'origin',
+        targetTeam: 'target',
+        status: 'received',
+      },
+    });
+    expect(collabBoard.getTask('dispatch-1')?.status).toBe('received');
+    expect(workspace.messages).toHaveLength(0);
+  });
+
+  it('only moves a received dispatch to doing/in_progress when Start is called', async () => {
+    const { service, workspace, collabBoard } = createService();
+    const onRuntimeStart = vi.fn().mockResolvedValue(undefined);
+    service.onRuntimeStart = onRuntimeStart;
+
+    await service.dispatchTask('origin', { subject: 'Start me manually' }, 'target', {
+      dispatchId: 'dispatch-2',
+    });
+    const queued = (await workspace.readTasks('target'))[0];
+
+    await service.startDispatchedTask('target', queued.id);
+
+    const [started] = await workspace.readTasks('target');
+    expect(started.status).toBe('doing');
+    expect(started.dispatchMeta).toMatchObject({
+      dispatchId: 'dispatch-2',
+      status: 'in_progress',
+      remoteTaskId: queued.id,
+    });
+    expect(collabBoard.getTask('dispatch-2')?.status).toBe('in_progress');
+    expect(onRuntimeStart).toHaveBeenCalledTimes(1);
+    expect(onRuntimeStart).toHaveBeenCalledWith(
+      expect.objectContaining({ teamName: 'target', text: expect.stringContaining('请开始执行') })
+    );
+  });
+
+  it('keeps legacy accept_task as receipt acknowledgement instead of execution start', async () => {
+    const { service, workspace, collabBoard } = createService();
+    const onRuntimeStart = vi.fn();
+    service.onRuntimeStart = onRuntimeStart;
+
+    await service.dispatchTask('origin', { subject: 'Legacy accept should not start' }, 'target', {
+      dispatchId: 'dispatch-3',
+    });
+
+    const result = await service.acceptTask('target', 'dispatch-3');
+
+    const [task] = await workspace.readTasks('target');
+    expect(result.taskId).toBe(task.id);
+    expect(task.status).toBe('todo');
+    expect(task.dispatchMeta).toMatchObject({
+      dispatchId: 'dispatch-3',
+      status: 'received',
+      remoteTaskId: task.id,
+    });
+    expect(collabBoard.getTask('dispatch-3')?.status).toBe('received');
+    expect(workspace.messages).toHaveLength(0);
+    expect(onRuntimeStart).not.toHaveBeenCalled();
+  });
+
+  it('rejects delivery before the target agent marks the local task done', async () => {
+    const { service, workspace, collabBoard } = createService();
+    service.onRuntimeStart = vi.fn().mockResolvedValue(undefined);
+
+    await service.dispatchTask('origin', { subject: 'Cannot deliver early' }, 'target', {
+      dispatchId: 'dispatch-4',
+    });
+    const [queued] = await workspace.readTasks('target');
+    await service.startDispatchedTask('target', queued.id);
+    const messageCountBeforeDelivery = workspace.messages.length;
+
+    await expect(service.deliverTask('target', 'dispatch-4', 'premature result')).rejects.toThrow(
+      'Task result cannot be delivered before the agent marks the task done.'
+    );
+    expect(collabBoard.getTask('dispatch-4')?.status).toBe('in_progress');
+    expect(workspace.messages).toHaveLength(messageCountBeforeDelivery);
+  });
+
+  it('delivers only after the target agent marks the local task done', async () => {
+    const { service, workspace, collabBoard } = createService();
+    service.onRuntimeStart = vi.fn().mockResolvedValue(undefined);
+
+    await service.dispatchTask('origin', { subject: 'Deliver after done' }, 'target', {
+      dispatchId: 'dispatch-5',
+    });
+    const [queued] = await workspace.readTasks('target');
+    await service.startDispatchedTask('target', queued.id);
+    await workspace.patchTask('target', queued.id, { status: 'done', result: 'finished' });
+    await service.onTaskCompleted('target', queued.id);
+
+    expect(collabBoard.getTask('dispatch-5')?.status).toBe('in_progress');
+    const originMessageCountBeforeDelivery = workspace.messages.filter(
+      (message) => message.teamSlug === 'origin'
+    ).length;
+
+    await expect(service.deliverTask('target', 'dispatch-5', 'finished')).resolves.toEqual({
+      ok: true,
+    });
+    expect(collabBoard.getTask('dispatch-5')?.status).toBe('delivered');
+    const originMessagesAfterDelivery = workspace.messages.filter(
+      (message) => message.teamSlug === 'origin'
+    );
+    expect(originMessagesAfterDelivery).toHaveLength(originMessageCountBeforeDelivery + 1);
+    expect(originMessagesAfterDelivery.at(-1)).toEqual(
+      expect.objectContaining({
+        teamSlug: 'origin',
+        content: expect.stringContaining('[跨团队任务待审核]'),
+      })
+    );
+  });
+
+  it('rejects re-delivery after approval before callback side effects', async () => {
+    const { service, workspace, collabBoard } = createService();
+    service.onRuntimeStart = vi.fn().mockResolvedValue(undefined);
+
+    await service.dispatchTask('origin', { subject: 'Do not deliver twice' }, 'target', {
+      dispatchId: 'dispatch-6',
+    });
+    const [queued] = await workspace.readTasks('target');
+    await service.startDispatchedTask('target', queued.id);
+    await workspace.patchTask('target', queued.id, { status: 'done', result: 'finished' });
+    await service.deliverTask('target', 'dispatch-6', 'finished');
+    await service.approveTask('origin', 'dispatch-6');
+    const originMessageCountBeforeRedelivery = workspace.messages.filter(
+      (message) => message.teamSlug === 'origin'
+    ).length;
+
+    await expect(service.deliverTask('target', 'dispatch-6', 'again')).rejects.toThrow(
+      'Task result has already been approved and cannot be delivered again.'
+    );
+    expect(collabBoard.getTask('dispatch-6')?.status).toBe('approved');
+    expect(workspace.messages.filter((message) => message.teamSlug === 'origin')).toHaveLength(
+      originMessageCountBeforeRedelivery
+    );
+  });
+});