github-issue-tower-defence-management 1.104.3 → 1.105.0

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

@@ -0,0 +1,139 @@
+import fs from 'fs';
+import path from 'path';
+import type { Issue } from '../../../domain/entities/Issue';
+import {
+  GenerateTokenStatusUseCase,
+  TokenRateLimitSnapshot,
+  TokenStatus,
+  TokenStatusInput,
+} from '../../../domain/usecases/dashboard/GenerateTokenStatusUseCase';
+import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
+import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
+import { ClaudeInteractiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { TakeOwnershipSpawnRepository } from '../../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
+import { RateLimitSnapshot, readRateLimit } from '../../proxy/RateLimitCache';
+import { loadTokenEntries } from '../../proxy/TokenListLoader';
+import { ProcClaudeInteractiveSessionRepository } from '../../repositories/ProcClaudeInteractiveSessionRepository';
+import { ProcTakeOwnershipSpawnRepository } from '../../repositories/ProcTakeOwnershipSpawnRepository';
+
+const SEVEN_DAY_SONNET_LIMIT_TYPE = 'seven_day_sonnet';
+const SEVEN_DAY_OPUS_LIMIT_TYPE = 'seven_day_opus';
+
+export type TokenStatusWriterParams = {
+  dashboardDataDir: string | null | undefined;
+  tokenListJsonPath: string | null | undefined;
+  issues: Issue[];
+  now?: Date;
+  readSnapshot?: (token: string) => RateLimitSnapshot | null;
+  interactiveSessionRepository?: ClaudeInteractiveSessionRepository;
+  spawnRepository?: TakeOwnershipSpawnRepository;
+};
+
+export type TokenStatusFile = {
+  tokens: TokenStatus[];
+  capturedAt: string;
+};
+
+const writeJsonAtomic = (filePath: string, data: unknown): void => {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data));
+  fs.renameSync(tmpPath, filePath);
+};
+
+export const toTokenRateLimitSnapshot = (
+  snapshot: RateLimitSnapshot | null,
+): TokenRateLimitSnapshot | null => {
+  if (snapshot === null) {
+    return null;
+  }
+  const hasWindowData =
+    snapshot.unifiedStatus !== null ||
+    snapshot.fiveHourReset > 0 ||
+    snapshot.sevenDayReset > 0 ||
+    snapshot.fiveHourUtilization > 0 ||
+    snapshot.sevenDayUtilization > 0;
+  return {
+    fiveHourUtilization: snapshot.fiveHourUtilization,
+    fiveHourReset: snapshot.fiveHourReset,
+    sevenDayUtilization: snapshot.sevenDayUtilization,
+    sevenDayReset: snapshot.sevenDayReset,
+    blocked: snapshot.blocked,
+    fiveHourRejected: snapshot.fiveHourRejected,
+    sevenDayRejected: snapshot.sevenDayRejected,
+    unifiedStatus: snapshot.unifiedStatus,
+    sevenDaySonnetRejected:
+      snapshot.modelWeeklyLimits[SEVEN_DAY_SONNET_LIMIT_TYPE]?.rejected ??
+      false,
+    sevenDayOpusRejected:
+      snapshot.modelWeeklyLimits[SEVEN_DAY_OPUS_LIMIT_TYPE]?.rejected ?? false,
+    hasWindowData,
+  };
+};
+
+export const writeTokenStatus = (params: TokenStatusWriterParams): void => {
+  const { dashboardDataDir, tokenListJsonPath, issues } = params;
+  if (!dashboardDataDir || !tokenListJsonPath) {
+    return;
+  }
+
+  const entries = loadTokenEntries(tokenListJsonPath);
+  if (entries === null) {
+    return;
+  }
+
+  const readSnapshot = params.readSnapshot ?? readRateLimit;
+  const interactiveSessionRepository =
+    params.interactiveSessionRepository ??
+    new ProcClaudeInteractiveSessionRepository();
+  const spawnRepository =
+    params.spawnRepository ?? new ProcTakeOwnershipSpawnRepository();
+
+  const tokenInputs: TokenStatusInput[] = entries.map((entry) => ({
+    name: entry.name,
+    token: entry.token,
+    snapshot: toTokenRateLimitSnapshot(readSnapshot(entry.token)),
+  }));
+
+  const distinctLogPathsByToken = new Map<string, Set<string>>();
+  for (const spawn of spawnRepository.listSpawns()) {
+    const logPaths =
+      distinctLogPathsByToken.get(spawn.token) ?? new Set<string>();
+    logPaths.add(spawn.logPath);
+    distinctLogPathsByToken.set(spawn.token, logPaths);
+  }
+  const prepCountByToken = new Map<string, number>();
+  for (const [token, logPaths] of distinctLogPathsByToken.entries()) {
+    prepCountByToken.set(token, logPaths.size);
+  }
+
+  const candidates: OauthTokenCandidate[] = entries.map((entry) => ({
+    name: entry.name,
+    token: entry.token,
+    snapshot: null,
+  }));
+  const humResult = new InTmuxByHumanSessionTokenCountUseCase().run(
+    candidates,
+    interactiveSessionRepository.listInteractiveSessions(),
+    issues,
+  );
+  const humCountByToken = new Map<string, number>(
+    humResult.counts.map((count) => [count.token, count.count]),
+  );
+
+  const now = params.now ?? new Date();
+  const tokens = new GenerateTokenStatusUseCase().run({
+    tokens: tokenInputs,
+    prepCountByToken,
+    humCountByToken,
+    nowEpochSeconds: Math.floor(now.getTime() / 1000),
+  });
+
+  const file: TokenStatusFile = {
+    tokens,
+    capturedAt: now.toISOString(),
+  };
+
+  writeJsonAtomic(path.join(dashboardDataDir, 'token-status.json'), file);
+};

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

