github-issue-tower-defence-management 1.84.1 → 1.86.0

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

@@ -60,6 +60,25 @@ jest.mock('../handlers/HandleScheduledEventUseCaseHandler', () => ({
     handle: jest.fn().mockResolvedValue(null),
   })),
 }));
+import type { StartConsoleServerOptions } from '../console/consoleServer';
+
+const mockStartConsoleServer = jest
+  .fn<Promise<unknown>, [StartConsoleServerOptions]>()
+  .mockResolvedValue({
+    close: jest.fn(),
+    address: jest.fn().mockReturnValue({ port: 9981 }),
+  });
+jest.mock('../console/consoleServer', () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    '../console/consoleServer',
+  );
+  return {
+    ...actual,
+    startConsoleServer: (
+      options: StartConsoleServerOptions,
+    ): Promise<unknown> => mockStartConsoleServer(options),
+  };
+});
 
 describe('CLI', () => {
   const originalEnv = process.env;
@@ -1644,4 +1663,111 @@ mysteryKey: 'value'
       processExitSpy.mockRestore();
     });
   });
+
+  describe('serveConsole', () => {
+    it('should appear in the CLI help output', () => {
+      const helpText = program.helpInformation();
+      expect(helpText).toContain('serveConsole');
+    });
+
+    it('should start the server on the default port 9981 when --port is omitted', async () => {
+      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
+      const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'serveConsole',
+        '--configFilePath',
+        configFilePath,
+      ]);
+
+      expect(mockStartConsoleServer).toHaveBeenCalledTimes(1);
+      const callArg = mockStartConsoleServer.mock.calls[0][0];
+      expect(callArg.port).toBe(9981);
+      expect(callArg.accessToken).toBe('config-token');
+      expect(callArg.consoleDataOutputDir).toBeNull();
+      expect(typeof callArg.uiDistDir).toBe('string');
+
+      logSpy.mockRestore();
+    });
+
+    it('should use the provided --port and --consoleDataOutputDir', async () => {
+      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
+      const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'serveConsole',
+        '--configFilePath',
+        configFilePath,
+        '--port',
+        '12345',
+        '--consoleDataOutputDir',
+        '/tmp/console-data',
+      ]);
+
+      const callArg = mockStartConsoleServer.mock.calls[0][0];
+      expect(callArg.port).toBe(12345);
+      expect(callArg.consoleDataOutputDir).toBe('/tmp/console-data');
+
+      logSpy.mockRestore();
+    });
+
+    it('should exit with error when consoleAccessToken is missing from config', async () => {
+      writeConfig(defaultConfig);
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
+
+      await expect(
+        program.parseAsync([
+          'node',
+          'test',
+          'serveConsole',
+          '--configFilePath',
+          configFilePath,
+        ]),
+      ).rejects.toThrow('process.exit called');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'consoleAccessToken is required. Provide it via the config file.',
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
+    });
+
+    it('should exit with error for an invalid --port value', async () => {
+      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
+
+      await expect(
+        program.parseAsync([
+          'node',
+          'test',
+          'serveConsole',
+          '--configFilePath',
+          configFilePath,
+          '--port',
+          'not-a-number',
+        ]),
+      ).rejects.toThrow('process.exit called');
+
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
+    });
+  });
 });

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

@@ -31,6 +31,11 @@ import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunne
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { FetchWebhookRepository } from '../../repositories/FetchWebhookRepository';
 import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
+import * as path from 'path';
+import {
+  DEFAULT_CONSOLE_PORT,
+  startConsoleServer,
+} from '../console/consoleServer';
 
 type StartDaemonOptions = {
   projectUrl?: string;
@@ -60,6 +65,12 @@ type CheckIssueReviewReadinessOptions = {
   configFilePath: string;
 };
 
+type ServeConsoleOptions = {
+  configFilePath: string;
+  port?: string;
+  consoleDataOutputDir?: string;
+};
+
 const buildGithubRepositoryParams = (
   localStorageRepository: LocalStorageRepository,
   token: string,
@@ -554,6 +565,61 @@ program
     process.stdout.write(`${JSON.stringify(result)}\n`);
   });
 
