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

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

@@ -1,85 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,552 +0,0 @@
-import * as http from 'http';
-import * as https from 'https';
-import { AddressInfo } from 'net';
-import * as RateLimitCache from './RateLimitCache';
-
-type HttpsRequestImpl = (
-  options: https.RequestOptions,
-  callback?: (response: http.IncomingMessage) => void,
-) => http.ClientRequest;
-
-let httpsRequestImpl: HttpsRequestImpl | null = null;
-
-jest.mock('https', () => ({
-  request: (
-    options: https.RequestOptions,
-    callback?: (response: http.IncomingMessage) => void,
-  ): http.ClientRequest => {
-    if (httpsRequestImpl === null) {
-      throw new Error('https.request implementation not set');
-    }
-    return httpsRequestImpl(options, callback);
-  },
-}));
-
-import { extractToken, startProxy } 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);
-  });
-});
-
-interface ClientResponse {
-  statusCode: number;
-  headers: http.IncomingHttpHeaders;
-  body: string;
-}
-
-const isAddressInfo = (
-  address: string | AddressInfo | null,
-): address is AddressInfo => address !== null && typeof address === 'object';
-
-const addressPort = (server: http.Server): number => {
-  const address = server.address();
-  if (!isAddressInfo(address)) {
-    throw new Error('Expected the server to be listening on a TCP port');
-  }
-  return address.port;
-};
-
-describe('startProxy', () => {
-  const TOKEN = 'sk-ant-proxy-token';
-
-  let upstreamServer: http.Server;
-  let proxyServer: http.Server;
-  let upstreamHandler: (
-    request: http.IncomingMessage,
-    response: http.ServerResponse,
-  ) => void;
-  let upstreamShouldError = false;
-  let upstreamPort = 0;
-  let proxyPort = 0;
-  let writeRateLimitSpy: jest.SpyInstance;
-  let writeModelRateLimitSpy: jest.SpyInstance;
-  let writeFableRejectionSpy: jest.SpyInstance;
-
-  const listen = (server: http.Server): Promise<number> =>
-    new Promise((resolve) => {
-      server.listen(0, '127.0.0.1', () => {
-        resolve(addressPort(server));
-      });
-    });
-
-  const closeServer = (server: http.Server): Promise<void> =>
-    new Promise((resolve, reject) => {
-      server.close((error) => (error ? reject(error) : resolve()));
-    });
-
-  const requestThroughProxy = (
-    method: string,
-    path: string,
-    requestBody: string | null,
-  ): Promise<ClientResponse> =>
-    new Promise((resolve, reject) => {
-      const clientRequest = http.request(
-        {
-          host: '127.0.0.1',
-          port: proxyPort,
-          method,
-          path,
-          headers: { authorization: `Bearer ${TOKEN}` },
-        },
-        (response) => {
-          const chunks: Uint8Array[] = [];
-          response.on('data', (chunk: Buffer) =>
-            chunks.push(new Uint8Array(chunk)),
-          );
-          response.on('end', () => {
-            resolve({
-              statusCode: response.statusCode ?? 0,
-              headers: response.headers,
-              body: Buffer.concat(chunks).toString('utf8'),
-            });
-          });
-          response.on('error', reject);
-        },
-      );
-      clientRequest.on('error', reject);
-      if (requestBody !== null) {
-        clientRequest.write(requestBody);
-      }
-      clientRequest.end();
-    });
-
-  beforeEach(async () => {
-    upstreamShouldError = false;
-    upstreamHandler = (_request, response) => {
-      response.writeHead(200, { 'content-type': 'application/json' });
-      response.end('{}');
-    };
-
-    upstreamServer = http.createServer((request, response) => {
-      upstreamHandler(request, response);
-    });
-    upstreamPort = await listen(upstreamServer);
-
-    httpsRequestImpl = (options, callback): http.ClientRequest => {
-      if (upstreamShouldError) {
-        return http.request({
-          host: '127.0.0.1',
-          port: 1,
-          method: options.method,
-          path: options.path,
-        });
-      }
-      return http.request(
-        {
-          host: '127.0.0.1',
-          port: upstreamPort,
-          method: options.method,
-          path: options.path,
-          headers: options.headers,
-        },
-        callback,
-      );
-    };
-
-    writeRateLimitSpy = jest
-      .spyOn(RateLimitCache, 'writeRateLimit')
-      .mockImplementation(() => undefined);
-    writeModelRateLimitSpy = jest
-      .spyOn(RateLimitCache, 'writeModelRateLimit')
-      .mockImplementation(() => undefined);
-    writeFableRejectionSpy = jest
-      .spyOn(RateLimitCache, 'writeFableRejection')
-      .mockImplementation(() => undefined);
-
-    proxyPort = await new Promise<number>((resolve) => {
-      const probe = http.createServer();
-      probe.listen(0, '127.0.0.1', () => {
-        const value = addressPort(probe);
-        probe.close(() => resolve(value));
-      });
-    });
-    proxyServer = startProxy(proxyPort);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  });
-
-  afterEach(async () => {
-    httpsRequestImpl = null;
-    writeRateLimitSpy.mockRestore();
-    writeModelRateLimitSpy.mockRestore();
-    writeFableRejectionSpy.mockRestore();
-    await closeServer(proxyServer);
-    await closeServer(upstreamServer);
-  });
-
-  it('should forward the full streamed response body to the client while teeing', async () => {
-    const payload = 'x'.repeat(300 * 1024);
-    upstreamHandler = (_request, response) => {
-      response.writeHead(200, { 'content-type': 'text/event-stream' });
-      let written = 0;
-      const writeNext = (): void => {
-        if (written >= payload.length) {
-          response.end();
-          return;
-        }
-        const slice = payload.slice(written, written + 16 * 1024);
-        written += slice.length;
-        response.write(slice);
-        setImmediate(writeNext);
-      };
-      writeNext();
-    };
-
-    const response = await requestThroughProxy('POST', '/v1/messages', '{}');
-
-    expect(response.statusCode).toBe(200);
-    expect(response.body).toHaveLength(payload.length);
-    expect(response.body).toBe(payload);
-  });
-
-  it('should keep forwarding the full stream even after the inspected body exceeds the 1MB cap', async () => {
-    const payload = 'y'.repeat(3 * 1024 * 1024);
-    const parseSpy = jest.spyOn(RateLimitCache, 'parseModelRateLimitsFromBody');
-    upstreamHandler = (_request, response) => {
-      response.writeHead(200, { 'content-type': 'text/event-stream' });
-      let written = 0;
-      const writeNext = (): void => {
-        if (written >= payload.length) {
-          response.end();
-          return;
-        }
-        const slice = payload.slice(written, written + 64 * 1024);
-        written += slice.length;
-        response.write(slice);
-        setImmediate(writeNext);
-      };
-      writeNext();
-    };
-
-    const response = await requestThroughProxy('POST', '/v1/messages', '{}');
-
-    expect(response.statusCode).toBe(200);
-    expect(response.body).toHaveLength(payload.length);
-    expect(response.body).toBe(payload);
-    expect(parseSpy).toHaveBeenCalledTimes(1);
-    const inspectedBody = parseSpy.mock.calls[0][0];
-    expect(inspectedBody.length).toBeLessThanOrEqual(1024 * 1024 + 64 * 1024);
-    parseSpy.mockRestore();
-  });
-
-  it('should parse the body on end and persist model weekly limits via writeModelRateLimit', async () => {
-    const resetsAt = 1893456000;
-    const body = JSON.stringify({
-      type: 'error',
-      error: {
-        rateLimitType: 'seven_day_sonnet',
-        status: 'rejected',
-        resetsAt,
-      },
-    });
-    upstreamHandler = (_request, response) => {
-      response.writeHead(429, { 'content-type': 'application/json' });
-      response.end(body);
-    };
-
-    const response = await requestThroughProxy('POST', '/v1/messages', '{}');
-
-    expect(response.statusCode).toBe(429);
-    expect(response.body).toBe(body);
-    expect(writeModelRateLimitSpy).toHaveBeenCalledWith(TOKEN, {
-      seven_day_sonnet: { rejected: true, resetsAt },
-    });
-    expect(writeModelRateLimitSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it('should forward the upstream status code to writeRateLimit on a 429 response', async () => {
-    upstreamHandler = (_request, response) => {
-      response.writeHead(429, { 'content-type': 'application/json' });
-      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
-    };
-
-    const response = await requestThroughProxy('POST', '/v1/messages', '{}');
-
-    expect(response.statusCode).toBe(429);
-    expect(writeRateLimitSpy).toHaveBeenCalledTimes(1);
-    expect(writeRateLimitSpy).toHaveBeenCalledWith(
-      TOKEN,
-      expect.objectContaining({ 'content-type': 'application/json' }),
-      429,
-    );
-  });
-
-  it('should mark the fable weekly limit when a fable 429 carries a rejected 7-day status, using the 7-day reset', async () => {
-    const sevenDayReset = 1893456000;
-    upstreamHandler = (_request, response) => {
-      response.writeHead(429, {
-        'content-type': 'application/json',
-        'retry-after': '120',
-        'anthropic-ratelimit-unified-7d-status': 'rejected',
-        'anthropic-ratelimit-unified-7d-reset': String(sevenDayReset),
-      });
-      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
-    };
-
-    const response = await requestThroughProxy(
-      'POST',
-      '/v1/messages',
-      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
-    );
-
-    expect(response.statusCode).toBe(429);
-    expect(writeFableRejectionSpy).toHaveBeenCalledTimes(1);
-    expect(writeFableRejectionSpy).toHaveBeenCalledWith(
-      TOKEN,
-      120,
-      sevenDayReset,
-    );
-  });
-
-  it('should fall back to retry-after for the reset when a rejected 7-day status carries no 7-day reset header', async () => {
-    upstreamHandler = (_request, response) => {
-      response.writeHead(429, {
-        'content-type': 'application/json',
-        'retry-after': '120',
-        'anthropic-ratelimit-unified-7d-status': 'rejected',
-      });
-      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
-    };
-
-    const response = await requestThroughProxy(
-      'POST',
-      '/v1/messages',
-      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
-    );
-
-    expect(response.statusCode).toBe(429);
-    expect(writeFableRejectionSpy).toHaveBeenCalledTimes(1);
-    expect(writeFableRejectionSpy).toHaveBeenCalledWith(TOKEN, 120, null);
-  });
-
-  it('should not mark the fable weekly limit when a fable 429 is a 5-hour rejection without a 7-day rejection', async () => {
-    upstreamHandler = (_request, response) => {
-      response.writeHead(429, {
-        'content-type': 'application/json',
-        'retry-after': '120',
-        'anthropic-ratelimit-unified-5h-status': 'rejected',
-        'anthropic-ratelimit-unified-7d-status': 'allowed',
-      });
-      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
-    };
-
-    const response = await requestThroughProxy(
-      'POST',
-      '/v1/messages',
-      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
-    );
-
-    expect(response.statusCode).toBe(429);
-    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
-  });
-
-  it('should not mark the fable weekly limit when a fable 429 carries no rate-limit rejection headers', async () => {
-    upstreamHandler = (_request, response) => {
-      response.writeHead(429, { 'content-type': 'application/json' });
-      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
-    };
-
-    const response = await requestThroughProxy(
-      'POST',
-      '/v1/messages',
-      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
-    );
-
-    expect(response.statusCode).toBe(429);
-    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
-  });
-
-  it('should not mark the fable weekly limit when a non-fable request is rejected with a 7-day-rejected 429', async () => {
-    upstreamHandler = (_request, response) => {
-      response.writeHead(429, {
-        'content-type': 'application/json',
-        'anthropic-ratelimit-unified-7d-status': 'rejected',
-        'anthropic-ratelimit-unified-7d-reset': '1893456000',
-      });
-      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
-    };
-
-    const response = await requestThroughProxy(
-      'POST',
-      '/v1/messages',
-      JSON.stringify({ model: 'claude-sonnet-4-6', messages: [] }),
-    );
-
-    expect(response.statusCode).toBe(429);
-    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
-  });
-
-  it('should not mark the fable weekly limit when a fable request succeeds', async () => {
-    upstreamHandler = (_request, response) => {
-      response.writeHead(200, { 'content-type': 'application/json' });
-      response.end('{"model":"claude-fable-5"}');
-    };
-
-    const response = await requestThroughProxy(
-      'POST',
-      '/v1/messages',
-      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
-    );
-
-    expect(response.statusCode).toBe(200);
-    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
-  });
-
-  it('should forward non-SSE responses without crashing', async () => {
-    upstreamHandler = (_request, response) => {
-      response.writeHead(200, { 'content-type': 'application/json' });
-      response.end('{"ok":true}');
-    };
-
-    const response = await requestThroughProxy('GET', '/v1/models', null);
-
-    expect(response.statusCode).toBe(200);
-    expect(response.body).toBe('{"ok":true}');
-    expect(writeModelRateLimitSpy).toHaveBeenCalledTimes(1);
-    expect(writeModelRateLimitSpy).toHaveBeenCalledWith(TOKEN, {});
-  });
-
-  it('should respond with 502 when the upstream request errors', async () => {
-    upstreamShouldError = true;
-
-    const response = await requestThroughProxy('GET', '/v1/models', null);
-
-    expect(response.statusCode).toBe(502);
-    expect(response.body).toBe('Upstream error');
-    expect(writeModelRateLimitSpy).not.toHaveBeenCalled();
-  });
-
-  it('should call writeSubscriptionDisabled when the response body contains the subscription-disabled message', async () => {
-    const writeSubscriptionDisabledSpy = jest
-      .spyOn(RateLimitCache, 'writeSubscriptionDisabled')
-      .mockImplementation(() => undefined);
-
-    upstreamHandler = (_request, response) => {
-      response.writeHead(403, { 'content-type': 'application/json' });
-      response.end(
-        JSON.stringify({
-          error: {
-            message:
-              'Your organization has disabled Claude subscription access for Claude Code',
-          },
-        }),
-      );
-    };
-
-    await requestThroughProxy('POST', '/v1/messages', null);
-
-    expect(writeSubscriptionDisabledSpy).toHaveBeenCalledTimes(1);
-    expect(writeSubscriptionDisabledSpy).toHaveBeenCalledWith(TOKEN);
-    writeSubscriptionDisabledSpy.mockRestore();
-  });
-
-  it('should call writeSubscriptionDisabled when a 403 response body is a permission_error', async () => {
-    const writeSubscriptionDisabledSpy = jest
-      .spyOn(RateLimitCache, 'writeSubscriptionDisabled')
-      .mockImplementation(() => undefined);
-
-    upstreamHandler = (_request, response) => {
-      response.writeHead(403, { 'content-type': 'application/json' });
-      response.end(
-        JSON.stringify({
-          type: 'error',
-          error: {
-            type: 'permission_error',
-            message:
-              'OAuth authentication is currently not allowed for this organization',
-          },
-        }),
-      );
-    };
-
-    await requestThroughProxy('POST', '/v1/messages', null);
-
-    expect(writeSubscriptionDisabledSpy).toHaveBeenCalledTimes(1);
-    expect(writeSubscriptionDisabledSpy).toHaveBeenCalledWith(TOKEN);
-    writeSubscriptionDisabledSpy.mockRestore();
-  });
-
-  it('should not call writeSubscriptionDisabled when a permission_error body has a non-403 status', async () => {
-    const writeSubscriptionDisabledSpy = jest
-      .spyOn(RateLimitCache, 'writeSubscriptionDisabled')
-      .mockImplementation(() => undefined);
-
-    upstreamHandler = (_request, response) => {
-      response.writeHead(200, { 'content-type': 'application/json' });
-      response.end(
-        JSON.stringify({
-          type: 'error',
-          error: { type: 'permission_error', message: 'noise' },
-        }),
-      );
-    };
-
-    await requestThroughProxy('POST', '/v1/messages', null);
-
-    expect(writeSubscriptionDisabledSpy).not.toHaveBeenCalled();
-    writeSubscriptionDisabledSpy.mockRestore();
-  });
-
-  it('should not call writeSubscriptionDisabled when a 403 body is not a permission_error', async () => {
-    const writeSubscriptionDisabledSpy = jest
-      .spyOn(RateLimitCache, 'writeSubscriptionDisabled')
-      .mockImplementation(() => undefined);
-
-    upstreamHandler = (_request, response) => {
-      response.writeHead(403, { 'content-type': 'application/json' });
-      response.end(
-        JSON.stringify({
-          type: 'error',
-          error: { type: 'authentication_error', message: 'bad token' },
-        }),
-      );
-    };
-
-    await requestThroughProxy('POST', '/v1/messages', null);
-
-    expect(writeSubscriptionDisabledSpy).not.toHaveBeenCalled();
-    writeSubscriptionDisabledSpy.mockRestore();
-  });
-});