github-issue-tower-defence-management 1.87.0 → 1.88.1

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

@@ -1,6 +1,27 @@
 import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { Project } from '../../../domain/entities/Project';
+import {
+  buildConsoleDataResponse,
+  parseConsoleDataRoute,
+} from './consoleDataDelivery';
+import {
+  IssueTitleStateCache,
+  handleComments,
+  handleIssueTitle,
+  handleItemBody,
+  handlePrCommits,
+  handlePrFiles,
+  handleRelatedPrs,
+} from './consoleReadApi';
+import {
+  ConsoleOperationContext,
+  handleIntmux,
+  handleReview,
+  handleTriage,
+} from './consoleOperationApi';
 
 export const DEFAULT_CONSOLE_PORT = 9981;
 
@@ -108,6 +129,10 @@ export type ConsoleServerOptions = {
   accessToken: string;
   uiDistDir: string;
   consoleDataOutputDir: string | null;
+  pjcode?: string | null;
+  issueRepository?: IssueRepository | null;
+  project?: Project | null;
+  issueTitleStateCache?: IssueTitleStateCache | null;
 };
 
 const sendNotFound = (response: http.ServerResponse): void => {
@@ -134,11 +159,189 @@ const serveBootstrapIndex = (response: http.ServerResponse): void => {
   response.end(PLACEHOLDER_INDEX_HTML);
 };
 
-export const handleConsoleRequest = (
+const sendJson = (
+  response: http.ServerResponse,
+  statusCode: number,
+  body: unknown,
+): void => {
+  response.writeHead(statusCode, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+  });
+  response.end(JSON.stringify(body));
+};
+
+const sendDataResponse = (
+  response: http.ServerResponse,
+  statusCode: number,
+  contentType: string,
+  body: string,
+): void => {
+  response.writeHead(statusCode, {
+    'Content-Type': contentType,
+    'Cache-Control': 'no-store',
+  });
+  response.end(body);
+};
+
+const readRequestBody = (request: http.IncomingMessage): Promise<string> =>
+  new Promise((resolve, reject) => {
+    const chunks: Uint8Array[] = [];
+    request.on('data', (chunk: Uint8Array) => chunks.push(chunk));
+    request.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    request.on('error', reject);
+  });
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const parseRequestBody = (raw: string): Record<string, unknown> | null => {
+  if (raw.length === 0) {
+    return {};
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed)) {
+    return null;
+  }
+  return parsed;
+};
+
+const handleReadApi = async (
+  options: ConsoleServerOptions,
+  requestPath: string,
+  searchParams: URLSearchParams,
+): Promise<{ statusCode: number; body: unknown } | null> => {
+  const issueRepository = options.issueRepository ?? null;
+  if (issueRepository === null) {
+    return null;
+  }
+  const cache = options.issueTitleStateCache ?? null;
+  const url = searchParams.get('url');
+  switch (requestPath) {
+    case '/api/itembody':
+      return handleItemBody(issueRepository, url);
+    case '/api/comments':
+      return handleComments(issueRepository, url);
+    case '/api/prfiles':
+      return handlePrFiles(issueRepository, url);
+    case '/api/prcommits':
+      return handlePrCommits(issueRepository, url);
+    case '/api/relatedprs':
+      return handleRelatedPrs(issueRepository, url);
+    case '/api/issuetitle':
+      if (cache === null) {
+        return null;
+      }
+      return handleIssueTitle(issueRepository, cache, url);
+    default:
+      return null;
+  }
+};
+
+const handleOperationApi = async (
+  options: ConsoleServerOptions,
+  requestPath: string,
+  body: Record<string, unknown>,
+): Promise<{ statusCode: number; body: unknown } | null> => {
+  const issueRepository = options.issueRepository ?? null;
+  const project = options.project ?? null;
+  if (issueRepository === null || project === null) {
+    return null;
+  }
+  const context: ConsoleOperationContext = {
+    issueRepository,
+    project,
+    consoleDataOutputDir: options.consoleDataOutputDir,
+    pjcode: options.pjcode ?? null,
+  };
+  switch (requestPath) {
+    case '/api/review':
+      return handleReview(context, body);
+    case '/api/triage':
+      return handleTriage(context, body);
+    case '/api/intmux':
+      return handleIntmux(context, body);
+    default:
+      return null;
+  }
+};
+
+const handleTokenedRequest = async (
   options: ConsoleServerOptions,
   request: http.IncomingMessage,
   response: http.ServerResponse,
-): void => {
+  requestPath: string,
+  searchParams: URLSearchParams,
+): Promise<void> => {
+  const method = (request.method ?? 'GET').toUpperCase();
+
+  if (requestPath.startsWith('/api/')) {
+    if (method === 'GET') {
+      const readResult = await handleReadApi(
+        options,
+        requestPath,
+        searchParams,
+      );
+      if (readResult === null) {
+        sendNotFound(response);
+        return;
+      }
+      sendJson(response, readResult.statusCode, readResult.body);
+      return;
+    }
+    if (method === 'POST') {
+      const raw = await readRequestBody(request);
+      const parsedBody = parseRequestBody(raw);
+      if (parsedBody === null) {
+        sendJson(response, 400, { error: 'invalid JSON body' });
+        return;
+      }
+      const operationResult = await handleOperationApi(
+        options,
+        requestPath,
+        parsedBody,
+      );
+      if (operationResult === null) {
+        sendNotFound(response);
+        return;
+      }
+      sendJson(response, operationResult.statusCode, operationResult.body);
+      return;
+    }
+    sendNotFound(response);
+    return;
+  }
+
+  if (method === 'GET') {
+    const dataRoute = parseConsoleDataRoute(requestPath);
+    if (dataRoute !== null && options.consoleDataOutputDir !== null) {
+      const dataResponse = buildConsoleDataResponse(
+        options.consoleDataOutputDir,
+        dataRoute,
+      );
+      sendDataResponse(
+        response,
+        dataResponse.statusCode,
+        dataResponse.contentType,
+        dataResponse.body,
+      );
+      return;
+    }
+  }
+
+  sendNotFound(response);
+};
+
+export const handleConsoleRequest = async (
+  options: ConsoleServerOptions,
+  request: http.IncomingMessage,
+  response: http.ServerResponse,
+): Promise<void> => {
   const requestUrl = new URL(request.url ?? '/', 'http://localhost');
   const requestPath = requestUrl.pathname;
 
@@ -156,7 +359,13 @@ export const handleConsoleRequest = (
       sendUnauthorized(response);
       return;
     }
-    sendNotFound(response);
+    await handleTokenedRequest(
+      options,
+      request,
+      response,
+      requestPath,
+      requestUrl.searchParams,
+    );
     return;
   }
 