@@ -180,6 +180,38 @@ describe('RateLimitCache', () => {
       expect(snapshot?.sevenDayRejected).toBe(false);
     });
 
+    it('should surface the raw unified status and overage-disabled reason headers', () => {
+      const token = 'unified-status-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed_warning',
+        'anthropic-ratelimit-unified-overage-disabled-reason': 'out_of_credits',
+        '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?.unifiedStatus).toBe('allowed_warning');
+      expect(snapshot?.overageDisabledReason).toBe('out_of_credits');
+    });
+
+    it('should expose null for the unified status and overage-disabled reason when absent', () => {
+      const token = 'no-unified-status-token';
+      writeRateLimit(token, {
+        '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?.unifiedStatus).toBeNull();
+      expect(snapshot?.overageDisabledReason).toBeNull();
+    });
+
     it('should return null when file does not exist', () => {
       expect(readRateLimit('never-written-token')).toBeNull();
     });

package/src/adapter/proxy/RateLimitCache.ts

@@ -18,6 +18,8 @@ export interface RateLimitSnapshot {
   unifiedRejected: boolean;
   fiveHourRejected: boolean;
   sevenDayRejected: boolean;
+  unifiedStatus: string | null;
+  overageDisabledReason: string | null;
   modelWeeklyLimits: Record<string, ModelWeeklyLimit>;
   lastUpdatedEpoch: number;
   blockedUntilEpoch: number;
@@ -252,6 +254,8 @@ export const readRateLimit = (
     const status = headers['anthropic-ratelimit-unified-status'];
     const fiveHourStatus = headers['anthropic-ratelimit-unified-5h-status'];
     const sevenDayStatus = headers['anthropic-ratelimit-unified-7d-status'];
+    const overageDisabledReason =
+      headers['anthropic-ratelimit-unified-overage-disabled-reason'];
     const unifiedRejected = status === 'rejected';
     const fiveHourRejected = fiveHourStatus === 'rejected';
     const sevenDayRejected = sevenDayStatus === 'rejected';
@@ -273,6 +277,8 @@ export const readRateLimit = (
       unifiedRejected,
       fiveHourRejected,
       sevenDayRejected,
+      unifiedStatus: status ?? null,
+      overageDisabledReason: overageDisabledReason ?? null,
       modelWeeklyLimits: {
         ...parseModelRateLimitsFromHeaders(headers),
         ...readModelWeeklyLimits(parsed),

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

@@ -0,0 +1,135 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  ProcHostMetricsRepository,
+  cpuUsedPercentFromSamples,
+  cycleMinutesFromMtimes,
+  parseCpuSample,
+  parseLoadAverages,
+  parseMemoryUsedPercent,
+} from './ProcHostMetricsRepository';
+
+describe('parseMemoryUsedPercent', () => {
+  it('computes (total - available) / total rounded to a whole percent', () => {
+    expect(
+      parseMemoryUsedPercent(
+        'MemTotal: 1000 kB\nMemFree: 100 kB\nMemAvailable: 380 kB\n',
+      ),
+    ).toBe(62);
+  });
+
+  it('throws when MemTotal is not positive', () => {
+    expect(() =>
+      parseMemoryUsedPercent('MemTotal: 0 kB\nMemAvailable: 0 kB\n'),
+    ).toThrow();
+  });
+});
+
+describe('parseCpuSample', () => {
+  it('uses the aggregate cpu line with idle = idle + iowait and total = sum of all fields', () => {
+    expect(
+      parseCpuSample('cpu  100 0 100 700 100 0 0 0 0 0\ncpu0 1 2 3 4\n'),
+    ).toEqual({ total: 1000, idle: 800 });
+  });
+
+  it('throws when there is no aggregate cpu line', () => {
+    expect(() => parseCpuSample('cpu0 1 2 3 4\n')).toThrow();
+  });
+});
+
+describe('cpuUsedPercentFromSamples', () => {
+  it('computes (total_delta - idle_delta) / total_delta', () => {
+    expect(
+      cpuUsedPercentFromSamples(
+        { total: 1000, idle: 700 },
+        { total: 1100, idle: 770 },
+      ),
+    ).toBe(30);
+  });
+
+  it('throws when the total delta is not positive', () => {
+    expect(() =>
+      cpuUsedPercentFromSamples(
+        { total: 1000, idle: 700 },
+        { total: 1000, idle: 700 },
+      ),
+    ).toThrow();
+  });
+});
+
+describe('parseLoadAverages', () => {
+  it('parses the first three floats from /proc/loadavg', () => {
+    expect(parseLoadAverages('1.20 0.98 0.75 1/123 4567\n')).toEqual({
+      oneMinute: 1.2,
+      fiveMinute: 0.98,
+      fifteenMinute: 0.75,
+    });
+  });
+
+  it('throws when fewer than three numeric values are present', () => {
+    expect(() => parseLoadAverages('1.20 0.98\n')).toThrow();
+  });
+});
+
+describe('cycleMinutesFromMtimes', () => {
+  it('rounds the gap between the two newest generations to whole minutes', () => {
+    expect(cycleMinutesFromMtimes([1782469254.0, 1782468443.0])).toBe(14);
+  });
+
+  it('rounds a 1620 second gap to 27 minutes', () => {
+    expect(cycleMinutesFromMtimes([1620.0, 0.0])).toBe(27);
+  });
+
+  it('returns null when a second generation is missing', () => {
+    expect(cycleMinutesFromMtimes([1000.0])).toBeNull();
+    expect(cycleMinutesFromMtimes([])).toBeNull();
+  });
+});
+
+describe('ProcHostMetricsRepository', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-proc-host-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { recursive: true, force: true });
+  });
+
+  it('reads memory used percent from /proc/meminfo', () => {
+    fs.writeFileSync(
+      path.join(procDirectory, 'meminfo'),
+      'MemTotal: 1000 kB\nMemAvailable: 380 kB\n',
+    );
+    const repository = new ProcHostMetricsRepository(procDirectory);
+    expect(repository.readMemoryUsedPercent()).toBe(62);
+  });
+
+  it('reads load averages from /proc/loadavg', () => {
+    fs.writeFileSync(
+      path.join(procDirectory, 'loadavg'),
+      '2.00 1.00 0.50 1/100 200\n',
+    );
+    const repository = new ProcHostMetricsRepository(procDirectory);
+    expect(repository.readLoadAverages()).toEqual({
+      oneMinute: 2.0,
+      fiveMinute: 1.0,
+      fifteenMinute: 0.5,
+    });
+  });
+
+  it('samples /proc/stat twice and computes the busy percent', async () => {
+    const statPath = path.join(procDirectory, 'stat');
+    let sampleIndex = 0;
+    fs.writeFileSync(statPath, 'cpu  700 0 0 300 0 0 0 0 0 0\n');
+    const sleep = async (): Promise<void> => {
+      sampleIndex += 1;
+      fs.writeFileSync(statPath, 'cpu  770 0 0 330 0 0 0 0 0 0\n');
+    };
+    const repository = new ProcHostMetricsRepository(procDirectory, sleep);
+    expect(await repository.readCpuUsedPercent()).toBe(70);
+    expect(sampleIndex).toBe(1);
+  });
+});

package/src/adapter/repositories/ProcHostMetricsRepository.ts

@@ -0,0 +1,136 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export type CpuSample = {
+  total: number;
+  idle: number;
+};
+
+export type LoadAverages = {
+  oneMinute: number;
+  fiveMinute: number;
+  fifteenMinute: number;
+};
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const CPU_SAMPLE_INTERVAL_MS = 400;
+
+export const parseMemoryUsedPercent = (meminfoText: string): number => {
+  const fields = new Map<string, number>();
+  for (const line of meminfoText.split('\n')) {
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    const valuePart = line
+      .slice(separatorIndex + 1)
+      .trim()
+      .split(/\s+/)[0];
+    const value = Number(valuePart);
+    if (Number.isFinite(value)) {
+      fields.set(key, value);
+    }
+  }
+  const total = fields.get('MemTotal');
+  const available = fields.get('MemAvailable');
+  if (total === undefined || available === undefined) {
+    throw new Error('MemTotal and MemAvailable are required');
+  }
+  if (total <= 0) {
+    throw new Error('MemTotal must be positive');
+  }
+  const used = total - available;
+  return Math.round((used / total) * 100);
+};
+
+export const parseCpuSample = (statText: string): CpuSample => {
+  for (const line of statText.split('\n')) {
+    if (line.startsWith('cpu ')) {
+      const values = line
+        .trim()
+        .split(/\s+/)
+        .slice(1)
+        .map((value) => Number(value));
+      if (values.some((value) => !Number.isFinite(value))) {
+        throw new Error('aggregate cpu line contains non-numeric values');
+      }
+      const idle = values[3] + (values.length > 4 ? values[4] : 0);
+      const total = values.reduce((sum, value) => sum + value, 0);
+      return { total, idle };
+    }
+  }
+  throw new Error('aggregate cpu line not found');
+};
+
+export const cpuUsedPercentFromSamples = (
+  first: CpuSample,
+  second: CpuSample,
+): number => {
+  const totalDelta = second.total - first.total;
+  const idleDelta = second.idle - first.idle;
+  if (totalDelta <= 0) {
+    throw new Error('total delta must be positive');
+  }
+  const busyDelta = totalDelta - idleDelta;
+  return Math.round((busyDelta / totalDelta) * 100);
+};
+
+export const parseLoadAverages = (loadavgText: string): LoadAverages => {
+  const parts = loadavgText.trim().split(/\s+/);
+  const oneMinute = Number(parts[0]);
+  const fiveMinute = Number(parts[1]);
+  const fifteenMinute = Number(parts[2]);
+  if (
+    !Number.isFinite(oneMinute) ||
+    !Number.isFinite(fiveMinute) ||
+    !Number.isFinite(fifteenMinute)
+  ) {
+    throw new Error('loadavg must contain three numeric values');
+  }
+  return { oneMinute, fiveMinute, fifteenMinute };
+};
+
+export const cycleMinutesFromMtimes = (
+  mtimesDescendingSeconds: number[],
+): number | null => {
+  if (mtimesDescendingSeconds.length < 2) {
+    return null;
+  }
+  return Math.round(
+    (mtimesDescendingSeconds[0] - mtimesDescendingSeconds[1]) / 60,
+  );
+};
+
+export class ProcHostMetricsRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+    private readonly sleep: (milliseconds: number) => Promise<void> = (
+      milliseconds,
+    ) =>
+      new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+      }),
+  ) {}
+
+  readMemoryUsedPercent = (): number =>
+    parseMemoryUsedPercent(
+      fs.readFileSync(path.join(this.procDirectory, 'meminfo'), 'utf8'),
+    );
+
+  readCpuUsedPercent = async (): Promise<number> => {
+    const first = parseCpuSample(
+      fs.readFileSync(path.join(this.procDirectory, 'stat'), 'utf8'),
+    );
+    await this.sleep(CPU_SAMPLE_INTERVAL_MS);
+    const second = parseCpuSample(
+      fs.readFileSync(path.join(this.procDirectory, 'stat'), 'utf8'),
+    );
+    return cpuUsedPercentFromSamples(first, second);
+  };
+
+  readLoadAverages = (): LoadAverages =>
+    parseLoadAverages(
+      fs.readFileSync(path.join(this.procDirectory, 'loadavg'), 'utf8'),
+    );
+}

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

