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

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

@@ -1,190 +0,0 @@
-import { LocalProcessLiveSessionProcessSnapshotProvider } from './LocalProcessLiveSessionProcessSnapshotProvider';
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
-import { SessionRecordReader } from '../../domain/usecases/adapter-interfaces/SessionRecordReader';
-
-describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
-  const makeRunner = (
-    handlers: Record<
-      string,
-      { stdout: string; stderr?: string; exitCode?: number }
-    >,
-  ): LocalCommandRunner => ({
-    runCommand: jest.fn(async (program: string, args: string[]) => {
-      const key = `${program} ${args.join(' ')}`;
-      const handler = handlers[key];
-      if (handler === undefined) {
-        return { stdout: '', stderr: '', exitCode: 1 };
-      }
-      return {
-        stdout: handler.stdout,
-        stderr: handler.stderr ?? '',
-        exitCode: handler.exitCode ?? 0,
-      };
-    }),
-    spawnInteractive: jest.fn(),
-  });
-
-  const makeEnvironReader = (
-    byPid: Record<number, Record<string, string>>,
-  ): ProcessEnvironReader => ({
-    readEnviron: (pid: number) => byPid[pid] ?? null,
-  });
-
-  const makeSessionRecordReader = (
-    byPid: Record<number, string>,
-  ): SessionRecordReader => ({
-    readCurrentSessionId: (_configDir: string, pid: number) =>
-      byPid[pid] ?? null,
-  });
-
-  it('builds a snapshot of sessions, pane pids, and processes with environment', async () => {
-    const runner = makeRunner({
-      'tmux list-sessions -F #{session_name}': {
-        stdout: 'workbench\nhttps_//github_com/owner/repo/issues/9\n',
-      },
-      'tmux list-panes -t workbench -F #{pane_pid}': { stdout: '200\n' },
-      'tmux list-panes -t https_//github_com/owner/repo/issues/9 -F #{pane_pid}':
-        { stdout: '100\n' },
-      'ps -eo pid=,ppid=,args=': {
-        stdout: [
-          '    100       1 shell',
-          '    101     100 claude --name issues-9',
-          '    200       1 shell',
-          '    201     200 claude --name workbench',
-        ].join('\n'),
-      },
-    });
-    const environReader = makeEnvironReader({
-      101: {
-        CLAUDE_CODE_SESSION_ID: 'issue-uuid',
-        CLAUDE_CONFIG_DIR: '/config/issues-9',
-      },
-      201: {
-        CLAUDE_CODE_SESSION_ID: 'wb-uuid',
-        CLAUDE_CONFIG_DIR: '/config/workbench',
-      },
-    });
-    const sessionRecordReader = makeSessionRecordReader({
-      101: 'issue-rotated-uuid',
-      201: 'wb-rotated-uuid',
-    });
-    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
-      runner,
-      environReader,
-      sessionRecordReader,
-    );
-
-    const snapshot = await provider.getSnapshot();
-
-    expect(snapshot.sessions).toEqual([
-      { sessionName: 'workbench', panePids: [200] },
-      {
-        sessionName: 'https_//github_com/owner/repo/issues/9',
-        panePids: [100],
-      },
-    ]);
-    expect(snapshot.processes).toContainEqual({
-      pid: 201,
-      ppid: 200,
-      commandLine: 'claude --name workbench',
-      sessionId: 'wb-uuid',
-      currentSessionId: 'wb-rotated-uuid',
-      configDir: '/config/workbench',
-    });
-    expect(snapshot.processes).toContainEqual({
-      pid: 100,
-      ppid: 1,
-      commandLine: 'shell',
-      sessionId: null,
-      currentSessionId: null,
-      configDir: null,
-    });
-  });
-
-  it('leaves currentSessionId null when the session record is absent', async () => {
-    const runner = makeRunner({
-      'tmux list-sessions -F #{session_name}': { stdout: 'workbench\n' },
-      'tmux list-panes -t workbench -F #{pane_pid}': { stdout: '200\n' },
-      'ps -eo pid=,ppid=,args=': {
-        stdout: '    201     200 claude --name workbench',
-      },
-    });
-    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
-      runner,
-      makeEnvironReader({
-        201: {
-          CLAUDE_CODE_SESSION_ID: 'wb-uuid',
-          CLAUDE_CONFIG_DIR: '/config/workbench',
-        },
-      }),
-      makeSessionRecordReader({}),
-    );
-
-    const snapshot = await provider.getSnapshot();
-
-    expect(snapshot.processes).toEqual([
-      {
-        pid: 201,
-        ppid: 200,
-        commandLine: 'claude --name workbench',
-        sessionId: 'wb-uuid',
-        currentSessionId: null,
-        configDir: '/config/workbench',
-      },
-    ]);
-  });
-
-  it('returns an empty snapshot when tmux reports no sessions', async () => {
-    const runner = makeRunner({
-      'tmux list-sessions -F #{session_name}': { stdout: '' },
-      'ps -eo pid=,ppid=,args=': { stdout: '' },
-    });
-    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
-      runner,
-      makeEnvironReader({}),
-      makeSessionRecordReader({}),
-    );
-
-    const snapshot = await provider.getSnapshot();
-
-    expect(snapshot.sessions).toEqual([]);
-    expect(snapshot.processes).toEqual([]);
-  });
-
-  it('skips malformed ps lines', async () => {
-    const runner = makeRunner({
-      'tmux list-sessions -F #{session_name}': { stdout: 'workbench\n' },
-      'tmux list-panes -t workbench -F #{pane_pid}': { stdout: '200\n' },
-      'ps -eo pid=,ppid=,args=': {
-        stdout: [
-          'garbage line',
-          '    201     200 claude --name workbench',
-        ].join('\n'),
-      },
-    });
-    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
-      runner,
-      makeEnvironReader({
-        201: {
-          CLAUDE_CODE_SESSION_ID: 'wb-uuid',
-          CLAUDE_CONFIG_DIR: '/config/workbench',
-        },
-      }),
-      makeSessionRecordReader({ 201: 'wb-rotated-uuid' }),
-    );
-
-    const snapshot = await provider.getSnapshot();
-
-    expect(snapshot.processes).toEqual([
-      {
-        pid: 201,
-        ppid: 200,
-        commandLine: 'claude --name workbench',
-        sessionId: 'wb-uuid',
-        currentSessionId: 'wb-rotated-uuid',
-        configDir: '/config/workbench',
-      },
-    ]);
-  });
-});

