npm - github-issue-tower-defence-management - Versions diffs - 1.95.0 → 1.97.0 - Mend

github-issue-tower-defence-management 1.95.0 → 1.97.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (69) hide show

package/src/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-BeJzGnfH.js"></script>
+    <script type="module" crossorigin src="/assets/index-B3F4E8LD.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CO3Vvzqr.css">
   </head>
   <body>

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts CHANGED Viewed

@@ -4,6 +4,7 @@ import fs from 'fs';
 import { writeSituationFile } from './situationFileWriter';
 import { writeConsoleLists } from './consoleListsWriter';
 import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
+import { reconcileInTmuxByHumanSessions } from './inTmuxByHumanSessionReconciler';
 import { writeRotationOrderFile } from './rotationOrderFileWriter';
 import {
   fetchProjectReadme,
@@ -73,6 +74,7 @@ export class HandleScheduledEventUseCaseHandler {
       inTmuxConsoleBaseUrl?: string;
       inTmuxConsoleToken?: string;
       inTmuxProjectOrder?: string[];
+      inTmuxLauncherCommand?: string;
       credentials: {
         manager: {
           github: {
@@ -409,6 +411,21 @@ export class HandleScheduledEventUseCaseHandler {
           }`,
         );
       }
+      try {
+        await reconcileInTmuxByHumanSessions({
+          inTmuxLauncherCommand: mergedInput.inTmuxLauncherCommand ?? null,
+          assigneeLogin: input.manager,
+          issues: result.issues,
+          localCommandRunner: nodeLocalCommandRunner,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to reconcile in-tmux-by-human sessions: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
     }
     return result;
   };

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.test.ts ADDED Viewed

@@ -0,0 +1,268 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  ClaudeLiveSession,
+  ClaudeLiveSessionRepository,
+} from '../../../domain/usecases/adapter-interfaces/ClaudeLiveSessionRepository';
+import { LiveSessionOauthTokenSelectUseCase } from '../../../domain/usecases/LiveSessionOauthTokenSelectUseCase';
+import { hashToken } from '../../proxy/RateLimitCache';
+import { LiveSessionOauthTokenSelectHandler } from './LiveSessionOauthTokenSelectHandler';
+const NOW = 2_000_000;
+const HOUR = 3600;
+const DAY = 86400;
+type FakeHeaders = {
+  fiveHourUtilization: number;
+  fiveHourReset: number;
+  sevenDayUtilization: number;
+  sevenDayReset: number;
+};
+class FakeClaudeLiveSessionRepository implements ClaudeLiveSessionRepository {
+  constructor(private readonly sessions: ClaudeLiveSession[]) {}
+  listLiveSessions = (): ClaudeLiveSession[] => this.sessions;
+}
+describe('LiveSessionOauthTokenSelectHandler', () => {
+  let tempDir: string;
+  let cacheDirectory: string;
+  let tokenListPath: string;
+  const originalTokenListEnv =
+    process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+  const originalCacheEnv = process.env.TDPM_RATELIMIT_CACHE_DIR;
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'select-live-token-'));
+    cacheDirectory = path.join(tempDir, 'cache');
+    fs.mkdirSync(cacheDirectory, { recursive: true });
+    tokenListPath = path.join(tempDir, 'tokens.json');
+    delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+    delete process.env.TDPM_RATELIMIT_CACHE_DIR;
+  });
+  afterEach(() => {
+    if (originalTokenListEnv === undefined) {
+      delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+    } else {
+      process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH = originalTokenListEnv;
+    }
+    if (originalCacheEnv === undefined) {
+      delete process.env.TDPM_RATELIMIT_CACHE_DIR;
+    } else {
+      process.env.TDPM_RATELIMIT_CACHE_DIR = originalCacheEnv;
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+  const writeTokenList = (entries: { name: string; token: string }[]): void => {
+    fs.writeFileSync(tokenListPath, JSON.stringify(entries));
+  };
+  const writeCache = (token: string, headers: FakeHeaders): void => {
+    const payload = {
+      ts: NOW,
+      headers: {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': String(headers.fiveHourReset),
+        'anthropic-ratelimit-unified-5h-utilization': String(
+          headers.fiveHourUtilization,
+        ),
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': String(headers.sevenDayReset),
+        'anthropic-ratelimit-unified-7d-utilization': String(
+          headers.sevenDayUtilization,
+        ),
+      },
+      modelWeeklyLimits: {},
+    };
+    fs.writeFileSync(
+      path.join(cacheDirectory, `${hashToken(token)}.json`),
+      JSON.stringify(payload),
+    );
+  };
+  const buildHandler = (
+    sessions: ClaudeLiveSession[],
+  ): LiveSessionOauthTokenSelectHandler =>
+    new LiveSessionOauthTokenSelectHandler(
+      new LiveSessionOauthTokenSelectUseCase(),
+      new FakeClaudeLiveSessionRepository(sessions),
+    );
+  it('selects the eligible token with the fewest live sessions', () => {
+    writeTokenList([
+      { name: 'busy', token: 'fake-busy' },
+      { name: 'idle', token: 'fake-idle' },
+    ]);
+    writeCache('fake-busy', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 2 * DAY,
+    });
+    writeCache('fake-idle', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 6 * DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-busy', sessionId: 'session-a' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('idle');
+    expect(output.selectedToken).toBe('fake-idle');
+  });
+  it('breaks an occupancy tie by the soonest 7d reset', () => {
+    writeTokenList([
+      { name: 'far', token: 'fake-far' },
+      { name: 'soon', token: 'fake-soon' },
+    ]);
+    writeCache('fake-far', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 6 * DAY,
+    });
+    writeCache('fake-soon', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 2 * DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-far', sessionId: 'session-a' },
+      { token: 'fake-soon', sessionId: 'session-b' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('soon');
+  });
+  it('dedupes child processes that share a session id when counting occupancy', () => {
+    writeTokenList([
+      { name: 'oneSession', token: 'fake-one' },
+      { name: 'twoSessions', token: 'fake-two' },
+    ]);
+    writeCache('fake-one', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 2 * DAY,
+    });
+    writeCache('fake-two', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + 6 * DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-one', sessionId: 'session-a' },
+      { token: 'fake-one', sessionId: 'session-a' },
+      { token: 'fake-two', sessionId: 'session-b' },
+      { token: 'fake-two', sessionId: 'session-c' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('oneSession');
+  });
+  it('excludes a rate-limit-ineligible token even when it is unoccupied', () => {
+    writeTokenList([
+      { name: 'blocked', token: 'fake-blocked' },
+      { name: 'free', token: 'fake-free' },
+    ]);
+    writeCache('fake-blocked', {
+      fiveHourUtilization: 0.9,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    writeCache('fake-free', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = buildHandler([
+      { token: 'fake-free', sessionId: 'session-a' },
+    ]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedName).toBe('free');
+  });
+  it('returns null and a diagnostic when no token passes the filter', () => {
+    writeTokenList([{ name: 'busy', token: 'fake-busy' }]);
+    writeCache('fake-busy', {
+      fiveHourUtilization: 0.9,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+    const handler = buildHandler([]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.diagnostics.join('\n')).toContain(
+      'No eligible token passed the rate-limit filter.',
+    );
+  });
+  it('returns a diagnostic when no token list path is resolvable', () => {
+    const handler = buildHandler([]);
+    const output = handler.handle({
+      tokenListJsonPath: null,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.diagnostics.join('\n')).toContain('No token list path');
+  });
+  it('returns a diagnostic when the token list file has no usable entries', () => {
+    fs.writeFileSync(tokenListPath, JSON.stringify([]));
+    const handler = buildHandler([]);
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+    expect(output.selectedToken).toBeNull();
+    expect(output.diagnostics.join('\n')).toContain('No usable token entries');
+  });
+});

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.ts ADDED Viewed

@@ -0,0 +1,116 @@
+import { ClaudeLiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeLiveSessionRepository';
+import {
+  LiveSessionOauthTokenSelectResult,
+  LiveSessionOauthTokenSelectUseCase,
+} from '../../../domain/usecases/LiveSessionOauthTokenSelectUseCase';
+import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
+import { ProcClaudeLiveSessionRepository } from '../../repositories/ProcClaudeLiveSessionRepository';
+import { readRateLimit } from '../../proxy/RateLimitCache';
+import { loadTokenEntries } from '../../proxy/TokenListLoader';
+import {
+  resolveCacheDirectory,
+  resolveTokenListJsonPath,
+} from './OauthTokenSelectHandler';
+export type LiveSessionOauthTokenSelectHandlerInput = {
+  tokenListJsonPath: string | null;
+  cacheDirectory: string | null;
+  nowEpochSeconds: number;
+};
+export type LiveSessionOauthTokenSelectHandlerOutput = {
+  selectedToken: string | null;
+  selectedName: string | null;
+  diagnostics: string[];
+};
+export class LiveSessionOauthTokenSelectHandler {
+  constructor(
+    private readonly useCase: LiveSessionOauthTokenSelectUseCase = new LiveSessionOauthTokenSelectUseCase(),
+    private readonly liveSessionRepository: ClaudeLiveSessionRepository = new ProcClaudeLiveSessionRepository(),
+  ) {}
+  handle = (
+    input: LiveSessionOauthTokenSelectHandlerInput,
+  ): LiveSessionOauthTokenSelectHandlerOutput => {
+    const tokenListJsonPath = resolveTokenListJsonPath(input.tokenListJsonPath);
+    if (tokenListJsonPath === null) {
+      return {
+        selectedToken: null,
+        selectedName: null,
+        diagnostics: [
+          'No token list path provided. Pass --tokenListJsonPath or set CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH.',
+        ],
+      };
+    }
+    const entries = loadTokenEntries(tokenListJsonPath);
+    if (entries === null) {
+      return {
+        selectedToken: null,
+        selectedName: null,
+        diagnostics: [
+          `No usable token entries loaded from ${tokenListJsonPath}.`,
+        ],
+      };
+    }
+    const cacheDirectory = resolveCacheDirectory(input.cacheDirectory);
+    const candidates: OauthTokenCandidate[] = entries.map(({ name, token }) => {
+      const snapshot = readRateLimit(token, cacheDirectory);
+      return {
+        name,
+        token,
+        snapshot:
+          snapshot === null
+            ? null
+            : {
+                fiveHourUtilization: snapshot.fiveHourUtilization,
+                fiveHourReset: snapshot.fiveHourReset,
+                sevenDayUtilization: snapshot.sevenDayUtilization,
+                sevenDayReset: snapshot.sevenDayReset,
+              },
+      };
+    });
+    const liveSessions = this.liveSessionRepository.listLiveSessions();
+    const result = this.useCase.run(
+      candidates,
+      liveSessions,
+      input.nowEpochSeconds,
+    );
+    return {
+      selectedToken: result.selected?.token ?? null,
+      selectedName: result.selected?.name ?? null,
+      diagnostics: this.formatDiagnostics(result, input.nowEpochSeconds),
+    };
+  };
+  private formatDiagnostics = (
+    result: LiveSessionOauthTokenSelectResult,
+    nowEpochSeconds: number,
+  ): string[] => {
+    const lines = result.metrics.map((metric) => {
+      const secondsUntilSevenDayEnd = Math.round(
+        metric.sevenDayEndEpoch - nowEpochSeconds,
+      );
+      const status = metric.eligible
+        ? 'eligible'
+        : `excluded (${metric.exclusionReason})`;
+      return `${metric.name}: ${metric.liveSessionCount} live session(s), 5h ${Math.round(metric.fiveHourFreeRatio * 100)}% free, 7d ${Math.round(metric.sevenDayFreeRatio * 100)}% free, 7d-end in ${secondsUntilSevenDayEnd}s -> ${status}`;
+    });
+    if (result.selected === null) {
+      lines.push('No eligible token passed the rate-limit filter.');
+    } else {
+      lines.push(
+        `Selected ${result.selected.name} (fewest live sessions, then soonest 7d reset among eligible tokens).`,
+      );
+    }
+    return lines;
+  };
+}

package/src/adapter/entry-points/handlers/inTmuxByHumanSessionReconciler.test.ts ADDED Viewed

@@ -0,0 +1,123 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { reconcileInTmuxByHumanSessions } from './inTmuxByHumanSessionReconciler';
+const ASSIGNEE = 'owner-login';
+const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: 'In Tmux by human',
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: [ASSIGNEE],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date(),
+  author: '',
+  ...overrides,
+});
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+const createMockRunner = (): Mocked<LocalCommandRunner> => ({
+  runCommand: jest.fn(),
+});
+describe('reconcileInTmuxByHumanSessions', () => {
+  it('does nothing when no launcher command is configured', async () => {
+    const runner = createMockRunner();
+    await reconcileInTmuxByHumanSessions({
+      inTmuxLauncherCommand: null,
+      assigneeLogin: ASSIGNEE,
+      issues: [makeIssue()],
+      localCommandRunner: runner,
+    });
+    expect(runner.runCommand.mock.calls).toHaveLength(0);
+  });
+  it('launches a detached tmux session when an In Tmux by human session is missing', async () => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return { stdout: '', stderr: '', exitCode: 0 };
+      }
+      if (program === 'ps') {
+        return { stdout: '', stderr: '', exitCode: 0 };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+    await reconcileInTmuxByHumanSessions({
+      inTmuxLauncherCommand: 'cl',
+      assigneeLogin: ASSIGNEE,
+      issues: [makeIssue()],
+      localCommandRunner: runner,
+    });
+    const newSessionCall = runner.runCommand.mock.calls.find(
+      (call) => call[0] === 'tmux' && call[1][0] === 'new-session',
+    );
+    expect(newSessionCall).toBeDefined();
+    expect(newSessionCall?.[1]).toEqual([
+      'new-session',
+      '-d',
+      '-s',
+      'https___github_com_demo_repo_issues_1',
+      'sh',
+      '-lc',
+      'exec "$1" "$2"',
+      'sh',
+      'cl',
+      'https://github.com/demo/repo/issues/1',
+    ]);
+  });
+  it('does not launch when a live session already exists', async () => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: 'https___github_com_demo_repo_issues_1\n',
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      if (program === 'ps') {
+        return {
+          stdout: 'claude --name https://github.com/demo/repo/issues/1\n',
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+    await reconcileInTmuxByHumanSessions({
+      inTmuxLauncherCommand: 'cl',
+      assigneeLogin: ASSIGNEE,
+      issues: [makeIssue()],
+      localCommandRunner: runner,
+    });
+    const newSessionCalls = runner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'tmux' && call[1][0] === 'new-session',
+    );
+    expect(newSessionCalls).toHaveLength(0);
+  });
+});

package/src/adapter/entry-points/handlers/inTmuxByHumanSessionReconciler.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { InTmuxByHumanSessionReconcileUseCase } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
+export type ReconcileInTmuxByHumanSessionsParams = {
+  inTmuxLauncherCommand: string | null;
+  assigneeLogin: string;
+  issues: Issue[];
+  localCommandRunner: LocalCommandRunner;
+};
+export const reconcileInTmuxByHumanSessions = async (
+  params: ReconcileInTmuxByHumanSessionsParams,
+): Promise<void> => {
+  const { inTmuxLauncherCommand, assigneeLogin, issues, localCommandRunner } =
+    params;
+  if (!inTmuxLauncherCommand || !assigneeLogin) {
+    return;
+  }
+  const useCase = new InTmuxByHumanSessionReconcileUseCase(
+    new NodeTmuxSessionRepository(localCommandRunner),
+  );
+  await useCase.run({
+    issues,
+    assigneeLogin,
+    launcherCommand: inTmuxLauncherCommand,
+  });
+};

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

@@ -0,0 +1,100 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { NodeTmuxSessionRepository } from './NodeTmuxSessionRepository';
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+const createMockRunner = (): Mocked<LocalCommandRunner> => ({
+  runCommand: jest.fn(),
+});
+describe('NodeTmuxSessionRepository', () => {
+  describe('listLiveSessionNames', () => {
+    it('parses tmux session names and drops blank lines', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: 'session-a\nsession-b\n\n',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+      const result = await repository.listLiveSessionNames();
+      expect(result).toEqual(['session-a', 'session-b']);
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'list-sessions',
+        '-F',
+        '#{session_name}',
+      ]);
+    });
+    it('returns an empty list when tmux exits non-zero', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: 'no server running',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+      const result = await repository.listLiveSessionNames();
+      expect(result).toEqual([]);
+    });
+  });
+  describe('listInteractiveProcessCommandLines', () => {
+    it('parses process command lines from ps output', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout:
+          'claude --name https://github.com/demo/repo/issues/1\n/usr/bin/tmux\n',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+      const result = await repository.listInteractiveProcessCommandLines();
+      expect(result).toEqual([
+        'claude --name https://github.com/demo/repo/issues/1',
+        '/usr/bin/tmux',
+      ]);
+      expect(runner.runCommand.mock.calls[0][0]).toBe('ps');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual(['-eo', 'args=']);
+    });
+  });
+  describe('launchDetachedSession', () => {
+    it('creates a detached tmux session running the launcher command with the issue url', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+      await repository.launchDetachedSession(
+        'https___github_com_demo_repo_issues_1',
+        'cl',
+        'https://github.com/demo/repo/issues/1',
+      );
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'new-session',
+        '-d',
+        '-s',
+        'https___github_com_demo_repo_issues_1',
+        'sh',
+        '-lc',
+        'exec "$1" "$2"',
+        'sh',
+        'cl',
+        'https://github.com/demo/repo/issues/1',
+      ]);
+    });
+  });
+});