github-issue-tower-defence-management 1.173.3 → 1.174.0

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts

@@ -69,6 +69,7 @@ import { ProxyRateLimitCacheRepository } from '../../repositories/ProxyRateLimit
 import { UpdateRateLimitCacheUseCase } from '../../../domain/usecases/UpdateRateLimitCacheUseCase';
 import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from '../../../domain/usecases/RevertNotReadyReviewQueueIssueUseCase';
+import { TriagerApprovalDispatchUseCase } from '../../../domain/usecases/TriagerApprovalDispatchUseCase';
 import { AgentDesignationLabelAdoptUseCase } from '../../../domain/usecases/AgentDesignationLabelAdoptUseCase';
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { ProjectRequiredFieldCreateUseCase } from '../../../domain/usecases/ProjectRequiredFieldCreateUseCase';
@@ -496,6 +497,11 @@ export class HandleScheduledEventUseCaseHandler {
         issueRepository,
         issueCommentRepository,
       );
+    const triagerApprovalDispatchUseCase = new TriagerApprovalDispatchUseCase(
+      projectRepository,
+      issueRepository,
+      issueCommentRepository,
+    );
     const agentDesignationLabelAdoptUseCase =
       new AgentDesignationLabelAdoptUseCase(projectRepository, issueRepository);
 
@@ -533,6 +539,7 @@ export class HandleScheduledEventUseCaseHandler {
       startPreparationUseCase,
       revertOrphanedPreparationUseCase,
       revertNotReadyReviewQueueIssueUseCase,
+      triagerApprovalDispatchUseCase,
       agentDesignationLabelAdoptUseCase,
       updateRateLimitCacheUseCase,
       dailySecurityScanUseCase,

package/src/adapter/repositories/LocalCommandIssueAttachmentRepository.test.ts

@@ -66,6 +66,44 @@ describe('relabelAttachmentMarkdown', () => {
 });
 
 describe('LocalCommandIssueAttachmentRepository', () => {
+  const resolveGithubToken = (): string => 'default-token';
+
+  it('should run the upload command with the github token resolved for the item url', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
+    const received: {
+      args: string[];
+      options: LocalCommandRunnerOptions | undefined;
+    }[] = [];
+    const runner: LocalCommandRunner = {
+      runCommand: async (_program, args, options) => {
+        received.push({ args, options });
+        return {
+          stdout:
+            '![attachment](https://github.com/user-attachments/assets/66666666-7777-8888-9999-000000000000)\n',
+          stderr: '',
+          exitCode: 0,
+        };
+      },
+    };
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      (issueOrPullRequestUrl) =>
+        issueOrPullRequestUrl.startsWith('https://github.com/acme/')
+          ? 'acme-token'
+          : 'other-token',
+      root,
+    );
+
+    await repository.uploadAttachment({
+      issueOrPullRequestUrl: 'https://github.com/acme/repo/issues/7',
+      fileName: 'screenshot.png',
+      content: new Uint8Array([1]),
+    });
+
+    expect(received).toHaveLength(1);
+    expect(received[0].options?.env).toEqual({ GH_TOKEN: 'acme-token' });
+  });
+
   it('should upload the written file and return the markdown the command printed', async () => {
     const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
     const received: { program: string; args: string[] }[] = [];
@@ -80,7 +118,11 @@ describe('LocalCommandIssueAttachmentRepository', () => {
         };
       },
     };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      resolveGithubToken,
+      root,
+    );
 
     const markdown = await repository.uploadAttachment({
       issueOrPullRequestUrl: 'https://github.com/owner/repo/issues/1',
@@ -107,7 +149,11 @@ describe('LocalCommandIssueAttachmentRepository', () => {
         exitCode: 1,
       }),
     };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      resolveGithubToken,
+      root,
+    );
 
     await expect(
       repository.uploadAttachment({
@@ -126,7 +172,11 @@ describe('LocalCommandIssueAttachmentRepository', () => {
     const runner: LocalCommandRunner = {
       runCommand: async () => ({ stdout: '\n', stderr: '', exitCode: 0 }),
     };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
+    const repository = new LocalCommandIssueAttachmentRepository(
+      runner,
+      resolveGithubToken,
+      root,
+    );
 
     await expect(
       repository.uploadAttachment({
@@ -136,71 +186,4 @@ describe('LocalCommandIssueAttachmentRepository', () => {
       }),
     ).rejects.toThrow(`${UPLOAD_COMMAND} returned no markdown`);
   });
-
-  it('should pass GH_TOKEN env resolved from the owner when resolveGithubToken is provided', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
-    const received: {
-      program: string;
-      args: string[];
-      options: LocalCommandRunnerOptions | undefined;
-    }[] = [];
-    const runner: LocalCommandRunner = {
-      runCommand: async (program, args, options) => {
-        received.push({ program, args, options });
-        return {
-          stdout:
-            '![screenshot](https://github.com/user-attachments/assets/abc)\n',
-          stderr: '',
-          exitCode: 0,
-        };
-      },
-    };
-    const resolveGithubToken = (owner: string): string => `token-for-${owner}`;
-    const repository = new LocalCommandIssueAttachmentRepository(
-      runner,
-      root,
-      resolveGithubToken,
-    );
-
-    await repository.uploadAttachment({
-      issueOrPullRequestUrl: 'https://github.com/meta-site/repo/issues/1',
-      fileName: 'screenshot.png',
-      content: new Uint8Array([1, 2, 3]),
-    });
-
-    expect(received).toHaveLength(1);
-    expect(received[0].options).toEqual({
-      env: { GH_TOKEN: 'token-for-meta-site' },
-    });
-  });
-
-  it('should pass undefined as third argument to runCommand when resolveGithubToken is not provided', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'attachment-test-root-'));
-    const received: {
-      program: string;
-      args: string[];
-      options: LocalCommandRunnerOptions | undefined;
-    }[] = [];
-    const runner: LocalCommandRunner = {
-      runCommand: async (program, args, options) => {
-        received.push({ program, args, options });
-        return {
-          stdout:
-            '![screenshot](https://github.com/user-attachments/assets/abc)\n',
-          stderr: '',
-          exitCode: 0,
-        };
-      },
-    };
-    const repository = new LocalCommandIssueAttachmentRepository(runner, root);
-
-    await repository.uploadAttachment({
-      issueOrPullRequestUrl: 'https://github.com/owner/repo/issues/1',
-      fileName: 'screenshot.png',
-      content: new Uint8Array([1]),
-    });
-
-    expect(received).toHaveLength(1);
-    expect(received[0].options).toBeUndefined();
-  });
 });

