github-issue-tower-defence-management 1.148.24 → 1.149.0

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.test.ts

@@ -10,6 +10,9 @@ const createFallback = (): Mocked<SilentSessionMessageComposer> => ({
     .fn()
     .mockReturnValue('FALLBACK_STALE_OWNER_CALL'),
   composeSubAgentSection: jest.fn().mockReturnValue('FALLBACK_SUB'),
+  composeSubAgentUnconsumedResultSection: jest
+    .fn()
+    .mockReturnValue('FALLBACK_UNCONSUMED_RESULT'),
 });
 
 const noTemplates = {
@@ -142,6 +145,7 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
       silentSeconds: 360,
       runningSeconds: 1200,
       waitingOnExternalProcess: false,
+      finishedResultUnconsumed: false,
     };
     expect(
       composer.composeSubAgentSection({
@@ -172,6 +176,7 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
           silentSeconds: 360,
           runningSeconds: 60,
           waitingOnExternalProcess: false,
+          finishedResultUnconsumed: false,
         },
       ],
       longRunningSubAgents: [],
@@ -202,6 +207,7 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
           silentSeconds: 30,
           runningSeconds: 1200,
           waitingOnExternalProcess: false,
+          finishedResultUnconsumed: false,
         },
       ],
     });
@@ -228,6 +234,7 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
       silentSeconds: 360,
       runningSeconds: 1200,
       waitingOnExternalProcess: false,
+      finishedResultUnconsumed: false,
     };
     const section = composer.composeSubAgentSection({
       idleSubAgents: [subAgent],
@@ -257,6 +264,7 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
       silentSeconds: 360,
       runningSeconds: 60,
       waitingOnExternalProcess: false,
+      finishedResultUnconsumed: false,
     };
     const section = composer.composeSubAgentSection({
       idleSubAgents: [idleSubAgent],
@@ -269,6 +277,33 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     });
   });
 
+  it('delegates the unconsumed-result section to the fallback composer because no template governs it', () => {
+    const fallback = createFallback();
+    const composer = new ConfigurableSilentSessionMessageComposer(
+      {
+        ...noTemplates,
+        subAgentIdleMessageHeader: 'CUSTOM_IDLE_HEADER',
+      },
+      fallback,
+    );
+    const unconsumedResultSubAgent = {
+      label: 'agent-aaabbbbcccc30001',
+      silentSeconds: 5220,
+      runningSeconds: 5400,
+      waitingOnExternalProcess: false,
+      finishedResultUnconsumed: true,
+    };
+
+    const section = composer.composeSubAgentUnconsumedResultSection([
+      unconsumedResultSubAgent,
+    ]);
+
+    expect(section).toBe('FALLBACK_UNCONSUMED_RESULT');
+    expect(
+      fallback.composeSubAgentUnconsumedResultSection,
+    ).toHaveBeenCalledWith([unconsumedResultSubAgent]);
+  });
+
   it('does not double-prepend the sentinel when the template already carries it', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.ts

@@ -99,6 +99,13 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
     return withReminderSentinel(sections.join('\n\n'));
   };
 
