github-issue-tower-defence-management 1.104.4 → 1.106.0

package/src/adapter/repositories/NodeTmuxSessionRepository.ts

@@ -1,5 +1,6 @@
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { TmuxSessionRepository } from '../../domain/usecases/adapter-interfaces/TmuxSessionRepository';
+import { LiveTmuxSession } from '../../domain/entities/LiveTmuxSession';
 
 export class NodeTmuxSessionRepository implements TmuxSessionRepository {
   constructor(private readonly localCommandRunner: LocalCommandRunner) {}
@@ -18,6 +19,26 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
       .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',
@@ -51,4 +72,18 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
       issueUrl,
     ]);
   };
+
+  killSession = async (sessionName: string): Promise<void> => {
+    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}` : ''
+        }`,
+      );
+    }
+  };
 }

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

@@ -0,0 +1,135 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  ProcHostMetricsRepository,
+  cpuUsedPercentFromSamples,
+  cycleMinutesFromMtimes,
+  parseCpuSample,
+  parseLoadAverages,
+  parseMemoryUsedPercent,
+} from './ProcHostMetricsRepository';
+
+describe('parseMemoryUsedPercent', () => {
+  it('computes (total - available) / total rounded to a whole percent', () => {
+    expect(
+      parseMemoryUsedPercent(
+        'MemTotal: 1000 kB\nMemFree: 100 kB\nMemAvailable: 380 kB\n',
+      ),
+    ).toBe(62);
+  });
+
+  it('throws when MemTotal is not positive', () => {
+    expect(() =>
+      parseMemoryUsedPercent('MemTotal: 0 kB\nMemAvailable: 0 kB\n'),
+    ).toThrow();
+  });
+});
+
+describe('parseCpuSample', () => {
+  it('uses the aggregate cpu line with idle = idle + iowait and total = sum of all fields', () => {
+    expect(
+      parseCpuSample('cpu  100 0 100 700 100 0 0 0 0 0\ncpu0 1 2 3 4\n'),
+    ).toEqual({ total: 1000, idle: 800 });
+  });
+
+  it('throws when there is no aggregate cpu line', () => {
+    expect(() => parseCpuSample('cpu0 1 2 3 4\n')).toThrow();
+  });
+});
+
+describe('cpuUsedPercentFromSamples', () => {
+  it('computes (total_delta - idle_delta) / total_delta', () => {
+    expect(
+      cpuUsedPercentFromSamples(
+        { total: 1000, idle: 700 },
+        { total: 1100, idle: 770 },
+      ),
+    ).toBe(30);
+  });
+
+  it('throws when the total delta is not positive', () => {
+    expect(() =>
+      cpuUsedPercentFromSamples(
+        { total: 1000, idle: 700 },
+        { total: 1000, idle: 700 },
+      ),
+    ).toThrow();
+  });
+});
+
+describe('parseLoadAverages', () => {
+  it('parses the first three floats from /proc/loadavg', () => {
+    expect(parseLoadAverages('1.20 0.98 0.75 1/123 4567\n')).toEqual({
+      oneMinute: 1.2,
+      fiveMinute: 0.98,
+      fifteenMinute: 0.75,
+    });
+  });
+
+  it('throws when fewer than three numeric values are present', () => {
+    expect(() => parseLoadAverages('1.20 0.98\n')).toThrow();
+  });
+});
+
+describe('cycleMinutesFromMtimes', () => {
+  it('rounds the gap between the two newest generations to whole minutes', () => {
+    expect(cycleMinutesFromMtimes([1782469254.0, 1782468443.0])).toBe(14);
+  });
+
+  it('rounds a 1620 second gap to 27 minutes', () => {
+    expect(cycleMinutesFromMtimes([1620.0, 0.0])).toBe(27);
+  });
+
+  it('returns null when a second generation is missing', () => {
+    expect(cycleMinutesFromMtimes([1000.0])).toBeNull();
+    expect(cycleMinutesFromMtimes([])).toBeNull();
+  });
+});
+
+describe('ProcHostMetricsRepository', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-proc-host-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { recursive: true, force: true });
+  });
+
+  it('reads memory used percent from /proc/meminfo', () => {
+    fs.writeFileSync(
+      path.join(procDirectory, 'meminfo'),
+      'MemTotal: 1000 kB\nMemAvailable: 380 kB\n',
+    );
+    const repository = new ProcHostMetricsRepository(procDirectory);
+    expect(repository.readMemoryUsedPercent()).toBe(62);
+  });
+
+  it('reads load averages from /proc/loadavg', () => {
+    fs.writeFileSync(
+      path.join(procDirectory, 'loadavg'),
+      '2.00 1.00 0.50 1/100 200\n',
+    );
+    const repository = new ProcHostMetricsRepository(procDirectory);
+    expect(repository.readLoadAverages()).toEqual({
+      oneMinute: 2.0,
+      fiveMinute: 1.0,
+      fifteenMinute: 0.5,
+    });
+  });
+
+  it('samples /proc/stat twice and computes the busy percent', async () => {
+    const statPath = path.join(procDirectory, 'stat');
+    let sampleIndex = 0;
+    fs.writeFileSync(statPath, 'cpu  700 0 0 300 0 0 0 0 0 0\n');
+    const sleep = async (): Promise<void> => {
+      sampleIndex += 1;
+      fs.writeFileSync(statPath, 'cpu  770 0 0 330 0 0 0 0 0 0\n');
+    };
+    const repository = new ProcHostMetricsRepository(procDirectory, sleep);
+    expect(await repository.readCpuUsedPercent()).toBe(70);
+    expect(sampleIndex).toBe(1);
+  });
+});

