github-issue-tower-defence-management 1.139.0 → 1.140.0

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

@@ -294,4 +294,136 @@ describe('NodeTmuxSessionRepository', () => {
       ]);
     });
   });
+
+  describe('sendKeys', () => {
+    it('sends the literal text then Enter and stops when the composer is empty', async () => {
+      const runner = createMockRunner();
+      runner.runCommand
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({
+          stdout: 'idle pane content\n> ',
+          stderr: '',
+          exitCode: 0,
+        });
+      const repository = new NodeTmuxSessionRepository(runner, '/proc', 0);
+
+      await repository.sendKeys('session-a', 'checkpoint now');
+
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'send-keys',
+        '-t',
+        'session-a',
+        '-l',
+        'checkpoint now',
+      ]);
+      expect(runner.runCommand.mock.calls[1][1]).toEqual([
+        'send-keys',
+        '-t',
+        'session-a',
+        'Enter',
+      ]);
+      expect(runner.runCommand.mock.calls[2][1]).toEqual([
+        'capture-pane',
+        '-p',
+        '-t',
+        'session-a',
+      ]);
+      expect(runner.runCommand.mock.calls).toHaveLength(3);
+    });
+
+    it('re-sends Enter when the message is still visible in the composer', async () => {
+      const runner = createMockRunner();
+      runner.runCommand
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({
+          stdout: '> checkpoint now',
+          stderr: '',
+          exitCode: 0,
+        })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+      const repository = new NodeTmuxSessionRepository(runner, '/proc', 0);
+
+      await repository.sendKeys('session-a', 'checkpoint now');
+
+      expect(runner.runCommand.mock.calls).toHaveLength(4);
+      expect(runner.runCommand.mock.calls[3][1]).toEqual([
+        'send-keys',
+        '-t',
+        'session-a',
+        'Enter',
+      ]);
+    });
+
+    it('throws when sending the literal text fails', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: 'no session',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner, '/proc', 0);
+
+      await expect(repository.sendKeys('session-a', 'text')).rejects.toThrow(
+        'Failed to send keys to tmux session "session-a"',
+      );
+    });
+  });
+
+  describe('launchBareNameLeaderSession', () => {
+    it('creates a detached tmux session running cl for the bare name', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.launchBareNameLeaderSession('app');
+
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'new-session',
+        '-d',
+        '-s',
+        'app',
+        'bash',
+        '-lc',
+        "cl 'app'; exec /bin/bash",
+      ]);
+    });
+
+    it('normalizes dots and colons in the session name', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.launchBareNameLeaderSession('tdpm-cli.v2');
+
+      expect(runner.runCommand.mock.calls[0][1][3]).toBe('tdpm-cli_v2');
+      expect(runner.runCommand.mock.calls[0][1][6]).toBe(
+        "cl 'tdpm-cli.v2'; exec /bin/bash",
+      );
+    });
+
+    it('throws when tmux fails to create the session', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: 'duplicate session',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await expect(
+        repository.launchBareNameLeaderSession('app'),
+      ).rejects.toThrow('Failed to relaunch bare-name leader session "app"');
+    });
+  });
 });

package/src/adapter/repositories/NodeTmuxSessionRepository.ts

@@ -6,10 +6,18 @@ import { LiveTmuxSession } from '../../domain/entities/LiveTmuxSession';
 import { clSessionScopeUnitName } from './clSessionScopeUnitName';
 import { clSessionScopeUnitNameFromCgroupContent } from './clSessionScopeUnitNameFromCgroupContent';
 
+const DEFAULT_SEND_KEYS_SUBMIT_DELAY_MS = 1000;
+const SEND_KEYS_COMPOSER_PROBE_LENGTH = 40;
+const SEND_KEYS_COMPOSER_TAIL_LINES = 8;
+
+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[]> => {
@@ -134,4 +142,96 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
       );
     }
   };
+
+  sendKeys = async (
+    sessionName: string,
+    literalText: string,
+  ): Promise<void> => {
+    const literalResult = await this.localCommandRunner.runCommand('tmux', [
+      'send-keys',
+      '-t',
+      sessionName,
+      '-l',
+      literalText,
+    ]);
+    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);
+    if (await this.messageStillInComposer(sessionName, literalText)) {
+      await this.delaySubmit();
+      await this.sendEnter(sessionName);
+    }
+  };
+
+  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 messageStillInComposer = async (
+    sessionName: string,
+    literalText: string,
+  ): Promise<boolean> => {
+    const probe = literalText
+      .trim()
+      .split('\n', 1)[0]
+      .slice(0, SEND_KEYS_COMPOSER_PROBE_LENGTH);
+    if (probe.length === 0) {
+      return false;
+    }
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['capture-pane', '-p', '-t', sessionName],
+    );
+    if (exitCode !== 0) {
+      return false;
+    }
+    const tail = stdout
+      .split('\n')
+      .slice(-SEND_KEYS_COMPOSER_TAIL_LINES)
+      .join('\n');
+    return tail.includes(probe);
+  };
+
+  private delaySubmit = async (): Promise<void> => {
+    if (this.submitDelayMilliseconds <= 0) {
+      return;
+    }
+    await new Promise((resolve) =>
+      setTimeout(resolve, this.submitDelayMilliseconds),
+    );
+  };
 }

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