+  composeSubAgentUnconsumedResultSection = (
+    unconsumedResultSubAgents: SubAgentActivity[],
+  ): string =>
+    this.fallback.composeSubAgentUnconsumedResultSection(
+      unconsumedResultSubAgents,
+    );
+
   private composeIdleSection = (
     idleSubAgents: SubAgentActivity[],
     header: string | null,

package/src/adapter/repositories/FileSystemKevReportWatermarkRepository.test.ts

@@ -0,0 +1,253 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemKevReportWatermarkRepository } from './FileSystemKevReportWatermarkRepository';
+
+describe('FileSystemKevReportWatermarkRepository', () => {
+  let temporaryDirectory: string;
+  let stateFilePath: string;
+  let errorLog: jest.SpyInstance;
+
+  beforeEach(() => {
+    temporaryDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'kev-report-watermark-'),
+    );
+    stateFilePath = path.join(
+      temporaryDirectory,
+      'nested',
+      'kev-report-watermark.json',
+    );
+    errorLog = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    errorLog.mockRestore();
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  const writeStoredContent = (content: string): void => {
+    fs.mkdirSync(path.dirname(stateFilePath), { recursive: true });
+    fs.writeFileSync(stateFilePath, content);
+  };
+
+  const loggedMessages = (): string[] =>
+    errorLog.mock.calls.map((call: unknown[]) => String(call[0]));
+
+  it('reports an absent state file as absent without logging an error', async () => {
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+    expect(await repository.load()).toEqual({ type: 'absent' });
+    expect(loggedMessages()).toEqual([]);
+  });
+
+  it('persists and reloads the watermark', async () => {
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+    await repository.save({
+      lastReportedDateAdded: '2024-01-02',
+      reportedCveIdsOnLastReportedDateAdded: ['CVE-2024-0002'],
+    });
+
+    expect(await repository.load()).toEqual({
+      type: 'stored',
+      watermark: {
+        lastReportedDateAdded: '2024-01-02',
+        reportedCveIdsOnLastReportedDateAdded: ['CVE-2024-0002'],
+      },
+    });
+    expect(loggedMessages()).toEqual([]);
+  });
+
+  it('overwrites a previously saved watermark', async () => {
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+    await repository.save({
+      lastReportedDateAdded: '2024-01-02',
+      reportedCveIdsOnLastReportedDateAdded: ['CVE-2024-0002'],
+    });
+    await repository.save({
+      lastReportedDateAdded: '2024-01-03',
+      reportedCveIdsOnLastReportedDateAdded: ['CVE-2024-0003'],
+    });
+
+    expect(await repository.load()).toEqual({
+      type: 'stored',
+      watermark: {
+        lastReportedDateAdded: '2024-01-03',
+        reportedCveIdsOnLastReportedDateAdded: ['CVE-2024-0003'],
+      },
+    });
+  });
+
+  it('reports invalid JSON as unreadable, logging the state file path and the cause, and leaves the file untouched', async () => {
+    writeStoredContent('not json');
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    const result = await repository.load();
+
+    expect(result.type).toBe('unreadable');
+    expect(result).toHaveProperty('reason');
+    expect(
+      loggedMessages().some(
+        (message) =>
+          message.includes(stateFilePath) &&
+          message.includes('valid JSON') &&
+          message.includes('SyntaxError'),
+      ),
+    ).toBe(true);
+    expect(fs.readFileSync(stateFilePath, 'utf8')).toBe('not json');
+  });
+
+  it('reports stored content that is not a JSON object as unreadable', async () => {
+    writeStoredContent(JSON.stringify(['2024-01-02']));
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    expect((await repository.load()).type).toBe('unreadable');
+    expect(
+      loggedMessages().some(
+        (message) =>
+          message.includes(stateFilePath) && message.includes('JSON object'),
+      ),
+    ).toBe(true);
+  });
+
+  it('reports a non-string stored date as unreadable', async () => {
+    writeStoredContent(
+      JSON.stringify({
+        lastReportedDateAdded: 20240102,
+        reportedCveIdsOnLastReportedDateAdded: [],
+      }),
+    );
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    expect((await repository.load()).type).toBe('unreadable');
+    expect(
+      loggedMessages().some(
+        (message) =>
+          message.includes(stateFilePath) &&
+          message.includes('lastReportedDateAdded'),
+      ),
+    ).toBe(true);
+  });
+
+  it('reports an empty stored date as unreadable rather than as a usable boundary', async () => {
+    writeStoredContent(
+      JSON.stringify({
+        lastReportedDateAdded: '',
+        reportedCveIdsOnLastReportedDateAdded: [],
+      }),
+    );
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    expect((await repository.load()).type).toBe('unreadable');
+    expect(
+      loggedMessages().some(
+        (message) =>
+          message.includes(stateFilePath) &&
+          message.includes('calendar date') &&
+          message.includes('YYYY-MM-DD'),
+      ),
+    ).toBe(true);
+  });
+
+  it('reports a stored date that is not a real calendar date as unreadable', async () => {
+    writeStoredContent(
+      JSON.stringify({
+        lastReportedDateAdded: '2024-02-31',
+        reportedCveIdsOnLastReportedDateAdded: [],
+      }),
+    );
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    expect((await repository.load()).type).toBe('unreadable');
+    expect(
+      loggedMessages().some((message) => message.includes('calendar date')),
+    ).toBe(true);
+  });
+
+  it('reports a stored identifier list that is not an array as unreadable', async () => {
+    writeStoredContent(
+      JSON.stringify({
+        lastReportedDateAdded: '2024-01-02',
+        reportedCveIdsOnLastReportedDateAdded: 'CVE-2024-0002',
+      }),
+    );
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    expect((await repository.load()).type).toBe('unreadable');
+    expect(
+      loggedMessages().some((message) =>
+        message.includes('reportedCveIdsOnLastReportedDateAdded'),
+      ),
+    ).toBe(true);
+  });
+
+  it('reports stored identifiers that are not all strings as unreadable', async () => {
+    writeStoredContent(
+      JSON.stringify({
+        lastReportedDateAdded: '2024-01-02',
+        reportedCveIdsOnLastReportedDateAdded: ['CVE-2024-0002', 7],
+      }),
+    );
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    expect((await repository.load()).type).toBe('unreadable');
+    expect(
+      loggedMessages().some((message) => message.includes('non-string')),
+    ).toBe(true);
+  });
+
+  it('reports a path that cannot be read as unreadable rather than as absent', async () => {
+    fs.mkdirSync(stateFilePath, { recursive: true });
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    expect((await repository.load()).type).toBe('unreadable');
+    expect(
+      loggedMessages().some(
+        (message) =>
+          message.includes(stateFilePath) &&
+          message.includes('could not be read'),
+      ),
+    ).toBe(true);
+  });
+
+  it('logs the state file path and the cause when the watermark cannot be written', async () => {
+    fs.writeFileSync(path.dirname(stateFilePath), 'not a directory');
+    const repository = new FileSystemKevReportWatermarkRepository(
+      stateFilePath,
+    );
+
+    await expect(
+      repository.save({
+        lastReportedDateAdded: '2024-01-02',
+        reportedCveIdsOnLastReportedDateAdded: ['CVE-2024-0002'],
+      }),
+    ).rejects.toThrow();
+    expect(
+      loggedMessages().some(
+        (message) =>
+          message.includes(stateFilePath) &&
+          message.includes('Unable to write the KEV report watermark'),
+      ),
+    ).toBe(true);
+  });
+});

