npm - github-issue-tower-defence-management - Versions diffs - 1.95.0 → 1.96.0 - Mend

github-issue-tower-defence-management 1.95.0 → 1.96.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

package/src/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-BeJzGnfH.js"></script>
+    <script type="module" crossorigin src="/assets/index-B3F4E8LD.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CO3Vvzqr.css">
   </head>
   <body>

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.test.ts ADDED Viewed

@@ -0,0 +1,268 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  ClaudeLiveSession,
+  ClaudeLiveSessionRepository,
+} from '../../../domain/usecases/adapter-interfaces/ClaudeLiveSessionRepository';
+import { LiveSessionOauthTokenSelectUseCase } from '../../../domain/usecases/LiveSessionOauthTokenSelectUseCase';
+import { hashToken } from '../../proxy/RateLimitCache';
+import { LiveSessionOauthTokenSelectHandler } from './LiveSessionOauthTokenSelectHandler';
+const NOW = 2_000_000;
+const HOUR = 3600;
+const DAY = 86400;
+type FakeHeaders = {
+  fiveHourUtilization: number;
+  fiveHourReset: number;
+  sevenDayUtilization: number;
+  sevenDayReset: number;
+};
+class FakeClaudeLiveSessionRepository implements ClaudeLiveSessionRepository {
+  constructor(private readonly sessions: ClaudeLiveSession[]) {}
+  listLiveSessions = (): ClaudeLiveSession[] => this.sessions;
+}
+describe('LiveSessionOauthTokenSelectHandler', () => {
+  let tempDir: string;
+  let cacheDirectory: string;
+  let tokenListPath: string;
+  const originalTokenListEnv =
+    process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+  const originalCacheEnv = process.env.TDPM_RATELIMIT_CACHE_DIR;
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'select-live-token-'));
+    cacheDirectory = path.join(tempDir, 'cache');
+    fs.mkdirSync(cacheDirectory, { recursive: true });
+    tokenListPath = path.join(tempDir, 'tokens.json');
+    delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+    delete process.env.TDPM_RATELIMIT_CACHE_DIR;
+  });
+  afterEach(() => {
+    if (originalTokenListEnv === undefined) {
+      delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+    } else {
+      process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH = originalTokenListEnv;
+    }
+    if (originalCacheEnv === undefined) {
+      delete process.env.TDPM_RATELIMIT_CACHE_DIR;
+    } else {
+      process.env.TDPM_RATELIMIT_CACHE_DIR = originalCacheEnv;
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+  const writeTokenList = (entries: { name: string; token: string }[]): void => {
+    fs.writeFileSync(tokenListPath, JSON.stringify(entries));
+  };
+  const writeCache = (token: string, headers: FakeHeaders): void => {
+    const payload = {
+      ts: NOW,
+      headers: {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': String(headers.fiveHourReset),
+        'anthropic-ratelimit-unified-5h-utilization': String(
+          headers.fiveHourUtilization,
+        ),
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': String(headers.sevenDayReset),
+        'anthropic-ratelimit-unified-7d-utilization': String(
+          headers.sevenDayUtilization,
+        ),
+      },
+      modelWeeklyLimits: {},
+    };
+    fs.writeFileSync(
+      path.join(cacheDirectory, `${hashToken(token)}.json`),
+      JSON.stringify(payload),
+    );
+  };
+  const buildHandler = (
+    sessions: ClaudeLiveSession[],
+  ): LiveSessionOauthTokenSelectHandler =>
+    new LiveSessionOauthTokenSelectHandler(
+      new LiveSessionOauthTokenSelectUseCase(),
+      new FakeClaudeLiveSessionRepository(sessions),
+    );
+  it('selects the eligible token with the fewest live sessions', () => {
+    writeTokenList([
+      { name: 'busy', token: 'fake-busy' },
+      { name: 'idle', token: 'fake-idle' },
+    ]);
+    writeCache('fake-busy', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 2 * DAY,
+    });
+    writeCache('fake-idle', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 6 * DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-busy', sessionId: 'session-a' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('idle');
+    expect(output.selectedToken).toBe('fake-idle');
+  });
+  it('breaks an occupancy tie by the soonest 7d reset', () => {
+    writeTokenList([
+      { name: 'far', token: 'fake-far' },
+      { name: 'soon', token: 'fake-soon' },
+    ]);
+    writeCache('fake-far', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 6 * DAY,
+    });
+    writeCache('fake-soon', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 2 * DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-far', sessionId: 'session-a' },
+      { token: 'fake-soon', sessionId: 'session-b' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('soon');
+  });
+  it('dedupes child processes that share a session id when counting occupancy', () => {
+    writeTokenList([
+      { name: 'oneSession', token: 'fake-one' },
+      { name: 'twoSessions', token: 'fake-two' },
+    ]);
+    writeCache('fake-one', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 2 * DAY,
+    });
+    writeCache('fake-two', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 6 * DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-one', sessionId: 'session-a' },
+      { token: 'fake-one', sessionId: 'session-a' },
+      { token: 'fake-two', sessionId: 'session-b' },
+      { token: 'fake-two', sessionId: 'session-c' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('oneSession');
+  });
+  it('excludes a rate-limit-ineligible token even when it is unoccupied', () => {
+    writeTokenList([
+      { name: 'blocked', token: 'fake-blocked' },
+      { name: 'free', token: 'fake-free' },
+    ]);
+    writeCache('fake-blocked', {
+      fiveHourUtilization: 0.9,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    writeCache('fake-free', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-free', sessionId: 'session-a' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('free');
+  });
+  it('returns null and a diagnostic when no token passes the filter', () => {
+    writeTokenList([{ name: 'busy', token: 'fake-busy' }]);
+    writeCache('fake-busy', {
+      fiveHourUtilization: 0.9,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = buildHandler([]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.diagnostics.join('\n')).toContain(
+      'No eligible token passed the rate-limit filter.',
+    );
+  });
+  it('returns a diagnostic when no token list path is resolvable', () => {
+    const handler = buildHandler([]);
+    const output = handler.handle({
+      tokenListJsonPath: null,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.diagnostics.join('\n')).toContain('No token list path');
+  });
+  it('returns a diagnostic when the token list file has no usable entries', () => {
+    fs.writeFileSync(tokenListPath, JSON.stringify([]));
+    const handler = buildHandler([]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.diagnostics.join('\n')).toContain('No usable token entries');
+  });
+});

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.ts ADDED Viewed

@@ -0,0 +1,116 @@
+import { ClaudeLiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeLiveSessionRepository';
+import {
+  LiveSessionOauthTokenSelectResult,
+  LiveSessionOauthTokenSelectUseCase,
+} from '../../../domain/usecases/LiveSessionOauthTokenSelectUseCase';
+import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
+import { ProcClaudeLiveSessionRepository } from '../../repositories/ProcClaudeLiveSessionRepository';
+import { readRateLimit } from '../../proxy/RateLimitCache';
+import { loadTokenEntries } from '../../proxy/TokenListLoader';
+import {
+  resolveCacheDirectory,
+  resolveTokenListJsonPath,
+} from './OauthTokenSelectHandler';
+export type LiveSessionOauthTokenSelectHandlerInput = {
+  tokenListJsonPath: string | null;
+  cacheDirectory: string | null;
+  nowEpochSeconds: number;
+};
+export type LiveSessionOauthTokenSelectHandlerOutput = {
+  selectedToken: string | null;
+  selectedName: string | null;
+  diagnostics: string[];
+};
+export class LiveSessionOauthTokenSelectHandler {
+  constructor(
+    private readonly useCase: LiveSessionOauthTokenSelectUseCase = new LiveSessionOauthTokenSelectUseCase(),
+    private readonly liveSessionRepository: ClaudeLiveSessionRepository = new ProcClaudeLiveSessionRepository(),
+  ) {}
+  handle = (
+    input: LiveSessionOauthTokenSelectHandlerInput,
+  ): LiveSessionOauthTokenSelectHandlerOutput => {
+    const tokenListJsonPath = resolveTokenListJsonPath(input.tokenListJsonPath);
+    if (tokenListJsonPath === null) {
+      return {
+        selectedToken: null,
+        selectedName: null,
+        diagnostics: [
+          'No token list path provided. Pass --tokenListJsonPath or set CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH.',
+        ],
+      };
+    }
+    const entries = loadTokenEntries(tokenListJsonPath);
+    if (entries === null) {
+      return {
+        selectedToken: null,
+        selectedName: null,
+        diagnostics: [
+          `No usable token entries loaded from ${tokenListJsonPath}.`,
+        ],
+      };
+    }
+    const cacheDirectory = resolveCacheDirectory(input.cacheDirectory);
+    const candidates: OauthTokenCandidate[] = entries.map(({ name, token }) => {
+      const snapshot = readRateLimit(token, cacheDirectory);
+      return {
+        name,
+        token,
+        snapshot:
+          snapshot === null
+            ? null
+            : {
+                fiveHourUtilization: snapshot.fiveHourUtilization,
+                fiveHourReset: snapshot.fiveHourReset,
+                sevenDayUtilization: snapshot.sevenDayUtilization,
+                sevenDayReset: snapshot.sevenDayReset,
+              },
+      };
+    });
+    const liveSessions = this.liveSessionRepository.listLiveSessions();
+    const result = this.useCase.run(
+      candidates,
+      liveSessions,
+      input.nowEpochSeconds,
+    );
+    return {
+      selectedToken: result.selected?.token ?? null,
+      selectedName: result.selected?.name ?? null,
+      diagnostics: this.formatDiagnostics(result, input.nowEpochSeconds),
+    };
+  };
+  private formatDiagnostics = (
+    result: LiveSessionOauthTokenSelectResult,
+    nowEpochSeconds: number,
+  ): string[] => {
+    const lines = result.metrics.map((metric) => {
+      const secondsUntilSevenDayEnd = Math.round(
+        metric.sevenDayEndEpoch - nowEpochSeconds,
+      );
+      const status = metric.eligible
+        ? 'eligible'
+        : `excluded (${metric.exclusionReason})`;
+      return `${metric.name}: ${metric.liveSessionCount} live session(s), 5h ${Math.round(metric.fiveHourFreeRatio * 100)}% free, 7d ${Math.round(metric.sevenDayFreeRatio * 100)}% free, 7d-end in ${secondsUntilSevenDayEnd}s -> ${status}`;
+    });
+    if (result.selected === null) {
+      lines.push('No eligible token passed the rate-limit filter.');
+    } else {
+      lines.push(
+        `Selected ${result.selected.name} (fewest live sessions, then soonest 7d reset among eligible tokens).`,
+      );
+    }
+    return lines;
+  };
+}

package/src/adapter/repositories/ProcClaudeLiveSessionRepository.test.ts ADDED Viewed

@@ -0,0 +1,146 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcClaudeLiveSessionRepository } from './ProcClaudeLiveSessionRepository';
+type FakeProcess = {
+  pid: number;
+  cmdline: string;
+  environ: Record<string, string>;
+};
+describe('ProcClaudeLiveSessionRepository', () => {
+  let procDirectory: string;
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-proc-'));
+  });
+  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);
+  };
+  const writeNonNumericEntry = (name: string): void => {
+    fs.mkdirSync(path.join(procDirectory, name), { recursive: true });
+  };
+  it('reads token and session id from a claude process environ', () => {
+    writeProcess({
+      pid: 101,
+      cmdline: '/home/user/.local/share/claude/cli.js\0--print\0',
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
+        CLAUDE_CODE_SESSION_ID: 'session-a',
+      },
+    });
+    const repository = new ProcClaudeLiveSessionRepository(procDirectory);
+    expect(repository.listLiveSessions()).toEqual([
+      { token: 'token-a', sessionId: 'session-a' },
+    ]);
+  });
+  it('identifies a claude process by the claude executable name', () => {
+    writeProcess({
+      pid: 102,
+      cmdline: '/usr/local/bin/claude\0',
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-b',
+        CLAUDE_CODE_SESSION_ID: 'session-b',
+      },
+    });
+    const repository = new ProcClaudeLiveSessionRepository(procDirectory);
+    expect(repository.listLiveSessions()).toEqual([
+      { token: 'token-b', sessionId: 'session-b' },
+    ]);
+  });
+  it('ignores a process without an oauth token (for example an api-key session)', () => {
+    writeProcess({
+      pid: 103,
+      cmdline: '/usr/local/bin/claude\0',
+      environ: {
+        CLAUDE_CODE_SESSION_ID: 'session-c',
+        ANTHROPIC_API_KEY: 'api-key',
+      },
+    });
+    const repository = new ProcClaudeLiveSessionRepository(procDirectory);
+    expect(repository.listLiveSessions()).toEqual([]);
+  });
+  it('ignores a non-claude process that happens to carry the token', () => {
+    writeProcess({
+      pid: 104,
+      cmdline: '/usr/bin/bash\0',
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-d',
+        CLAUDE_CODE_SESSION_ID: 'session-d',
+      },
+    });
+    const repository = new ProcClaudeLiveSessionRepository(procDirectory);
+    expect(repository.listLiveSessions()).toEqual([]);
+  });
+  it('returns one entry per child process so the use case can dedupe by session id', () => {
+    writeProcess({
+      pid: 105,
+      cmdline: '/home/user/.local/share/claude/cli.js\0',
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-e',
+        CLAUDE_CODE_SESSION_ID: 'session-e',
+      },
+    });
+    writeProcess({
+      pid: 106,
+      cmdline: '/home/user/.local/share/claude/cli.js\0',
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-e',
+        CLAUDE_CODE_SESSION_ID: 'session-e',
+      },
+    });
+    const repository = new ProcClaudeLiveSessionRepository(procDirectory);
+    expect(repository.listLiveSessions()).toEqual([
+      { token: 'token-e', sessionId: 'session-e' },
+      { token: 'token-e', sessionId: 'session-e' },
+    ]);
+  });
+  it('skips non-numeric proc entries and unreadable processes', () => {
+    writeNonNumericEntry('cpuinfo');
+    fs.mkdirSync(path.join(procDirectory, '107'), { recursive: true });
+    const repository = new ProcClaudeLiveSessionRepository(procDirectory);
+    expect(repository.listLiveSessions()).toEqual([]);
+  });
+  it('returns an empty list when the proc directory does not exist', () => {
+    const repository = new ProcClaudeLiveSessionRepository(
+      path.join(procDirectory, 'missing'),
+    );
+    expect(repository.listLiveSessions()).toEqual([]);
+  });
+});

