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

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

@@ -34,7 +34,6 @@ import { AssignNoAssigneeIssueToManagerUseCase } from '../../../domain/usecases/
 import { UpdateIssueStatusByLabelUseCase } from '../../../domain/usecases/UpdateIssueStatusByLabelUseCase';
 import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
 import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunner';
-import { OauthAPIProxyClaudeRepository } from '../../repositories/OauthAPIProxyClaudeRepository';
 import { ProxyClaudeTokenUsageRepository } from '../../repositories/ProxyClaudeTokenUsageRepository';
 import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
 import { RevertNotReadyAwaitingQualityCheckUseCase } from '../../../domain/usecases/RevertNotReadyAwaitingQualityCheckUseCase';
@@ -221,14 +220,12 @@ export class HandleScheduledEventUseCaseHandler {
       issueRepository,
     );
     const nodeLocalCommandRunner = new NodeLocalCommandRunner();
-    const claudeRepository = new OauthAPIProxyClaudeRepository();
     const claudeTokenUsageRepository = new ProxyClaudeTokenUsageRepository(
       mergedInput.claudeCodeOauthTokenListJsonPath ?? null,
     );
     const startPreparationUseCase = new StartPreparationUseCase(
       projectRepository,
       issueRepository,
-      claudeRepository,
       nodeLocalCommandRunner,
       claudeTokenUsageRepository,
     );

package/src/adapter/proxy/RateLimitCache.test.ts

@@ -5,7 +5,9 @@ import {
   cacheDir,
   cachePathForToken,
   hashToken,
+  parseModelRateLimitsFromBody,
   readRateLimit,
+  writeModelRateLimit,
   writeRateLimit,
 } from './RateLimitCache';
 
@@ -84,6 +86,7 @@ describe('RateLimitCache', () => {
       expect(snapshot.sevenDayUtilization).toBe(17);
       expect(snapshot.sevenDayReset).toBe(1700100000);
       expect(snapshot.blocked).toBe(false);
+      expect(snapshot.rejected).toBe(false);
     });
 
     it('should mark snapshot as blocked when status header is blocked', () => {
@@ -101,6 +104,79 @@ describe('RateLimitCache', () => {
       expect(snapshot?.blocked).toBe(true);
     });
 
+    it('should mark snapshot as rejected when unified status header is rejected', () => {
+      const token = 'rejected-unified-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'rejected',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '100',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '99',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.rejected).toBe(true);
+      expect(snapshot?.blocked).toBe(false);
+      expect(snapshot?.unifiedRejected).toBe(true);
+      expect(snapshot?.fiveHourRejected).toBe(false);
+      expect(snapshot?.sevenDayRejected).toBe(false);
+    });
+
+    it('should mark snapshot as rejected when 5h status header is rejected', () => {
+      const token = 'rejected-5h-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'rejected',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '100',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '99',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.rejected).toBe(true);
+      expect(snapshot?.fiveHourRejected).toBe(true);
+      expect(snapshot?.sevenDayRejected).toBe(false);
+      expect(snapshot?.unifiedRejected).toBe(false);
+    });
+
+    it('should mark snapshot as rejected when 7d status header is rejected', () => {
+      const token = 'rejected-7d-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '50',
+        'anthropic-ratelimit-unified-7d-status': 'rejected',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '100',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.rejected).toBe(true);
+      expect(snapshot?.sevenDayRejected).toBe(true);
+      expect(snapshot?.fiveHourRejected).toBe(false);
+      expect(snapshot?.unifiedRejected).toBe(false);
+    });
+
+    it('should not mark snapshot as rejected when no status header is rejected', () => {
+      const token = 'allowed-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '50',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '40',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.rejected).toBe(false);
+      expect(snapshot?.unifiedRejected).toBe(false);
+      expect(snapshot?.fiveHourRejected).toBe(false);
+      expect(snapshot?.sevenDayRejected).toBe(false);
+    });
+
     it('should return null when file does not exist', () => {
       expect(readRateLimit('never-written-token')).toBeNull();
     });
@@ -127,5 +203,119 @@ describe('RateLimitCache', () => {
       expect(snapshot?.fiveHourUtilization).toBe(55);
       expect(snapshot?.fiveHourReset).toBe(1700000000);
     });
+
+    it('should default modelWeeklyLimits to an empty object when none are recorded', () => {
+      const token = 'no-model-limits-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '10',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '5',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.modelWeeklyLimits).toEqual({});
+    });
+  });
+
+  describe('parseModelRateLimitsFromBody', () => {
+    it('should extract a rejected seven_day_sonnet limit from a rate_limit event body', () => {
+      const body =
+        'event: error\n' +
+        'data: {"status":"rejected","resetsAt":1779642000,"rateLimitType":"seven_day_sonnet","overageStatus":"rejected"}\n\n';
+      expect(parseModelRateLimitsFromBody(body)).toEqual({
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+      });
+    });
+
+    it('should extract multiple distinct rate limit types', () => {
+      const body =
+        'data: {"status":"rejected","resetsAt":1779642000,"rateLimitType":"seven_day_sonnet"}\n' +
+        'data: {"status":"allowed","resetsAt":1779700000,"rateLimitType":"seven_day"}\n';
+      expect(parseModelRateLimitsFromBody(body)).toEqual({
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+        seven_day: { rejected: false, resetsAt: 1779700000 },
+      });
+    });
+
+    it('should return an empty object when no rate limit information is present', () => {
+      const body =
+        'event: message_start\n' +
+        'data: {"type":"message_start","message":{"id":"msg_1"}}\n\n';
+      expect(parseModelRateLimitsFromBody(body)).toEqual({});
+    });
+
+    it('should ignore entries that lack a numeric resetsAt', () => {
+      const body =
+        'data: {"status":"rejected","rateLimitType":"seven_day_sonnet"}\n';
+      expect(parseModelRateLimitsFromBody(body)).toEqual({});
+    });
+  });
+
+  describe('writeModelRateLimit', () => {
+    it('should persist model weekly limits readable by readRateLimit', () => {
+      const token = 'model-limit-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '10',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '5',
+      });
+      writeModelRateLimit(token, {
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.modelWeeklyLimits).toEqual({
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+      });
+      expect(snapshot?.fiveHourUtilization).toBe(10);
+    });
+
+    it('should preserve previously recorded model limits when headers are rewritten', () => {
+      const token = 'preserve-token';
+      writeModelRateLimit(token, {
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+      });
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '20',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '5',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.modelWeeklyLimits).toEqual({
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+      });
+      expect(snapshot?.fiveHourUtilization).toBe(20);
+    });
+
+    it('should merge new model limits with existing ones', () => {
+      const token = 'merge-token';
+      writeModelRateLimit(token, {
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+      });
+      writeModelRateLimit(token, {
+        seven_day: { rejected: false, resetsAt: 1779700000 },
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.modelWeeklyLimits).toEqual({
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+        seven_day: { rejected: false, resetsAt: 1779700000 },
+      });
+    });
+
+    it('should not write a file when there are no limits to record', () => {
+      const token = 'empty-limits-token';
+      writeModelRateLimit(token, {});
+      expect(readRateLimit(token)).toBeNull();
+    });
   });
 });

