npm-cli-gh-issue-preparator 1.32.1 → 1.33.0

package/bin/domain/usecases/StaleTmuxSessionKillUseCase.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleTmuxSessionKillUseCase = exports.DEFAULT_IDLE_THRESHOLD_SECONDS = exports.DEFAULT_EXCLUDED_STATUS = void 0;
+exports.DEFAULT_EXCLUDED_STATUS = 'In Tmux by human';
+exports.DEFAULT_IDLE_THRESHOLD_SECONDS = 24 * 60 * 60;
+class StaleTmuxSessionKillUseCase {
+    constructor(projectRepository, issueRepository, localCommandRunner) {
+        this.projectRepository = projectRepository;
+        this.issueRepository = issueRepository;
+        this.localCommandRunner = localCommandRunner;
+        this.run = async (params) => {
+            const liveSessions = await this.listLiveSessions();
+            const project = await this.projectRepository.getByUrl(params.projectUrl);
+            const openIssues = await this.issueRepository.getAllOpened(project);
+            const issueBySessionName = new Map();
+            for (const issue of openIssues) {
+                issueBySessionName.set(this.deriveSessionName(issue.url), issue);
+            }
+            const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
+            const killCandidates = [];
+            for (const session of liveSessions) {
+                const reason = this.evaluateKillReason(session, issueBySessionName.get(session.sessionName) ?? null, nowEpochSeconds, params.excludedStatus, params.idleThresholdSeconds);
+                if (reason !== null) {
+                    killCandidates.push({ sessionName: session.sessionName, reason });
+                }
+            }
+            console.log(`Stale tmux session cleanup: ${killCandidates.length} kill candidate(s) of ${liveSessions.length} live session(s).`);
+            for (const candidate of killCandidates) {
+                console.log(`Kill candidate: ${candidate.sessionName} (${candidate.reason})`);
+            }
+            for (const candidate of killCandidates) {
+                await this.localCommandRunner.runCommand('tmux', [
+                    'kill-session',
+                    '-t',
+                    candidate.sessionName,
+                ]);
+                console.log(`Killed tmux session: ${candidate.sessionName} (${candidate.reason})`);
+            }
+        };
+        this.listLiveSessions = async () => {
+            const result = await this.localCommandRunner.runCommand('tmux', [
+                'list-sessions',
+                '-F',
+                '#{session_name} #{session_activity}',
+            ]);
+            return result.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 };
+            });
+        };
+        this.deriveSessionName = (issueUrl) => issueUrl.replace(/[.:]/g, '_');
+        this.evaluateKillReason = (session, issue, nowEpochSeconds, excludedStatus, idleThresholdSeconds) => {
+            if (issue !== null) {
+                if (issue.status !== excludedStatus) {
+                    return `mapped to open issue ${issue.url} with status "${issue.status ?? 'null'}" which is not the excluded status "${excludedStatus}"`;
+                }
+                if (issue.nextActionDate !== null) {
+                    return `mapped to open issue ${issue.url} which has a next action date set`;
+                }
+                if (issue.nextActionHour !== null) {
+                    return `mapped to open issue ${issue.url} which has a next action hour set`;
+                }
+                return null;
+            }
+            const idleSeconds = nowEpochSeconds - session.activityEpochSeconds;
+            if (idleSeconds >= idleThresholdSeconds) {
+                return `maps to no open issue and has been idle for ${idleSeconds} seconds (threshold ${idleThresholdSeconds} seconds)`;
+            }
+            return null;
+        };
+    }
+}
+exports.StaleTmuxSessionKillUseCase = StaleTmuxSessionKillUseCase;
+//# sourceMappingURL=StaleTmuxSessionKillUseCase.js.map