package/src/adapter/repositories/FileSystemKevReportWatermarkRepository.ts

@@ -0,0 +1,130 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { KevReportWatermark } from '../../domain/entities/KevReportWatermark';
+import {
+  KevReportWatermarkLoadResult,
+  KevReportWatermarkRepository,
+} from '../../domain/usecases/adapter-interfaces/KevReportWatermarkRepository';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const errorCode = (error: unknown): string | null => {
+  if (!isRecord(error)) {
+    return null;
+  }
+  const code = error.code;
+  return typeof code === 'string' ? code : null;
+};
+
+const isCalendarYmd = (value: string): boolean => {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    return false;
+  }
+  const parsed = new Date(`${value}T00:00:00.000Z`);
+  return (
+    !Number.isNaN(parsed.getTime()) &&
+    parsed.toISOString().slice(0, 10) === value
+  );
+};
+
+const defaultStateFilePath = (): string => {
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+  return path.join(base, 'tdpm', 'kev-report-watermark.json');
+};
+
+export class FileSystemKevReportWatermarkRepository implements KevReportWatermarkRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+  ) {}
+
+  load = async (): Promise<KevReportWatermarkLoadResult> => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(this.stateFilePath, 'utf8');
+    } catch (error) {
+      if (errorCode(error) === 'ENOENT') {
+        return { type: 'absent' };
+      }
+      return this.unreadable(
+        `the stored watermark file could not be read (${String(error)})`,
+      );
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      return this.unreadable(
+        `the stored watermark file does not contain valid JSON (${String(error)})`,
+      );
+    }
+
+    if (!isRecord(parsed)) {
+      return this.unreadable(
+        'the stored watermark file does not contain a JSON object',
+      );
+    }
+
+    const lastReportedDateAdded = parsed.lastReportedDateAdded;
+    if (typeof lastReportedDateAdded !== 'string') {
+      return this.unreadable(
+        `the stored lastReportedDateAdded is not a string (${JSON.stringify(lastReportedDateAdded)})`,
+      );
+    }
+    if (!isCalendarYmd(lastReportedDateAdded)) {
+      return this.unreadable(
+        `the stored lastReportedDateAdded is not a calendar date in YYYY-MM-DD form (${JSON.stringify(lastReportedDateAdded)})`,
+      );
+    }
+
+    const reportedCveIdsOnLastReportedDateAdded =
+      parsed.reportedCveIdsOnLastReportedDateAdded;
+    if (!Array.isArray(reportedCveIdsOnLastReportedDateAdded)) {
+      return this.unreadable(
+        'the stored reportedCveIdsOnLastReportedDateAdded is not an array',
+      );
+    }
+    if (
+      !reportedCveIdsOnLastReportedDateAdded.every(
+        (cveId) => typeof cveId === 'string',
+      )
+    ) {
+      return this.unreadable(
+        'the stored reportedCveIdsOnLastReportedDateAdded contains a non-string entry',
+      );
+    }
+
+    return {
+      type: 'stored',
+      watermark: {
+        lastReportedDateAdded,
+        reportedCveIdsOnLastReportedDateAdded:
+          reportedCveIdsOnLastReportedDateAdded,
+      },
+    };
+  };
+
+  save = async (watermark: KevReportWatermark): Promise<void> => {
+    try {
+      const directory = path.dirname(this.stateFilePath);
+      fs.mkdirSync(directory, { recursive: true });
+      const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
+      fs.writeFileSync(temporaryPath, JSON.stringify(watermark));
+      fs.renameSync(temporaryPath, this.stateFilePath);
+    } catch (error) {
+      console.error(
+        `Unable to write the KEV report watermark to ${this.stateFilePath}: ${String(error)}`,
+      );
+      throw error;
+    }
+  };
+
+  private unreadable = (reason: string): KevReportWatermarkLoadResult => {
+    console.error(
+      `Unable to use the KEV report watermark stored at ${this.stateFilePath}: ${reason}. The file is left untouched for inspection.`,
+    );
+    return { type: 'unreadable', reason };
+  };
+}

