github-issue-tower-defence-management 1.41.0 → 1.42.1

package/src/adapter/entry-points/cli/index.test.ts

@@ -138,6 +138,7 @@ describe('CLI', () => {
         thresholdForAutoReject: 5,
         workflowBlockerResolvedWebhookUrl: 'https://example.com/webhook',
         projectName: 'test-project',
+        codexHomeCandidates: ['.codex-dev1', '.codex-main'],
       };
       writeConfig(config);
 
@@ -146,6 +147,42 @@ describe('CLI', () => {
       expect(result).toEqual(config);
     });
 
+    it('should load codexHomeCandidates string array from config file', () => {
+      const config = {
+        ...defaultConfig,
+        codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
+      };
+      writeConfig(config);
+
+      const result = loadConfigFile(configFilePath);
+
+      expect(result.codexHomeCandidates).toEqual([
+        '.codex-dev1',
+        '.codex-dev2',
+        '.codex-main',
+      ]);
+    });
+
+    it('should return undefined codexHomeCandidates when not in config', () => {
+      writeConfig(defaultConfig);
+
+      const result = loadConfigFile(configFilePath);
+
+      expect(result.codexHomeCandidates).toBeUndefined();
+    });
+
+    it('should return undefined codexHomeCandidates when array contains non-string items', () => {
+      const config = {
+        ...defaultConfig,
+        codexHomeCandidates: ['.codex-dev1', 123],
+      };
+      writeConfig(config);
+
+      const result = loadConfigFile(configFilePath);
+
+      expect(result.codexHomeCandidates).toBeUndefined();
+    });
+
     it('should return empty config for empty YAML', () => {
       fs.writeFileSync(configFilePath, '');
 
@@ -300,6 +337,24 @@ defaultAgentName: 'case-test-agent'
 
       expect(result.defaultAgentName).toBe('case-test-agent');
     });
+
+    it('should parse codexHomeCandidates string array from README config', () => {
+      const readme = `<details>
+<summary>config</summary>
+codexHomeCandidates:
+  - .codex-dev1
+  - .codex-dev2
+  - .codex-main
+</details>`;
+
+      const result = parseProjectReadmeConfig(readme);
+
+      expect(result.codexHomeCandidates).toEqual([
+        '.codex-dev1',
+        '.codex-dev2',
+        '.codex-main',
+      ]);
+    });
   });
 
   describe('mergeConfigs', () => {
@@ -457,6 +512,7 @@ defaultAgentName: 'case-test-agent'
         maximumPreparingIssuesCount: null,
         utilizationPercentageThreshold: 90,
         allowedIssueAuthors: null,
+        codexHomeCandidates: null,
       });
     });
 
@@ -497,6 +553,7 @@ defaultAgentName: 'case-test-agent'
         maximumPreparingIssuesCount: null,
         utilizationPercentageThreshold: 90,
         allowedIssueAuthors: null,
+        codexHomeCandidates: null,
       });
     });
 
@@ -905,6 +962,107 @@ defaultAgentName: 'case-test-agent'
         }),
       );
     });
