github-issue-tower-defence-management 1.152.2 → 1.153.0

package/src/adapter/entry-points/console/webServer.ts

@@ -36,6 +36,10 @@ import {
   composeDashboardText,
   dashboardComposeFilesPresent,
 } from './dashboardComposeService';
+import {
+  OWNER_CALL_FILE_DIRECTORY_NAME,
+  OWNER_CALL_FILE_EXTENSION,
+} from '../../../domain/usecases/intmux/OwnerCallFile';
 
 export const DEFAULT_WEB_PORT = 9980;
 
@@ -74,6 +78,7 @@ const MIME_TYPES: Record<string, string> = {
   '.map': 'application/json; charset=utf-8',
   '.woff': 'font/woff',
   '.woff2': 'font/woff2',
+  '.yaml': 'text/yaml; charset=utf-8',
 };
 
 export const hasDotSegment = (requestPath: string): boolean =>
@@ -84,7 +89,8 @@ export const hasDotSegment = (requestPath: string): boolean =>
 export const requiresToken = (requestPath: string): boolean =>
   requestPath.startsWith('/api/') ||
   requestPath === '/api' ||
-  requestPath.endsWith('.json');
+  requestPath.endsWith('.json') ||
+  requestPath.endsWith(OWNER_CALL_FILE_EXTENSION);
 
 const SAFE_PJCODE = /^[A-Za-z0-9._-]+$/;
 
@@ -227,6 +233,12 @@ const FLAT_IN_TMUX_PREFIX = '/in-tmux-by-human/';
 
 const FLAT_IN_TMUX_FILE = /^[A-Za-z0-9._-]+\.json$/;
 
+const NAME_SEGMENT = '[A-Za-z0-9_-][A-Za-z0-9._-]*';
+
+const OWNER_CALL_FILE = new RegExp(
+  `^${OWNER_CALL_FILE_DIRECTORY_NAME}/${NAME_SEGMENT}/${NAME_SEGMENT}${OWNER_CALL_FILE_EXTENSION.replace('.', '\\.')}$`,
+);
+
 export const DASHBOARD_REQUEST_PATH = '/tdpm.txt';
 
 export const IMAGE_PROXY_REQUEST_PATH = '/api/img';
@@ -249,6 +261,10 @@ export const resolveDashboardFilePath = (
   return resolvedCandidate;
 };
 