package/src/adapter/repositories/ProcessListSessionSubAgentActivityRepository.test.ts

@@ -59,6 +59,7 @@ describe('ProcessListSessionSubAgentActivityRepository', () => {
         silentSeconds: 180,
         runningSeconds: 1200,
         waitingOnExternalProcess: false,
+        finishedResultUnconsumed: false,
       },
     ]);
   });
@@ -88,6 +89,7 @@ describe('ProcessListSessionSubAgentActivityRepository', () => {
         silentSeconds: 0,
         runningSeconds: 30,
         waitingOnExternalProcess: false,
+        finishedResultUnconsumed: false,
       },
     ]);
   });

package/src/adapter/repositories/ProcessListSessionSubAgentActivityRepository.ts

@@ -44,6 +44,7 @@ export class ProcessListSessionSubAgentActivityRepository implements SessionSubA
         silentSeconds: this.silentSecondsResolver.resolveSilentSeconds(label),
         runningSeconds: process.elapsedSeconds,
         waitingOnExternalProcess: false,
+        finishedResultUnconsumed: false,
       };
       const existing = result.get(sessionName);
       if (existing === undefined) {

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.test.ts

@@ -940,6 +940,9 @@ describe('TranscriptOwnerCallStatusProvider wired into NotifySilentLiveSessionsU
           .fn()
           .mockReturnValue('MAIN_STALLED_STALE'),
         composeSubAgentSection: jest.fn().mockReturnValue('SUBAGENT'),
+        composeSubAgentUnconsumedResultSection: jest
+          .fn()
+          .mockReturnValue('SUBAGENT_UNCONSUMED'),
       },
       { sleep: jest.fn().mockResolvedValue(undefined) },
     );