package/src/adapter/repositories/ProcHostMetricsRepository.ts

@@ -0,0 +1,136 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export type CpuSample = {
+  total: number;
+  idle: number;
+};
+
+export type LoadAverages = {
+  oneMinute: number;
+  fiveMinute: number;
+  fifteenMinute: number;
+};
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const CPU_SAMPLE_INTERVAL_MS = 400;
+
+export const parseMemoryUsedPercent = (meminfoText: string): number => {
+  const fields = new Map<string, number>();
+  for (const line of meminfoText.split('\n')) {
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    const valuePart = line
+      .slice(separatorIndex + 1)
+      .trim()
+      .split(/\s+/)[0];
+    const value = Number(valuePart);
+    if (Number.isFinite(value)) {
+      fields.set(key, value);
+    }
+  }
+  const total = fields.get('MemTotal');
+  const available = fields.get('MemAvailable');
+  if (total === undefined || available === undefined) {
+    throw new Error('MemTotal and MemAvailable are required');
+  }
+  if (total <= 0) {
+    throw new Error('MemTotal must be positive');
+  }
+  const used = total - available;
+  return Math.round((used / total) * 100);
+};
+
+export const parseCpuSample = (statText: string): CpuSample => {
+  for (const line of statText.split('\n')) {
+    if (line.startsWith('cpu ')) {
+      const values = line
+        .trim()
+        .split(/\s+/)
+        .slice(1)
+        .map((value) => Number(value));
+      if (values.some((value) => !Number.isFinite(value))) {
+        throw new Error('aggregate cpu line contains non-numeric values');
+      }
+      const idle = values[3] + (values.length > 4 ? values[4] : 0);
+      const total = values.reduce((sum, value) => sum + value, 0);
+      return { total, idle };
+    }
+  }
+  throw new Error('aggregate cpu line not found');
+};
+
+export const cpuUsedPercentFromSamples = (
+  first: CpuSample,
+  second: CpuSample,
+): number => {
+  const totalDelta = second.total - first.total;
+  const idleDelta = second.idle - first.idle;
+  if (totalDelta <= 0) {
+    throw new Error('total delta must be positive');
+  }
+  const busyDelta = totalDelta - idleDelta;
+  return Math.round((busyDelta / totalDelta) * 100);
+};
+
+export const parseLoadAverages = (loadavgText: string): LoadAverages => {
+  const parts = loadavgText.trim().split(/\s+/);
+  const oneMinute = Number(parts[0]);
+  const fiveMinute = Number(parts[1]);
+  const fifteenMinute = Number(parts[2]);
+  if (
+    !Number.isFinite(oneMinute) ||
+    !Number.isFinite(fiveMinute) ||
+    !Number.isFinite(fifteenMinute)
+  ) {
+    throw new Error('loadavg must contain three numeric values');
+  }
+  return { oneMinute, fiveMinute, fifteenMinute };
+};
+
+export const cycleMinutesFromMtimes = (
+  mtimesDescendingSeconds: number[],
+): number | null => {
+  if (mtimesDescendingSeconds.length < 2) {
+    return null;
+  }
+  return Math.round(
+    (mtimesDescendingSeconds[0] - mtimesDescendingSeconds[1]) / 60,
+  );
+};
+
+export class ProcHostMetricsRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+    private readonly sleep: (milliseconds: number) => Promise<void> = (
+      milliseconds,
+    ) =>
+      new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+      }),
+  ) {}
+
+  readMemoryUsedPercent = (): number =>
+    parseMemoryUsedPercent(
+      fs.readFileSync(path.join(this.procDirectory, 'meminfo'), 'utf8'),
+    );
+
+  readCpuUsedPercent = async (): Promise<number> => {
+    const first = parseCpuSample(
+      fs.readFileSync(path.join(this.procDirectory, 'stat'), 'utf8'),
+    );
+    await this.sleep(CPU_SAMPLE_INTERVAL_MS);
+    const second = parseCpuSample(
+      fs.readFileSync(path.join(this.procDirectory, 'stat'), 'utf8'),
+    );
+    return cpuUsedPercentFromSamples(first, second);
+  };
+
+  readLoadAverages = (): LoadAverages =>
+    parseLoadAverages(
+      fs.readFileSync(path.join(this.procDirectory, 'loadavg'), 'utf8'),
+    );
+}

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

