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

package/src/adapter/entry-points/handlers/situationFileWriter.test.ts

@@ -50,6 +50,7 @@ const baseParams = {
     awaitingQualityCheckStatus: 'Awaiting quality check',
     preparationStatus: 'Preparation',
     awaitingWorkspaceStatus: 'Awaiting workspace',
+    failedPreparationStatus: 'Failed Preparation',
   },
   config: {
     maximumPreparingIssuesCount: 6,
@@ -183,6 +184,7 @@ describe('writeSituationFile', () => {
           awaitingQualityCheckStatus: null,
           preparationStatus: null,
           awaitingWorkspaceStatus: null,
+          failedPreparationStatus: null,
         },
         issues,
       };
@@ -207,6 +209,40 @@ describe('writeSituationFile', () => {
         expect.any(String),
         expect.stringContaining('"awaitingWorkspaceBlockedByDependency":0'),
       );
+      expect(jest.mocked(fs.writeFileSync)).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining('"failedPreparation":0'),
+      );
+    });
+
+    it('counts failedPreparation correctly from fixture issues', async () => {
+      const issues = [
+        createIssue({ status: 'Failed Preparation' }),
+        createIssue({ status: 'Failed Preparation' }),
+        createIssue({ status: 'Preparation' }),
+        createIssue({ status: 'Awaiting workspace' }),
+      ];
+
+      await writeSituationFile({ ...baseParams, issues });
+
+      expect(jest.mocked(fs.writeFileSync)).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining('"failedPreparation":2'),
+      );
+    });
+
+    it('sets failedPreparation to 0 when no issues match the failed preparation status', async () => {
+      const issues = [
+        createIssue({ status: 'Preparation' }),
+        createIssue({ status: 'Awaiting workspace' }),
+      ];
+
+      await writeSituationFile({ ...baseParams, issues });
+
+      expect(jest.mocked(fs.writeFileSync)).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining('"failedPreparation":0'),
+      );
     });
   });
 

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

@@ -10,6 +10,7 @@ export type SituationFileParams = {
     awaitingQualityCheckStatus: string | null;
     preparationStatus: string | null;
     awaitingWorkspaceStatus: string | null;
+    failedPreparationStatus: string | null;
   };
   config: {
     maximumPreparingIssuesCount: number | null;
@@ -104,6 +105,12 @@ export const writeSituationFile = async (
       ? issues.filter((i) => i.status === statusNames.awaitingWorkspaceStatus)
       : [];
 
+  const failedPreparation =
+    statusNames.failedPreparationStatus !== null
+      ? issues.filter((i) => i.status === statusNames.failedPreparationStatus)
+          .length
+      : 0;
+
   const awaitingWorkspaceImmediatelyActionable = awaitingWorkspaceIssues.filter(
     isImmediatelyActionable,
   ).length;
@@ -142,6 +149,7 @@ export const writeSituationFile = async (
       preparation: preparationIssues.length,
       awaitingWorkspaceImmediatelyActionable,
       awaitingWorkspaceBlockedByDependency,
+      failedPreparation,
     },
     processes: {
       runningPreparation,

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

@@ -1,7 +1,56 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { loadTokens } from './TokenListLoader';
+import { loadTokenEntries, loadTokens } from './TokenListLoader';
+
+describe('loadTokenEntries', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-entries-loader-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should return entries with name and token', () => {
+    const filePath = path.join(tempDir, 'tokens.json');
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify([
+        { name: 'alice', token: 'token-a' },
+        { name: 'bob', token: 'token-b' },
+      ]),
+    );
+    expect(loadTokenEntries(filePath)).toEqual([
+      { name: 'alice', token: 'token-a' },
+      { name: 'bob', token: 'token-b' },
+    ]);
+  });
+
+  it('should assign a unique positional name when name is absent from entry', () => {
+    const filePath = path.join(tempDir, 'tokens.json');
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify([{ token: 'token-a' }, { token: 'token-b' }]),
+    );
+    expect(loadTokenEntries(filePath)).toEqual([
+      { name: 'token-1', token: 'token-a' },
+      { name: 'token-2', token: 'token-b' },
+    ]);
+  });
+
+  it('should return null when file does not exist', () => {
+    expect(loadTokenEntries(path.join(tempDir, 'missing.json'))).toBeNull();
+  });
+
+  it('should return null when every entry is invalid', () => {
+    const filePath = path.join(tempDir, 'invalid.json');
+    fs.writeFileSync(filePath, JSON.stringify([{ name: 'no-token' }]));
+    expect(loadTokenEntries(filePath)).toBeNull();
+  });
+});
 
 describe('TokenListLoader', () => {
   let tempDir: string;

package/src/adapter/proxy/TokenListLoader.ts

@@ -15,21 +15,41 @@ const expandHome = (filePath: string): string => {
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   value !== null && typeof value === 'object' && !Array.isArray(value);
 
-export const loadTokens = (jsonPath: string): string[] | null => {
+export type TokenEntry = {
+  name: string;
+  token: string;
+};
+
+export const loadTokenEntries = (jsonPath: string): TokenEntry[] | 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[] = [];
+    const entries: TokenEntry[] = [];
     for (const entry of parsed) {
-      if (isRecord(entry) && typeof entry.token === 'string') {
-        tokens.push(entry.token);
+      if (
+        isRecord(entry) &&
+        typeof entry.token === 'string' &&
+        typeof entry.name === 'string'
+      ) {
+        entries.push({ name: entry.name, token: entry.token });
+      } else if (isRecord(entry) && typeof entry.token === 'string') {
+        entries.push({
+          name: `token-${entries.length + 1}`,
+          token: entry.token,
+        });
       }
     }
-    return tokens.length > 0 ? tokens : null;
+    return entries.length > 0 ? entries : null;
   } catch {
     return null;
   }
 };
+
+export const loadTokens = (jsonPath: string): string[] | null => {
+  const entries = loadTokenEntries(jsonPath);
+  if (entries === null) return null;
+  return entries.map((e) => e.token);
+};

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',
-      );
-    });
-  });
 });