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

package/src/adapter/proxy/proxyEntry.ts

@@ -1,214 +0,0 @@
-import * as http from 'http';
-import * as https from 'https';
-import {
-  PROXY_PORT,
-  hashToken,
-  isFableModel,
-  parseModelRateLimitsFromBody,
-  parseSevenDayRejection,
-  writeFableRejection,
-  writeModelRateLimit,
-  writeRateLimit,
-  writeSubscriptionDisabled,
-} from './RateLimitCache';
-import { ClaudeMessageResponseRepository } from '../../domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository';
-import { parseClaudeMessageResponse } from './ClaudeMessageResponseParser';
-import { SqliteClaudeMessageResponseRepository } from '../repositories/SqliteClaudeMessageResponseRepository';
-
-const UPSTREAM_HOST = 'api.anthropic.com';
-
-const MAX_INSPECTED_BODY_BYTES = 1024 * 1024;
-
-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 isRecord = (value: unknown): value is Record<string, unknown> =>
-  value !== null && typeof value === 'object' && !Array.isArray(value);
-
-const isPermissionError = (body: string): boolean => {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    return false;
-  }
-  if (!isRecord(parsed)) return false;
-  const error = parsed.error;
-  if (!isRecord(error)) return false;
-  return error.type === 'permission_error';
-};
-
-const matchModelInBody = (requestBody: string): string | null => {
-  const match = requestBody.match(/"model"\s*:\s*"([^"]+)"/);
-  return match !== null ? match[1] : null;
-};
-
-const extractRequestModel = (requestBody: string): string | null => {
-  try {
-    const parsed: unknown = JSON.parse(requestBody);
-    if (isRecord(parsed) && typeof parsed.model === 'string') {
-      return parsed.model;
-    }
-    return null;
-  } catch {
-    return matchModelInBody(requestBody);
-  }
-};
-
-const parseRetryAfterSeconds = (
-  headers: http.IncomingHttpHeaders,
-): number | null => {
-  const raw = headers['retry-after'];
-  const value =
-    typeof raw === 'string' ? raw : Array.isArray(raw) ? raw[0] : null;
-  if (typeof value !== 'string') return null;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : null;
-};
-
-const startProxy = (
-  port: number,
-  claudeMessageResponseRepository: ClaudeMessageResponseRepository | null = null,
-): http.Server => {
-  const server = http.createServer((clientRequest, clientResponse) => {
-    const token = extractToken(clientRequest.headers['authorization']);
-    const requestChunks: Uint8Array[] = [];
-    let requestBytes = 0;
-    if (token !== null) {
-      clientRequest.on('data', (chunk: Buffer) => {
-        if (requestBytes >= MAX_INSPECTED_BODY_BYTES) return;
-        requestChunks.push(new Uint8Array(chunk));
-        requestBytes += chunk.length;
-      });
-    }
-    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,
-              upstreamResponse.statusCode ?? null,
-            );
-          } catch (error) {
-            console.error('Failed to write rate limit cache:', error);
-          }
-          const inspectedChunks: Uint8Array[] = [];
-          let inspectedBytes = 0;
-          upstreamResponse.on('data', (chunk: Buffer) => {
-            if (inspectedBytes >= MAX_INSPECTED_BODY_BYTES) return;
-            inspectedChunks.push(new Uint8Array(chunk));
-            inspectedBytes += chunk.length;
-          });
-          upstreamResponse.on('end', () => {
-            const body = Buffer.concat(inspectedChunks).toString('utf8');
-            try {
-              const limits = parseModelRateLimitsFromBody(body);
-              writeModelRateLimit(token, limits);
-            } catch (error) {
-              console.error('Failed to write model rate limit cache:', error);
-            }
-            if (
-              body.includes(
-                'Your organization has disabled Claude subscription access for Claude Code',
-              ) ||
-              (upstreamResponse.statusCode === 403 && isPermissionError(body))
-            ) {
-              try {
-                writeSubscriptionDisabled(token);
-              } catch (error) {
-                console.error(
-                  'Failed to write subscription disabled cache:',
-                  error,
-                );
-              }
-            }
-            if (upstreamResponse.statusCode === 429) {
-              try {
-                const requestModel = extractRequestModel(
-                  Buffer.concat(requestChunks).toString('utf8'),
-                );
-                if (isFableModel(requestModel)) {
-                  const { sevenDayRejected, sevenDayReset } =
-                    parseSevenDayRejection(upstreamResponse.headers);
-                  if (sevenDayRejected) {
-                    writeFableRejection(
-                      token,
-                      parseRetryAfterSeconds(upstreamResponse.headers),
-                      sevenDayReset,
-                    );
-                  }
-                }
-              } catch (error) {
-                console.error('Failed to write fable rejection cache:', error);
-              }
-            }
-            if (claudeMessageResponseRepository !== null) {
-              try {
-                const response = parseClaudeMessageResponse(
-                  hashToken(token),
-                  upstreamResponse.statusCode ?? 0,
-                  upstreamResponse.headers,
-                  body,
-                );
-                claudeMessageResponseRepository.append(response);
-              } catch (error) {
-                console.error(
-                  'Failed to record Claude message response:',
-                  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}`);
-  });
-  return server;
-};
-
-if (require.main === module) {
-  const dbPath = './db/claude_message_response.db';
-  const repository = new SqliteClaudeMessageResponseRepository(dbPath);
-  startProxy(PROXY_PORT, repository);
-}
-
-export { startProxy, extractToken };

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

@@ -1,26 +0,0 @@
-import { BaseGitHubRepository } from './BaseGitHubRepository';
-import { LocalStorageRepository } from './LocalStorageRepository';
-describe('BaseGitHubRepository', () => {
-  const localStorageRepository = new LocalStorageRepository();
-  class TestGitHubRepository extends BaseGitHubRepository {
-    constructor() {
-      super(localStorageRepository, process.env.GH_TOKEN);
-    }
-    extractIssueFromUrlPublic = this.extractIssueFromUrl;
-  }
-  const baseGitHubRepository: TestGitHubRepository = new TestGitHubRepository();
-
-  describe('extractIssueFromUrl', () => {
-    it('should return issue number', () => {
-      const extracted = baseGitHubRepository.extractIssueFromUrlPublic(
-        'https://github.com/HiromiShikata/test-repository/issues/38',
-      );
-      expect(extracted).toEqual({
-        owner: 'HiromiShikata',
-        repo: 'test-repository',
-        issueNumber: 38,
-        isIssue: true,
-      });
-    });
-  });
-});

package/src/adapter/repositories/BaseGitHubRepository.ts

@@ -1,26 +0,0 @@
-import { LocalStorageRepository } from './LocalStorageRepository';
-
-export class BaseGitHubRepository {
-  constructor(
-    readonly localStorageRepository: LocalStorageRepository,
-    readonly ghToken: string = process.env.GH_TOKEN || 'dummy',
-  ) {}
-  protected extractIssueFromUrl = (
-    issueUrl: string,
-  ): { owner: string; repo: string; issueNumber: number; isIssue: boolean } => {
-    const match = issueUrl.match(
-      /https:\/\/github.com\/([^/]+)\/([^/]+)\/(issues|pull)\/(\d+)/,
-    );
-    if (!match) {
-      throw new Error(`Invalid issue URL: ${issueUrl}`);
-    }
-    const [, owner, repo, pullOrIssue, issueNumberStr] = match;
-    const issueNumber = parseInt(issueNumberStr, 10);
-    if (isNaN(issueNumber)) {
-      throw new Error(
-        `Invalid issue number: ${issueNumberStr}. URL: ${issueUrl}`,
-      );
-    }
-    return { owner, repo, issueNumber, isIssue: pullOrIssue === 'issues' };
-  };
-}

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

@@ -1,108 +0,0 @@
-import { BrowserGitHubProjectRepository } from './BrowserGitHubProjectRepository';
-import { Project } from '../../domain/entities/Project';
-
-jest.mock('playwright', () => ({
-  chromium: {
-    launch: jest.fn(),
-  },
-}));
-
-const buildProject = (url: string): Project => ({
-  id: 'project-1',
-  url,
-  databaseId: 1,
-  name: 'test-project',
-  status: {
-    name: 'Status',
-    fieldId: 'status-field-1',
-    statuses: [
-      {
-        id: 'opt-aw',
-        name: 'Awaiting Workspace',
-        color: 'BLUE',
-        description: '',
-      },
-    ],
-  },
-  nextActionDate: null,
-  nextActionHour: null,
-  story: null,
-  remainingEstimationMinutes: null,
-  dependedIssueUrlSeparatedByComma: null,
-  completionDate50PercentConfidence: null,
-  agent: null,
-});
-
-describe('BrowserGitHubProjectRepository', () => {
-  it('should call console.warn and return without throwing when username is undefined', async () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-    const repo = new BrowserGitHubProjectRepository(
-      undefined,
-      'password',
-      undefined,
-    );
-    const project = buildProject(
-      'https://github.com/users/testuser/projects/1',
-    );
-
-    await expect(
-      repo.setStatusFieldDefault(project, 'opt-aw'),
-    ).resolves.toBeUndefined();
-
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining('GITHUB_USERNAME or GITHUB_PASSWORD is unset'),
-    );
-    warnSpy.mockRestore();
-  });
-
-  it('should call console.warn and return without throwing when password is undefined', async () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-    const repo = new BrowserGitHubProjectRepository(
-      'username',
-      undefined,
-      undefined,
-    );
-    const project = buildProject(
-      'https://github.com/users/testuser/projects/1',
-    );
-
-    await expect(
-      repo.setStatusFieldDefault(project, 'opt-aw'),
-    ).resolves.toBeUndefined();
-
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining('GITHUB_USERNAME or GITHUB_PASSWORD is unset'),
-    );
-    warnSpy.mockRestore();
-  });
-
-  it('should throw when projectLocationFromUrl returns null for an invalid URL', async () => {
-    const repo = new BrowserGitHubProjectRepository(
-      'username',
-      'password',
-      undefined,
-    );
-    const project = buildProject('https://example.com/invalid/url');
-
-    await expect(repo.setStatusFieldDefault(project, 'opt-aw')).rejects.toThrow(
-      'cannot parse project URL',
-    );
-  });
-
-  it('should throw when optionId is not found in project status list', async () => {
-    const repo = new BrowserGitHubProjectRepository(
-      'username',
-      'password',
-      undefined,
-    );
-    const project = buildProject(
-      'https://github.com/users/testuser/projects/1',
-    );
-
-    await expect(
-      repo.setStatusFieldDefault(project, 'nonexistent-id'),
-    ).rejects.toThrow(
-      'option with id "nonexistent-id" not found in project status list',
-    );
-  });
-});

package/src/adapter/repositories/BrowserGitHubProjectRepository.ts

@@ -1,118 +0,0 @@
-import { createHmac } from 'crypto';
-import { chromium } from 'playwright';
-import { Project } from '../../domain/entities/Project';
-import { StatusDefaultRepository } from '../../domain/usecases/adapter-interfaces/StatusDefaultRepository';
-import { projectLocationFromUrl } from './RestProjectRepository';
-
-const generateTotp = (secret: string): string => {
-  const base32Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-  const secretUpper = secret.toUpperCase().replace(/=+$/, '');
-  let bytes = 0n;
-  let bitsLeft = 0;
-  const output: number[] = [];
-  for (const char of secretUpper) {
-    const val = base32Chars.indexOf(char);
-    if (val === -1) continue;
-    bytes = (bytes << 5n) | BigInt(val);
-    bitsLeft += 5;
-    if (bitsLeft >= 8) {
-      bitsLeft -= 8;
-      output.push(Number((bytes >> BigInt(bitsLeft)) & 0xffn));
-      bytes &= (1n << BigInt(bitsLeft)) - 1n;
-    }
-  }
-  const key = Buffer.from(output);
-  const counter = BigInt(Math.floor(Date.now() / 1000 / 30));
-  const counterBuffer = Buffer.alloc(8);
-  counterBuffer.writeBigUInt64BE(counter);
-  const hmac = createHmac('sha1', key).update(counterBuffer).digest();
-  const offset = hmac[hmac.length - 1] & 0x0f;
-  const code =
-    ((hmac[offset] & 0x7f) << 24) |
-    ((hmac[offset + 1] & 0xff) << 16) |
-    ((hmac[offset + 2] & 0xff) << 8) |
-    (hmac[offset + 3] & 0xff);
-  return String(code % 1_000_000).padStart(6, '0');
-};
-
-export class BrowserGitHubProjectRepository implements Pick<
-  StatusDefaultRepository,
-  'setStatusFieldDefault'
-> {
-  constructor(
-    private readonly username: string | undefined,
-    private readonly password: string | undefined,
-    private readonly totpSecret: string | undefined,
-  ) {}
-
-  setStatusFieldDefault = async (
-    project: Project,
-    optionId: string,
-  ): Promise<void> => {
-    const location = projectLocationFromUrl(project.url);
-    if (!location) {
-      throw new Error(
-        `BrowserGitHubProjectRepository: cannot parse project URL: ${project.url}`,
-      );
-    }
-
-    const settingsUrl = `https://github.com/${location.ownerType}/${location.owner}/projects/${location.projectNumber}/settings/fields/Status`;
-
-    if (!this.username || !this.password) {
-      console.warn(
-        `BrowserGitHubProjectRepository: GITHUB_USERNAME or GITHUB_PASSWORD is unset; skipping setStatusFieldDefault. Settings URL: ${settingsUrl}`,
-      );
-      return;
-    }
-
-    const optionName = project.status.statuses.find(
-      (s) => s.id === optionId,
-    )?.name;
-    if (!optionName) {
-      throw new Error(
-        `BrowserGitHubProjectRepository: option with id "${optionId}" not found in project status list`,
-      );
-    }
-
-    const browser = await chromium.launch({ headless: true });
-    try {
-      const page = await browser.newPage();
-
-      await page.goto('https://github.com/login');
-      await page.fill('#login_field', this.username);
-      await page.fill('#password', this.password);
-      await page.click('[name="commit"]');
-
-      const otpInput = page.locator('#app_totp');
-      const isOtpVisible = await otpInput.isVisible().catch(() => false);
-      if (isOtpVisible && this.totpSecret) {
-        const totp = generateTotp(this.totpSecret);
-        await otpInput.fill(totp);
-        await page.click('[type="submit"]');
-      }
-
-      await page.goto(settingsUrl);
-
-      const defaultSelect = page
-        .locator('select[aria-label="Default value"]')
-        .first();
-      await defaultSelect.waitFor({ state: 'visible' });
-      const options = await defaultSelect.locator('option').allTextContents();
-      const matchingOption = options.find((o) => o.trim() === optionName);
-      if (!matchingOption) {
-        throw new Error(
-          `BrowserGitHubProjectRepository: option "${optionName}" not found in Default dropdown. Available: ${options.join(', ')}`,
-        );
-      }
-      await defaultSelect.selectOption({ label: optionName });
-
-      const saveButton = page
-        .locator('button[type="submit"]')
-        .filter({ hasText: /save/i })
-        .first();
-      await saveButton.click();
-    } finally {
-      await browser.close();
-    }
-  };
-}

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

@@ -1,71 +0,0 @@
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { CliGitHubGraphqlRateLimitRepository } from './CliGitHubGraphqlRateLimitRepository';
-
-type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
-
-describe('CliGitHubGraphqlRateLimitRepository', () => {
-  let mockLocalCommandRunner: Mocked<LocalCommandRunner>;
-  let repository: CliGitHubGraphqlRateLimitRepository;
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    mockLocalCommandRunner = {
-      runCommand: jest.fn(),
-      spawnInteractive: jest.fn(),
-    };
-    repository = new CliGitHubGraphqlRateLimitRepository(
-      mockLocalCommandRunner,
-    );
-  });
-
-  it('returns the remaining GraphQL request count when gh succeeds', async () => {
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '4873\n',
-      stderr: '',
-      exitCode: 0,
-    });
-
-    const result = await repository.getRemainingRequestCount();
-
-    expect(result).toBe(4873);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toEqual([
-      ['gh', ['api', 'rate_limit', '--jq', '.resources.graphql.remaining']],
-    ]);
-  });
-
-  it('returns null when gh exits with a non-zero code', async () => {
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: 'error: authentication required',
-      exitCode: 1,
-    });
-
-    const result = await repository.getRemainingRequestCount();
-
-    expect(result).toBeNull();
-  });
-
-  it('returns null when the output is not a valid integer', async () => {
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: 'not-a-number\n',
-      stderr: '',
-      exitCode: 0,
-    });
-
-    const result = await repository.getRemainingRequestCount();
-
-    expect(result).toBeNull();
-  });
-
-  it('returns zero when the remaining count is zero', async () => {
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '0\n',
-      stderr: '',
-      exitCode: 0,
-    });
-
-    const result = await repository.getRemainingRequestCount();
-
-    expect(result).toBe(0);
-  });
-});

package/src/adapter/repositories/CliGitHubGraphqlRateLimitRepository.ts

@@ -1,21 +0,0 @@
-import { GitHubGraphqlRateLimitRepository } from '../../domain/usecases/adapter-interfaces/GitHubGraphqlRateLimitRepository';
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-
-export class CliGitHubGraphqlRateLimitRepository implements GitHubGraphqlRateLimitRepository {
-  constructor(private readonly localCommandRunner: LocalCommandRunner) {}
-
-  getRemainingRequestCount = async (): Promise<number | null> => {
-    const result = await this.localCommandRunner.runCommand('gh', [
-      'api',
-      'rate_limit',
-      '--jq',
-      '.resources.graphql.remaining',
-    ]);
-    if (result.exitCode !== 0) {
-      return null;
-    }
-    const trimmed = result.stdout.trim();
-    const parsed = Number(trimmed);
-    return trimmed !== '' && Number.isInteger(parsed) ? parsed : null;
-  };
-}