github-issue-tower-defence-management 2.19.1 → 2.19.3

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.ts

@@ -1,185 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { ClaudeTokenUsage } from '../../domain/entities/ClaudeTokenUsage';
-import { ClaudeTokenUsageRepository } from '../../domain/usecases/adapter-interfaces/ClaudeTokenUsageRepository';
-import { ensureProxyRunning } from '../proxy/ensureProxyRunning';
-import { PROXY_PORT, readRateLimit } from '../proxy/RateLimitCache';
-import { loadTokenEntries } from '../proxy/TokenListLoader';
-
-const TAKE_OWNERSHIP_COMMAND_MARKER = 'Take ownership';
-
-export class ProxyClaudeTokenUsageRepository implements ClaudeTokenUsageRepository {
-  constructor(
-    private readonly tokenListJsonPath: string | null,
-    private readonly port: number = PROXY_PORT,
-  ) {}
-
-  ensureObservable = async (): Promise<void> => {
-    await ensureProxyRunning(this.port);
-  };
-
-  getAvailableTokenUsages = async (): Promise<ClaudeTokenUsage[]> => {
-    if (this.tokenListJsonPath === null) {
-      return [];
-    }
-    const entries = loadTokenEntries(this.tokenListJsonPath);
-    if (entries === null) {
-      return [];
-    }
-    const nowEpochSeconds = Date.now() / 1000;
-    const usages = entries.map(
-      ({ name, token, selectionWeight }): ClaudeTokenUsage | null => {
-        const snapshot = readRateLimit(token);
-        if (snapshot !== null && snapshot.subscriptionDisabled) {
-          console.error(
-            `Claude subscription access is disabled for token '${name}'; leaving it out of the preparation concurrency allocation.`,
-          );
-          return null;
-        }
-        if (snapshot === null) {
-          return {
-            name,
-            token,
-            fiveHourUtilization: 0,
-            sevenDayUtilization: 0,
-            blocked: false,
-            rejected: false,
-            fiveHourRejected: false,
-            modelWeeklyLimits: {},
-            blockedUntilEpoch: 0,
-            selectionWeight,
-          };
-        }
-        const fiveHourExpired =
-          nowEpochSeconds > snapshot.fiveHourReset &&
-          snapshot.lastUpdatedEpoch >= snapshot.fiveHourReset;
-        const sevenDayExpired =
-          nowEpochSeconds > snapshot.sevenDayReset &&
-          snapshot.lastUpdatedEpoch >= snapshot.sevenDayReset;
-        const fiveHourUtilization = fiveHourExpired
-          ? 0
-          : snapshot.fiveHourUtilization;
-        const sevenDayUtilization = sevenDayExpired
-          ? 0
-          : snapshot.sevenDayUtilization;
-        const fiveHourRejectionActive =
-          snapshot.fiveHourRejected && !fiveHourExpired;
-        const sevenDayRejectionActive =
-          snapshot.sevenDayRejected && !sevenDayExpired;
-        const unifiedRejectionActive =
-          snapshot.unifiedRejected && !fiveHourExpired;
-        const rejected =
-          unifiedRejectionActive ||
-          fiveHourRejectionActive ||
-          sevenDayRejectionActive;
-        const modelWeeklyLimits: Record<
-          string,
-          { rejected: boolean; resetsAt: number }
-        > = {};
-        for (const [limitType, limit] of Object.entries(
-          snapshot.modelWeeklyLimits,
-        )) {
-          const expired = nowEpochSeconds > limit.resetsAt;
-          modelWeeklyLimits[limitType] = {
-            rejected: limit.rejected && !expired,
-            resetsAt: limit.resetsAt,
-          };
-        }
-        const hasAnySevenDayWeeklyLimit =
-          modelWeeklyLimits['seven_day'] !== undefined ||
-          modelWeeklyLimits['seven_day_opus'] !== undefined ||
-          modelWeeklyLimits['seven_day_sonnet'] !== undefined;
-        const needsGenericSevenDayBridge =
-          modelWeeklyLimits['seven_day'] === undefined &&
-          (!hasAnySevenDayWeeklyLimit || sevenDayRejectionActive);
-        if (
-          snapshot.sevenDayReset > 0 &&
-          !sevenDayExpired &&
-          needsGenericSevenDayBridge
-        ) {
-          modelWeeklyLimits['seven_day'] = {
-            rejected: sevenDayRejectionActive,
-            resetsAt: snapshot.sevenDayReset,
-          };
-        }
-        const cooldownActive = snapshot.blockedUntilEpoch > nowEpochSeconds;
-        return {
-          name,
-          token,
-          fiveHourUtilization,
-          sevenDayUtilization,
-          blocked: snapshot.blocked,
-          rejected,
-          fiveHourRejected: fiveHourRejectionActive,
-          modelWeeklyLimits,
-          blockedUntilEpoch: cooldownActive ? snapshot.blockedUntilEpoch : 0,
-          selectionWeight,
-        };
-      },
-    );
-    return usages.filter((usage): usage is ClaudeTokenUsage => usage !== null);
-  };
-
-  getTokenInFlightCounts = async (): Promise<Record<string, number>> => {
-    const counts: Record<string, number> = {};
-    let procEntries: string[];
-    try {
-      procEntries = fs.readdirSync('/proc');
-    } catch {
-      return counts;
-    }
-    const tokenByPid = new Map<number, string>();
-    for (const entry of procEntries) {
-      if (!/^\d+$/.test(entry)) continue;
-      const environPath = path.join('/proc', entry, 'environ');
-      let environ: string;
-      try {
-        environ = fs.readFileSync(environPath, 'utf8');
-      } catch {
-        continue;
-      }
-      const vars = environ.split('\0');
-      const tokenEntry = vars.find((v) =>
-        v.startsWith('CLAUDE_CODE_OAUTH_TOKEN='),
-      );
-      if (tokenEntry === undefined) continue;
-      const token = tokenEntry.slice('CLAUDE_CODE_OAUTH_TOKEN='.length);
-      if (token.length === 0) continue;
-      if (!this.isPreparationWorkerProcess(entry)) continue;
-      tokenByPid.set(Number(entry), token);
-    }
-    for (const [pid, token] of tokenByPid) {
-      const parentPid = this.readParentPid(pid);
-      if (parentPid !== null && tokenByPid.has(parentPid)) continue;
-      counts[token] = (counts[token] ?? 0) + 1;
-    }
-    return counts;
-  };
-
-  private isPreparationWorkerProcess = (procEntry: string): boolean => {
-    const commandLinePath = path.join('/proc', procEntry, 'cmdline');
-    let commandLine: string;
-    try {
-      commandLine = fs.readFileSync(commandLinePath, 'utf8');
-    } catch {
-      return false;
-    }
-    return commandLine.includes(TAKE_OWNERSHIP_COMMAND_MARKER);
-  };
-
-  private readParentPid = (pid: number): number | null => {
-    let stat: string;
-    try {
-      stat = fs.readFileSync(path.join('/proc', String(pid), 'stat'), 'utf8');
-    } catch {
-      return null;
-    }
-    const afterComm = stat.slice(stat.lastIndexOf(') ') + 2);
-    const fields = afterComm.trim().split(/\s+/);
-    const parentPid = Number(fields[1]);
-    if (!Number.isInteger(parentPid)) return null;
-    return parentPid;
-  };
-
-  proxyBaseUrl = (): string => `http://127.0.0.1:${this.port}`;
-}

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

