github-issue-tower-defence-management 1.54.0 → 1.56.0

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

@@ -0,0 +1,82 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { loadTokens } from './TokenListLoader';
+
+describe('TokenListLoader', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-list-loader-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should return tokens in the order they appear in the JSON file', () => {
+    const filePath = path.join(tempDir, 'tokens.json');
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify([
+        { name: 'first', token: 'token-1' },
+        { name: 'second', token: 'token-2' },
+      ]),
+    );
+    expect(loadTokens(filePath)).toEqual(['token-1', 'token-2']);
+  });
+
+  it('should return null when the file does not exist', () => {
+    expect(loadTokens(path.join(tempDir, 'missing.json'))).toBeNull();
+  });
+
+  it('should return null when the JSON root is not an array', () => {
+    const filePath = path.join(tempDir, 'object.json');
+    fs.writeFileSync(filePath, JSON.stringify({ token: 'token-1' }));
+    expect(loadTokens(filePath)).toBeNull();
+  });
+
+  it('should return null when JSON parsing fails', () => {
+    const filePath = path.join(tempDir, 'malformed.json');
+    fs.writeFileSync(filePath, '{not json');
+    expect(loadTokens(filePath)).toBeNull();
+  });
+
+  it('should skip entries that do not contain a string token', () => {
+    const filePath = path.join(tempDir, 'mixed.json');
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify([
+        { name: 'no-token' },
+        { name: 'first', token: 'token-1' },
+        { name: 'numeric', token: 123 },
+        { name: 'second', token: 'token-2' },
+      ]),
+    );
+    expect(loadTokens(filePath)).toEqual(['token-1', 'token-2']);
+  });
+
+  it('should return null when every entry is invalid', () => {
+    const filePath = path.join(tempDir, 'no-valid-entries.json');
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify([{ name: 'no-token' }, { token: 42 }]),
+    );
+    expect(loadTokens(filePath)).toBeNull();
+  });
+
+  it('should expand a leading tilde to the home directory', () => {
+    const home = os.homedir();
+    const fileName = `tdpm-loader-${process.pid}-${Date.now()}.json`;
+    const targetPath = path.join(home, fileName);
+    fs.writeFileSync(
+      targetPath,
+      JSON.stringify([{ name: 'first', token: 'home-token' }]),
+    );
+    try {
+      expect(loadTokens(`~/${fileName}`)).toEqual(['home-token']);
+    } finally {
+      fs.unlinkSync(targetPath);
+    }
+  });
+});