@@ -196,11 +405,26 @@ export const handleConsoleRequest = (
   response.end(staticContent);
 };
 
+const sendInternalServerError = (response: http.ServerResponse): void => {
+  if (response.headersSent) {
+    response.end();
+    return;
+  }
+  response.writeHead(500, {
+    'Content-Type': 'text/plain; charset=utf-8',
+    'Cache-Control': 'no-store',
+  });
+  response.end('Internal Server Error');
+};
+
 export const createConsoleServer = (
   options: ConsoleServerOptions,
 ): http.Server =>
   http.createServer((request, response) => {
-    handleConsoleRequest(options, request, response);
+    handleConsoleRequest(options, request, response).catch((error) => {
+      console.error('console request failed', error);
+      sendInternalServerError(response);
+    });
   });
 
 export type StartConsoleServerOptions = ConsoleServerOptions & {

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

@@ -3,6 +3,7 @@ import TYPIA from 'typia';
 import fs from 'fs';
 import { writeSituationFile } from './situationFileWriter';
 import { writeConsoleLists } from './consoleListsWriter';
+import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
 import { writeRotationOrderFile } from './rotationOrderFileWriter';
 import {
   fetchProjectReadme,
@@ -68,6 +69,10 @@ export class HandleScheduledEventUseCaseHandler {
     type inputType = Parameters<HandleScheduledEventUseCase['run']>[0] & {
       claudeCodeOauthTokenListJsonPath?: string;
       consoleDataOutputDir?: string;
+      inTmuxDataOutputDir?: string;
+      inTmuxConsoleBaseUrl?: string;
+      inTmuxConsoleToken?: string;
+      inTmuxProjectOrder?: string[];
       credentials: {
         manager: {
           github: {
@@ -383,6 +388,27 @@ export class HandleScheduledEventUseCaseHandler {
           }`,
         );
       }
+
+      try {
+        writeInTmuxByHumanData({
+          inTmuxDataOutputDir: mergedInput.inTmuxDataOutputDir ?? null,
+          inTmuxConsoleBaseUrl: mergedInput.inTmuxConsoleBaseUrl ?? null,
+          inTmuxConsoleToken: mergedInput.inTmuxConsoleToken ?? null,
+          inTmuxProjectOrder: mergedInput.inTmuxProjectOrder ?? null,
+          pjcode: input.projectName,
+          assigneeLogin: input.manager,
+          org: input.org,
+          repo: input.workingReport.repo,
+          project: result.project,
+          issues: result.issues,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to write in-tmux-by-human data: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
     }
     return result;
   };

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

@@ -0,0 +1,266 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { FieldOption, Project } from '../../../domain/entities/Project';
+import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
+
+const ASSIGNEE = 'owner-login';
+const CONSOLE_BASE_URL = 'https://console.example.test';
+const CONSOLE_TOKEN = 'test-token-value';
+
+const option = (
+  id: string,
+  name: string,
+  color: FieldOption['color'],
+): FieldOption => ({ id, name, color, description: '' });
+
+const project: Project = {
+  id: 'project-node-id',
+  url: 'https://github.com/orgs/demo/projects/1',
+  databaseId: 1,
+  name: 'demo',
+  status: {
+    name: 'Status',
+    fieldId: 'status-field',
+    statuses: [option('st-tmux', 'In Tmux by human', 'RED')],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: {
+    name: 'story',
+    fieldId: 'story-field',
+    databaseId: 2,
+    stories: [option('s1', 'Story Alpha', 'BLUE')],
+    workflowManagementStory: { id: 'wm', name: 'workflow management' },
+  },
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+};
+
+const makeIssue = (overrides: Partial<Issue>): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: 'In Tmux by human',
+  story: 'Story Alpha',
+  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: 'should never be written',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-06-13T08:18:45.000Z'),
+  author: 'someone',
+  ...overrides,
+});
+
+const baseParams = (outDir: string) => ({
+  inTmuxDataOutputDir: outDir,
+  inTmuxConsoleBaseUrl: CONSOLE_BASE_URL,
+  inTmuxConsoleToken: CONSOLE_TOKEN,
+  inTmuxProjectOrder: ['demo'],
+  pjcode: 'demo',
+  assigneeLogin: ASSIGNEE,
+  org: 'demo-org',
+  repo: 'demo-repo',
+  project,
+  issues: [makeIssue({})],
+});
+
+const readJson = (filePath: string): unknown =>
+  JSON.parse(fs.readFileSync(filePath, 'utf8'));
+
+describe('writeInTmuxByHumanData', () => {
+  let outDir: string;
+
+  beforeEach(() => {
+    outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'intmux-out-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(outDir, { recursive: true, force: true });
+  });
+
+  const file = (name: string): string => path.join(outDir, name);
+
+  it('writes the four per-project files and the four index files', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    for (const name of [
+      'demo.json',
+      'demo.v2.json',
+      'demo.v3.json',
+      'demo.v4.json',
+      'index.json',
+      'index.v2.json',
+      'index.v3.json',
+      'index.v4.json',
+    ]) {
+      expect(fs.existsSync(file(name))).toBe(true);
+    }
+  });
+
+  it('writes pretty-printed JSON ending with a trailing newline', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    const raw = fs.readFileSync(file('demo.json'), 'utf8');
+    expect(raw.endsWith('\n')).toBe(true);
+    expect(raw).toContain('\n  ');
+  });
+
+  it('writes the v1 shape with a flat url string array', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.json'))).toEqual([
+      {
+        story: 'Story Alpha',
+        urls: ['https://github.com/demo/repo/issues/1'],
+      },
+    ]);
+  });
+
+  it('writes the v2 shape with url and title objects', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v2.json'))).toEqual([
+      {
+        story: 'Story Alpha',
+        urls: [
+          { url: 'https://github.com/demo/repo/issues/1', title: 'Issue 1' },
+        ],
+      },
+    ]);
+  });
+
+  it('writes the v3 document with overviewUrl and a token-free console url', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v3.json'))).toEqual({
+      version: 3,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl: 'https://console.example.test/projects/demo/prs',
+      groups: [
+        {
+          story: 'Story Alpha',
+          urls: [
+            { url: 'https://github.com/demo/repo/issues/1', title: 'Issue 1' },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('writes the v4 document with the token-bearing console url and derived new issue url', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v4.json'))).toEqual({
+      version: 4,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl:
+        'https://console.example.test/projects/demo/prs?k=test-token-value',
+      newIssueUrl:
+        'https://github.com/demo-org/demo-repo/issues/new?assignees=owner-login',
+      groups: [
+        {
+          story: 'Story Alpha',
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              description: 'Issue 1',
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('writes index files listing configured projects whose per-project file exists', () => {
+    fs.writeFileSync(file('xmile.json'), '[]\n');
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxProjectOrder: ['demo', 'xmile', 'xcare'],
+    });
+    expect(readJson(file('index.json'))).toEqual({
+      projects: ['demo', 'xmile'],
+    });
+    expect(readJson(file('index.v2.json'))).toEqual({
+      version: 2,
+      projects: ['demo', 'xmile'],
+    });
+    expect(readJson(file('index.v3.json'))).toEqual({
+      version: 3,
+      projects: ['demo', 'xmile'],
+    });
+  });
+
+  it('builds the v4 index path from the output dir basename and the token', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    const basename = path.basename(outDir);
+    expect(readJson(file('index.v4.json'))).toEqual({
+      version: 4,
+      projects: [
+        { name: 'demo', path: `/${basename}/demo.v4.json?k=test-token-value` },
+      ],
+    });
+  });
+
+  it('skips the v4 file and the v4 index when the token is unset but still writes v1, v2, v3 and v1-v3 index', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxConsoleToken: undefined,
+    });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v2.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v3.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v4.json'))).toBe(false);
+    expect(fs.existsSync(file('index.json'))).toBe(true);
+    expect(fs.existsSync(file('index.v3.json'))).toBe(true);
+    expect(fs.existsSync(file('index.v4.json'))).toBe(false);
+  });
+
+  it('skips the v3 and v4 files when the console base url is unset', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxConsoleBaseUrl: undefined,
+    });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v2.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v3.json'))).toBe(false);
+    expect(fs.existsSync(file('demo.v4.json'))).toBe(false);
+  });
+
+  it('skips the index files when the project order is empty', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), inTmuxProjectOrder: [] });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('index.json'))).toBe(false);
+  });
+
+  it('does not leave a temp file behind after writing', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(fs.existsSync(`${file('demo.json')}.tmp`)).toBe(false);
+  });
+
+  it('is a no-op when the output dir is unset', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxDataOutputDir: undefined,
+    });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+
+  it('is a no-op when pjcode is unset', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), pjcode: '' });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+
+  it('is a no-op when the assignee login is unset', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), assigneeLogin: null });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+import type { Issue } from '../../../domain/entities/Issue';
+import type { Project } from '../../../domain/entities/Project';
+import {
+  GenerateInTmuxByHumanDataUseCase,
+  InTmuxByHumanData,
+} from '../../../domain/usecases/intmux/GenerateInTmuxByHumanDataUseCase';
+
+export type InTmuxByHumanDataWriterParams = {
+  inTmuxDataOutputDir: string | null | undefined;
+  inTmuxConsoleBaseUrl: string | null | undefined;
+  inTmuxConsoleToken: string | null | undefined;
+  inTmuxProjectOrder: string[] | null | undefined;
+  pjcode: string | null | undefined;
+  assigneeLogin: string | null | undefined;
+  org: string;
+  repo: string;
+  project: Project;
+  issues: Issue[];
+};
+
+const writeJsonAtomic = (filePath: string, data: unknown): void => {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, `${JSON.stringify(data, null, 2)}\n`);
+  fs.renameSync(tmpPath, filePath);
+};
+
+export const writeInTmuxByHumanData = (
+  params: InTmuxByHumanDataWriterParams,
+): void => {
+  const {
+    inTmuxDataOutputDir,
+    inTmuxConsoleBaseUrl,
+    inTmuxConsoleToken,
+    inTmuxProjectOrder,
+    pjcode,
+    assigneeLogin,
+    org,
+    repo,
+    project,
+    issues,
+  } = params;
+  if (!inTmuxDataOutputDir || !pjcode || !assigneeLogin) {
+    return;
+  }
+
+  const data: InTmuxByHumanData = new GenerateInTmuxByHumanDataUseCase().run({
+    project,
+    issues,
+    pjcode,
+    assigneeLogin,
+    org,
+    repo,
+    consoleBaseUrl: inTmuxConsoleBaseUrl ?? null,
+    consoleToken: inTmuxConsoleToken ?? null,
+  });
+
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, `${pjcode}.json`), data.v1);
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, `${pjcode}.v2.json`), data.v2);
+  if (data.v3) {
+    writeJsonAtomic(
+      path.join(inTmuxDataOutputDir, `${pjcode}.v3.json`),
+      data.v3,
+    );
+  }
+  if (data.v4) {
+    writeJsonAtomic(
+      path.join(inTmuxDataOutputDir, `${pjcode}.v4.json`),
+      data.v4,
+    );
+  }
+
+  if (!inTmuxProjectOrder || inTmuxProjectOrder.length === 0) {
+    return;
+  }
+  const presentProjects = inTmuxProjectOrder.filter((name) =>
+    fs.existsSync(path.join(inTmuxDataOutputDir, `${name}.json`)),
+  );
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.json'), {
+    projects: presentProjects,
+  });
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v2.json'), {
+    version: 2,
+    projects: presentProjects,
+  });
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v3.json'), {
+    version: 3,
+    projects: presentProjects,
+  });
+  if (inTmuxConsoleToken) {
+    const outputDirBasename = path.basename(inTmuxDataOutputDir);
+    writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v4.json'), {
+      version: 4,
+      projects: presentProjects.map((name) => ({
+        name,
+        path: `/${outputDirBasename}/${name}.v4.json?k=${inTmuxConsoleToken}`,
+      })),
+    });
+  }
+};