package/src/adapter/proxy/RateLimitCache.ts

@@ -3,12 +3,22 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 
+export interface ModelWeeklyLimit {
+  rejected: boolean;
+  resetsAt: number;
+}
+
 export interface RateLimitSnapshot {
   fiveHourUtilization: number;
   fiveHourReset: number;
   sevenDayUtilization: number;
   sevenDayReset: number;
   blocked: boolean;
+  rejected: boolean;
+  unifiedRejected: boolean;
+  fiveHourRejected: boolean;
+  sevenDayRejected: boolean;
+  modelWeeklyLimits: Record<string, ModelWeeklyLimit>;
 }
 
 export const PROXY_PORT = 8787;
@@ -26,6 +36,37 @@ export const hashToken = (token: string): string =>
 export const cachePathForToken = (token: string): string =>
   path.join(cacheDir(), `${hashToken(token)}.json`);
 
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const readPayload = (filePath: string): Record<string, unknown> => {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed: unknown = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+};
+
+const readModelWeeklyLimits = (
+  payload: Record<string, unknown>,
+): Record<string, ModelWeeklyLimit> => {
+  const stored = payload.modelWeeklyLimits;
+  const result: Record<string, ModelWeeklyLimit> = {};
+  if (!isRecord(stored)) return result;
+  for (const [limitType, value] of Object.entries(stored)) {
+    if (!isRecord(value)) continue;
+    const rejected = value.rejected;
+    const resetsAt = value.resetsAt;
+    if (typeof rejected === 'boolean' && typeof resetsAt === 'number') {
+      result[limitType] = { rejected, resetsAt };
+    }
+  }
+  return result;
+};
+
 export const writeRateLimit = (
   token: string,
   headers: Record<string, string | string[] | undefined>,
@@ -39,6 +80,8 @@ export const writeRateLimit = (
     if (Array.isArray(value)) return value[0];
     return value;
   };
+  const filePath = path.join(dir, `${hashToken(token)}.json`);
+  const existing = readPayload(filePath);
   const payload = {
     ts: Date.now() / 1000,
     headers: {
@@ -64,19 +107,70 @@ export const writeRateLimit = (
         'anthropic-ratelimit-unified-7d-utilization',
       ),
     },
+    modelWeeklyLimits: readModelWeeklyLimits(existing),
   };
+  fs.writeFileSync(filePath, JSON.stringify(payload));
+};
+
+export const writeModelRateLimit = (
+  token: string,
+  limits: Record<string, ModelWeeklyLimit>,
+): void => {
+  const limitTypes = Object.keys(limits);
+  if (limitTypes.length === 0) return;
+  const dir = cacheDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
   const filePath = path.join(dir, `${hashToken(token)}.json`);
+  const existing = readPayload(filePath);
+  const merged = {
+    ...readModelWeeklyLimits(existing),
+    ...limits,
+  };
+  const payload = {
+    ...existing,
+    modelWeeklyLimits: merged,
+  };
   fs.writeFileSync(filePath, JSON.stringify(payload));
 };
 