package/src/adapter/repositories/LocalProcessLiveSessionProcessSnapshotProvider.ts

@@ -1,102 +0,0 @@
-import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { LiveSessionProcessSnapshotProvider } from '../../domain/usecases/adapter-interfaces/LiveSessionProcessSnapshotProvider';
-import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
-import { SessionRecordReader } from '../../domain/usecases/adapter-interfaces/SessionRecordReader';
-import {
-  LiveSessionPaneProcess,
-  LiveSessionProcessInfo,
-  LiveSessionProcessSnapshot,
-} from '../../domain/entities/LiveSessionProcessSnapshot';
-import { FileSystemSessionRecordReader } from './FileSystemSessionRecordReader';
-
-const SESSION_ID_ENV_KEY = 'CLAUDE_CODE_SESSION_ID';
-const CONFIG_DIR_ENV_KEY = 'CLAUDE_CONFIG_DIR';
-
-/**
- * Builds a live-session process snapshot from the local host: it lists the live
- * tmux sessions and each session's pane process ids, lists the full process
- * tree with command lines, and reads each process environment to expose the
- * Claude Code session id and config directory. The snapshot is consumed by a
- * pure resolver, so all host access is contained in this adapter.
- */
-export class LocalProcessLiveSessionProcessSnapshotProvider implements LiveSessionProcessSnapshotProvider {
-  constructor(
-    private readonly localCommandRunner: LocalCommandRunner,
-    private readonly environReader: ProcessEnvironReader,
-    private readonly sessionRecordReader: SessionRecordReader = new FileSystemSessionRecordReader(),
-  ) {}
-
-  getSnapshot = async (): Promise<LiveSessionProcessSnapshot> => {
-    const sessionNames = await this.listSessionNames();
-    const sessions: LiveSessionPaneProcess[] = [];
-    for (const sessionName of sessionNames) {
-      const panePids = await this.listPanePids(sessionName);
-      sessions.push({ sessionName, panePids });
-    }
-    const processes = await this.listProcesses();
-    return { sessions, processes };
-  };
-
-  private listSessionNames = 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);
-  };
-
-  private listPanePids = async (sessionName: string): Promise<number[]> => {
-    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
-      'tmux',
-      ['list-panes', '-t', sessionName, '-F', '#{pane_pid}'],
-    );
-    if (exitCode !== 0) {
-      return [];
-    }
-    return stdout
-      .split('\n')
-      .map((line) => Number(line.trim()))
-      .filter((pid) => Number.isInteger(pid) && pid > 0);
-  };
-
-  private listProcesses = async (): Promise<LiveSessionProcessInfo[]> => {
-    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
-      'ps',
-      ['-eo', 'pid=,ppid=,args='],
-    );
-    if (exitCode !== 0) {
-      return [];
-    }
-    const processes: LiveSessionProcessInfo[] = [];
-    for (const line of stdout.split('\n')) {
-      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
-      if (match === null) {
-        continue;
-      }
-      const pid = Number(match[1]);
-      const ppid = Number(match[2]);
-      const commandLine = match[3].trim();
-      const environ = this.environReader.readEnviron(pid);
-      const configDir = environ?.[CONFIG_DIR_ENV_KEY] ?? null;
-      const currentSessionId =
-        configDir === null
-          ? null
-          : this.sessionRecordReader.readCurrentSessionId(configDir, pid);
-      processes.push({
-        pid,
-        ppid,
-        commandLine,
-        sessionId: environ?.[SESSION_ID_ENV_KEY] ?? null,
-        currentSessionId,
-        configDir,
-      });
-    }
-    return processes;
-  };
-}

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