package/bin/domain/usecases/StaleTmuxSessionKillUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaleTmuxSessionKillUseCase.js","sourceRoot":"","sources":["../../../src/domain/usecases/StaleTmuxSessionKillUseCase.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-cli-gh-issue-preparator",
-  "version": "1.32.1",
+  "version": "1.33.0",
   "description": "",
   "main": "bin/index.js",
   "scripts": {
@@ -52,7 +52,7 @@
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
     "check-node-version": "^4.2.1",
-    "commitlint": "^20.0.0",
+    "commitlint": "^21.0.0",
     "conventional-changelog-conventionalcommits": "^9.0.0",
     "eslint": "^8.57.0",
     "eslint-plugin-import": "^2.29.1",

package/renovate.json

@@ -1,3 +1,7 @@
+// DO NOT EDIT DIRECTLY.
+// This file is auto-synchronized from HiromiShikata/repositories-management.
+// Direct edits in downstream repositories will be overwritten by the next sync.
+// Update the source file in HiromiShikata/repositories-management instead.
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
   "extends": ["config:base"],
@@ -10,6 +14,7 @@
   "dependencyDashboard": false,
   "branchConcurrentLimit": 2,
   "ignorePaths": ["**/generated/*", "**/_gen/*"],
+  "osvVulnerabilityAlerts": true,
   "packageRules": [
     {
       "matchPackageNames": ["eslint"],

package/src/adapter/entry-points/cli/index.test.ts

@@ -8,9 +8,11 @@ import {
   mergeConfigs,
 } from './index';
 import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
+import { StaleTmuxSessionKillUseCase } from '../../../domain/usecases/StaleTmuxSessionKillUseCase';
 import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
 
 jest.mock('../../../domain/usecases/StartPreparationUseCase');
+jest.mock('../../../domain/usecases/StaleTmuxSessionKillUseCase');
 jest.mock('../../../domain/usecases/NotifyFinishedIssuePreparationUseCase');
 jest.mock('../../repositories/TowerDefenceIssueRepository', () => ({
   TowerDefenceIssueRepository: jest.fn().mockImplementation(() => ({
@@ -420,6 +422,62 @@ defaultAgentName: 'case-test-agent'
   });
 
   describe('startDaemon', () => {
+    const setupStaleTmuxMock = (): jest.Mock<
+      Promise<void>,
+      Parameters<StaleTmuxSessionKillUseCase['run']>
+    > => {
+      const staleTmuxRun = jest.fn<
+        Promise<void>,
+        Parameters<StaleTmuxSessionKillUseCase['run']>
+      >(() => Promise.resolve());
+      const MockedStaleTmuxSessionKillUseCase = jest.mocked(
+        StaleTmuxSessionKillUseCase,
+      );
+      MockedStaleTmuxSessionKillUseCase.mockImplementation(function (
+        this: StaleTmuxSessionKillUseCase,
+      ) {
+        this.run = staleTmuxRun;
+        return this;
+      });
+      return staleTmuxRun;
+    };
+    beforeEach(() => {
+      setupStaleTmuxMock();
+    });
+
+    it('should run stale tmux session cleanup after preparation', async () => {
+      const mockStaleTmuxRun = setupStaleTmuxMock();
+      const mockRun = jest.fn().mockResolvedValue(undefined);
+      const MockedStartPreparationUseCase = jest.mocked(
+        StartPreparationUseCase,
+      );
+      MockedStartPreparationUseCase.mockImplementation(function (
+        this: StartPreparationUseCase,
+      ) {
+        this.run = mockRun;
+        return this;
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockStaleTmuxRun).toHaveBeenCalledTimes(1);
+      expect(mockStaleTmuxRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          projectUrl: 'https://github.com/test/project',
+          excludedStatus: 'In Tmux by human',
+          idleThresholdSeconds: 86400,
+        }),
+      );
+      const staleTmuxCallArgument = mockStaleTmuxRun.mock.calls[0][0];
+      expect(staleTmuxCallArgument.now).toBeInstanceOf(Date);
+    });
+
     it('should read parameters from config file', async () => {
       const mockRun = jest.fn().mockResolvedValue(undefined);
       const MockedStartPreparationUseCase = jest.mocked(

package/src/adapter/entry-points/cli/index.ts

@@ -6,6 +6,11 @@ import * as fs from 'fs';
 import * as yaml from 'js-yaml';
 import { Command } from 'commander';
 import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
+import {
+  StaleTmuxSessionKillUseCase,
+  DEFAULT_EXCLUDED_STATUS,
+  DEFAULT_IDLE_THRESHOLD_SECONDS,
+} from '../../../domain/usecases/StaleTmuxSessionKillUseCase';
 import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
 import { TowerDefenceIssueRepository } from '../../repositories/TowerDefenceIssueRepository';
 import { GraphqlIssueRepository } from '../../repositories/GraphqlIssueRepository';
@@ -455,6 +460,22 @@ program
       utilizationPercentageThreshold,
       allowedIssueAuthors,
     });
+
+    const staleTmuxSessionKillUseCase = new StaleTmuxSessionKillUseCase(
+      projectRepository,
+      {
+        getAllOpened: towerDefenceIssueRepository.getAllOpened.bind(
+          towerDefenceIssueRepository,
+        ),
+      },
+      localCommandRunner,
+    );
+    await staleTmuxSessionKillUseCase.run({
+      projectUrl,
+      excludedStatus: DEFAULT_EXCLUDED_STATUS,
+      idleThresholdSeconds: DEFAULT_IDLE_THRESHOLD_SECONDS,
+      now: new Date(),
+    });
   });
 
 program

package/src/domain/usecases/StaleTmuxSessionKillUseCase.test.ts

@@ -0,0 +1,262 @@
+import {
+  StaleTmuxSessionKillUseCase,
+  DEFAULT_EXCLUDED_STATUS,
+  DEFAULT_IDLE_THRESHOLD_SECONDS,
+} from './StaleTmuxSessionKillUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+const createMockProject = (): Project => ({
+  id: 'project-1',
+  url: 'https://github.com/users/user/projects/1',
+  databaseId: 1,
+  name: 'Test Project',
+  readme: null,
+  status: {
+    name: 'Status',
+    fieldId: 'status-field-id',
+    statuses: [],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+});
+
+const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'user/repo',
+  number: 1,
+  title: 'Test Issue',
+  state: 'OPEN',
+  status: DEFAULT_EXCLUDED_STATUS,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/user/repo/issues/1',
+  assignees: [],
+  labels: [],
+  org: 'user',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date(),
+  author: 'testuser',
+  ...overrides,
+});
+
+const sessionNameOf = (issueUrl: string): string =>
+  issueUrl.replace(/[.:]/g, '_');
+
+describe('StaleTmuxSessionKillUseCase', () => {
+  let useCase: StaleTmuxSessionKillUseCase;
+  let mockProjectRepository: Mocked<Pick<ProjectRepository, 'getByUrl'>>;
+  let mockIssueRepository: Mocked<Pick<IssueRepository, 'getAllOpened'>>;
+  let mockLocalCommandRunner: Mocked<Pick<LocalCommandRunner, 'runCommand'>>;
+  let mockProject: Project;
+  const now = new Date('2026-06-26T00:00:00Z');
+  const nowEpochSeconds = Math.floor(now.getTime() / 1000);
+
+  const runParams = {
+    projectUrl: 'https://github.com/user/repo',
+    excludedStatus: DEFAULT_EXCLUDED_STATUS,
+    idleThresholdSeconds: DEFAULT_IDLE_THRESHOLD_SECONDS,
+    now,
+  };
+
+  const setLiveSessions = (lines: string[]): void => {
+    mockLocalCommandRunner.runCommand.mockResolvedValueOnce({
+      stdout: lines.join('\n'),
+      stderr: '',
+      exitCode: 0,
+    });
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    mockProject = createMockProject();
+    mockProjectRepository = {
+      getByUrl: jest.fn().mockResolvedValue(mockProject),
+    };
+    mockIssueRepository = {
+      getAllOpened: jest.fn().mockResolvedValue([]),
+    };
+    mockLocalCommandRunner = {
+      runCommand: jest.fn().mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      }),
+    };
+    useCase = new StaleTmuxSessionKillUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+      mockLocalCommandRunner,
+    );
+  });
+
+  it('exposes the excluded status and idle threshold as named constants', () => {
+    expect(DEFAULT_EXCLUDED_STATUS).toBe('In Tmux by human');
+    expect(DEFAULT_IDLE_THRESHOLD_SECONDS).toBe(86400);
+  });
+
+  it('lists live sessions via the local command runner', async () => {
+    setLiveSessions([]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledWith('tmux', [
+      'list-sessions',
+      '-F',
+      '#{session_name} #{session_activity}',
+    ]);
+  });
+
+  it('kills a session mapping to an open issue whose status is not the excluded status', async () => {
+    const issueUrl = 'https://github.com/user/repo/issues/10';
+    const sessionName = sessionNameOf(issueUrl);
+    setLiveSessions([`${sessionName} ${nowEpochSeconds}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([
+      createMockIssue({ url: issueUrl, status: 'In Progress' }),
+    ]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+
+  it('kills a session mapping to an open issue whose status is null', async () => {
+    const issueUrl = 'https://github.com/user/repo/issues/11';
+    const sessionName = sessionNameOf(issueUrl);
+    setLiveSessions([`${sessionName} ${nowEpochSeconds}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([
+      createMockIssue({ url: issueUrl, status: null }),
+    ]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+
+  it('kills an excluded-status session that has a next action date set', async () => {
+    const issueUrl = 'https://github.com/user/repo/issues/12';
+    const sessionName = sessionNameOf(issueUrl);
+    setLiveSessions([`${sessionName} ${nowEpochSeconds}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([
+      createMockIssue({
+        url: issueUrl,
+        status: DEFAULT_EXCLUDED_STATUS,
+        nextActionDate: new Date('2026-06-27T00:00:00Z'),
+      }),
+    ]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+
+  it('kills an excluded-status session that has a next action hour set', async () => {
+    const issueUrl = 'https://github.com/user/repo/issues/13';
+    const sessionName = sessionNameOf(issueUrl);
+    setLiveSessions([`${sessionName} ${nowEpochSeconds}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([
+      createMockIssue({
+        url: issueUrl,
+        status: DEFAULT_EXCLUDED_STATUS,
+        nextActionHour: 9,
+      }),
+    ]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+
+  it('never kills an excluded-status session that has no reactivation trigger', async () => {
+    const issueUrl = 'https://github.com/user/repo/issues/14';
+    const sessionName = sessionNameOf(issueUrl);
+    setLiveSessions([`${sessionName} ${nowEpochSeconds}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([
+      createMockIssue({
+        url: issueUrl,
+        status: DEFAULT_EXCLUDED_STATUS,
+        nextActionDate: null,
+        nextActionHour: null,
+      }),
+    ]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).not.toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+
+  it('kills a no-task session that has been idle at least the idle threshold', async () => {
+    const sessionName = 'no_task_session';
+    const idleActivity = nowEpochSeconds - DEFAULT_IDLE_THRESHOLD_SECONDS;
+    setLiveSessions([`${sessionName} ${idleActivity}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+
+  it('never kills a no-task session that was active within the idle threshold', async () => {
+    const sessionName = 'no_task_session';
+    const recentActivity = nowEpochSeconds - DEFAULT_IDLE_THRESHOLD_SECONDS + 1;
+    setLiveSessions([`${sessionName} ${recentActivity}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).not.toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+
+  it('does nothing when there are no live sessions', async () => {
+    setLiveSessions(['', '   ']);
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledTimes(1);
+  });
+
+  it('maps a session back to its issue using the dot-and-colon-to-underscore convention', async () => {
+    const issueUrl = 'https://github.com/owner/repo/issues/9';
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    expect(sessionNameOf(issueUrl)).toBe(sessionName);
+    setLiveSessions([`${sessionName} ${nowEpochSeconds}`]);
+    mockIssueRepository.getAllOpened.mockResolvedValue([
+      createMockIssue({ url: issueUrl, status: 'In Progress' }),
+    ]);
+    await useCase.run(runParams);
+    expect(mockLocalCommandRunner.runCommand).toHaveBeenCalledWith('tmux', [
+      'kill-session',
+      '-t',
+      sessionName,
+    ]);
+  });
+});

package/src/domain/usecases/StaleTmuxSessionKillUseCase.ts

@@ -0,0 +1,123 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
+import { Issue } from '../entities/Issue';
+
+export const DEFAULT_EXCLUDED_STATUS = 'In Tmux by human';
+export const DEFAULT_IDLE_THRESHOLD_SECONDS = 24 * 60 * 60;
+
+type LiveTmuxSession = {
+  sessionName: string;
+  activityEpochSeconds: number;
+};
+
+type KillCandidate = {
+  sessionName: string;
+  reason: string;
+};
+
+export class StaleTmuxSessionKillUseCase {
+  constructor(
+    private readonly projectRepository: Pick<ProjectRepository, 'getByUrl'>,
+    private readonly issueRepository: Pick<IssueRepository, 'getAllOpened'>,
+    private readonly localCommandRunner: Pick<LocalCommandRunner, 'runCommand'>,
+  ) {}
+
+  run = async (params: {
+    projectUrl: string;
+    excludedStatus: string;
+    idleThresholdSeconds: number;
+    now: Date;
+  }): Promise<void> => {
+    const liveSessions = await this.listLiveSessions();
+    const project = await this.projectRepository.getByUrl(params.projectUrl);
+    const openIssues = await this.issueRepository.getAllOpened(project);
+    const issueBySessionName = new Map<string, Issue>();
+    for (const issue of openIssues) {
+      issueBySessionName.set(this.deriveSessionName(issue.url), issue);
+    }
+
+    const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const killCandidates: KillCandidate[] = [];
+    for (const session of liveSessions) {
+      const reason = this.evaluateKillReason(
+        session,
+        issueBySessionName.get(session.sessionName) ?? null,
+        nowEpochSeconds,
+        params.excludedStatus,
+        params.idleThresholdSeconds,
+      );
+      if (reason !== null) {
+        killCandidates.push({ sessionName: session.sessionName, reason });
+      }
+    }
+
+    console.log(
+      `Stale tmux session cleanup: ${killCandidates.length} kill candidate(s) of ${liveSessions.length} live session(s).`,
+    );
+    for (const candidate of killCandidates) {
+      console.log(
+        `Kill candidate: ${candidate.sessionName} (${candidate.reason})`,
+      );
+    }
+
+    for (const candidate of killCandidates) {
+      await this.localCommandRunner.runCommand('tmux', [
+        'kill-session',
+        '-t',
+        candidate.sessionName,
+      ]);
+      console.log(
+        `Killed tmux session: ${candidate.sessionName} (${candidate.reason})`,
+      );
+    }
+  };
+
+  private listLiveSessions = async (): Promise<LiveTmuxSession[]> => {
+    const result = await this.localCommandRunner.runCommand('tmux', [
+      'list-sessions',
+      '-F',
+      '#{session_name} #{session_activity}',
+    ]);
+    return result.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 };
+      });
+  };
+
+  private deriveSessionName = (issueUrl: string): string =>
+    issueUrl.replace(/[.:]/g, '_');
+
+  private evaluateKillReason = (
+    session: LiveTmuxSession,
+    issue: Issue | null,
+    nowEpochSeconds: number,
+    excludedStatus: string,
+    idleThresholdSeconds: number,
+  ): string | null => {
+    if (issue !== null) {
+      if (issue.status !== excludedStatus) {
+        return `mapped to open issue ${issue.url} with status "${issue.status ?? 'null'}" which is not the excluded status "${excludedStatus}"`;
+      }
+      if (issue.nextActionDate !== null) {
+        return `mapped to open issue ${issue.url} which has a next action date set`;
+      }
+      if (issue.nextActionHour !== null) {
+        return `mapped to open issue ${issue.url} which has a next action hour set`;
+      }
+      return null;
+    }
+
+    const idleSeconds = nowEpochSeconds - session.activityEpochSeconds;
+    if (idleSeconds >= idleThresholdSeconds) {
+      return `maps to no open issue and has been idle for ${idleSeconds} seconds (threshold ${idleThresholdSeconds} seconds)`;
+    }
+    return null;
+  };
+}

package/types/adapter/entry-points/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,KAAK,UAAU,GAAG;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iCAAiC,CAAC,EAAE,MAAM,CAAC;CAC5C,CAAC;AA6CF,QAAA,MAAM,cAAc,GAAI,gBAAgB,MAAM,KAAG,UA6ChD,CAAC;AAEF,QAAA,MAAM,wBAAwB,GAAI,QAAQ,MAAM,KAAG,UAiDlD,CAAC;AAEF,QAAA,MAAM,YAAY,GAChB,YAAY,UAAU,EACtB,cAAc,UAAU,EACxB,iBAAiB,UAAU,KAC1B,UAmDD,CAAC;AAeH,QAAA,MAAM,OAAO,SAAgB,CAAC;AAyX9B,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,KAAK,UAAU,GAAG;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iCAAiC,CAAC,EAAE,MAAM,CAAC;CAC5C,CAAC;AA6CF,QAAA,MAAM,cAAc,GAAI,gBAAgB,MAAM,KAAG,UA6ChD,CAAC;AAEF,QAAA,MAAM,wBAAwB,GAAI,QAAQ,MAAM,KAAG,UAiDlD,CAAC;AAEF,QAAA,MAAM,YAAY,GAChB,YAAY,UAAU,EACtB,cAAc,UAAU,EACxB,iBAAiB,UAAU,KAC1B,UAmDD,CAAC;AAeH,QAAA,MAAM,OAAO,SAAgB,CAAC;AAyY9B,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,YAAY,EAAE,CAAC"}

package/types/domain/usecases/StaleTmuxSessionKillUseCase.d.ts

@@ -0,0 +1,25 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
+export declare const DEFAULT_EXCLUDED_STATUS = 'In Tmux by human';
+export declare const DEFAULT_IDLE_THRESHOLD_SECONDS: number;
+export declare class StaleTmuxSessionKillUseCase {
+  private readonly projectRepository;
+  private readonly issueRepository;
+  private readonly localCommandRunner;
+  constructor(
+    projectRepository: Pick<ProjectRepository, 'getByUrl'>,
+    issueRepository: Pick<IssueRepository, 'getAllOpened'>,
+    localCommandRunner: Pick<LocalCommandRunner, 'runCommand'>,
+  );
+  run: (params: {
+    projectUrl: string;
+    excludedStatus: string;
+    idleThresholdSeconds: number;
+    now: Date;
+  }) => Promise<void>;
+  private listLiveSessions;
+  private deriveSessionName;
+  private evaluateKillReason;
+}
+//# sourceMappingURL=StaleTmuxSessionKillUseCase.d.ts.map

package/types/domain/usecases/StaleTmuxSessionKillUseCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaleTmuxSessionKillUseCase.d.ts","sourceRoot":"","sources":["../../../src/domain/usecases/StaleTmuxSessionKillUseCase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAG7E,eAAO,MAAM,uBAAuB,qBAAqB,CAAC;AAC1D,eAAO,MAAM,8BAA8B,QAAe,CAAC;AAY3D,qBAAa,2BAA2B;IAEpC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAFlB,iBAAiB,EAAE,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,EACtD,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EACtD,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC;IAG7E,GAAG,GAAU,QAAQ;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,GAAG,EAAE,IAAI,CAAC;KACX,KAAG,OAAO,CAAC,IAAI,CAAC,CA2Cf;IAEF,OAAO,CAAC,gBAAgB,CAgBtB;IAEF,OAAO,CAAC,iBAAiB,CACQ;IAEjC,OAAO,CAAC,kBAAkB,CAyBxB;CACH"}