github-issue-tower-defence-management 1.58.2 → 1.59.0

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

@@ -0,0 +1,101 @@
+const mockReadRateLimit = jest.fn();
+const mockLoadTokens = jest.fn();
+
+jest.mock('../proxy/RateLimitCache', () => ({
+  PROXY_PORT: 8787,
+  readRateLimit: mockReadRateLimit,
+}));
+
+jest.mock('../proxy/TokenListLoader', () => ({
+  loadTokens: mockLoadTokens,
+}));
+
+import { ProxyRateLimitCacheRepository } from './ProxyRateLimitCacheRepository';
+
+describe('ProxyRateLimitCacheRepository', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getTokenRateLimitCaches', () => {
+    it('should return an empty list when no token path is configured', () => {
+      const repository = new ProxyRateLimitCacheRepository(null);
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([]);
+      expect(mockLoadTokens).not.toHaveBeenCalled();
+    });
+
+    it('should return an empty list when the token list cannot be loaded', () => {
+      mockLoadTokens.mockReturnValue(null);
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([]);
+    });
+
+    const futureReset = Math.floor(Date.now() / 1000) + 3600;
+
+    it('should return fiveHourReset as unifiedReset for a token with a cached snapshot', () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 42,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([{ token: 'token-a', unifiedReset: futureReset }]);
+    });
+
+    it('should return unifiedReset of 0 when no snapshot exists for a token', () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue(null);
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([{ token: 'token-a', unifiedReset: 0 }]);
+    });
+
+    it('should return entries for all tokens in the list', () => {
+      mockLoadTokens.mockReturnValue(['token-a', 'token-b']);
+      mockReadRateLimit.mockImplementation((token: string) => {
+        if (token === 'token-a') {
+          return {
+            fiveHourUtilization: 10,
+            fiveHourReset: futureReset,
+            sevenDayUtilization: 0,
+            sevenDayReset: futureReset,
+            blocked: false,
+            rejected: false,
+            unifiedRejected: false,
+            fiveHourRejected: false,
+            sevenDayRejected: false,
+            modelWeeklyLimits: {},
+          };
+        }
+        return null;
+      });
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([
+        { token: 'token-a', unifiedReset: futureReset },
+        { token: 'token-b', unifiedReset: 0 },
+      ]);
+    });
+  });
+});

package/src/adapter/repositories/ProxyRateLimitCacheRepository.ts

@@ -0,0 +1,66 @@
+import * as http from 'http';
+import { RateLimitCacheRepository } from '../../domain/usecases/adapter-interfaces/RateLimitCacheRepository';
+import { TokenRateLimitCache } from '../../domain/usecases/adapter-interfaces/RateLimitCacheRepository';
+import { PROXY_PORT, readRateLimit } from '../proxy/RateLimitCache';
+import { loadTokens } from '../proxy/TokenListLoader';
+
+const HAIKU_MODEL = 'claude-haiku-4-5';
+
+const PROBE_REQUEST_BODY = JSON.stringify({
+  model: HAIKU_MODEL,
+  max_tokens: 1,
+  messages: [{ role: 'user', content: 'hi' }],
+});
+
+export class ProxyRateLimitCacheRepository implements RateLimitCacheRepository {
+  constructor(
+    private readonly tokenListJsonPath: string | null,
+    private readonly port: number = PROXY_PORT,
+  ) {}
+
+  getTokenRateLimitCaches = (): TokenRateLimitCache[] => {
+    if (this.tokenListJsonPath === null) {
+      return [];
+    }
+    const tokens = loadTokens(this.tokenListJsonPath);
+    if (tokens === null) {
+      return [];
+    }
+    return tokens.map((token) => {
+      const snapshot = readRateLimit(token);
+      const unifiedReset = snapshot !== null ? snapshot.fiveHourReset : 0;
+      return { token, unifiedReset };
+    });
+  };
+
+  probeToken = async (token: string): Promise<void> => {
+    await new Promise<void>((resolve) => {
+      const request = http.request(
+        {
+          host: '127.0.0.1',
+          port: this.port,
+          method: 'POST',
+          path: '/v1/messages',
+          headers: {
+            'content-type': 'application/json',
+            'anthropic-version': '2023-06-01',
+            authorization: `Bearer ${token}`,
+            'content-length': Buffer.byteLength(PROBE_REQUEST_BODY),
+          },
+        },
+        (response) => {
+          response.resume();
+          response.on('end', () => resolve());
+        },
+      );
+      request.on('error', (error) => {
+        console.error(
+          `[UpdateRateLimitCache] Probe request failed for token hash: ${error.message}`,
+        );
+        resolve();
+      });
+      request.write(PROBE_REQUEST_BODY);
+      request.end();
+    });
+  };
+}

