github-issue-tower-defence-management 1.60.2 → 1.63.1

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

@@ -1,4 +1,28 @@
-import { extractToken } from './proxyEntry';
+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', () => {
@@ -46,3 +70,248 @@ describe('extractToken', () => {
     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;
+
+  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);
+
+    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();
+    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 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();
+  });
+});

package/src/adapter/proxy/proxyEntry.ts

@@ -32,7 +32,7 @@ const extractToken = (
 const startProxy = (
   port: number,
   claudeMessageResponseRepository: ClaudeMessageResponseRepository | null = null,
-): void => {
+): http.Server => {
   const server = http.createServer((clientRequest, clientResponse) => {
     const token = extractToken(clientRequest.headers['authorization']);
     const upstreamHeaders: Record<string, string | string[] | undefined> = {
@@ -106,6 +106,7 @@ const startProxy = (
   server.listen(port, '127.0.0.1', () => {
     console.log(`tdpm proxy listening on 127.0.0.1:${port}`);
   });
+  return server;
 };
 
 if (require.main === module) {

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

@@ -1,56 +1,14 @@
-const mockKyGetText = jest.fn<Promise<string>, []>();
-const mockKyGet = jest.fn(() => ({ text: mockKyGetText }));
-
-jest.mock('ky', () => ({
-  default: {
-    get: mockKyGet,
-    post: jest.fn(),
-    put: jest.fn(),
-    patch: jest.fn(),
-    delete: jest.fn(),
-    extend: jest.fn(),
-    create: jest.fn(),
-    stop: jest.fn(),
-  },
-  __esModule: true,
-}));
-
-import fs from 'fs';
 import { BaseGitHubRepository } from './BaseGitHubRepository';
-import resetAllMocks = jest.resetAllMocks;
 import { LocalStorageRepository } from './LocalStorageRepository';
 describe('BaseGitHubRepository', () => {
-  const jsonFilePath = './tmp/github.com.cookies.json';
   const localStorageRepository = new LocalStorageRepository();
   class TestGitHubRepository extends BaseGitHubRepository {
     constructor() {
-      super(localStorageRepository, jsonFilePath, process.env.GH_TOKEN);
+      super(localStorageRepository, process.env.GH_TOKEN);
     }
     extractIssueFromUrlPublic = this.extractIssueFromUrl;
-    createHeaderPublic = this.createHeader;
-    createCookieStringFromFilePublic = this.createCookieStringFromFile;
-    isCookiePublic = this.isCookie;
   }
   const baseGitHubRepository: TestGitHubRepository = new TestGitHubRepository();
-  beforeAll(() => {
-    resetAllMocks();
-    const cookies = [
-      {
-        name: 'name',
-        value: 'value',
-        domain: 'domain',
-        path: 'path',
-        expires: 1,
-        httpOnly: true,
-        secure: true,
-        sameSite: 'Lax',
-      },
-    ];
-    fs.writeFileSync(jsonFilePath, JSON.stringify(cookies));
-  });
-  afterAll(() => {
-    fs.rmSync(jsonFilePath);
-  });
 
   describe('extractIssueFromUrl', () => {
     it('should return issue number', () => {
@@ -65,147 +23,4 @@ describe('BaseGitHubRepository', () => {
       });
     });
   });
-
-  describe('createHeader', () => {
-    it('should return headers with cookie', async () => {
-      const headers = await baseGitHubRepository.createHeaderPublic();
-      expect(headers).toHaveProperty('cookie');
-    });
-  });
-
-  describe('createCookieStringFromFile', () => {
-    it('should return cookie string', async () => {
-      const cookie =
-        await baseGitHubRepository.createCookieStringFromFilePublic();
-      expect(cookie).toEqual(
-        'name=value; Domain=domain; Path=path; Expires=Thu, 01 Jan 1970 00:00:01 GMT; HttpOnly; Secure; SameSite=Lax',
-      );
-    });
-  });
-
-  describe('isCookie', () => {
-    it('should return true if cookie is valid', () => {
-      const cookie = {
-        name: 'name',
-        value: 'value',
-        domain: 'domain',
-        path: 'path',
-        expires: 1,
-        httpOnly: true,
-        secure: true,
-        sameSite: 'lax',
-      };
-      expect(baseGitHubRepository.isCookiePublic(cookie)).toBe(true);
-    });
-
-    it('should return false if cookie is invalid', () => {
-      const cookie = {
-        name: 'name',
-        value: 'value',
-        domain: 'domain',
-        path: 'path',
-        expires: 1,
-        httpOnly: true,
-        secure: true,
-      };
-      expect(baseGitHubRepository.isCookiePublic(cookie)).toBe(false);
-    });
-  });
-
-  describe('refreshCookie', () => {
-    const localStorageRepositoryForRefresh = new LocalStorageRepository();
-    const refreshCookieJsonFilePath =
-      './tmp/refresh-test-github.com.cookies.json';
-    const ghUserName = 'testuser';
-    class RefreshTestRepository extends BaseGitHubRepository {
-      constructor() {
-        super(
-          localStorageRepositoryForRefresh,
-          refreshCookieJsonFilePath,
-          'dummy-token',
-          ghUserName,
-          'dummy-password',
-          'dummy-authenticator-key',
-        );
-      }
-    }
-
-    const validCookieJson = JSON.stringify([
-      {
-        name: 'name',
-        value: 'value',
-        domain: 'domain',
-        path: 'path',
-        expires: 1,
-        httpOnly: true,
-        secure: true,
-        sameSite: 'Lax',
-      },
-    ]);
-
-    beforeEach(() => {
-      mockKyGet.mockReset().mockReturnValue({ text: mockKyGetText });
-      mockKyGetText.mockReset();
-      fs.writeFileSync(refreshCookieJsonFilePath, validCookieJson);
-    });
-
-    afterEach(() => {
-      if (fs.existsSync(refreshCookieJsonFilePath)) {
-        fs.rmSync(refreshCookieJsonFilePath);
-      }
-    });
-
-    it('should return when HTML contains user-login meta tag for current user (logged in)', async () => {
-      const repository = new RefreshTestRepository();
-      mockKyGetText.mockResolvedValueOnce(
-        `<html><head><meta name="user-login" content="${ghUserName}"></head><body><h1>${ghUserName}</h1></body></html>`,
-      );
-
-      await expect(repository.refreshCookie()).resolves.toBeUndefined();
-
-      expect(mockKyGet).toHaveBeenCalledWith(
-        `https://github.com/${ghUserName}`,
-        expect.anything(),
-      );
-      expect(mockKyGet).toHaveBeenCalledTimes(1);
-    });
-
-    it('should fail when HTML contains username in content but not in user-login meta tag (not logged in)', async () => {
-      const repository = new RefreshTestRepository();
-      const notLoggedInHtml = `<html><head><meta name="user-login" content=""></head><body><h1>${ghUserName}</h1><p>Public profile</p></body></html>`;
-      mockKyGetText.mockResolvedValueOnce(notLoggedInHtml);
-
-      await expect(repository.refreshCookie()).rejects.toThrow(
-        'Failed to refresh cookie',
-      );
-    });
-
-    it('should use profile page URL not homepage to check authentication', async () => {
-      const repository = new RefreshTestRepository();
-      mockKyGetText.mockResolvedValueOnce(
-        `<html><head><meta name="user-login" content="${ghUserName}"></head><body></body></html>`,
-      );
-
-      await repository.refreshCookie();
-
-      expect(mockKyGet).toHaveBeenCalledWith(
-        `https://github.com/${ghUserName}`,
-        expect.anything(),
-      );
-      expect(mockKyGet).not.toHaveBeenCalledWith(
-        'https://github.com',
-        expect.anything(),
-      );
-    });
-
-    it('should throw when the authentication check fails', async () => {
-      const repository = new RefreshTestRepository();
-      const notLoggedInHtml = `<html><head><meta name="user-login" content=""></head><body></body></html>`;
-      mockKyGetText.mockResolvedValueOnce(notLoggedInHtml);
-
-      await expect(repository.refreshCookie()).rejects.toThrow(
-        'Failed to refresh cookie',
-      );
-    });
-  });
 });

package/src/adapter/repositories/BaseGitHubRepository.ts

@@ -1,33 +1,10 @@
-import { promises as fsPromises } from 'fs';
-import { serialize } from 'cookie';
-import fs from 'fs';
 import { LocalStorageRepository } from './LocalStorageRepository';
-import ky from 'ky';
-
-interface Cookie {
-  name: string;
-  value: string;
-  domain?: string;
-  path?: string;
-  expires?: number;
-  httpOnly?: boolean;
-  secure?: boolean;
-  sameSite?: 'lax' | 'strict' | 'none';
-}
 
 export class BaseGitHubRepository {
-  cookie: string | null;
   constructor(
     readonly localStorageRepository: LocalStorageRepository,
-    readonly jsonFilePath: string = './tmp/github.com.cookies.json',
     readonly ghToken: string = process.env.GH_TOKEN || 'dummy',
-    readonly ghUserName: string | undefined = process.env.GH_USER_NAME,
-    readonly ghUserPassword: string | undefined = process.env.GH_USER_PASSWORD,
-    readonly ghAuthenticatorKey: string | undefined = process.env
-      .GH_AUTHENTICATOR_KEY,
-  ) {
-    this.cookie = null;
-  }
+  ) {}
   protected extractIssueFromUrl = (
     issueUrl: string,
   ): { owner: string; repo: string; issueNumber: number; isIssue: boolean } => {
@@ -46,119 +23,4 @@ export class BaseGitHubRepository {
     }
     return { owner, repo, issueNumber, isIssue: pullOrIssue === 'issues' };
   };
-
-  getCookie = async (): Promise<string> => {
-    if (!this.cookie) {
-      this.cookie = await this.createCookieStringFromFile();
-    }
-    return this.cookie;
-  };
-  createHeader = async (): Promise<Record<string, string>> => {
-    const cookie = await this.getCookie();
-    const headers = {
-      accept:
-        'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
-      'accept-language':
-        'en-US,en;q=0.9,es-MX;q=0.8,es;q=0.7,ja-JP;q=0.6,ja;q=0.5',
-      'cache-control': 'max-age=0',
-      'sec-ch-ua':
-        '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
-      'sec-ch-ua-mobile': '?0',
-      'sec-ch-ua-platform': '"Linux"',
-      'sec-fetch-dest': 'document',
-      'sec-fetch-mode': 'navigate',
-      'sec-fetch-site': 'same-origin',
-      'sec-fetch-user': '?1',
-      'upgrade-insecure-requests': '1',
-      Referer: 'https://github.com/orgs/community/discussions/30979',
-      'Referrer-Policy': 'no-referrer-when-downgrade',
-    };
-    return {
-      ...headers,
-      cookie: cookie,
-    };
-  };
-  protected createCookieStringFromFile = async (): Promise<string> => {
-    if (!fs.existsSync(this.jsonFilePath)) {
-      throw new Error('No cookie file found');
-    }
-    const data = await fsPromises.readFile(this.jsonFilePath, {
-      encoding: 'utf-8',
-    });
-    const cookiesData: unknown = JSON.parse(data);
-    return this.generateCookieHeaderFromJson(cookiesData);
-  };
-  protected isCookie = (cookie: object): cookie is Cookie => {
-    return (
-      'name' in cookie &&
-      typeof cookie.name === 'string' &&
-      'value' in cookie &&
-      typeof cookie.value === 'string' &&
-      'domain' in cookie &&
-      typeof cookie.domain === 'string' &&
-      'path' in cookie &&
-      typeof cookie.path === 'string' &&
-      'expires' in cookie &&
-      typeof cookie.expires === 'number' &&
-      'httpOnly' in cookie &&
-      typeof cookie.httpOnly === 'boolean' &&
-      'secure' in cookie &&
-      typeof cookie.secure === 'boolean' &&
-      'sameSite' in cookie &&
-      typeof cookie.sameSite === 'string' &&
-      ['lax', 'strict', 'none'].indexOf(cookie.sameSite) !== -1
-    );
-  };
-
-  protected generateCookieHeaderFromJson = async (
-    cookieData: unknown,
-  ): Promise<string> => {
-    if (!Array.isArray(cookieData)) {
-      throw new Error('Invalid cookie array');
-    }
-
-    const cookies: Cookie[] = cookieData.map((cookieOrig: object) => {
-      const sameSite =
-        typeof cookieOrig !== 'object' ||
-        !('sameSite' in cookieOrig) ||
-        typeof cookieOrig.sameSite !== 'string'
-          ? 'none'
-          : cookieOrig.sameSite.toLowerCase();
-      const cookie = {
-        ...cookieOrig,
-        sameSite,
-      };
-
-      if (!this.isCookie(cookie)) {
-        throw new Error(`Invalid cookie properties: ${JSON.stringify(cookie)}`);
-      }
-      return cookie;
-    });
-    const cookieHeader = cookies
-      .map((cookie) =>
-        serialize(cookie.name, cookie.value, {
-          domain: cookie.domain,
-          path: cookie.path,
-          expires: cookie.expires ? new Date(cookie.expires * 1000) : undefined,
-          httpOnly: cookie.httpOnly,
-          secure: cookie.secure,
-          sameSite: cookie.sameSite,
-        }),
-      )
-      .join('; ');
-    return cookieHeader;
-  };
-  refreshCookie = async (): Promise<void> => {
-    if (!this.ghUserName || !this.ghUserPassword || !this.ghAuthenticatorKey) {
-      throw new Error(
-        'GitHub username, password, and authenticator key must be set',
-      );
-    }
-    const profileUrl = `https://github.com/${this.ghUserName}`;
-    const headers = await this.createHeader();
-    const html = await ky.get(profileUrl, { headers }).text();
-    if (!html.includes(`meta name="user-login" content="${this.ghUserName}"`)) {
-      throw new Error('Failed to refresh cookie');
-    }
-  };
 }

package/src/adapter/repositories/GraphqlProjectRepository.errorHandling.test.ts

@@ -28,7 +28,6 @@ describe('GraphqlProjectRepository error handling', () => {
     mockPost.mockClear();
     repository = new GraphqlProjectRepository(
       new LocalStorageRepository(),
-      '',
       'dummy-token',
     );
   });

package/src/adapter/repositories/GraphqlProjectRepository.fetchProjectId.test.ts

@@ -28,7 +28,10 @@ describe('GraphqlProjectRepository.fetchProjectId', () => {
   beforeEach(() => {
     jest.useFakeTimers();
     mockPost.mockReset();
-    repository = new GraphqlProjectRepository(localStorageRepository, '');
+    repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+    );
   });
 
   afterEach(() => {