+export const parseModelRateLimitsFromBody = (
+  body: string,
+): Record<string, ModelWeeklyLimit> => {
+  const result: Record<string, ModelWeeklyLimit> = {};
+  const matches = body.match(
+    /\{[^{}]*"rateLimitType"[^{}]*\}|\{[^{}]*"resetsAt"[^{}]*"rateLimitType"[^{}]*\}/g,
+  );
+  if (matches === null) return result;
+  for (const candidate of matches) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) continue;
+    const rateLimitType = parsed.rateLimitType;
+    const status = parsed.status;
+    const resetsAt = parsed.resetsAt;
+    if (typeof rateLimitType !== 'string') continue;
+    if (typeof status !== 'string') continue;
+    if (typeof resetsAt !== 'number') continue;
+    result[rateLimitType] = {
+      rejected: status === 'rejected',
+      resetsAt,
+    };
+  }
+  return result;
+};
+
 export const readRateLimit = (token: string): RateLimitSnapshot | null => {
   const filePath = cachePathForToken(token);
   if (!fs.existsSync(filePath)) return null;
   try {
     const raw = fs.readFileSync(filePath, 'utf8');
     const parsed: unknown = JSON.parse(raw);
-    const isRecord = (value: unknown): value is Record<string, unknown> =>
-      value !== null && typeof value === 'object' && !Array.isArray(value);
     if (!isRecord(parsed)) return null;
     const headersUnknown = parsed.headers;
     const headers: Record<string, string> = {};
@@ -96,6 +190,9 @@ export const readRateLimit = (token: string): RateLimitSnapshot | null => {
     const status = headers['anthropic-ratelimit-unified-status'];
     const fiveHourStatus = headers['anthropic-ratelimit-unified-5h-status'];
     const sevenDayStatus = headers['anthropic-ratelimit-unified-7d-status'];
+    const unifiedRejected = status === 'rejected';
+    const fiveHourRejected = fiveHourStatus === 'rejected';
+    const sevenDayRejected = sevenDayStatus === 'rejected';
     return {
       fiveHourUtilization: num('anthropic-ratelimit-unified-5h-utilization'),
       fiveHourReset: num('anthropic-ratelimit-unified-5h-reset'),
@@ -105,6 +202,11 @@ export const readRateLimit = (token: string): RateLimitSnapshot | null => {
         status === 'blocked' ||
         fiveHourStatus === 'blocked' ||
         sevenDayStatus === 'blocked',
+      rejected: unifiedRejected || fiveHourRejected || sevenDayRejected,
+      unifiedRejected,
+      fiveHourRejected,
+      sevenDayRejected,
+      modelWeeklyLimits: readModelWeeklyLimits(parsed),
     };
   } catch {
     return null;

package/src/adapter/proxy/proxyEntry.ts

@@ -1,9 +1,16 @@
 import * as http from 'http';
 import * as https from 'https';
-import { PROXY_PORT, writeRateLimit } from './RateLimitCache';
+import {
+  PROXY_PORT,
+  parseModelRateLimitsFromBody,
+  writeModelRateLimit,
+  writeRateLimit,
+} from './RateLimitCache';
 
 const UPSTREAM_HOST = 'api.anthropic.com';
 
+const MAX_INSPECTED_BODY_BYTES = 1024 * 1024;
+
 const BEARER_PREFIX = 'bearer ';
 
 const extractToken = (
@@ -40,6 +47,22 @@ const startProxy = (port: number): void => {
           } catch (error) {
             console.error('Failed to write rate limit cache:', error);
           }
+          const inspectedChunks: Uint8Array[] = [];
+          let inspectedBytes = 0;
+          upstreamResponse.on('data', (chunk: Buffer) => {
+            if (inspectedBytes >= MAX_INSPECTED_BODY_BYTES) return;
+            inspectedChunks.push(new Uint8Array(chunk));
+            inspectedBytes += chunk.length;
+          });
+          upstreamResponse.on('end', () => {
+            try {
+              const body = Buffer.concat(inspectedChunks).toString('utf8');
+              const limits = parseModelRateLimitsFromBody(body);
+              writeModelRateLimit(token, limits);
+            } catch (error) {
+              console.error('Failed to write model rate limit cache:', error);
+            }
+          });
         }
         clientResponse.writeHead(
           upstreamResponse.statusCode ?? 502,