package/src/adapter/repositories/LocalCommandIssueAttachmentRepository.ts

@@ -9,6 +9,10 @@ import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/Loc
 
 export const UPLOAD_COMMAND = 'upload-file-to-gh-issue';
 
+export type IssueAttachmentGithubTokenResolver = (
+  issueOrPullRequestUrl: string,
+) => string;
+
 export const ALLOWED_ATTACHMENT_EXTENSIONS = [
   '.png',
   '.jpg',
@@ -57,8 +61,8 @@ export const relabelAttachmentMarkdown = (
 export class LocalCommandIssueAttachmentRepository implements IssueAttachmentRepository {
   constructor(
     private readonly localCommandRunner: LocalCommandRunner,
+    private readonly resolveGithubToken: IssueAttachmentGithubTokenResolver,
     private readonly temporaryDirectoryRoot: string = tmpdir(),
-    private readonly resolveGithubToken?: (repositoryOwner: string) => string,
   ) {}
 
   async uploadAttachment(
@@ -73,21 +77,14 @@ export class LocalCommandIssueAttachmentRepository implements IssueAttachmentRep
     );
     try {
       await writeFile(filePath, request.content);
-      let commandOptions: { env: { GH_TOKEN: string } } | undefined;
-      if (this.resolveGithubToken !== undefined) {
-        const ownerMatch = request.issueOrPullRequestUrl.match(
-          /https:\/\/github\.com\/([A-Za-z0-9._-]+)\//,
-        );
-        if (ownerMatch !== null) {
-          commandOptions = {
-            env: { GH_TOKEN: this.resolveGithubToken(ownerMatch[1]) },
-          };
-        }
-      }
       const result = await this.localCommandRunner.runCommand(
         UPLOAD_COMMAND,
         [filePath, request.issueOrPullRequestUrl],
-        commandOptions,
+        {
+          env: {
+            GH_TOKEN: this.resolveGithubToken(request.issueOrPullRequestUrl),
+          },
+        },
       );
       if (result.exitCode !== 0) {
         throw new Error(

package/src/domain/usecases/HandleScheduledEventUseCase.test.ts

@@ -24,6 +24,7 @@ import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCa
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
+import { TriagerApprovalDispatchUseCase } from './TriagerApprovalDispatchUseCase';
 import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
 import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
@@ -125,6 +126,8 @@ describe('HandleScheduledEventUseCase', () => {
       mock<RevertOrphanedPreparationUseCase>();
     const mockRevertNotReadyReviewQueueIssueUseCase =
       mock<RevertNotReadyReviewQueueIssueUseCase>();
+    const mockTriagerApprovalDispatchUseCase =
+      mock<TriagerApprovalDispatchUseCase>();
     const mockAgentDesignationLabelAdoptUseCase =
       mock<AgentDesignationLabelAdoptUseCase>();
     const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
@@ -156,6 +159,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockStartPreparationUseCase,
       mockRevertOrphanedPreparationUseCase,
       mockRevertNotReadyReviewQueueIssueUseCase,
+      mockTriagerApprovalDispatchUseCase,
       mockAgentDesignationLabelAdoptUseCase,
       mockUpdateRateLimitCacheUseCase,
       mockDailySecurityScanUseCase,
@@ -236,6 +240,29 @@ describe('HandleScheduledEventUseCase', () => {
       });
     });
 
+    it('should call TriagerApprovalDispatchUseCase with project URL', async () => {
+      const input = {
+        projectName: 'test-project',
+        org: 'test-org',
+        projectUrl: 'https://github.com/test-org/test-project',
+        manager: 'test-manager',
+        workingReport: {
+          repo: 'test-repo',
+          members: ['member1'],
+          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
+        },
+        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
+        disabled: false,
+      };
+
+      await useCase.run(input);
+      expect(mockTriagerApprovalDispatchUseCase.run).toHaveBeenCalledWith(
+        expect.objectContaining({
+          projectUrl: 'https://github.com/test-org/test-project',
+        }),
+      );
+    });
+
     it('should return null and skip all processing when disabled is true', async () => {
       const input = {
         projectName: 'test-project',

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -28,6 +28,8 @@ import {
 import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
+import { TriagerApprovalDispatchUseCase } from './TriagerApprovalDispatchUseCase';
+import { isRecord } from './isRecord';
 import { resolveLabelsAsLlmAgentName } from './resolveLabelsAsLlmAgentName';
 import { resolveAllowedIssueAuthors } from './resolveAllowedIssueAuthors';
 import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
@@ -64,9 +66,6 @@ const isTransientApiError = (error: Error): boolean => {
 const TRANSIENT_NETWORK_ERROR_CODE_PATTERN =
   /\b(ECONNRESET|ECONNREFUSED|ECONNABORTED|ETIMEDOUT|EPIPE|ENOTFOUND|EAI_AGAIN|ERR_NETWORK|ERR_SOCKET_CONNECTION_TIMEOUT)\b/;
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null;
-
 const extractHttpStatusFromError = (error: Error): number | null => {
   if (!isRecord(error)) {
     return null;
@@ -137,6 +136,7 @@ export class HandleScheduledEventUseCase {
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
     readonly revertNotReadyReviewQueueIssueUseCase: RevertNotReadyReviewQueueIssueUseCase,
+    readonly triagerApprovalDispatchUseCase: TriagerApprovalDispatchUseCase,
     readonly agentDesignationLabelAdoptUseCase: AgentDesignationLabelAdoptUseCase,
     readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dailySecurityScanUseCase: DailySecurityScanUseCase | null,
@@ -437,6 +437,10 @@ ${JSON.stringify(e)}
       changeTargetPathAliases: input.changeTargetPathAliases,
       allowedIssueAuthors,
     });
+    await this.triagerApprovalDispatchUseCase.run({
+      projectUrl: input.projectUrl,
+      allowedIssueAuthors,
+    });
     if (this.dailySecurityScanUseCase !== null && input.dailySecurityScan) {
       await this.dailySecurityScanUseCase.run({
         targetDates: targetDateTimes,