@@ -0,0 +1,130 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcTakeOwnershipSpawnRepository } from './ProcTakeOwnershipSpawnRepository';
+
+type FakeProcess = {
+  pid: number;
+  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('ProcTakeOwnershipSpawnRepository', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-proc-spawn-'));
+  });
+
+  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, 'cmdline'),
+      fakeProcess.cmdline,
+    );
+    const environBuffer = Object.entries(fakeProcess.environ)
+      .map(([key, value]) => `${key}=${value}\0`)
+      .join('');
+    fs.writeFileSync(path.join(processDirectory, 'environ'), environBuffer);
+  };
+
+  it('reads the token and log path of a Take ownership spawn', () => {
+    writeProcess({
+      pid: 301,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `claude-agent -p "Take ownership of ${issueUrl}" | tee /home/user/logs-aw/20260626_120000_abc.log`,
+      ),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-a' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([
+      { token: 'token-a', logPath: '/logs-aw/20260626_120000_abc.log' },
+    ]);
+  });
+
+  it('ignores a process that is not a Take ownership spawn', () => {
+    writeProcess({
+      pid: 302,
+      cmdline: argv('claude', '--name', issueUrl),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-b' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('ignores a Take ownership process whose cmdline carries no log path', () => {
+    writeProcess({
+      pid: 303,
+      cmdline: argv('claude-agent', '-p', `Take ownership of ${issueUrl}`),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-c' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('ignores a Take ownership process without an oauth token', () => {
+    writeProcess({
+      pid: 304,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `Take ownership of ${issueUrl} | tee /home/user/logs-aw/x.log`,
+      ),
+      environ: { ANTHROPIC_API_KEY: 'api-key' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('returns one entry per child process so the use case can dedupe by log path', () => {
+    const fullLogPath = '/home/user/logs-aw/20260626_120000_dup.log';
+    const capturedLogPath = '/logs-aw/20260626_120000_dup.log';
+    writeProcess({
+      pid: 305,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `Take ownership of ${issueUrl} | tee ${fullLogPath}`,
+      ),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-d' },
+    });
+    writeProcess({
+      pid: 306,
+      cmdline: argv('tee', fullLogPath, 'Take ownership marker'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-d' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([
+      { token: 'token-d', logPath: capturedLogPath },
+      { token: 'token-d', logPath: capturedLogPath },
+    ]);
+  });
+
+  it('returns an empty list when the proc directory does not exist', () => {
+    const repository = new ProcTakeOwnershipSpawnRepository(
+      path.join(procDirectory, 'missing'),
+    );
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+});

package/src/adapter/repositories/ProcTakeOwnershipSpawnRepository.ts

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  TakeOwnershipSpawn,
+  TakeOwnershipSpawnRepository,
+} from '../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const OAUTH_TOKEN_ENVIRON_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const TAKE_OWNERSHIP_MARKER = 'Take ownership';
+const LOG_PATH_PATTERN = /\/logs-aw\/[^\0"]+\.log/;
+
+const parseCommandLineArguments = (cmdline: string): string[] =>
+  cmdline.split('\0').filter((argument) => argument.length > 0);
+
+const isTakeOwnershipSpawn = (commandArguments: string[]): boolean =>
+  commandArguments.some((argument) => argument.includes(TAKE_OWNERSHIP_MARKER));
+
+const extractLogPath = (cmdline: string): string | null => {
+  const match = cmdline.match(LOG_PATH_PATTERN);
+  return match === null ? null : match[0];
+};
+
+export class ProcTakeOwnershipSpawnRepository implements TakeOwnershipSpawnRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+  ) {}
+
+  listSpawns = (): TakeOwnershipSpawn[] => {
+    const spawns: TakeOwnershipSpawn[] = [];
+    for (const pidDirectory of this.listProcessIdDirectories()) {
+      const spawn = this.readSpawn(pidDirectory);
+      if (spawn !== null) {
+        spawns.push(spawn);
+      }
+    }
+    return spawns;
+  };
+
+  private listProcessIdDirectories = (): string[] => {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.procDirectory);
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => /^\d+$/.test(entry));
+  };
+
+  private readSpawn = (
+    processIdDirectory: string,
+  ): TakeOwnershipSpawn | null => {
+    const rawCmdline = this.readRawCmdline(processIdDirectory);
+    if (rawCmdline === null) {
+      return null;
+    }
+    const commandArguments = parseCommandLineArguments(rawCmdline);
+    if (!isTakeOwnershipSpawn(commandArguments)) {
+      return null;
+    }
+    const logPath = extractLogPath(rawCmdline);
+    if (logPath === null) {
+      return null;
+    }
+    const environ = this.readEnviron(processIdDirectory);
+    if (environ === null) {
+      return null;
+    }
+    const token = environ.get(OAUTH_TOKEN_ENVIRON_KEY);
+    if (token === undefined || token.length === 0) {
+      return null;
+    }
+    return { token, logPath };
+  };
+
+  private readRawCmdline = (processIdDirectory: string): string | null => {
+    const cmdlinePath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'cmdline',
+    );
+    try {
+      return fs.readFileSync(cmdlinePath, 'utf8');
+    } catch {
+      return null;
+    }
+  };
+
+  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;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ.set(key, value);
+    }
+    return environ;
+  };
+}

package/src/domain/entities/LiveTmuxSession.ts

@@ -0,0 +1,4 @@
+export type LiveTmuxSession = {
+  sessionName: string;
+  activityEpochSeconds: number;
+};