github-issue-tower-defence-management 1.148.23 → 1.148.25

package/src/adapter/ci/workflowRunCancellation.test.ts

@@ -0,0 +1,86 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { parse } from 'yaml';
+
+const repositoryRoot = path.resolve(__dirname, '..', '..', '..');
+const workflowDirectory = path.join(repositoryRoot, '.github', 'workflows');
+const defaultBranchRef = 'refs/heads/main';
+const nonDefaultBranchOnlyCancellation = `\${{ github.ref != '${defaultBranchRef}' }}`;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const readWorkflowSource = (fileName: string): string =>
+  fs.readFileSync(path.join(workflowDirectory, fileName), 'utf8');
+
+const readWorkflowConcurrency = (fileName: string): Record<string, unknown> => {
+  const workflow: unknown = parse(readWorkflowSource(fileName));
+  if (!isRecord(workflow)) {
+    throw new Error(`${fileName} does not parse to a workflow mapping`);
+  }
+  const concurrency = workflow['concurrency'];
+  if (concurrency === undefined) {
+    return {};
+  }
+  if (!isRecord(concurrency)) {
+    throw new Error(
+      `${fileName} declares a concurrency value that is not a mapping`,
+    );
+  }
+  return concurrency;
+};
+
+const workflowFileNames = (): string[] =>
+  fs
+    .readdirSync(workflowDirectory)
+    .filter((name) => name.endsWith('.yml') || name.endsWith('.yaml'))
+    .sort();
+
+const pushesCommitsToTheRepository = (fileName: string): boolean => {
+  const source = readWorkflowSource(fileName);
+  return (
+    source.includes('git-auto-commit-action') || source.includes('git push')
+  );
+};
+
+const guardedWorkflows = [
+  { fileName: 'test.yml', concurrencyGroup: `test-\${{ github.ref }}` },
+  {
+    fileName: 'console-ui.yml',
+    concurrencyGroup: `console-ui-\${{ github.ref }}`,
+  },
+];
+
+describe('push-triggered workflow run cancellation', () => {
+  it.each(guardedWorkflows)(
+    'keys the concurrency group of $fileName on the workflow and the pushed ref',
+    ({ fileName, concurrencyGroup }) => {
+      expect(readWorkflowConcurrency(fileName)['group']).toBe(concurrencyGroup);
+    },
+  );
+
+  it('gives every guarded workflow its own concurrency group so unrelated runs never cancel each other', () => {
+    const groups = guardedWorkflows.map(
+      ({ fileName }) => readWorkflowConcurrency(fileName)['group'],
+    );
+    expect(new Set(groups).size).toBe(groups.length);
+  });
+
+  it.each(guardedWorkflows)(
+    'cancels a superseded run of $fileName only when the pushed ref is not the default branch',
+    ({ fileName }) => {
+      expect(readWorkflowConcurrency(fileName)['cancel-in-progress']).toBe(
+        nonDefaultBranchOnlyCancellation,
+      );
+    },
+  );
+
+  it.each(workflowFileNames().filter(pushesCommitsToTheRepository))(
+    'never cancels a run of %s, which pushes commits to the repository',
+    (fileName) => {
+      expect([undefined, false]).toContain(
+        readWorkflowConcurrency(fileName)['cancel-in-progress'],
+      );
+    },
+  );
+});

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

@@ -96,6 +96,7 @@ jest.mock('../console/ensureConsoleRunning', () => ({
   ensureConsoleRunning: jest.fn().mockResolvedValue(null),
 }));
 import * as ensureConsoleRunningModule from '../console/ensureConsoleRunning';
+import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
 
 import type { StartWebServerOptions } from '../console/webServer';
 