+export const isOwnerCallFileRequestPath = (requestPath: string): boolean =>
+  requestPath.startsWith(FLAT_IN_TMUX_PREFIX) &&
+  OWNER_CALL_FILE.test(requestPath.slice(FLAT_IN_TMUX_PREFIX.length));
+
 export const resolveFlatInTmuxFilePath = (
   inTmuxDataDir: string,
   requestPath: string,
@@ -256,11 +272,16 @@ export const resolveFlatInTmuxFilePath = (
   if (!requestPath.startsWith(FLAT_IN_TMUX_PREFIX)) {
     return null;
   }
-  const fileName = requestPath.slice(FLAT_IN_TMUX_PREFIX.length);
-  if (fileName.length === 0 || !FLAT_IN_TMUX_FILE.test(fileName)) {
+  const relativePath = requestPath.slice(FLAT_IN_TMUX_PREFIX.length);
+  if (
+    relativePath.length === 0 ||
+    !(
+      FLAT_IN_TMUX_FILE.test(relativePath) || OWNER_CALL_FILE.test(relativePath)
+    )
+  ) {
     return null;
   }
-  const candidate = path.join(inTmuxDataDir, fileName);
+  const candidate = path.join(inTmuxDataDir, relativePath);
   const resolvedRoot = path.resolve(inTmuxDataDir);
   const resolvedCandidate = path.resolve(candidate);
   if (!resolvedCandidate.startsWith(resolvedRoot + path.sep)) {
@@ -530,6 +551,56 @@ const handleOperationApi = async (
   }
 };
 
+const serveFlatInTmuxFile = (
+  options: WebServerOptions,
+  response: http.ServerResponse,
+  requestPath: string,
+): void => {
+  if (options.inTmuxDataDir === null) {
+    sendNotFound(response);
+    return;
+  }
+  const filePath = resolveFlatInTmuxFilePath(
+    options.inTmuxDataDir,
+    requestPath,
+  );
+  const content = filePath === null ? null : readStaticFile(filePath);
+  if (filePath === null || content === null) {
+    sendNotFound(response);
+    return;
+  }
+  response.writeHead(200, {
+    'Content-Type': contentTypeForPath(filePath),
+    'Cache-Control': 'no-store',
+    'Content-Length': String(content.length),
+  });
+  response.end(content);
+};
+
+const removeOwnerCallFile = (
+  options: WebServerOptions,
+  response: http.ServerResponse,
+  requestPath: string,
+): void => {
+  if (options.inTmuxDataDir === null) {
+    sendNotFound(response);
+    return;
+  }
+  const filePath = resolveFlatInTmuxFilePath(
+    options.inTmuxDataDir,
+    requestPath,
+  );
+  if (filePath === null) {
+    sendNotFound(response);
+    return;
+  }
+  fs.rmSync(filePath, { force: true });
+  response.writeHead(204, {
+    'Cache-Control': 'no-store',
+  });
+  response.end();
+};
+
 const handleTokenedRequest = async (
   options: WebServerOptions,
   request: http.IncomingMessage,
@@ -580,31 +651,20 @@ const handleTokenedRequest = async (
     return;
   }
 
-  if (method === 'GET') {
-    if (requestPath.startsWith(FLAT_IN_TMUX_PREFIX)) {
-      if (options.inTmuxDataDir === null) {
-        sendNotFound(response);
-        return;
-      }
-      const flatFilePath = resolveFlatInTmuxFilePath(
-        options.inTmuxDataDir,
-        requestPath,
-      );
-      const flatContent =
-        flatFilePath === null ? null : readStaticFile(flatFilePath);
-      if (flatContent === null) {
-        sendNotFound(response);
-        return;
-      }
-      response.writeHead(200, {
-        'Content-Type': 'application/json; charset=utf-8',
-        'Cache-Control': 'no-store',
-        'Content-Length': String(flatContent.length),
-      });
-      response.end(flatContent);
+  if (requestPath.startsWith(FLAT_IN_TMUX_PREFIX)) {
+    if (method === 'GET') {
+      serveFlatInTmuxFile(options, response, requestPath);
       return;
     }
+    if (method === 'DELETE' && isOwnerCallFileRequestPath(requestPath)) {
+      removeOwnerCallFile(options, response, requestPath);
+      return;
+    }
+    sendNotFound(response);
+    return;
+  }
 
+  if (method === 'GET') {
     const dataRoute = parseConsoleDataRoute(requestPath);
     if (dataRoute !== null && options.consoleDataOutputDir !== null) {
       const dataResponse = buildConsoleDataResponse(

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.test.ts

@@ -129,6 +129,9 @@ jest.mock('./rotationOrderFileWriter', () => ({
 jest.mock('./inTmuxByHumanDataWriter', () => ({
   writeInTmuxByHumanData: jest.fn(),
 }));
+jest.mock('./ownerCallFileCleaner', () => ({
+  cleanClosedIssueOwnerCallFiles: jest.fn(),
+}));
 jest.mock('./consoleListsWriter', () => {
   const actual = jest.requireActual<typeof import('./consoleListsWriter')>(
     './consoleListsWriter',
@@ -139,6 +142,7 @@ jest.mock('./consoleListsWriter', () => {
 import { HandleScheduledEventUseCaseHandler } from './HandleScheduledEventUseCaseHandler';
 import { writeSituationFile } from './situationFileWriter';
 import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
+import { cleanClosedIssueOwnerCallFiles } from './ownerCallFileCleaner';
 import { writeConsoleLists } from './consoleListsWriter';
 import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
 import { ApiV3IssueRepository } from '../../repositories/issue/ApiV3IssueRepository';
@@ -756,4 +760,35 @@ defaultAgentName: readme-agent
       expect(getInTmuxProjectOrderArg()).toBeNull();
     });
   });
+
+  describe('owner call file cleanup of closed issues', () => {
+    it('should hand the project issues to the cleanup with the configured project code and data directory', async () => {
+      jest.mocked(fs.readFileSync).mockReturnValue(
+        YAML.stringify({
+          ...validConfig,
+          inTmuxDataOutputDir: '/data/in-tmux-by-human',
+        }),
+      );
+      const closedIssue = {
+        url: 'https://github.com/TestOrg/test-repo/issues/9',
+        isClosed: true,
+      };
+      mockRun.mockResolvedValueOnce({
+        project: { id: 'PVT_kwHOtest123' },
+        issues: [closedIssue],
+        cacheUsed: false,
+        targetDateTimes: [],
+        rotationOrder: null,
+      });
+
+      const handler = new HandleScheduledEventUseCaseHandler();
+      await handler.handle('config.yml', false);
+
+      expect(jest.mocked(cleanClosedIssueOwnerCallFiles)).toHaveBeenCalledWith({
+        inTmuxDataOutputDir: '/data/in-tmux-by-human',
+        pjcode: validConfig.projectName,
+        issues: [closedIssue],
+      });
+    });
+  });
 });

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

@@ -11,6 +11,7 @@ import { writeDashboardRow } from './dashboardRowWriter';
 import { writeMachineStatus } from './machineStatusWriter';
 import { writeTokenStatus } from './tokenStatusWriter';
 import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
+import { cleanClosedIssueOwnerCallFiles } from './ownerCallFileCleaner';
 import { reconcileInTmuxByHumanSessions } from './inTmuxByHumanSessionReconciler';
 import { handleTokenExhaustionHandover } from './tokenExhaustionHandover';
 import { cleanStaleTmuxSessions } from './staleTmuxSessionCleaner';
@@ -682,6 +683,20 @@ export class HandleScheduledEventUseCaseHandler {
         );
       }
 
+      try {
+        cleanClosedIssueOwnerCallFiles({
+          inTmuxDataOutputDir: mergedInput.inTmuxDataOutputDir ?? null,
+          pjcode: input.projectName,
+          issues: result.issues,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to clean owner call files of closed issues: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
       try {
         await handleTokenExhaustionHandover({
           enabled: mergedInput.tokenExhaustionHandoverEnabled ?? false,

package/src/adapter/entry-points/handlers/ownerCallFileCleaner.test.ts

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+import { cleanClosedIssueOwnerCallFiles } from './ownerCallFileCleaner';
+import { ownerCallFileAppend, ownerCallFilePath } from './ownerCallFileStore';
+
+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: ['owner-login'],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-08-01T00:00:00.000Z'),
+  author: '',
+  closingIssueReferenceUrls: [],
+  ...overrides,
+});
+
+describe('cleanClosedIssueOwnerCallFiles', () => {
+  let dataDir = '';
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-cleaner-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  const appendCallFor = (issue: Issue): string => {
+    const sessionName = toTmuxSessionName(issue.url);
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'an unanswered call\n',
+      },
+    });
+    return ownerCallFilePath(dataDir, 'umino', sessionName);
+  };
+
+  it('deletes the owner call file of a session whose issue is closed', () => {
+    const closedIssue = makeIssue({
+      url: 'https://github.com/demo/repo/issues/7',
+      state: 'CLOSED',
+      isClosed: true,
+    });
+    const filePath = appendCallFor(closedIssue);
+
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: dataDir,
+      pjcode: 'umino',
+      issues: [closedIssue],
+    });
+
+    expect(fs.existsSync(filePath)).toBe(false);
+  });
+
+  it('keeps the owner call file of a session whose issue is still open', () => {
+    const openIssue = makeIssue();
+    const filePath = appendCallFor(openIssue);
+
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: dataDir,
+      pjcode: 'umino',
+      issues: [openIssue],
+    });
+
+    expect(fs.existsSync(filePath)).toBe(true);
+  });
+
+  it('does nothing when the data directory or the project code is not configured', () => {
+    const closedIssue = makeIssue({ isClosed: true, state: 'CLOSED' });
+    const filePath = appendCallFor(closedIssue);
+
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: null,
+      pjcode: 'umino',
+      issues: [closedIssue],
+    });
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: dataDir,
+      pjcode: null,
+      issues: [closedIssue],
+    });
+
+    expect(fs.existsSync(filePath)).toBe(true);
+  });
+});

package/src/adapter/entry-points/handlers/ownerCallFileCleaner.ts

@@ -0,0 +1,25 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+import { ownerCallFileDelete } from './ownerCallFileStore';
+
+export type CleanClosedIssueOwnerCallFilesParams = {
+  inTmuxDataOutputDir: string | null | undefined;
+  pjcode: string | null | undefined;
+  issues: Issue[];
+};
+
+export const cleanClosedIssueOwnerCallFiles = (
+  params: CleanClosedIssueOwnerCallFilesParams,
+): void => {
+  const { inTmuxDataOutputDir, pjcode, issues } = params;
+  if (!inTmuxDataOutputDir || !pjcode) {
+    return;
+  }
+  for (const issue of issues.filter((candidate) => candidate.isClosed)) {
+    ownerCallFileDelete({
+      dataDir: inTmuxDataOutputDir,
+      projectCode: pjcode,
+      sessionName: toTmuxSessionName(issue.url),
+    });
+  }
+};

package/src/adapter/entry-points/handlers/ownerCallFileStore.test.ts

@@ -0,0 +1,286 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { parseAllDocuments } from 'yaml';
+import {
+  ownerCallFileAppend,
+  ownerCallFileDelete,
+  ownerCallFileDeleteInEveryProject,
+  ownerCallFilePath,
+  ownerCallProjectCodeInInTmuxByHumanData,
+} from './ownerCallFileStore';
+import { ownerCallFileRelativePath } from '../../../domain/usecases/intmux/OwnerCallFile';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+
+const toPlainValue = (document: { toJS: () => unknown }): unknown =>
+  document.toJS();
+
+describe('ownerCallFileStore', () => {
+  let dataDir = '';
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-store-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  const sessionName = 'https_//github_com/OWNER/REPO/issues/1';
+
+  it('creates the file and its project directory on the first append', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the only call\n',
+      },
+    });
+
+    const filePath = path.join(
+      dataDir,
+      ownerCallFileRelativePath('umino', sessionName),
+    );
+    expect(fs.existsSync(filePath)).toBe(true);
+    const documents = parseAllDocuments(fs.readFileSync(filePath, 'utf-8'));
+    expect(documents).toHaveLength(1);
+    expect(documents[0].toJS()).toEqual({
+      sessionName,
+      calledAt: '2026-08-14T04:22:28Z',
+      body: 'the only call\n',
+    });
+  });
+
+  it('appends a second document after the first one, oldest first', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the older call\n',
+      },
+    });
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T05:00:00Z',
+        body: 'the newer call\n',
+      },
+    });
+
+    const documents = parseAllDocuments(
+      fs.readFileSync(
+        ownerCallFilePath(dataDir, 'umino', sessionName),
+        'utf-8',
+      ),
+    );
+    expect(documents.map(toPlainValue)).toEqual([
+      {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the older call\n',
+      },
+      {
+        sessionName,
+        calledAt: '2026-08-14T05:00:00Z',
+        body: 'the newer call\n',
+      },
+    ]);
+  });
+
+  it('writes the file of a session that belongs to no project under NA', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: null,
+      ownerCall: {
+        sessionName: 'secretary',
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'a call from a long running session\n',
+      },
+    });
+
+    expect(
+      fs.existsSync(
+        path.join(dataDir, ownerCallFileRelativePath(null, 'secretary')),
+      ),
+    ).toBe(true);
+  });
+
+  it('removes the file of the named project', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the only call\n',
+      },
+    });
+
+    ownerCallFileDelete({ dataDir, projectCode: 'umino', sessionName });
+
+    expect(
+      fs.existsSync(ownerCallFilePath(dataDir, 'umino', sessionName)),
+    ).toBe(false);
+  });
+
+  it('succeeds when the file to delete is already absent', () => {
+    expect(() =>
+      ownerCallFileDelete({ dataDir, projectCode: 'umino', sessionName }),
+    ).not.toThrow();
+  });
+
+  it('removes the file of a session whose project code the caller does not know', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the only call\n',
+      },
+    });
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'other',
+      ownerCall: {
+        sessionName: 'other_session',
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'a call of another session\n',
+      },
+    });
+
+    ownerCallFileDeleteInEveryProject({ dataDir, sessionName });
+
+    expect(
+      fs.existsSync(ownerCallFilePath(dataDir, 'umino', sessionName)),
+    ).toBe(false);
+    expect(
+      fs.existsSync(ownerCallFilePath(dataDir, 'other', 'other_session')),
+    ).toBe(true);
+  });
+
+  it('succeeds when no owner call directory exists at all', () => {
+    expect(() =>
+      ownerCallFileDeleteInEveryProject({ dataDir, sessionName }),
+    ).not.toThrow();
+  });
+});
+
+describe('ownerCallProjectCodeInInTmuxByHumanData', () => {
+  const issueUrl = 'https://github.com/OWNER/REPO/issues/1';
+  const otherIssueUrl = 'https://github.com/OWNER/REPO/issues/2';
+  let dataDir = '';
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-project-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  const writeProjectData = (projectCode: string, urls: string[]): void => {
+    fs.writeFileSync(
+      path.join(dataDir, `${projectCode}.v4.json`),
+      `${JSON.stringify({
+        version: 4,
+        overviewUrl: 'https://github.com/orgs/OWNER/projects/1',
+        tdpmConsoleUrl: 'http://localhost/projects/code',
+        newIssueUrl: 'https://github.com/OWNER/REPO/issues/new',
+        groups: [
+          {
+            story: 'a story',
+            sessions: urls.map((url) => ({ name: url, description: 'title' })),
+          },
+        ],
+      })}\n`,
+    );
+  };
+
+  it('gives the code of the project whose session list holds the session', () => {
+    writeProjectData('other', [otherIssueUrl]);
+    writeProjectData('umino', [issueUrl]);
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBe('umino');
+  });
+
+  it('gives null when no project lists the session', () => {
+    writeProjectData('umino', [otherIssueUrl]);
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('gives null when the directory holds no in-tmux-by-human data at all', () => {
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('gives null when the directory itself is absent', () => {
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        path.join(dataDir, 'absent'),
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('reads neither the project index nor the older versions of the project data', () => {
+    fs.writeFileSync(
+      path.join(dataDir, 'index.v4.json'),
+      `${JSON.stringify({
+        version: 4,
+        projects: [{ name: 'umino', path: '/in-tmux-by-human/umino.v4.json' }],
+      })}\n`,
+    );
+    fs.writeFileSync(
+      path.join(dataDir, 'umino.v3.json'),
+      `${JSON.stringify({
+        version: 3,
+        groups: [{ story: 'a story', urls: [{ url: issueUrl, title: 't' }] }],
+      })}\n`,
+    );
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('skips a project data file that cannot be read as the expected shape', () => {
+    fs.writeFileSync(path.join(dataDir, 'broken.v4.json'), 'not json at all\n');
+    fs.writeFileSync(
+      path.join(dataDir, 'shapeless.v4.json'),
+      `${JSON.stringify({ version: 4, groups: 'not a list' })}\n`,
+    );
+    writeProjectData('umino', [issueUrl]);
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBe('umino');
+  });
+});