@@ -1,116 +0,0 @@
-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;
-    const recentEpoch = Math.floor(Date.now() / 1000) - 60;
-
-    it('should return fiveHourReset as unifiedReset and ts as lastProbeEpoch 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: {},
-        lastUpdatedEpoch: recentEpoch,
-      });
-      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
-
-      const result = repository.getTokenRateLimitCaches();
-
-      expect(result).toEqual([
-        {
-          token: 'token-a',
-          unifiedReset: futureReset,
-          lastProbeEpoch: recentEpoch,
-        },
-      ]);
-    });
-
-    it('should return unifiedReset of 0 and lastProbeEpoch 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, lastProbeEpoch: 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: {},
-            lastUpdatedEpoch: recentEpoch,
-          };
-        }
-        return null;
-      });
-      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
-
-      const result = repository.getTokenRateLimitCaches();
-
-      expect(result).toEqual([
-        {
-          token: 'token-a',
-          unifiedReset: futureReset,
-          lastProbeEpoch: recentEpoch,
-        },
-        { token: 'token-b', unifiedReset: 0, lastProbeEpoch: 0 },
-      ]);
-    });
-  });
-});

package/src/adapter/repositories/ProxyRateLimitCacheRepository.ts

@@ -1,67 +0,0 @@
-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;
-      const lastProbeEpoch = snapshot !== null ? snapshot.lastUpdatedEpoch : 0;
-      return { token, unifiedReset, lastProbeEpoch };
-    });
-  };
-
-  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/adapter/repositories/RateLimitSnapshotRepository.ts