package/src/adapter/proxy/TokenListLoader.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+const expandHome = (filePath: string): string => {
+  if (filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  if (filePath === '~') {
+    return os.homedir();
+  }
+  return filePath;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+export const loadTokens = (jsonPath: string): string[] | null => {
+  const resolved = expandHome(jsonPath);
+  if (!fs.existsSync(resolved)) return null;
+  try {
+    const raw = fs.readFileSync(resolved, 'utf8');
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return null;
+    const tokens: string[] = [];
+    for (const entry of parsed) {
+      if (isRecord(entry) && typeof entry.token === 'string') {
+        tokens.push(entry.token);
+      }
+    }
+    return tokens.length > 0 ? tokens : null;
+  } catch {
+    return null;
+  }
+};

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

@@ -0,0 +1,85 @@
+import * as net from 'net';
+import * as path from 'path';
+
+const spawnCalls: unknown[][] = [];
+const unrefMock = jest.fn();
+const spawnReturnValue = { unref: unrefMock };
+
+jest.mock('child_process', () => ({
+  spawn: (...args: unknown[]): { unref: jest.Mock } => {
+    spawnCalls.push(args);
+    return spawnReturnValue;
+  },
+}));
+
+import { ensureProxyRunning } from './ensureProxyRunning';
+
+describe('ensureProxyRunning', () => {
+  let server: net.Server | null = null;
+  let port = 0;
+
+  const startProbeServer = (): Promise<void> =>
+    new Promise((resolve) => {
+      server = net.createServer((socket) => socket.end());
+      server.listen(0, '127.0.0.1', () => {
+        const address = server?.address();
+        if (address !== null && typeof address === 'object') {
+          port = address.port;
+        }
+        resolve();
+      });
+    });
+
+  beforeEach(() => {
+    spawnCalls.length = 0;
+    unrefMock.mockReset();
+  });
+
+  afterEach(async () => {
+    if (server !== null) {
+      await new Promise<void>((resolve) => server?.close(() => resolve()));
+      server = null;
+    }
+  });
+
+  it('should short-circuit and not spawn when the port already responds', async () => {
+    await startProbeServer();
+    await ensureProxyRunning(port);
+    expect(spawnCalls).toHaveLength(0);
+  });
+
+  it('should spawn the proxy detached when the port is unresponsive', async () => {
+    const unusedPort = await new Promise<number>((resolve) => {
+      const probe = net.createServer();
+      probe.listen(0, '127.0.0.1', () => {
+        const address = probe.address();
+        const portValue =
+          address !== null && typeof address === 'object' ? address.port : 0;
+        probe.close(() => resolve(portValue));
+      });
+    });
+
+    await ensureProxyRunning(unusedPort);
+
+    expect(spawnCalls).toHaveLength(1);
+    const [program, args, options] = spawnCalls[0];
+    expect(program).toBe(process.execPath);
+    if (!Array.isArray(args)) {
+      throw new Error('Expected spawn args to be an array');
+    }
+    expect(args).toHaveLength(1);
+    const firstArg: unknown = args[0];
+    if (typeof firstArg !== 'string') {
+      throw new Error('Expected first spawn argument to be a string');
+    }
+    expect(firstArg.endsWith(path.join('proxy', 'proxyEntry.js'))).toBe(true);
+    const isObject = (value: unknown): value is { [key: string]: unknown } =>
+      value !== null && typeof value === 'object' && !Array.isArray(value);
+    if (!isObject(options)) {
+      throw new Error('Expected spawn options to be an object');
+    }
+    expect(options.detached).toBe(true);
+    expect(options.stdio).toBe('ignore');
+    expect(unrefMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/adapter/proxy/ensureProxyRunning.ts

@@ -0,0 +1,41 @@
+import { spawn } from 'child_process';
+import * as net from 'net';
+import * as path from 'path';
+import { PROXY_PORT } from './RateLimitCache';
+
+const PROBE_TIMEOUT_MS = 200;
+const STARTUP_WAIT_MS = 1500;
+
+const isProxyResponding = (port: number): Promise<boolean> =>
+  new Promise((resolve) => {
+    const socket = new net.Socket();
+    let resolved = false;
+    const cleanup = (result: boolean): void => {
+      if (resolved) return;
+      resolved = true;
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(PROBE_TIMEOUT_MS);
+    socket.once('connect', () => cleanup(true));
+    socket.once('timeout', () => cleanup(false));
+    socket.once('error', () => cleanup(false));
+    socket.connect(port, '127.0.0.1');
+  });
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+export const ensureProxyRunning = async (
+  port: number = PROXY_PORT,
+): Promise<void> => {
+  if (await isProxyResponding(port)) return;
+  const entryPath = path.resolve(__dirname, 'proxyEntry.js');
+  const child = spawn(process.execPath, [entryPath], {
+    detached: true,
+    stdio: 'ignore',
+    env: process.env,
+  });
+  child.unref();
+  await sleep(STARTUP_WAIT_MS);
+};

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

@@ -0,0 +1,48 @@
+import { extractToken } from './proxyEntry';
+
+describe('extractToken', () => {
+  it('should return the token after a Bearer prefix', () => {
+    expect(extractToken('Bearer sk-ant-token-123')).toBe('sk-ant-token-123');
+  });
+
+  it('should accept a lowercase bearer prefix', () => {
+    expect(extractToken('bearer sk-ant-token-123')).toBe('sk-ant-token-123');
+  });
+
+  it('should accept a mixed-case Bearer prefix', () => {
+    expect(extractToken('BeArEr sk-ant-token-123')).toBe('sk-ant-token-123');
+  });
+
+  it('should trim surrounding whitespace from the token', () => {
+    expect(extractToken('Bearer   sk-ant-token-123   ')).toBe(
+      'sk-ant-token-123',
+    );
+  });
+
+  it('should pick the first value when authorization is an array', () => {
+    expect(extractToken(['Bearer token-a', 'Bearer token-b'])).toBe('token-a');
+  });
+
+  it('should return null when authorization is undefined', () => {
+    expect(extractToken(undefined)).toBeNull();
+  });
+
+  it('should return null when the prefix is missing', () => {
+    expect(extractToken('Basic some-credential')).toBeNull();
+  });
+
+  it('should return null when only the prefix is provided', () => {
+    expect(extractToken('Bearer ')).toBeNull();
+  });
+
+  it('should return null when the input is shorter than the prefix', () => {
+    expect(extractToken('Bear')).toBeNull();
+  });
+
+  it('should run in linear time on adversarial whitespace input', () => {
+    const adversarial = `bearer ${' '.repeat(50000)}`;
+    const startedAt = Date.now();
+    expect(extractToken(adversarial)).toBeNull();
+    expect(Date.now() - startedAt).toBeLessThan(500);
+  });
+});

package/src/adapter/proxy/proxyEntry.ts

@@ -0,0 +1,69 @@
+import * as http from 'http';
+import * as https from 'https';
+import { PROXY_PORT, writeRateLimit } from './RateLimitCache';
+
+const UPSTREAM_HOST = 'api.anthropic.com';
+
+const BEARER_PREFIX = 'bearer ';
+
+const extractToken = (
+  authorization: string | string[] | undefined,
+): string | null => {
+  const value = Array.isArray(authorization) ? authorization[0] : authorization;
+  if (typeof value !== 'string') return null;
+  if (value.length < BEARER_PREFIX.length) return null;
+  if (value.slice(0, BEARER_PREFIX.length).toLowerCase() !== BEARER_PREFIX)
+    return null;
+  const token = value.slice(BEARER_PREFIX.length).trim();
+  return token.length > 0 ? token : null;
+};
+
+const startProxy = (port: number): void => {
+  const server = http.createServer((clientRequest, clientResponse) => {
+    const token = extractToken(clientRequest.headers['authorization']);
+    const upstreamHeaders: Record<string, string | string[] | undefined> = {
+      ...clientRequest.headers,
+      host: UPSTREAM_HOST,
+    };
+    const upstreamRequest = https.request(
+      {
+        host: UPSTREAM_HOST,
+        port: 443,
+        method: clientRequest.method,
+        path: clientRequest.url,
+        headers: upstreamHeaders,
+      },
+      (upstreamResponse) => {
+        if (token !== null) {
+          try {
+            writeRateLimit(token, upstreamResponse.headers);
+          } catch (error) {
+            console.error('Failed to write rate limit cache:', error);
+          }
+        }
+        clientResponse.writeHead(
+          upstreamResponse.statusCode ?? 502,
+          upstreamResponse.headers,
+        );
+        upstreamResponse.pipe(clientResponse);
+      },
+    );
+    upstreamRequest.on('error', (error) => {
+      console.error('Upstream request error:', error.message);
+      if (!clientResponse.headersSent) {
+        clientResponse.writeHead(502, { 'content-type': 'text/plain' });
+      }
+      clientResponse.end('Upstream error');
+    });
+    clientRequest.pipe(upstreamRequest);
+  });
+  server.listen(port, '127.0.0.1', () => {
+    console.log(`tdpm proxy listening on 127.0.0.1:${port}`);
+  });
+};
+
+if (require.main === module) {
+  startProxy(PROXY_PORT);
+}
+
+export { startProxy, extractToken };

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

@@ -32,7 +32,9 @@ describe('NodeLocalCommandRunner', () => {
         stderr: '',
         exitCode: 0,
       });
-      expect(mockExecFileAsync).toHaveBeenCalledWith('echo', ['"test"']);
+      expect(mockExecFileAsync).toHaveBeenCalledWith('echo', ['"test"'], {
+        encoding: 'utf8',
+      });
     });
 
     it('should handle command errors with exit code', async () => {

package/src/adapter/repositories/NodeLocalCommandRunner.ts

@@ -1,4 +1,7 @@
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import {
+  LocalCommandRunner,
+  LocalCommandRunnerOptions,
+} from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 
@@ -8,16 +11,27 @@ export class NodeLocalCommandRunner implements LocalCommandRunner {
   async runCommand(
     program: string,
     args: string[],
+    options?: LocalCommandRunnerOptions,
   ): Promise<{
     stdout: string;
     stderr: string;
     exitCode: number;
   }> {
+    const execOptions: Parameters<typeof execFileAsync>[2] = {
+      encoding: 'utf8',
+    };
+    if (options?.env) {
+      execOptions.env = { ...process.env, ...options.env };
+    }
     try {
-      const { stdout, stderr } = await execFileAsync(program, args);
+      const { stdout, stderr } = await execFileAsync(
+        program,
+        args,
+        execOptions,
+      );
       return {
-        stdout,
-        stderr,
+        stdout: String(stdout),
+        stderr: String(stderr),
         exitCode: 0,
       };
     } catch (error) {

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

@@ -0,0 +1,127 @@
+const mockEnsureProxyRunning = jest.fn();
+const mockReadRateLimit = jest.fn();
+const mockLoadTokens = jest.fn();
+
+jest.mock('../proxy/ensureProxyRunning', () => ({
+  ensureProxyRunning: mockEnsureProxyRunning,
+}));
+
+jest.mock('../proxy/RateLimitCache', () => ({
+  PROXY_PORT: 8787,
+  readRateLimit: mockReadRateLimit,
+}));
+
+jest.mock('../proxy/TokenListLoader', () => ({
+  loadTokens: mockLoadTokens,
+}));
+
+import { ProxyClaudeTokenUsageRepository } from './ProxyClaudeTokenUsageRepository';
+
+describe('ProxyClaudeTokenUsageRepository', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('ensureObservable', () => {
+    it('should start the proxy on the default port', async () => {
+      mockEnsureProxyRunning.mockResolvedValue(undefined);
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      await repository.ensureObservable();
+
+      expect(mockEnsureProxyRunning.mock.calls).toEqual([[8787]]);
+    });
+
+    it('should start the proxy on the configured port', async () => {
+      mockEnsureProxyRunning.mockResolvedValue(undefined);
+      const repository = new ProxyClaudeTokenUsageRepository(
+        '/tokens.json',
+        9999,
+      );
+
+      await repository.ensureObservable();
+
+      expect(mockEnsureProxyRunning.mock.calls).toEqual([[9999]]);
+    });
+  });
+
+  describe('getAvailableTokenUsages', () => {
+    it('should return an empty list when no token path is configured', async () => {
+      const repository = new ProxyClaudeTokenUsageRepository(null);
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([]);
+      expect(mockLoadTokens.mock.calls).toHaveLength(0);
+    });
+
+    it('should return an empty list when the token list cannot be loaded', async () => {
+      mockLoadTokens.mockReturnValue(null);
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([]);
+      expect(mockLoadTokens.mock.calls).toEqual([['/tokens.json']]);
+    });
+
+    it('should map each token to its cached utilization', async () => {
+      mockLoadTokens.mockReturnValue(['token-a', 'token-b']);
+      mockReadRateLimit.mockImplementation((token: string) => {
+        if (token === 'token-a') {
+          return {
+            fiveHourUtilization: 42,
+            fiveHourReset: 0,
+            sevenDayUtilization: 0,
+            sevenDayReset: 0,
+            blocked: false,
+          };
+        }
+        return null;
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        { token: 'token-a', fiveHourUtilization: 42, blocked: false },
+        { token: 'token-b', fiveHourUtilization: 0, blocked: false },
+      ]);
+    });
+
+    it('should propagate the blocked status from the cache', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 5,
+        fiveHourReset: 0,
+        sevenDayUtilization: 0,
+        sevenDayReset: 0,
+        blocked: true,
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        { token: 'token-a', fiveHourUtilization: 5, blocked: true },
+      ]);
+    });
+  });
+
+  describe('proxyBaseUrl', () => {
+    it('should build the loopback url for the default port', () => {
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      expect(repository.proxyBaseUrl()).toBe('http://127.0.0.1:8787');
+    });
+
+    it('should build the loopback url for the configured port', () => {
+      const repository = new ProxyClaudeTokenUsageRepository(
+        '/tokens.json',
+        9999,
+      );
+
+      expect(repository.proxyBaseUrl()).toBe('http://127.0.0.1:9999');
+    });
+  });
+});

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.ts

@@ -0,0 +1,36 @@
+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 { loadTokens } from '../proxy/TokenListLoader';
+
+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 tokens = loadTokens(this.tokenListJsonPath);
+    if (tokens === null) {
+      return [];
+    }
+    return tokens.map((token) => {
+      const snapshot = readRateLimit(token);
+      return {
+        token,
+        fiveHourUtilization: snapshot ? snapshot.fiveHourUtilization : 0,
+        blocked: snapshot?.blocked ?? false,
+      };
+    });
+  };
+
+  proxyBaseUrl = (): string => `http://127.0.0.1:${this.port}`;
+}

package/src/domain/entities/ClaudeTokenUsage.ts

@@ -0,0 +1,5 @@
+export type ClaudeTokenUsage = {
+  token: string;
+  fiveHourUtilization: number;
+  blocked: boolean;
+};