package/src/domain/entities/ClaudeTokenUsage.ts

@@ -1,5 +1,12 @@
+export type ClaudeModelWeeklyLimit = {
+  rejected: boolean;
+  resetsAt: number;
+};
+
 export type ClaudeTokenUsage = {
   token: string;
   fiveHourUtilization: number;
   blocked: boolean;
+  rejected: boolean;
+  modelWeeklyLimits: Record<string, ClaudeModelWeeklyLimit>;
 };

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

@@ -23,6 +23,7 @@ import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
+import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 
 describe('HandleScheduledEventUseCase', () => {
   describe('createTargetDateTimes', () => {
@@ -112,6 +113,7 @@ describe('HandleScheduledEventUseCase', () => {
       mock<RevertOrphanedPreparationUseCase>();
     const mockRevertNotReadyAwaitingQualityCheckUseCase =
       mock<RevertNotReadyAwaitingQualityCheckUseCase>();
+    const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
     const mockDateRepository = mock<DateRepository>();
     const mockSpreadsheetRepository = mock<SpreadsheetRepository>();
     const mockProjectRepository = mock<ProjectRepository>();
@@ -135,6 +137,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockStartPreparationUseCase,
       mockRevertOrphanedPreparationUseCase,
       mockRevertNotReadyAwaitingQualityCheckUseCase,
+      mockUpdateRateLimitCacheUseCase,
       mockDateRepository,
       mockSpreadsheetRepository,
       mockProjectRepository,
@@ -367,6 +370,66 @@ describe('HandleScheduledEventUseCase', () => {
       ).not.toHaveBeenCalled();
     });
 
+    it('should invoke UpdateRateLimitCacheUseCase before StartPreparationUseCase when startPreparation is configured', async () => {
+      const callOrder: string[] = [];
+      mockUpdateRateLimitCacheUseCase.run.mockImplementation(async () => {
+        callOrder.push('updateRateLimitCache');
+      });
+      mockStartPreparationUseCase.run.mockImplementation(async () => {
+        callOrder.push('startPreparation');
+      });
+
+      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,
+        allowIssueCacheMinutes: 60,
+        startPreparation: {
+          defaultAgentName: 'aw',
+          configFilePath: '/path/to/config.yml',
+          maximumPreparingIssuesCount: null,
+        },
+      };
+
+      mockProjectRepository.getProject.mockResolvedValue(mock<Project>());
+      await useCase.run(input);
+
+      expect(mockUpdateRateLimitCacheUseCase.run).toHaveBeenCalledTimes(1);
+      expect(callOrder.indexOf('updateRateLimitCache')).toBeLessThan(
+        callOrder.indexOf('startPreparation'),
+      );
+    });
+
+    it('should not invoke UpdateRateLimitCacheUseCase when startPreparation is absent', 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,
+        allowIssueCacheMinutes: 60,
+      };
+
+      mockProjectRepository.getProject.mockResolvedValue(mock<Project>());
+      await useCase.run(input);
+
+      expect(mockUpdateRateLimitCacheUseCase.run).not.toHaveBeenCalled();
+    });
+
     describe('story issue creation progress logs', () => {
       const storyInput = {
         projectName: 'test-project',

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -23,6 +23,7 @@ import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
+import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 
 export class ProjectNotFoundError extends Error {
   constructor(message: string) {
@@ -52,6 +53,7 @@ export class HandleScheduledEventUseCase {
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
     readonly revertNotReadyAwaitingQualityCheckUseCase: RevertNotReadyAwaitingQualityCheckUseCase,
+    readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dateRepository: DateRepository,
     readonly spreadsheetRepository: SpreadsheetRepository,
     readonly projectRepository: ProjectRepository,
@@ -264,6 +266,11 @@ ${JSON.stringify(e)}
       });
     }
     if (input.startPreparation) {
+      if (this.updateRateLimitCacheUseCase !== null) {
+        await this.updateRateLimitCacheUseCase.run({
+          nowEpochSeconds: Date.now() / 1000,
+        });
+      }
       if (input.startPreparation.preparationProcessCheckCommand) {
         await this.revertOrphanedPreparationUseCase.run({
           projectUrl: input.projectUrl,