@@ -1,265 +0,0 @@
-import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
-import { localStorageCacheBaseDirectory } from './localStorageCacheDirectory';
-import { LocalStorageRepository } from './LocalStorageRepository';
-
-describe('LocalStorageCacheRepository', () => {
-  let localStorageRepository: jest.Mocked<LocalStorageRepository>;
-  let repository: LocalStorageCacheRepository;
-  let now: Date;
-
-  beforeEach(() => {
-    now = new Date('2024-01-01T00:00:00.000Z');
-    jest.useFakeTimers();
-    jest.setSystemTime(now);
-
-    localStorageRepository = {
-      listFiles: jest.fn(),
-      read: jest.fn(),
-      write: jest.fn(),
-      rename: jest.fn(),
-      mkdir: jest.fn(),
-      remove: jest.fn(),
-    };
-    repository = new LocalStorageCacheRepository(
-      localStorageRepository,
-      './tmp/cache',
-    );
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  test('defaults its base to the shared cache directory, so a process started in any working directory reads what the others cached', () => {
-    const defaulted = new LocalStorageCacheRepository(localStorageRepository);
-
-    expect(defaulted.cachePath).toBe(localStorageCacheBaseDirectory());
-  });
-
-  describe('getLatest', () => {
-    type GetLatestParams = Parameters<LocalStorageCacheRepository['getLatest']>;
-    type GetLatestReturn = ReturnType<LocalStorageCacheRepository['getLatest']>;
-
-    interface TestCase {
-      name: string;
-      key: GetLatestParams[0];
-      files: string[];
-      fileContent: string | null;
-      expected: Awaited<GetLatestReturn>;
-    }
-
-    const testCases: TestCase[] = [
-      {
-        name: 'returns null when no files exist',
-        key: 'test-key',
-        files: [],
-        fileContent: null,
-        expected: null,
-      },
-      {
-        name: 'returns null when file content is empty',
-        key: 'test-key',
-        files: ['2024-01-01T00:00:00.000Z'],
-        fileContent: null,
-        expected: null,
-      },
-      {
-        name: 'returns null when content is invalid JSON',
-        key: 'test-key',
-        files: ['2024-01-01T00:00:00.000Z'],
-        fileContent: 'invalid-json',
-        expected: null,
-      },
-      {
-        name: 'returns value when valid JSON exists',
-        key: 'test-key',
-        files: ['2024-01-01T00:00:00.000Z'],
-        fileContent: '{"test": "value"}',
-        expected: {
-          value: { test: 'value' },
-          timestamp: new Date('2024-01-01T00:00:00.000Z'),
-        },
-      },
-      {
-        name: 'ignores in-progress temp files and reads the latest committed file',
-        key: 'test-key',
-        files: [
-          '2024-01-01T00:00:00.000Z.json',
-          '2024-01-01T00:00:01.000Z.json.1234.abc.tmp',
-        ],
-        fileContent: '{"test": "value"}',
-        expected: {
-          value: { test: 'value' },
-          timestamp: new Date('2024-01-01T00:00:00.000Z'),
-        },
-      },
-    ];
-
-    test.each(testCases)(
-      '$name',
-      async ({ key, files, fileContent, expected }) => {
-        localStorageRepository.listFiles.mockReturnValue(files);
-        localStorageRepository.read.mockReturnValue(fileContent);
-
-        const result = await repository.getLatest(key);
-
-        expect(result).toEqual(expected);
-      },
-    );
-  });
-
-  describe('set', () => {
-    type SetParams = Parameters<LocalStorageCacheRepository['set']>;
-
-    interface TestCase {
-      name: string;
-      key: SetParams[0];
-      value: SetParams[1];
-      expectedDirPath: string;
-      expectedFilePath: string;
-      expectedContent: string;
-    }
-
-    const testCases: TestCase[] = [
-      {
-        name: 'stores string value',
-        key: 'test-key',
-        value: 'test-value',
-        expectedDirPath: './tmp/cache/test-key',
-        expectedFilePath: './tmp/cache/test-key/2024-01-01T00:00:00.000Z.json',
-        expectedContent: '"test-value"',
-      },
-      {
-        name: 'stores object value',
-        key: 'test-key',
-        value: { test: 'value' },
-        expectedDirPath: './tmp/cache/test-key',
-        expectedFilePath: './tmp/cache/test-key/2024-01-01T00:00:00.000Z.json',
-        expectedContent: '{"test":"value"}',
-      },
-      {
-        name: 'stores array value',
-        key: 'test-key',
-        value: [1, 2, 3],
-        expectedDirPath: './tmp/cache/test-key',
-        expectedFilePath: './tmp/cache/test-key/2024-01-01T00:00:00.000Z.json',
-        expectedContent: '[1,2,3]',
-      },
-    ];
-
-    test.each(testCases)(
-      '$name',
-      async ({
-        key,
-        value,
-        expectedDirPath,
-        expectedFilePath,
-        expectedContent,
-      }) => {
-        await repository.set(key, value);
-
-        expect(localStorageRepository.mkdir).toHaveBeenCalledWith(
-          expectedDirPath,
-        );
-        const writeArgs = localStorageRepository.write.mock.calls[0];
-        const writtenPath = writeArgs[0];
-        expect(writtenPath.startsWith(`${expectedFilePath}.`)).toBe(true);
-        expect(writtenPath.endsWith('.tmp')).toBe(true);
-        expect(writeArgs[1]).toBe(expectedContent);
-        expect(localStorageRepository.rename).toHaveBeenCalledWith(
-          writtenPath,
-          expectedFilePath,
-        );
-      },
-    );
-
-    test('writes to the temp file before renaming it into place', async () => {
-      const callOrder: string[] = [];
-      localStorageRepository.write.mockImplementation(() => {
-        callOrder.push('write');
-      });
-      localStorageRepository.rename.mockImplementation(() => {
-        callOrder.push('rename');
-      });
-
-      await repository.set('ordering-key', { ordered: true });
-
-      expect(callOrder).toEqual(['write', 'rename']);
-    });
-  });
-
-  describe('getSingle', () => {
-    test('returns null when latest.json does not exist', async () => {
-      localStorageRepository.listFiles.mockReturnValue([]);
-
-      const result = await repository.getSingle('test-key');
-
-      expect(result).toBeNull();
-      expect(localStorageRepository.read).not.toHaveBeenCalled();
-    });
-
-    test('returns null when the file content is empty', async () => {
-      localStorageRepository.listFiles.mockReturnValue(['latest.json']);
-      localStorageRepository.read.mockReturnValue(null);
-
-      const result = await repository.getSingle('test-key');
-
-      expect(result).toBeNull();
-    });
-
-    test('returns null when the file content is invalid JSON', async () => {
-      localStorageRepository.listFiles.mockReturnValue(['latest.json']);
-      localStorageRepository.read.mockReturnValue('not-json');
-
-      const result = await repository.getSingle('test-key');
-
-      expect(result).toBeNull();
-    });
-
-    test('returns the parsed value from latest.json', async () => {
-      localStorageRepository.listFiles.mockReturnValue(['latest.json']);
-      localStorageRepository.read.mockReturnValue('{"lastFetchedAt":"x"}');
-
-      const result = await repository.getSingle('test-key');
-
-      expect(result).toEqual({ lastFetchedAt: 'x' });
-      expect(localStorageRepository.read).toHaveBeenCalledWith(
-        './tmp/cache/test-key/latest.json',
-      );
-    });
-  });
-
-  describe('setSingle', () => {
-    test('atomically writes a temp file then renames it to latest.json', async () => {
-      await repository.setSingle('test-key', { test: 'value' });
-
-      expect(localStorageRepository.mkdir).toHaveBeenCalledWith(
-        './tmp/cache/test-key',
-      );
-      const writeArgs = localStorageRepository.write.mock.calls[0];
-      const writtenPath = writeArgs[0];
-      const finalPath = './tmp/cache/test-key/latest.json';
-      expect(writtenPath.startsWith(`${finalPath}.`)).toBe(true);
-      expect(writtenPath.endsWith('.tmp')).toBe(true);
-      expect(writeArgs[1]).toBe('{"test":"value"}');
-      expect(localStorageRepository.rename).toHaveBeenCalledWith(
-        writtenPath,
-        finalPath,
-      );
-    });
-
-    test('writes to the temp file before renaming it into place', async () => {
-      const callOrder: string[] = [];
-      localStorageRepository.write.mockImplementation(() => {
-        callOrder.push('write');
-      });
-      localStorageRepository.rename.mockImplementation(() => {
-        callOrder.push('rename');
-      });
-
-      await repository.setSingle('ordering-key', { ordered: true });
-
-      expect(callOrder).toEqual(['write', 'rename']);
-    });
-  });
-});

package/src/adapter/repositories/LocalStorageCacheRepository.ts

@@ -1,79 +0,0 @@
-import { localStorageCacheBaseDirectory } from './localStorageCacheDirectory';
-import { LocalStorageRepository } from './LocalStorageRepository';
-
-export class LocalStorageCacheRepository {
-  constructor(
-    readonly localStorageRepository: LocalStorageRepository,
-    readonly cachePath = localStorageCacheBaseDirectory(),
-  ) {}
-
-  getLatest = async (
-    key: string,
-  ): Promise<{
-    value: object;
-    timestamp: Date;
-  } | null> => {
-    const dirPath = `${this.cachePath}/${key}`;
-    const latestFile = this.localStorageRepository
-      .listFiles(dirPath)
-      .filter((fileName) => !fileName.endsWith('.tmp'))
-      .sort((a, b) => a.localeCompare(b))
-      .reverse()[0];
-    if (!latestFile) {
-      return null;
-    }
-    const valueStr = this.localStorageRepository.read(
-      `${dirPath}/${latestFile}`,
-    );
-    if (!valueStr) {
-      return null;
-    }
-    let value: unknown;
-    try {
-      value = JSON.parse(valueStr);
-    } catch {
-      return null;
-    }
-    if (typeof value !== 'object' || value === null) {
-      return null;
-    }
-    const timestampStr = latestFile.split('.')[0];
-    return {
-      value,
-      timestamp: new Date(timestampStr),
-    };
-  };
-  set = async <T>(key: string, value: T): Promise<void> => {
-    const dirPath = `${this.cachePath}/${key}`;
-    this.localStorageRepository.mkdir(dirPath);
-    const timestamp = new Date().toISOString();
-    const finalPath = `${dirPath}/${timestamp}.json`;
-    const tmpPath = `${finalPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-    this.localStorageRepository.write(tmpPath, JSON.stringify(value));
-    this.localStorageRepository.rename(tmpPath, finalPath);
-  };
-  getSingle = async (key: string): Promise<unknown> => {
-    const dirPath = `${this.cachePath}/${key}`;
-    const fileName = 'latest.json';
-    if (!this.localStorageRepository.listFiles(dirPath).includes(fileName)) {
-      return null;
-    }
-    const valueStr = this.localStorageRepository.read(`${dirPath}/${fileName}`);
-    if (!valueStr) {
-      return null;
-    }
-    try {
-      return JSON.parse(valueStr);
-    } catch {
-      return null;
-    }
-  };
-  setSingle = async <T>(key: string, value: T): Promise<void> => {
-    const dirPath = `${this.cachePath}/${key}`;
-    this.localStorageRepository.mkdir(dirPath);
-    const finalPath = `${dirPath}/latest.json`;
-    const tmpPath = `${finalPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-    this.localStorageRepository.write(tmpPath, JSON.stringify(value));
-    this.localStorageRepository.rename(tmpPath, finalPath);
-  };
-}