package/src/adapter/repositories/ProcClaudeLiveSessionRepository.ts ADDED Viewed

@@ -0,0 +1,119 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  ClaudeLiveSession,
+  ClaudeLiveSessionRepository,
+} from '../../domain/usecases/adapter-interfaces/ClaudeLiveSessionRepository';
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const OAUTH_TOKEN_ENVIRON_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const SESSION_ID_ENVIRON_KEY = 'CLAUDE_CODE_SESSION_ID';
+const isClaudeProcessCommand = (command: string): boolean => {
+  if (command.length === 0) {
+    return false;
+  }
+  if (command.includes('.local/share/claude')) {
+    return true;
+  }
+  const executableName = path.basename(command.split('\0')[0] ?? '');
+  return executableName === 'claude';
+};
+export class ProcClaudeLiveSessionRepository implements ClaudeLiveSessionRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+  ) {}
+  listLiveSessions = (): ClaudeLiveSession[] => {
+    const liveSessions: ClaudeLiveSession[] = [];
+    for (const pidDirectory of this.listProcessIdDirectories()) {
+      const liveSession = this.readLiveSession(pidDirectory);
+      if (liveSession !== null) {
+        liveSessions.push(liveSession);
+      }
+    }
+    return liveSessions;
+  };
+  private listProcessIdDirectories = (): string[] => {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.procDirectory);
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => /^\d+$/.test(entry));
+  };
+  private readLiveSession = (
+    processIdDirectory: string,
+  ): ClaudeLiveSession | null => {
+    const environ = this.readEnviron(processIdDirectory);
+    if (environ === null) {
+      return null;
+    }
+    const token = environ.get(OAUTH_TOKEN_ENVIRON_KEY);
+    const sessionId = environ.get(SESSION_ID_ENVIRON_KEY);
+    if (
+      token === undefined ||
+      token.length === 0 ||
+      sessionId === undefined ||
+      sessionId.length === 0
+    ) {
+      return null;
+    }
+    if (!this.isClaudeProcess(processIdDirectory)) {
+      return null;
+    }
+    return { token, sessionId };
+  };
+  private isClaudeProcess = (processIdDirectory: string): boolean => {
+    const basePath = path.join(this.procDirectory, processIdDirectory);
+    try {
+      const cmdline = fs.readFileSync(path.join(basePath, 'cmdline'), 'utf8');
+      if (isClaudeProcessCommand(cmdline)) {
+        return true;
+      }
+    } catch {
+      return false;
+    }
+    try {
+      const exe = fs.readlinkSync(path.join(basePath, 'exe'));
+      return isClaudeProcessCommand(exe);
+    } catch {
+      return false;
+    }
+  };
+  private readEnviron = (
+    processIdDirectory: string,
+  ): Map<string, string> | null => {
+    const environPath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'environ',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(environPath, 'utf8');
+    } catch {
+      return null;
+    }
+    const environ = new Map<string, string>();
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ.set(key, value);
+    }
+    return environ;
+  };
+}