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

package/src/adapter/repositories/NodeTmuxSessionRepository.ts

@@ -1,245 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { TmuxSessionRepository } from '../../domain/usecases/adapter-interfaces/TmuxSessionRepository';
-import { LiveTmuxSession } from '../../domain/entities/LiveTmuxSession';
-import { clSessionScopeUnitName } from './clSessionScopeUnitName';
-import { clSessionScopeUnitNameFromCgroupContent } from './clSessionScopeUnitNameFromCgroupContent';
-
-const DEFAULT_SEND_KEYS_SUBMIT_DELAY_MS = 1000;
-const BRACKETED_PASTE_START = '\x1b[200~';
-const BRACKETED_PASTE_END = '\x1b[201~';
-
-const shellSingleQuote = (value: string): string =>
-  `'${value.replace(/'/g, `'\\''`)}'`;
-
-export class NodeTmuxSessionRepository implements TmuxSessionRepository {
-  constructor(
-    private readonly localCommandRunner: LocalCommandRunner,
-    private readonly procDirectory: string = '/proc',
-    private readonly submitDelayMilliseconds: number = DEFAULT_SEND_KEYS_SUBMIT_DELAY_MS,
-  ) {}
-
-  listLiveSessionNames = async (): Promise<string[]> => {
-    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
-      'tmux',
-      ['list-sessions', '-F', '#{session_name}'],
-    );
-    if (exitCode !== 0) {
-      return [];
-    }
-    return stdout
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0);
-  };
-
-  listLiveSessionsWithActivity = async (): Promise<LiveTmuxSession[]> => {
-    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
-      'tmux',
-      ['list-sessions', '-F', '#{session_name} #{session_activity}'],
-    );
-    if (exitCode !== 0) {
-      return [];
-    }
-    return stdout
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0)
-      .map((line) => {
-        const separatorIndex = line.lastIndexOf(' ');
-        const sessionName = line.slice(0, separatorIndex);
-        const activityEpochSeconds = Number(line.slice(separatorIndex + 1));
-        return { sessionName, activityEpochSeconds };
-      });
-  };
-
-  listInteractiveProcessCommandLines = async (): Promise<string[]> => {
-    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
-      'ps',
-      ['-eo', 'args='],
-    );
-    if (exitCode !== 0) {
-      return [];
-    }
-    return stdout
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0);
-  };
-
-  launchDetachedSession = async (
-    sessionName: string,
-    launcherCommand: string,
-    issueUrl: string,
-  ): Promise<void> => {
-    await this.localCommandRunner.runCommand('tmux', [
-      'new-session',
-      '-A',
-      '-d',
-      '-s',
-      sessionName,
-      'sh',
-      '-lc',
-      `exec "$1" "$2"`,
-      'sh',
-      launcherCommand,
-      issueUrl,
-    ]);
-  };
-
-  killSession = async (sessionName: string): Promise<void> => {
-    const scopeUnitName = clSessionScopeUnitName(sessionName);
-    await this.stopScopeUnit(scopeUnitName);
-    const { stderr, exitCode } = await this.localCommandRunner.runCommand(
-      'tmux',
-      ['kill-session', '-t', `=${sessionName}`],
-    );
-    if (exitCode !== 0) {
-      throw new Error(
-        `Failed to kill tmux session "${sessionName}": exit code ${exitCode}${
-          stderr ? `: ${stderr}` : ''
-        }`,
-      );
-    }
-  };
-
-  killOwnSession = async (): Promise<void> => {
-    const cgroupContent = fs.readFileSync(
-      path.join(this.procDirectory, 'self', 'cgroup'),
-      'utf8',
-    );
-    const scopeUnitName =
-      clSessionScopeUnitNameFromCgroupContent(cgroupContent);
-    if (scopeUnitName === null) {
-      throw new Error(
-        'Failed to determine the current cl-*.scope systemd user unit from /proc/self/cgroup',
-      );
-    }
-    await this.stopScopeUnit(scopeUnitName);
-  };
-
-  private stopScopeUnit = async (scopeUnitName: string): Promise<void> => {
-    await this.localCommandRunner.runCommand('systemctl', [
-      '--user',
-      'reset-failed',
-      scopeUnitName,
-    ]);
-    const { stderr, exitCode } = await this.localCommandRunner.runCommand(
-      'systemctl',
-      ['--user', 'stop', scopeUnitName],
-    );
-    await this.localCommandRunner.runCommand('systemctl', [
-      '--user',
-      'reset-failed',
-      scopeUnitName,
-    ]);
-    if (exitCode !== 0) {
-      console.error(
-        `Failed to stop systemd user scope "${scopeUnitName}": exit code ${exitCode}${
-          stderr ? `: ${stderr}` : ''
-        }`,
-      );
-    }
-  };
-
-  sendKeys = async (
-    sessionName: string,
-    literalText: string,
-  ): Promise<void> => {
-    const literalResult = await this.localCommandRunner.runCommand('tmux', [
-      'send-keys',
-      '-t',
-      sessionName,
-      '-l',
-      `${BRACKETED_PASTE_START}${literalText}${BRACKETED_PASTE_END}`,
-    ]);
-    if (literalResult.exitCode !== 0) {
-      throw new Error(
-        `Failed to send keys to tmux session "${sessionName}": exit code ${literalResult.exitCode}${
-          literalResult.stderr ? `: ${literalResult.stderr}` : ''
-        }`,
-      );
-    }
-    await this.delaySubmit();
-    await this.sendEnter(sessionName);
-  };
-
-  attachOrCreateInteractiveSession = async (
-    issueUrl: string,
-    scopeLibPath: string | null,
-  ): Promise<void> => {
-    if (scopeLibPath !== null) {
-      const { stdout, exitCode } = await this.localCommandRunner.runCommand(
-        'bash',
-        [scopeLibPath, 'registry-get-session', issueUrl],
-      );
-      if (exitCode === 0 && stdout.trim().length > 0) {
-        const registeredSessionName = stdout.trim();
-        const { exitCode: hasSessionExitCode } =
-          await this.localCommandRunner.runCommand('tmux', [
-            'has-session',
-            '-t',
-            `=${registeredSessionName}`,
-          ]);
-        if (hasSessionExitCode === 0) {
-          this.localCommandRunner.spawnInteractive('tmux', [
-            'attach-session',
-            '-t',
-            `=${registeredSessionName}`,
-          ]);
-          return;
-        }
-      }
-    }
-    this.localCommandRunner.spawnInteractive('tmux', [
-      'new-session',
-      '-A',
-      '-s',
-      issueUrl,
-      'cl',
-      issueUrl,
-    ]);
-  };
-
-  launchBareNameLeaderSession = async (name: string): Promise<void> => {
-    const sessionName = name.replace(/[.:]/g, '_');
-    const leaderCommand = `cl ${shellSingleQuote(name)}; exec /bin/bash`;
-    const { stderr, exitCode } = await this.localCommandRunner.runCommand(
-      'tmux',
-      ['new-session', '-d', '-s', sessionName, 'bash', '-lc', leaderCommand],
-    );
-    if (exitCode !== 0) {
-      throw new Error(
-        `Failed to relaunch bare-name leader session "${sessionName}": exit code ${exitCode}${
-          stderr ? `: ${stderr}` : ''
-        }`,
-      );
-    }
-  };
-
-  private sendEnter = async (sessionName: string): Promise<void> => {
-    const enterResult = await this.localCommandRunner.runCommand('tmux', [
-      'send-keys',
-      '-t',
-      sessionName,
-      'Enter',
-    ]);
-    if (enterResult.exitCode !== 0) {
-      throw new Error(
-        `Failed to send Enter to tmux session "${sessionName}": exit code ${enterResult.exitCode}${
-          enterResult.stderr ? `: ${enterResult.stderr}` : ''
-        }`,
-      );
-    }
-  };
-
-  private delaySubmit = async (): Promise<void> => {
-    if (this.submitDelayMilliseconds <= 0) {
-      return;
-    }
-    await new Promise((resolve) =>
-      setTimeout(resolve, this.submitDelayMilliseconds),
-    );
-  };
-}

package/src/adapter/repositories/OauthAPIClaudeRepository.ts

@@ -1,279 +0,0 @@
-import { ClaudeRepository } from '../../domain/usecases/adapter-interfaces/ClaudeRepository';
-import { ClaudeWindowUsage } from '../../domain/entities/ClaudeWindowUsage';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-type CredentialsFile = {
-  claudeAiOauth?: {
-    accessToken?: string;
-  };
-};
-
-type CredentialInfo = {
-  name: string;
-  priority: number;
-  filePath: string;
-};
-
-type UsageWindow = {
-  utilization?: number;
-  resets_at?: string;
-};
-
-type UsageResponse = {
-  five_hour?: UsageWindow;
-  seven_day?: UsageWindow;
-  seven_day_opus?: UsageWindow;
-  seven_day_sonnet?: UsageWindow;
-  error?: string;
-};
-
-const isCredentialsFile = (value: unknown): value is CredentialsFile => {
-  if (typeof value !== 'object' || value === null) return false;
-  return true;
-};
-
-const isUsageResponse = (value: unknown): value is UsageResponse => {
-  if (typeof value !== 'object' || value === null) return false;
-  return true;
-};
-
-const findCredentials = (filePathList: string[]): CredentialInfo[] => {
-  const credentials: CredentialInfo[] = [];
-  const baseFileName = '.credentials.json';
-
-  for (const filePath of filePathList) {
-    const fileName = path.basename(filePath);
-
-    if (fileName === baseFileName) {
-      continue;
-    }
-
-    const suffix = fileName.slice(baseFileName.length + 1);
-    const parts = suffix.split('.');
-    if (parts.length !== 2) {
-      continue;
-    }
-
-    const name = parts[0];
-    const priorityStr = parts[1];
-    const priority = parseInt(priorityStr, 10);
-
-    if (isNaN(priority)) {
-      continue;
-    }
-
-    credentials.push({
-      name,
-      priority,
-      filePath,
-    });
-  }
-
-  return credentials.sort((a, b) => a.priority - b.priority);
-};
-
-export class OauthAPIClaudeRepository implements ClaudeRepository {
-  private readonly credentialsPath: string;
-  private readonly claudeDir: string;
-
-  constructor() {
-    this.claudeDir = path.join(os.homedir(), '.claude');
-    this.credentialsPath = path.join(this.claudeDir, '.credentials.json');
-  }
-
-  private getAccessToken(): string {
-    if (!fs.existsSync(this.credentialsPath)) {
-      throw new Error(
-        `Claude credentials file not found at ${this.credentialsPath}. Please login to Claude Code first using: claude login`,
-      );
-    }
-
-    const fileContent = fs.readFileSync(this.credentialsPath, 'utf-8');
-    const credentials: unknown = JSON.parse(fileContent);
-
-    if (!isCredentialsFile(credentials)) {
-      throw new Error('Invalid credentials file format');
-    }
-
-    const accessToken = credentials.claudeAiOauth?.accessToken;
-
-    if (!accessToken) {
-      throw new Error('No access token found in credentials file');
-    }
-
-    return accessToken;
-  }
-
-  async getUsage(): Promise<ClaudeWindowUsage[]> {
-    const accessToken = this.getAccessToken();
-
-    const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json, text/plain, */*',
-        'Content-Type': 'application/json',
-        'User-Agent': 'claude-code/2.0.32',
-        Authorization: `Bearer ${accessToken}`,
-        'anthropic-beta': 'oauth-2025-04-20',
-      },
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Claude API error: ${errorText}`);
-    }
-
-    const responseData: unknown = await response.json();
-
-    if (!isUsageResponse(responseData)) {
-      throw new Error('Invalid API response format');
-    }
-
-    if (responseData.error) {
-      throw new Error(`API error: ${responseData.error}`);
-    }
-
-    const usages: ClaudeWindowUsage[] = [];
-
-    if (responseData.five_hour?.utilization !== undefined) {
-      usages.push({
-        hour: 5,
-        utilizationPercentage: responseData.five_hour.utilization,
-        resetsAt: responseData.five_hour.resets_at
-          ? new Date(responseData.five_hour.resets_at)
-          : new Date(),
-      });
-    }
-
-    if (responseData.seven_day?.utilization !== undefined) {
-      usages.push({
-        hour: 168,
-        utilizationPercentage: responseData.seven_day.utilization,
-        resetsAt: responseData.seven_day.resets_at
-          ? new Date(responseData.seven_day.resets_at)
-          : new Date(),
-      });
-    }
-
-    if (responseData.seven_day_opus?.utilization !== undefined) {
-      usages.push({
-        hour: 168,
-        utilizationPercentage: responseData.seven_day_opus.utilization,
-        resetsAt: responseData.seven_day_opus.resets_at
-          ? new Date(responseData.seven_day_opus.resets_at)
-          : new Date(),
-      });
-    }
-
-    if (responseData.seven_day_sonnet?.utilization !== undefined) {
-      usages.push({
-        hour: 168,
-        utilizationPercentage: responseData.seven_day_sonnet.utilization,
-        resetsAt: responseData.seven_day_sonnet.resets_at
-          ? new Date(responseData.seven_day_sonnet.resets_at)
-          : new Date(),
-      });
-    }
-
-    return usages;
-  }
-
-  private async getUsageWithToken(accessToken: string): Promise<UsageResponse> {
-    const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json, text/plain, */*',
-        'Content-Type': 'application/json',
-        'User-Agent': 'claude-code/2.0.32',
-        Authorization: `Bearer ${accessToken}`,
-        'anthropic-beta': 'oauth-2025-04-20',
-      },
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Claude API error: ${errorText}`);
-    }
-
-    const responseData: unknown = await response.json();
-
-    if (!isUsageResponse(responseData)) {
-      throw new Error('Invalid API response format');
-    }
-
-    if (responseData.error) {
-      throw new Error(`API error: ${responseData.error}`);
-    }
-
-    return responseData;
-  }
-
-  private isUsageUnderThreshold(
-    usageResponse: UsageResponse,
-    threshold: number,
-  ): boolean {
-    const windows = [
-      usageResponse.five_hour,
-      usageResponse.seven_day,
-      usageResponse.seven_day_opus,
-      usageResponse.seven_day_sonnet,
-    ];
-
-    for (const window of windows) {
-      if (
-        window?.utilization !== undefined &&
-        window.utilization >= threshold
-      ) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  async isClaudeAvailable(threshold: number): Promise<boolean> {
-    if (!fs.existsSync(this.claudeDir)) {
-      return false;
-    }
-
-    const files = fs.readdirSync(this.claudeDir);
-    const filePathList = files
-      .filter((file) => file.startsWith('.credentials.json'))
-      .map((file) => path.join(this.claudeDir, file));
-
-    const credentials = findCredentials(filePathList);
-
-    if (credentials.length === 0) {
-      return false;
-    }
-
-    for (const credential of credentials) {
-      const fileContent = fs.readFileSync(credential.filePath, 'utf-8');
-      const credentialData: unknown = JSON.parse(fileContent);
-
-      if (!isCredentialsFile(credentialData)) {
-        continue;
-      }
-
-      const accessToken = credentialData.claudeAiOauth?.accessToken;
-      if (!accessToken) {
-        continue;
-      }
-
-      try {
-        const usageResponse = await this.getUsageWithToken(accessToken);
-
-        if (this.isUsageUnderThreshold(usageResponse, threshold)) {
-          fs.copyFileSync(credential.filePath, this.credentialsPath);
-          return true;
-        }
-      } catch {
-        continue;
-      }
-    }
-
-    return false;
-  }
-}

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

@@ -1,166 +0,0 @@
-import { OauthAPIProxyClaudeRepository } from './OauthAPIProxyClaudeRepository';
-import { ClaudeRepository } from '../../domain/usecases/adapter-interfaces/ClaudeRepository';
-import { ClaudeWindowUsage } from '../../domain/entities/ClaudeWindowUsage';
-
-type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
-
-describe('OauthAPIProxyClaudeRepository', () => {
-  let mockProxyRepository: Mocked<Pick<ClaudeRepository, 'getUsage'>>;
-  let mockApiRepository: Mocked<ClaudeRepository>;
-  let repository: OauthAPIProxyClaudeRepository;
-
-  const fiveHourUsage: ClaudeWindowUsage = {
-    hour: 5,
-    utilizationPercentage: 23,
-    resetsAt: new Date(1772575200 * 1000),
-  };
-
-  const sevenDayUsage: ClaudeWindowUsage = {
-    hour: 168,
-    utilizationPercentage: 34,
-    resetsAt: new Date(1772769600 * 1000),
-  };
-
-  const apiUsage: ClaudeWindowUsage = {
-    hour: 5,
-    utilizationPercentage: 50,
-    resetsAt: new Date(),
-  };
-
-  beforeEach(() => {
-    mockProxyRepository = {
-      getUsage: jest.fn(),
-    };
-    mockApiRepository = {
-      getUsage: jest.fn(),
-      isClaudeAvailable: jest.fn(),
-    };
-    repository = new OauthAPIProxyClaudeRepository(
-      mockProxyRepository,
-      mockApiRepository,
-    );
-  });
-
-  describe('getUsage', () => {
-    interface TestCase {
-      name: string;
-      proxyUsages: ClaudeWindowUsage[];
-      apiUsages: ClaudeWindowUsage[];
-      expected: ClaudeWindowUsage[];
-      expectApiCalled: boolean;
-    }
-
-    const testCases: TestCase[] = [
-      {
-        name: 'returns proxy usages when proxy has data',
-        proxyUsages: [fiveHourUsage, sevenDayUsage],
-        apiUsages: [apiUsage],
-        expected: [fiveHourUsage, sevenDayUsage],
-        expectApiCalled: false,
-      },
-      {
-        name: 'falls back to API usages when proxy has no data',
-        proxyUsages: [],
-        apiUsages: [apiUsage],
-        expected: [apiUsage],
-        expectApiCalled: true,
-      },
-    ];
-
-    test.each(testCases)(
-      '$name',
-      async ({ proxyUsages, apiUsages, expected, expectApiCalled }) => {
-        mockProxyRepository.getUsage.mockResolvedValue(proxyUsages);
-        mockApiRepository.getUsage.mockResolvedValue(apiUsages);
-
-        const result = await repository.getUsage();
-
-        expect(result).toEqual(expected);
-        if (expectApiCalled) {
-          expect(mockApiRepository.getUsage.mock.calls).not.toHaveLength(0);
-        } else {
-          expect(mockApiRepository.getUsage.mock.calls).toHaveLength(0);
-        }
-      },
-    );
-  });
-
-  describe('isClaudeAvailable', () => {
-    interface TestCase {
-      name: string;
-      proxyUsages: ClaudeWindowUsage[];
-      apiAvailable: boolean;
-      threshold: number;
-      expected: boolean;
-      expectApiCalled: boolean;
-    }
-
-    const testCases: TestCase[] = [
-      {
-        name: 'returns true when proxy has data and all usages under threshold',
-        proxyUsages: [fiveHourUsage, sevenDayUsage],
-        apiAvailable: false,
-        threshold: 90,
-        expected: true,
-        expectApiCalled: false,
-      },
-      {
-        name: 'returns false when proxy has data and 5h usage above threshold',
-        proxyUsages: [
-          {
-            hour: 5,
-            utilizationPercentage: 95,
-            resetsAt: new Date(),
-          },
-        ],
-        apiAvailable: true,
-        threshold: 90,
-        expected: false,
-        expectApiCalled: false,
-      },
-      {
-        name: 'delegates to API when proxy has no data',
-        proxyUsages: [],
-        apiAvailable: true,
-        threshold: 90,
-        expected: true,
-        expectApiCalled: true,
-      },
-      {
-        name: 'returns API result when proxy has no data and API returns false',
-        proxyUsages: [],
-        apiAvailable: false,
-        threshold: 90,
-        expected: false,
-        expectApiCalled: true,
-      },
-    ];
-
-    test.each(testCases)(
-      '$name',
-      async ({
-        proxyUsages,
-        apiAvailable,
-        threshold,
-        expected,
-        expectApiCalled,
-      }) => {
-        mockProxyRepository.getUsage.mockResolvedValue(proxyUsages);
-        mockApiRepository.isClaudeAvailable.mockResolvedValue(apiAvailable);
-
-        const result = await repository.isClaudeAvailable(threshold);
-
-        expect(result).toBe(expected);
-        if (expectApiCalled) {
-          expect(mockApiRepository.isClaudeAvailable.mock.calls).toEqual([
-            [threshold],
-          ]);
-        } else {
-          expect(mockApiRepository.isClaudeAvailable.mock.calls).toHaveLength(
-            0,
-          );
-        }
-      },
-    );
-  });
-});