@@ -1,50 +0,0 @@
-import {
-  TokenModelWeeklyLimit,
-  TokenRateLimitSnapshot,
-  TokenRateLimitSnapshotRepository,
-} from '../../domain/usecases/adapter-interfaces/TokenRateLimitSnapshotRepository';
-import { loadTokenEntries } from '../proxy/TokenListLoader';
-import { readRateLimit, cacheDir } from '../proxy/RateLimitCache';
-
-export class RateLimitSnapshotRepository implements TokenRateLimitSnapshotRepository {
-  constructor(
-    private readonly tokenListJsonPath: string,
-    private readonly baseDir: string = cacheDir(),
-  ) {}
-
-  listSnapshots = (): TokenRateLimitSnapshot[] => {
-    const entries = loadTokenEntries(this.tokenListJsonPath);
-    if (entries === null) {
-      return [];
-    }
-    const snapshots: TokenRateLimitSnapshot[] = [];
-    for (const { name, token } of entries) {
-      const snapshot = readRateLimit(token, this.baseDir);
-      if (snapshot === null) {
-        continue;
-      }
-      snapshots.push({
-        token,
-        name,
-        fiveHourUtilization: snapshot.fiveHourUtilization,
-        fiveHourReset: snapshot.fiveHourReset,
-        sevenDayUtilization: snapshot.sevenDayUtilization,
-        sevenDayReset: snapshot.sevenDayReset,
-        blocked: snapshot.blocked,
-        rejected: snapshot.rejected,
-        blockedUntilEpoch: snapshot.blockedUntilEpoch,
-        modelWeeklyLimits: this.toModelWeeklyLimits(snapshot.modelWeeklyLimits),
-        lastUpdatedEpoch: snapshot.lastUpdatedEpoch,
-      });
-    }
-    return snapshots;
-  };
-
-  private toModelWeeklyLimits = (
-    modelWeeklyLimits: Record<string, { rejected: boolean; resetsAt: number }>,
-  ): TokenModelWeeklyLimit[] =>
-    Object.values(modelWeeklyLimits).map((limit) => ({
-      rejected: limit.rejected,
-      resetsAt: limit.resetsAt,
-    }));
-}

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

@@ -1,19 +0,0 @@
-import { RealSleeper } from './RealSleeper';
-
-describe('RealSleeper', () => {
-  it('resolves after roughly the requested delay', async () => {
-    const sleeper = new RealSleeper();
-    const start = Date.now();
-    await sleeper.sleep(30);
-    const elapsed = Date.now() - start;
-    expect(elapsed).toBeGreaterThanOrEqual(20);
-  });
-
-  it('resolves immediately for a non-positive delay', async () => {
-    const sleeper = new RealSleeper();
-    const start = Date.now();
-    await sleeper.sleep(0);
-    const elapsed = Date.now() - start;
-    expect(elapsed).toBeLessThan(20);
-  });
-});

package/src/adapter/repositories/RealSleeper.ts

@@ -1,12 +0,0 @@
-import { Sleeper } from '../../domain/usecases/adapter-interfaces/Sleeper';
-
-export class RealSleeper implements Sleeper {
-  sleep = (milliseconds: number): Promise<void> => {
-    if (milliseconds <= 0) {
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-      setTimeout(resolve, milliseconds);
-    });
-  };
-}