@@ -1952,7 +1953,12 @@ mysteryKey: 'value'
 
     it('should exit with error when --dashboardProjectNames is omitted', async () => {
       writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const logSpy = jest.spyOn(console, 'log').mockImplementation();
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
 
       await expect(
         program.parseAsync([
@@ -1962,17 +1968,26 @@ mysteryKey: 'value'
           '--configFilePath',
           configFilePath,
         ]),
-      ).rejects.toThrow(
+      ).rejects.toThrow('process.exit called');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
         '--dashboardProjectNames must list at least one project name',
       );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
       expect(mockStartWebServer).not.toHaveBeenCalled();
 
-      logSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
     });
 
     it('should exit with error when two --dashboardProjectNames share a display label', async () => {
       writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const logSpy = jest.spyOn(console, 'log').mockImplementation();
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
 
       await expect(
         program.parseAsync([
@@ -1984,12 +1999,42 @@ mysteryKey: 'value'
           '--dashboardProjectNames',
           'acme,acmelabs',
         ]),
-      ).rejects.toThrow(
+      ).rejects.toThrow('process.exit called');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
         'Dashboard project names acme and acmelabs share the display label ac',
       );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
       expect(mockStartWebServer).not.toHaveBeenCalled();
 
-      logSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
+    });
+
+    it('should validate --dashboardProjectNames before constructing the GitHub repositories', async () => {
+      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
+      jest.mocked(GraphqlProjectRepository).mockClear();
+      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',
+          'serveWeb',
+          '--configFilePath',
+          configFilePath,
+        ]),
+      ).rejects.toThrow('process.exit called');
+
+      expect(jest.mocked(GraphqlProjectRepository)).not.toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
     });
 
     it('should use the provided --port and --consoleDataOutputDir', async () => {

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

@@ -115,11 +115,17 @@ const parseDashboardProjectNames = (raw: string | undefined): string[] => {
     .map((name) => name.trim())
     .filter((name) => name.length > 0);
   if (names.length === 0) {
-    throw new Error(
+    console.error(
       '--dashboardProjectNames must list at least one project name',
     );
+    return process.exit(1);
+  }
+  try {
+    assertDashboardDisplayLabelsUnique(names);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return process.exit(1);
   }
-  assertDashboardDisplayLabelsUnique(names);
   return names;
 };
 
@@ -739,6 +745,10 @@ const runServeWeb = async (options: ServeWebOptions): Promise<void> => {
     process.exit(1);
   }
 
+  const dashboardProjectNames = parseDashboardProjectNames(
+    options.dashboardProjectNames,
+  );
+
   const projectName = config.projectName ?? 'default';
   const localStorageRepository = new LocalStorageRepository();
   const cachePath = `./tmp/cache/${projectName}`;
@@ -855,9 +865,6 @@ const runServeWeb = async (options: ServeWebOptions): Promise<void> => {
   const dashboardDir = options.dashboardDir ?? DEFAULT_DASHBOARD_DIR;
   const dashboardDataDir =
     options.dashboardDataDir ?? DEFAULT_DASHBOARD_DATA_DIR;
-  const dashboardProjectNames = parseDashboardProjectNames(
-    options.dashboardProjectNames,
-  );
 
   await startWebServer({
     accessToken,

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

@@ -290,9 +290,10 @@ describe('notifySilentTmuxSessions', () => {
     expect(sendCall?.[1][4]).toContain(
       `${SILENT_SESSION_REMINDER_SENTINEL} CUSTOM_MAIN_TEMPLATE`,
     );
-    expect(sendCall?.[1][4]).toContain(
+    expect(sendCall?.[1][4]).not.toContain(
       'in the format documented for this session',
     );
+    expect(sendCall?.[1][4]).not.toContain('share it through a new owner-call');
   });
 
   it('suppresses the notification while the latest owner call is unanswered', async () => {

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

@@ -47,7 +47,7 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     expect(fallback.composeMainStalledSection).not.toHaveBeenCalled();
   });
 
-  it('appends the owner-call format guidance, including the self-contained requirement, to the configured main template', () => {
+  it('appends no owner-call guidance and no self-diagnosis guidance to the configured main template', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(
       {
@@ -58,11 +58,13 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     );
     const section = composer.composeMainStalledSection(600);
     expect(section).toContain('CUSTOM_MAIN');
-    expect(section).toContain(
-      'share it through a new owner-call in the format documented for this session',
+    expect(section).not.toContain('share it through a new owner-call');
+    expect(section).not.toContain('in the format documented for this session');
+    expect(section).not.toContain('written to be self-contained');
+    expect(section).not.toContain(
+      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
     );
-    expect(section).toContain('written to be self-contained');
-    expect(section).not.toContain('marker tag');
+    expect(section).not.toContain('re-raise');
     expect(section).not.toContain('<');
     expect(section).not.toContain('>');
     expect(section).not.toMatch(
@@ -71,24 +73,6 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     expect(section).not.toContain('\u{FE0F}');
   });
 
-  it('appends the self-diagnosis guidance to the configured main template', () => {
-    const fallback = createFallback();
-    const composer = new ConfigurableSilentSessionMessageComposer(
-      {
-        ...noTemplates,
-        mainStalledMessage: 'CUSTOM_MAIN',
-      },
-      fallback,
-    );
-    const section = composer.composeMainStalledSection(600);
-    expect(section).toContain(
-      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
-    );
-    expect(section).toContain(
-      're-raise the pending request as a new owner-call in that format',
-    );
-  });
-
   it('omits the self-diagnosis guidance from the configured stale-owner-call template section', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.ts

@@ -1,8 +1,5 @@
 import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
-import {
-  composeMainStalledSelfDiagnosisGuidance,
-  composeOwnerCallFormatGuidance,
-} from '../../domain/usecases/DefaultSilentSessionMessageComposer';
+import { composeOwnerCallFormatGuidance } from '../../domain/usecases/DefaultSilentSessionMessageComposer';
 import {
   SilentSessionMessageComposer,
   SubAgentStallSections,
@@ -38,9 +35,7 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
     if (this.templates.mainStalledMessage === null) {
       return this.fallback.composeMainStalledSection(mainSilentSeconds);
     }
-    return withReminderSentinel(
-      `${this.templates.mainStalledMessage} ${composeOwnerCallFormatGuidance()} ${composeMainStalledSelfDiagnosisGuidance()}`,
-    );
+    return withReminderSentinel(this.templates.mainStalledMessage);
   };
 
   composeMainStalledWithStaleOwnerCallSection = (

package/src/adapter/repositories/GoogleSpreadsheetRepository.integration.test.ts

@@ -157,6 +157,16 @@ describeWhenCredentials('GoogleSpreadsheetRepository integration tests', () => {
       );
       expect(result).toBeNull();
     });
+
+    test('rejects with the Google Sheets not-found status when the spreadsheet does not exist', async () => {
+      const missingSpreadsheetId =
+        '1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+      const missingSpreadsheetUrl = `https://docs.google.com/spreadsheets/d/${missingSpreadsheetId}/edit`;
+
+      await expect(
+        repository.getSheet(missingSpreadsheetUrl, 'Sheet1'),
+      ).rejects.toMatchObject({ status: 404 });
+    });
   });
 
   describe('createNewSheetIfNotExists', () => {

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.test.ts

@@ -268,6 +268,114 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('get', () => {
+    it('reads the single project item scoped to the given project without consulting the getAllIssues memo', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const project = buildTestProject('test-project-id');
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:00:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue(null);
+      projectRepository.getProject.mockResolvedValue(project);
+      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+      graphqlProjectItemRepository.fetchProjectItemByUrl.mockResolvedValue(
+        buildProjectItem('https://github.com/o/r/issues/1', 'live title'),
+      );
+
+      await repository.getAllIssues('test-project-id');
+      const issue = await repository.get(
+        'https://github.com/o/r/issues/1',
+        project,
+      );
+
+      expect(issue?.title).toBe('live title');
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemByUrl.mock.calls,
+      ).toEqual([['https://github.com/o/r/issues/1', 'test-project-id']]);
+    });
+
+    const issueUrlOnTwoProjects = 'https://github.com/o/r/issues/1';
+
+    const buildProjectScopedItem = (
+      itemId: string,
+      status: string,
+      story: string,
+      nextActionHour: string,
+    ): ProjectItem => ({
+      ...buildProjectItem(issueUrlOnTwoProjects, itemId),
+      id: itemId,
+      customFields: [
+        { name: 'Status', value: status },
+        { name: 'story', value: story },
+        { name: 'nextActionHour', value: nextActionHour },
+      ],
+    });
+
+    const itemOnOtherProject = buildProjectScopedItem(
+      'item-on-other-project',
+      'Awaiting Workspace',
+      'other story',
+      '9',
+    );
+    const itemOnRequestedProject = buildProjectScopedItem(
+      'item-on-requested-project',
+      'Preparation',
+      'requested story',
+      '17',
+    );
+
+    const arrangeItemsOnTwoProjects = (
+      graphqlProjectItemRepository: ReturnType<
+        typeof createApiV3CheerioRestIssueRepository
+      >['graphqlProjectItemRepository'],
+    ): void => {
+      const itemsByProjectId = new Map<string, ProjectItem>([
+        ['other-project-id', itemOnOtherProject],
+        ['requested-project-id', itemOnRequestedProject],
+      ]);
+      graphqlProjectItemRepository.fetchProjectItemByUrl.mockImplementation(
+        async (_issueUrl: string, projectId?: string) =>
+          projectId === undefined
+            ? Array.from(itemsByProjectId.values())[0]
+            : (itemsByProjectId.get(projectId) ?? null),
+      );
+    };
+
+    it('returns the project item of the requested project when the issue is on two projects', async () => {
+      const { repository, graphqlProjectItemRepository } =
+        createApiV3CheerioRestIssueRepository();
+      arrangeItemsOnTwoProjects(graphqlProjectItemRepository);
+
+      const issue = await repository.get(
+        issueUrlOnTwoProjects,
+        buildTestProject('requested-project-id'),
+      );
+
+      expect(issue?.itemId).toBe('item-on-requested-project');
+      expect(issue?.status).toBe('Preparation');
+      expect(issue?.story).toBe('requested story');
+      expect(issue?.nextActionHour).toBe(17);
+    });
+
+    it('returns null when the issue has project items only on other projects', async () => {
+      const { repository, graphqlProjectItemRepository } =
+        createApiV3CheerioRestIssueRepository();
+      arrangeItemsOnTwoProjects(graphqlProjectItemRepository);
+
+      const issue = await repository.get(
+        issueUrlOnTwoProjects,
+        buildTestProject('project-without-any-item'),
+      );
+
+      expect(issue).toBeNull();
+    });
+  });
+
   describe('getAllIssues incremental fetch', () => {
     it('light-scans the lastFetchedAt UTC day with no previous-day overlap, detail-fetches changed items by id, and upserts by url', async () => {
       const {

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.ts

@@ -911,8 +911,16 @@ export class ApiV3CheerioRestIssueRepository
   searchIssues = (query: string): Promise<SearchedIssue[]> => {
     return this.restIssueRepository.searchIssues(query);
   };
-  get = async (_issueUrl: string, _project: Project): Promise<Issue | null> => {
-    return this.getIssueByUrl(_issueUrl);
+  get = async (issueUrl: string, project: Project): Promise<Issue | null> => {
+    const projectItem =
+      await this.graphqlProjectItemRepository.fetchProjectItemByUrl(
+        issueUrl,
+        project.id,
+      );
+    if (!projectItem) {
+      return null;
+    }
+    return this.convertProjectItemToIssue(projectItem);
   };
   update = async (issue: Issue, _project: Project): Promise<void> => {
     await this.updateIssue(issue);