@@ -0,0 +1,130 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcTakeOwnershipSpawnRepository } from './ProcTakeOwnershipSpawnRepository';
+
+type FakeProcess = {
+  pid: number;
+  cmdline: string;
+  environ: Record<string, string>;
+};
+
+const issueUrl = 'https://github.com/HiromiShikata/example/issues/1';
+const argv = (...parts: string[]): string => `${parts.join('\0')}\0`;
+
+describe('ProcTakeOwnershipSpawnRepository', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-proc-spawn-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { recursive: true, force: true });
+  });
+
+  const writeProcess = (fakeProcess: FakeProcess): void => {
+    const processDirectory = path.join(procDirectory, String(fakeProcess.pid));
+    fs.mkdirSync(processDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(processDirectory, 'cmdline'),
+      fakeProcess.cmdline,
+    );
+    const environBuffer = Object.entries(fakeProcess.environ)
+      .map(([key, value]) => `${key}=${value}\0`)
+      .join('');
+    fs.writeFileSync(path.join(processDirectory, 'environ'), environBuffer);
+  };
+
+  it('reads the token and log path of a Take ownership spawn', () => {
+    writeProcess({
+      pid: 301,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `claude-agent -p "Take ownership of ${issueUrl}" | tee /home/user/logs-aw/20260626_120000_abc.log`,
+      ),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-a' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([
+      { token: 'token-a', logPath: '/logs-aw/20260626_120000_abc.log' },
+    ]);
+  });
+
+  it('ignores a process that is not a Take ownership spawn', () => {
+    writeProcess({
+      pid: 302,
+      cmdline: argv('claude', '--name', issueUrl),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-b' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('ignores a Take ownership process whose cmdline carries no log path', () => {
+    writeProcess({
+      pid: 303,
+      cmdline: argv('claude-agent', '-p', `Take ownership of ${issueUrl}`),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-c' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('ignores a Take ownership process without an oauth token', () => {
+    writeProcess({
+      pid: 304,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `Take ownership of ${issueUrl} | tee /home/user/logs-aw/x.log`,
+      ),
+      environ: { ANTHROPIC_API_KEY: 'api-key' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('returns one entry per child process so the use case can dedupe by log path', () => {
+    const fullLogPath = '/home/user/logs-aw/20260626_120000_dup.log';
+    const capturedLogPath = '/logs-aw/20260626_120000_dup.log';
+    writeProcess({
+      pid: 305,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `Take ownership of ${issueUrl} | tee ${fullLogPath}`,
+      ),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-d' },
+    });
+    writeProcess({
+      pid: 306,
+      cmdline: argv('tee', fullLogPath, 'Take ownership marker'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-d' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([
+      { token: 'token-d', logPath: capturedLogPath },
+      { token: 'token-d', logPath: capturedLogPath },
+    ]);
+  });
+
+  it('returns an empty list when the proc directory does not exist', () => {
+    const repository = new ProcTakeOwnershipSpawnRepository(
+      path.join(procDirectory, 'missing'),
+    );
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+});