@@ -0,0 +1,194 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcClaudeHandoverSessionRepository } from './ProcClaudeHandoverSessionRepository';
+
+type FakeProcess = {
+  pid: number;
+  comm: string;
+  cmdline: string;
+  environ: Record<string, string>;
+};
+
+const issueUrl = 'https://github.com/HiromiShikata/example/issues/1';
+const argv = (...parts: string[]): string => `${parts.join('\0')}\0`;
+
+describe('ProcClaudeHandoverSessionRepository', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'fake-proc-handover-'),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { recursive: true, force: true });
+  });
+
+  const writeProcess = (fakeProcess: FakeProcess): void => {
+    const processDirectory = path.join(procDirectory, String(fakeProcess.pid));
+    fs.mkdirSync(processDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(processDirectory, 'comm'),
+      `${fakeProcess.comm}\n`,
+    );
+    fs.writeFileSync(
+      path.join(processDirectory, 'cmdline'),
+      fakeProcess.cmdline,
+    );
+    const environBuffer = Object.entries(fakeProcess.environ)
+      .map(([key, value]) => `${key}=${value}\0`)
+      .join('');
+    fs.writeFileSync(path.join(processDirectory, 'environ'), environBuffer);
+  };
+
+  it('classifies an issue-URL leader from a cl --name url launch', () => {
+    writeProcess({
+      pid: 201,
+      comm: 'claude',
+      cmdline: argv('claude', '--model', 'opus', '--name', issueUrl),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-a' },
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()).toEqual([
+      {
+        kind: 'issueUrlLeader',
+        pid: 201,
+        token: 'token-a',
+        sessionName: issueUrl.replace(/[.:]/g, '_'),
+        name: issueUrl,
+        issueUrl,
+      },
+    ]);
+  });
+
+  it('classifies a bare-name resident leader from a cl --name bare launch', () => {
+    writeProcess({
+      pid: 202,
+      comm: 'claude',
+      cmdline: argv('claude', '--name', 'app'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-b' },
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()).toEqual([
+      {
+        kind: 'bareNameLeader',
+        pid: 202,
+        token: 'token-b',
+        sessionName: 'app',
+        name: 'app',
+        issueUrl: null,
+      },
+    ]);
+  });
+
+  it('classifies an impl subagent from a -p task string containing an issue URL', () => {
+    writeProcess({
+      pid: 203,
+      comm: 'claude',
+      cmdline: argv(
+        'claude',
+        '--verbose',
+        '-p',
+        `Take ownership of ${issueUrl} and finish it`,
+      ),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-c' },
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()).toEqual([
+      {
+        kind: 'implSubagent',
+        pid: 203,
+        token: 'token-c',
+        sessionName: null,
+        name: null,
+        issueUrl,
+      },
+    ]);
+  });
+
+  it('normalizes dots and colons in a bare name to the tmux session name', () => {
+    writeProcess({
+      pid: 204,
+      comm: 'claude',
+      cmdline: argv('claude', '--name', 'tdpm-cli.v2'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-d' },
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()[0].sessionName).toBe(
+      'tdpm-cli_v2',
+    );
+  });
+
+  it('ignores a non-claude process even when it has a token and a name', () => {
+    writeProcess({
+      pid: 205,
+      comm: 'node',
+      cmdline: argv('node', '--name', 'app'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-e' },
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()).toEqual([]);
+  });
+
+  it('ignores a claude process without an OAuth token', () => {
+    writeProcess({
+      pid: 206,
+      comm: 'claude',
+      cmdline: argv('claude', '--name', 'app'),
+      environ: {},
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()).toEqual([]);
+  });
+
+  it('ignores a claude process with neither a name nor an issue URL', () => {
+    writeProcess({
+      pid: 207,
+      comm: 'claude',
+      cmdline: argv('claude', '--model', 'opus'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-f' },
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()).toEqual([]);
+  });
+
+  it('accepts a claude-agent comm', () => {
+    writeProcess({
+      pid: 208,
+      comm: 'claude-agent',
+      cmdline: argv('claude-agent', '--name', 'secretary'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-g' },
+    });
+
+    const repository = new ProcClaudeHandoverSessionRepository(procDirectory);
+
+    expect(repository.listHandoverSessions()[0]).toMatchObject({
+      kind: 'bareNameLeader',
+      name: 'secretary',
+    });
+  });
+
+  it('returns an empty list when the proc directory cannot be read', () => {
+    const repository = new ProcClaudeHandoverSessionRepository(
+      path.join(procDirectory, 'does-not-exist'),
+    );
+
+    expect(repository.listHandoverSessions()).toEqual([]);
+  });
+});

package/src/adapter/repositories/ProcClaudeHandoverSessionRepository.ts

@@ -0,0 +1,208 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  ClaudeHandoverSession,
+  ClaudeHandoverSessionKind,
+} from '../../domain/entities/ClaudeHandoverSession';
+import { ClaudeHandoverSessionRepository } from '../../domain/usecases/adapter-interfaces/ClaudeHandoverSessionRepository';
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const OAUTH_TOKEN_ENVIRON_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const NAME_ARGUMENT = '--name';
+const NAME_ARGUMENT_PREFIX = '--name=';
+const PRINT_ARGUMENTS = ['-p', '--print'];
+const PRINT_ARGUMENT_PREFIXES = ['-p=', '--print='];
+const CLAUDE_COMM_PATTERN = /^claude(-agent)?$/;
+const ISSUE_OR_PR_URL_PATTERN =
+  /https:\/\/github\.com\/[^\s\0]+?\/(?:issues|pull)\/\d+/;
+
+const normalizeName = (value: string): string => value.replace(/[.:]/g, '_');
+
+const isIssueUrl = (value: string): boolean =>
+  value.startsWith('http://') || value.startsWith('https://');
+
+const extractIssueUrlFromText = (text: string): string | null => {
+  const match = text.match(ISSUE_OR_PR_URL_PATTERN);
+  return match ? match[0] : null;
+};
+
+const parseName = (commandArguments: string[]): string | null => {
+  for (let index = 0; index < commandArguments.length; index += 1) {
+    const argument = commandArguments[index];
+    if (argument === NAME_ARGUMENT && index + 1 < commandArguments.length) {
+      const value = commandArguments[index + 1];
+      return value.length > 0 ? value : null;
+    }
+    if (argument.startsWith(NAME_ARGUMENT_PREFIX)) {
+      const value = argument.slice(NAME_ARGUMENT_PREFIX.length);
+      return value.length > 0 ? value : null;
+    }
+  }
+  return null;
+};
+
+const parseIssueUrlFromPrint = (commandArguments: string[]): string | null => {
+  for (let index = 0; index < commandArguments.length; index += 1) {
+    const argument = commandArguments[index];
+    if (
+      PRINT_ARGUMENTS.includes(argument) &&
+      index + 1 < commandArguments.length
+    ) {
+      const url = extractIssueUrlFromText(commandArguments[index + 1]);
+      if (url !== null) {
+        return url;
+      }
+    }
+    for (const prefix of PRINT_ARGUMENT_PREFIXES) {
+      if (argument.startsWith(prefix)) {
+        const url = extractIssueUrlFromText(argument.slice(prefix.length));
+        if (url !== null) {
+          return url;
+        }
+      }
+    }
+  }
+  return extractIssueUrlFromText(commandArguments.join(' '));
+};
+
+const classifySession = (
+  pid: number,
+  commandArguments: string[],
+  token: string | null,
+): ClaudeHandoverSession | null => {
+  if (token === null || token.length === 0) {
+    return null;
+  }
+  const name = parseName(commandArguments);
+  if (name !== null) {
+    const sessionName = normalizeName(name);
+    if (isIssueUrl(name)) {
+      const kind: ClaudeHandoverSessionKind = 'issueUrlLeader';
+      return {
+        kind,
+        pid,
+        token,
+        sessionName,
+        name,
+        issueUrl: extractIssueUrlFromText(name),
+      };
+    }
+    const kind: ClaudeHandoverSessionKind = 'bareNameLeader';
+    return { kind, pid, token, sessionName, name, issueUrl: null };
+  }
+  const issueUrl = parseIssueUrlFromPrint(commandArguments);
+  if (issueUrl === null) {
+    return null;
+  }
+  return {
+    kind: 'implSubagent',
+    pid,
+    token,
+    sessionName: null,
+    name: null,
+    issueUrl,
+  };
+};
+
+export class ProcClaudeHandoverSessionRepository implements ClaudeHandoverSessionRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+  ) {}
+
+  listHandoverSessions = (): ClaudeHandoverSession[] => {
+    const sessions: ClaudeHandoverSession[] = [];
+    for (const processIdDirectory of this.listProcessIdDirectories()) {
+      const session = this.readHandoverSession(processIdDirectory);
+      if (session !== null) {
+        sessions.push(session);
+      }
+    }
+    return sessions;
+  };
+
+  private listProcessIdDirectories = (): string[] => {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.procDirectory);
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => /^\d+$/.test(entry));
+  };
+
+  private readHandoverSession = (
+    processIdDirectory: string,
+  ): ClaudeHandoverSession | null => {
+    const comm = this.readComm(processIdDirectory);
+    if (comm === null || !CLAUDE_COMM_PATTERN.test(comm)) {
+      return null;
+    }
+    const commandArguments = this.readCommandArguments(processIdDirectory);
+    if (commandArguments === null) {
+      return null;
+    }
+    const environ = this.readEnviron(processIdDirectory);
+    if (environ === null) {
+      return null;
+    }
+    const token = environ.get(OAUTH_TOKEN_ENVIRON_KEY) ?? null;
+    return classifySession(Number(processIdDirectory), commandArguments, token);
+  };
+
+  private readComm = (processIdDirectory: string): string | null => {
+    const commPath = path.join(this.procDirectory, processIdDirectory, 'comm');
+    try {
+      return fs.readFileSync(commPath, 'utf8').trim();
+    } catch {
+      return null;
+    }
+  };
+
+  private readCommandArguments = (
+    processIdDirectory: string,
+  ): string[] | null => {
+    const cmdlinePath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'cmdline',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(cmdlinePath, 'utf8');
+    } catch {
+      return null;
+    }
+    return raw.split('\0').filter((argument) => argument.length > 0);
+  };
+
+  private readEnviron = (
+    processIdDirectory: string,
+  ): Map<string, string> | null => {
+    const environPath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'environ',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(environPath, 'utf8');
+    } catch {
+      return null;
+    }
+    const environ = new Map<string, string>();
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+      environ.set(
+        entry.slice(0, separatorIndex),
+        entry.slice(separatorIndex + 1),
+      );
+    }
+    return environ;
+  };
+}

package/src/adapter/repositories/RateLimitSnapshotRepository.ts

@@ -0,0 +1,50 @@
+import {
+  TokenModelWeeklyLimit,
+  TokenRateLimitSnapshot,
+  TokenRateLimitSnapshotRepository,
+} from '../../domain/usecases/adapter-interfaces/TokenRateLimitSnapshotRepository';
+import { loadTokenEntries } from '../proxy/TokenListLoader';
+import { readRateLimit, cacheDir } from '../proxy/RateLimitCache';
+
+export class RateLimitSnapshotRepository implements TokenRateLimitSnapshotRepository {
+  constructor(
+    private readonly tokenListJsonPath: string,
+    private readonly baseDir: string = cacheDir(),
+  ) {}
+
+  listSnapshots = (): TokenRateLimitSnapshot[] => {
+    const entries = loadTokenEntries(this.tokenListJsonPath);
+    if (entries === null) {
+      return [];
+    }
+    const snapshots: TokenRateLimitSnapshot[] = [];
+    for (const { name, token } of entries) {
+      const snapshot = readRateLimit(token, this.baseDir);
+      if (snapshot === null) {
+        continue;
+      }
+      snapshots.push({
+        token,
+        name,
+        fiveHourUtilization: snapshot.fiveHourUtilization,
+        fiveHourReset: snapshot.fiveHourReset,
+        sevenDayUtilization: snapshot.sevenDayUtilization,
+        sevenDayReset: snapshot.sevenDayReset,
+        blocked: snapshot.blocked,
+        rejected: snapshot.rejected,
+        blockedUntilEpoch: snapshot.blockedUntilEpoch,
+        modelWeeklyLimits: this.toModelWeeklyLimits(snapshot.modelWeeklyLimits),
+        lastUpdatedEpoch: snapshot.lastUpdatedEpoch,
+      });
+    }
+    return snapshots;
+  };
+
+  private toModelWeeklyLimits = (
+    modelWeeklyLimits: Record<string, { rejected: boolean; resetsAt: number }>,
+  ): TokenModelWeeklyLimit[] =>
+    Object.values(modelWeeklyLimits).map((limit) => ({
+      rejected: limit.rejected,
+      resetsAt: limit.resetsAt,
+    }));
+}