+program
+  .command('serveConsole')
+  .description('Start the local TDPM Console HTTP server')
+  .requiredOption(
+    '--configFilePath <path>',
+    'Path to config file for tower defence management',
+  )
+  .option(
+    '--port <number>',
+    `Port for the console HTTP server (default: ${DEFAULT_CONSOLE_PORT})`,
+  )
+  .option(
+    '--consoleDataOutputDir <path>',
+    'Directory where console data files are written and served from',
+  )
+  .action(async (options: ServeConsoleOptions) => {
+    const config = loadConfigFile(options.configFilePath);
+
+    const accessToken = config.consoleAccessToken;
+    if (!accessToken) {
+      console.error(
+        'consoleAccessToken is required. Provide it via the config file.',
+      );
+      process.exit(1);
+    }
+
+    let port = DEFAULT_CONSOLE_PORT;
+    if (options.port !== undefined) {
+      const parsedPort = Number(options.port);
+      if (
+        !Number.isFinite(parsedPort) ||
+        !Number.isInteger(parsedPort) ||
+        parsedPort <= 0 ||
+        parsedPort > 65535
+      ) {
+        console.error(
+          'Invalid value for --port. It must be a positive integer between 1 and 65535.',
+        );
+        process.exit(1);
+      }
+      port = parsedPort;
+    }
+
+    const uiDistDir = path.join(__dirname, 'ui-dist');
+    const consoleDataOutputDir = options.consoleDataOutputDir ?? null;
+
+    await startConsoleServer({
+      accessToken,
+      uiDistDir,
+      consoleDataOutputDir,
+      port,
+    });
+    console.log(`TDPM Console server listening on port ${port}`);
+  });
+
 /* istanbul ignore next */
 if (process.argv && require.main === module) {
   program.parse(process.argv);

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

@@ -21,6 +21,7 @@ export type ConfigFile = {
   awLogStaleThresholdMinutes?: number;
   labelsAsLlmAgentName?: string[];
   changeTargetPathAliases?: Record<string, string>;
+  consoleAccessToken?: string;
 };
 
 const getStringValue = (
@@ -145,6 +146,7 @@ export const loadConfigFile = (configFilePath: string): ConfigFile => {
         parsed,
         'changeTargetPathAliases',
       ),
+      consoleAccessToken: getStringValue(parsed, 'consoleAccessToken'),
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -303,6 +305,8 @@ export const mergeConfigs = (
     readmeOverrides.changeTargetPathAliases ??
     cliOverrides.changeTargetPathAliases ??
     configFile.changeTargetPathAliases,
+  consoleAccessToken:
+    cliOverrides.consoleAccessToken ?? configFile.consoleAccessToken,
 });
 
 type GraphqlProjectV2ReadmeResponse = {

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

@@ -0,0 +1,297 @@
+import * as http from 'http';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  DEFAULT_CONSOLE_PORT,
+  CONSOLE_TOKEN_HEADER,
+  hasDotSegment,
+  requiresToken,
+  isTokenValid,
+  extractProvidedToken,
+  startConsoleServer,
+} from './consoleServer';
+
+describe('consoleServer pure helpers', () => {
+  describe('DEFAULT_CONSOLE_PORT', () => {
+    it('is 9981', () => {
+      expect(DEFAULT_CONSOLE_PORT).toBe(9981);
+    });
+  });
+
+  describe('hasDotSegment', () => {
+    it('returns true for a top-level dot segment', () => {
+      expect(hasDotSegment('/.git')).toBe(true);
+      expect(hasDotSegment('/.env')).toBe(true);
+    });
+
+    it('returns true for a nested dot segment', () => {
+      expect(hasDotSegment('/foo/.bar')).toBe(true);
+      expect(hasDotSegment('/a/b/.hidden/c')).toBe(true);
+    });
+
+    it('returns false for paths without dot segments', () => {
+      expect(hasDotSegment('/')).toBe(false);
+      expect(hasDotSegment('/index.html')).toBe(false);
+      expect(hasDotSegment('/assets/app.js')).toBe(false);
+      expect(hasDotSegment('/api/itembody')).toBe(false);
+    });
+  });
+
+  describe('requiresToken', () => {
+    it('requires a token for .json paths', () => {
+      expect(requiresToken('/data/situation.json')).toBe(true);
+    });
+
+    it('requires a token for /api/* paths', () => {
+      expect(requiresToken('/api/review')).toBe(true);
+      expect(requiresToken('/api')).toBe(true);
+    });
+
+    it('does not require a token for bootstrap assets', () => {
+      expect(requiresToken('/')).toBe(false);
+      expect(requiresToken('/index.html')).toBe(false);
+      expect(requiresToken('/assets/app.js')).toBe(false);
+    });
+  });
+
+  describe('isTokenValid', () => {
+    it('accepts a matching token', () => {
+      expect(isTokenValid('expected', 'expected')).toBe(true);
+    });
+
+    it('rejects a missing or mismatched token', () => {
+      expect(isTokenValid('expected', null)).toBe(false);
+      expect(isTokenValid('expected', 'other')).toBe(false);
+      expect(isTokenValid('expected', '')).toBe(false);
+    });
+  });
+
+  describe('extractProvidedToken', () => {
+    it('prefers the query token', () => {
+      expect(extractProvidedToken('fromQuery', 'fromHeader')).toBe('fromQuery');
+    });
+
+    it('falls back to the header token', () => {
+      expect(extractProvidedToken(null, 'fromHeader')).toBe('fromHeader');
+    });
+
+    it('returns null when neither is present', () => {
+      expect(extractProvidedToken(null, undefined)).toBeNull();
+      expect(extractProvidedToken('', undefined)).toBeNull();
+    });
+  });
+});
+
+describe('consoleServer integration', () => {
+  const testToken = 'integration-test-token-value';
+
+  const requestServer = (
+    server: http.Server,
+    requestPath: string,
+    headers: http.OutgoingHttpHeaders = {},
+  ): Promise<{
+    statusCode: number;
+    body: string;
+    cacheControl: string | undefined;
+    contentType: string | undefined;
+  }> => {
+    const address = server.address();
+    if (address === null || typeof address === 'string') {
+      throw new Error('server is not listening on a TCP port');
+    }
+    const port = address.port;
+    return new Promise((resolve, reject) => {
+      const request = http.request(
+        { host: '127.0.0.1', port, path: requestPath, headers },
+        (response) => {
+          const chunks: Uint8Array[] = [];
+          response.on('data', (chunk: Uint8Array) => chunks.push(chunk));
+          response.on('end', () => {
+            resolve({
+              statusCode: response.statusCode ?? 0,
+              body: Buffer.concat(chunks).toString('utf-8'),
+              cacheControl: response.headers['cache-control'],
+              contentType: response.headers['content-type'],
+            });
+          });
+        },
+      );
+      request.on('error', reject);
+      request.end();
+    });
+  };
+
+  const closeServer = (server: http.Server): Promise<void> =>
+    new Promise((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+
+  it('starts on an ephemeral port and closes gracefully', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    const address = server.address();
+    expect(address).not.toBeNull();
+    expect(typeof address).not.toBe('string');
+    await closeServer(server);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('serves the placeholder index without a token when ui-dist is absent', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'missing-ui-dist'),
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    try {
+      const root = await requestServer(server, '/');
+      expect(root.statusCode).toBe(200);
+      expect(root.body).toContain('TDPM Console');
+      expect(root.cacheControl).toBe('no-store');
+      expect(root.contentType).toContain('text/html');
+
+      const indexHtml = await requestServer(server, '/index.html');
+      expect(indexHtml.statusCode).toBe(200);
+      expect(indexHtml.cacheControl).toBe('no-store');
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('returns 404 for a missing non-index file when ui-dist is absent', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'missing-ui-dist'),
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    try {
+      const missing = await requestServer(server, '/assets/app.js');
+      expect(missing.statusCode).toBe(404);
+      expect(missing.cacheControl).toBe('no-store');
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('serves built bootstrap assets without a token', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const uiDistDir = path.join(tmpDir, 'ui-dist');
+    fs.mkdirSync(path.join(uiDistDir, 'assets'), { recursive: true });
+    fs.writeFileSync(
+      path.join(uiDistDir, 'index.html'),
+      '<!DOCTYPE html><title>built</title>',
+    );
+    fs.writeFileSync(
+      path.join(uiDistDir, 'assets', 'app.js'),
+      'console.log("app");',
+    );
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir,
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    try {
+      const index = await requestServer(server, '/');
+      expect(index.statusCode).toBe(200);
+      expect(index.body).toContain('built');
+
+      const appJs = await requestServer(server, '/assets/app.js');
+      expect(appJs.statusCode).toBe(200);
+      expect(appJs.body).toContain('app');
+      expect(appJs.contentType).toContain('text/javascript');
+      expect(appJs.cacheControl).toBe('no-store');
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('rejects dot-prefixed paths with 404', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const uiDistDir = path.join(tmpDir, 'ui-dist');
+    fs.mkdirSync(uiDistDir, { recursive: true });
+    fs.writeFileSync(path.join(uiDistDir, '.env'), 'SECRET=should-not-serve');
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir,
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    try {
+      const dotEnv = await requestServer(server, '/.env');
+      expect(dotEnv.statusCode).toBe(404);
+      expect(dotEnv.body).not.toContain('SECRET');
+
+      const dotGit = await requestServer(server, '/.git/config');
+      expect(dotGit.statusCode).toBe(404);
+
+      const nestedDot = await requestServer(server, '/foo/.bar');
+      expect(nestedDot.statusCode).toBe(404);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('rejects .json and /api/* without a token and passes the gate with a valid token', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    try {
+      const jsonNoToken = await requestServer(server, '/data/situation.json');
+      expect(jsonNoToken.statusCode).toBe(401);
+      expect(jsonNoToken.cacheControl).toBe('no-store');
+
+      const apiNoToken = await requestServer(server, '/api/review');
+      expect(apiNoToken.statusCode).toBe(401);
+
+      const jsonWithQueryToken = await requestServer(
+        server,
+        `/data/situation.json?k=${testToken}`,
+      );
+      expect(jsonWithQueryToken.statusCode).toBe(404);
+
+      const apiWithQueryToken = await requestServer(
+        server,
+        `/api/review?k=${testToken}`,
+      );
+      expect(apiWithQueryToken.statusCode).toBe(404);
+
+      const apiWithHeaderToken = await requestServer(server, '/api/review', {
+        [CONSOLE_TOKEN_HEADER]: testToken,
+      });
+      expect(apiWithHeaderToken.statusCode).toBe(404);
+
+      const apiWithWrongToken = await requestServer(
+        server,
+        '/api/review?k=wrong-token',
+      );
+      expect(apiWithWrongToken.statusCode).toBe(401);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});