+
+    it('should pass codexHomeCandidates from config file', async () => {
+      const configWithCandidates = {
+        ...defaultConfig,
+        codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
+      };
+      writeConfig(configWithCandidates);
+
+      const mockRun = jest.fn().mockResolvedValue(undefined);
+      const MockedStartPreparationUseCase = jest.mocked(
+        StartPreparationUseCase,
+      );
+
+      MockedStartPreparationUseCase.mockImplementation(function (
+        this: StartPreparationUseCase,
+      ) {
+        this.run = mockRun;
+        return this;
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
+        }),
+      );
+    });
+
+    it('should pass codexHomeCandidates as null when not in config', async () => {
+      const mockRun = jest.fn().mockResolvedValue(undefined);
+      const MockedStartPreparationUseCase = jest.mocked(
+        StartPreparationUseCase,
+      );
+
+      MockedStartPreparationUseCase.mockImplementation(function (
+        this: StartPreparationUseCase,
+      ) {
+        this.run = mockRun;
+        return this;
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          codexHomeCandidates: null,
+        }),
+      );
+    });
+
+    it('should pass codexHomeCandidates from README config', async () => {
+      const readmeContent = [
+        '# Project',
+        '<details>',
+        '<summary>config</summary>',
+        'codexHomeCandidates:',
+        '  - .codex-readme1',
+        '  - .codex-readme2',
+        '</details>',
+      ].join('\n');
+      mockFetchReturningReadme(readmeContent);
+
+      const mockRun = jest.fn().mockResolvedValue(undefined);
+      const MockedStartPreparationUseCase = jest.mocked(
+        StartPreparationUseCase,
+      );
+
+      MockedStartPreparationUseCase.mockImplementation(function (
+        this: StartPreparationUseCase,
+      ) {
+        this.run = mockRun;
+        return this;
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          codexHomeCandidates: ['.codex-readme1', '.codex-readme2'],
+        }),
+      );
+    });
   });
 
   describe('notifyFinishedIssuePreparation', () => {

package/src/adapter/entry-points/cli/index.ts

@@ -37,6 +37,7 @@ type ConfigFile = {
   workflowBlockerResolvedWebhookUrl?: string;
   projectName?: string;
   preparationProcessCheckCommand?: string;
+  codexHomeCandidates?: string[];
 };
 
 type StartDaemonOptions = {
@@ -81,6 +82,24 @@ const getNumberValue = (
   return typeof value === 'number' ? value : undefined;
 };
 
+const getStringArrayValue = (
+  obj: Record<string, unknown>,
+  key: string,
+): string[] | undefined => {
+  const value = obj[key];
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const strings: string[] = [];
+  for (const item of value) {
+    if (typeof item !== 'string') {
+      return undefined;
+    }
+    strings.push(item);
+  }
+  return strings;
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
@@ -125,6 +144,7 @@ export const loadConfigFile = (configFilePath: string): ConfigFile => {
         parsed,
         'preparationProcessCheckCommand',
       ),
+      codexHomeCandidates: getStringArrayValue(parsed, 'codexHomeCandidates'),
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -183,6 +203,7 @@ export const parseProjectReadmeConfig = (readme: string): ConfigFile => {
         parsed,
         'preparationProcessCheckCommand',
       ),
+      codexHomeCandidates: getStringArrayValue(parsed, 'codexHomeCandidates'),
     };
   } catch {
     console.warn('Failed to parse YAML from project README config section');
@@ -249,6 +270,10 @@ export const mergeConfigs = (
     readmeOverrides.preparationProcessCheckCommand ??
     cliOverrides.preparationProcessCheckCommand ??
     configFile.preparationProcessCheckCommand,
+  codexHomeCandidates:
+    readmeOverrides.codexHomeCandidates ??
+    cliOverrides.codexHomeCandidates ??
+    configFile.codexHomeCandidates,
 });
 
 type GraphqlProjectV2ReadmeResponse = {
@@ -585,6 +610,11 @@ program
           .filter(Boolean)
       : null;
 
+    const codexHomeCandidates =
+      config.codexHomeCandidates && config.codexHomeCandidates.length > 0
+        ? config.codexHomeCandidates
+        : null;
+
     await useCase.run({
       projectUrl,
       awaitingWorkspaceStatus,
@@ -597,6 +627,7 @@ program
       utilizationPercentageThreshold:
         config.utilizationPercentageThreshold ?? 90,
       allowedIssueAuthors,
+      codexHomeCandidates,
     });
   });
 

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -80,6 +80,7 @@ export class HandleScheduledEventUseCase {
       utilizationPercentageThreshold?: number;
       allowedIssueAuthors?: string[] | null;
       preparationProcessCheckCommand?: string;
+      codexHomeCandidates?: string[] | null;
     } | null;
     notifyFinishedPreparation?: {
       preparationStatus: string;
@@ -356,6 +357,7 @@ ${JSON.stringify(e)}
         utilizationPercentageThreshold:
           input.startPreparation.utilizationPercentageThreshold ?? 90,
         allowedIssueAuthors: input.startPreparation.allowedIssueAuthors ?? null,
+        codexHomeCandidates: input.startPreparation.codexHomeCandidates ?? null,
       });
     }
     if (input.notifyFinishedPreparation) {

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

@@ -259,6 +259,48 @@ describe('RevertOrphanedPreparationUseCase', () => {
     ).rejects.toThrow('Project not found');
   });
 
+  it('should throw when getProject returns null after findProjectIdByUrl succeeds', async () => {
+    mockProjectRepository.findProjectIdByUrl.mockResolvedValue('project-1');
+    mockProjectRepository.getProject.mockResolvedValue(null);
+
+    await expect(
+      useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        preparationStatus: 'Preparation',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        allowIssueCacheMinutes: 0,
+        preparationProcessCheckCommand: 'check {URL}',
+      }),
+    ).rejects.toThrow('Project not found. projectId: project-1');
+  });
+
+  it('should do nothing when awaitingWorkspaceStatus is not found in project statuses', async () => {
+    const preparationIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/10',
+      status: 'Preparation',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [preparationIssue],
+      cacheUsed: false,
+    });
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 1,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'NonExistentStatus',
+      allowIssueCacheMinutes: 0,
+      preparationProcessCheckCommand: 'check {URL}',
+    });
+
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.createComment.mock.calls).toHaveLength(0);
+  });
+
   it('should do nothing when there are no Preparation issues', async () => {
     mockIssueRepository.getAllIssues.mockResolvedValue({
       issues: [