github-issue-tower-defence-management 1.104.3 → 1.105.0

package/src/adapter/repositories/ProcTakeOwnershipSpawnRepository.ts

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  TakeOwnershipSpawn,
+  TakeOwnershipSpawnRepository,
+} from '../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const OAUTH_TOKEN_ENVIRON_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const TAKE_OWNERSHIP_MARKER = 'Take ownership';
+const LOG_PATH_PATTERN = /\/logs-aw\/[^\0"]+\.log/;
+
+const parseCommandLineArguments = (cmdline: string): string[] =>
+  cmdline.split('\0').filter((argument) => argument.length > 0);
+
+const isTakeOwnershipSpawn = (commandArguments: string[]): boolean =>
+  commandArguments.some((argument) => argument.includes(TAKE_OWNERSHIP_MARKER));
+
+const extractLogPath = (cmdline: string): string | null => {
+  const match = cmdline.match(LOG_PATH_PATTERN);
+  return match === null ? null : match[0];
+};
+
+export class ProcTakeOwnershipSpawnRepository implements TakeOwnershipSpawnRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+  ) {}
+
+  listSpawns = (): TakeOwnershipSpawn[] => {
+    const spawns: TakeOwnershipSpawn[] = [];
+    for (const pidDirectory of this.listProcessIdDirectories()) {
+      const spawn = this.readSpawn(pidDirectory);
+      if (spawn !== null) {
+        spawns.push(spawn);
+      }
+    }
+    return spawns;
+  };
+
+  private listProcessIdDirectories = (): string[] => {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.procDirectory);
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => /^\d+$/.test(entry));
+  };
+
+  private readSpawn = (
+    processIdDirectory: string,
+  ): TakeOwnershipSpawn | null => {
+    const rawCmdline = this.readRawCmdline(processIdDirectory);
+    if (rawCmdline === null) {
+      return null;
+    }
+    const commandArguments = parseCommandLineArguments(rawCmdline);
+    if (!isTakeOwnershipSpawn(commandArguments)) {
+      return null;
+    }
+    const logPath = extractLogPath(rawCmdline);
+    if (logPath === null) {
+      return null;
+    }
+    const environ = this.readEnviron(processIdDirectory);
+    if (environ === null) {
+      return null;
+    }
+    const token = environ.get(OAUTH_TOKEN_ENVIRON_KEY);
+    if (token === undefined || token.length === 0) {
+      return null;
+    }
+    return { token, logPath };
+  };
+
+  private readRawCmdline = (processIdDirectory: string): string | null => {
+    const cmdlinePath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'cmdline',
+    );
+    try {
+      return fs.readFileSync(cmdlinePath, 'utf8');
+    } catch {
+      return null;
+    }
+  };
+
+  private readEnviron = (
+    processIdDirectory: string,
+  ): Map<string, string> | null => {
+    const environPath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'environ',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(environPath, 'utf8');
+    } catch {
+      return null;
+    }
+    const environ = new Map<string, string>();
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ.set(key, value);
+    }
+    return environ;
+  };
+}

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

@@ -1,22 +1,29 @@
 const mockPost = jest.fn();
 
-jest.mock('ky', () => ({
-  default: {
-    post: mockPost,
-    get: jest.fn(),
-    put: jest.fn(),
-    patch: jest.fn(),
-    delete: jest.fn(),
-    extend: jest.fn(),
-    create: jest.fn(),
-    stop: jest.fn(),
-  },
-  __esModule: true,
-}));
+jest.mock('ky', () => {
+  const actualKy: typeof import('ky') = jest.requireActual('ky');
+  return {
+    default: {
+      post: mockPost,
+      get: jest.fn(),
+      put: jest.fn(),
+      patch: jest.fn(),
+      delete: jest.fn(),
+      extend: jest.fn(),
+      create: jest.fn(),
+      stop: jest.fn(),
+    },
+    HTTPError: actualKy.HTTPError,
+    __esModule: true,
+  };
+});
 
+import { HTTPError } from 'ky';
 import {
   GraphqlProjectItemRepository,
   PAGINATION_DELAY_MS,
+  RATE_LIMIT_MAX_RETRIES,
+  callWithRateLimitRetry,
 } from './GraphqlProjectItemRepository';
 import { LocalStorageRepository } from '../LocalStorageRepository';
 
@@ -24,6 +31,30 @@ const mockJsonResponse = <T>(data: T) => ({
   json: jest.fn().mockResolvedValue(data),
 });
 
+const makeHttpError = (
+  status: number,
+  headers: Record<string, string> = {},
+): HTTPError => {
+  const response = new Response('rate limited', {
+    status,
+    headers,
+  });
+  const request = new Request('https://api.github.com/graphql');
+  const normalizedOptions: ConstructorParameters<typeof HTTPError>[2] = {
+    method: 'post',
+    retry: {},
+    prefix: '',
+    onDownloadProgress: undefined,
+    onUploadProgress: undefined,
+    context: {},
+  };
+  return new HTTPError(response, request, normalizedOptions);
+};
+
+const mockRejectedJsonResponse = (error: HTTPError) => ({
+  json: jest.fn().mockRejectedValue(error),
+});
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null;
 
@@ -434,6 +465,229 @@ describe('GraphqlProjectItemRepository', () => {
       );
       expect(requestedFirstSeries).toEqual([100, 50, 25, 12, 6, 3, 1]);
     });
+
+    it('should not sleep the legacy 5000ms blanket delay between pages', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
+      mockPost
+        .mockReturnValueOnce(makePageResponse(true, 'cursor-1'))
+        .mockReturnValueOnce(makePageResponse(false, 'cursor-2'));
+
+      const resultPromise = repository.fetchProjectItems('test-project-id');
+      await jest.advanceTimersByTimeAsync(PAGINATION_DELAY_MS);
+      const result = await resultPromise;
+
+      expect(result).toHaveLength(2);
+      expect(PAGINATION_DELAY_MS).toBeLessThanOrEqual(500);
+      expect(setTimeoutSpy).not.toHaveBeenCalledWith(
+        expect.any(Function),
+        5000,
+      );
+      setTimeoutSpy.mockRestore();
+    });
+
+    it('should back off and retry once when GitHub responds 429, then succeed', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      mockPost
+        .mockReturnValueOnce(
+          mockRejectedJsonResponse(makeHttpError(429, { 'retry-after': '3' })),
+        )
+        .mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
+
+      const resultPromise = repository.fetchProjectItems('test-project-id');
+      await jest.advanceTimersByTimeAsync(3000);
+      const result = await resultPromise;
+
+      expect(result).toHaveLength(1);
+      expect(mockPost).toHaveBeenCalledTimes(2);
+    });
+
+    it('should honor the retry-after header duration before retrying after a 429', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      mockPost
+        .mockReturnValueOnce(
+          mockRejectedJsonResponse(makeHttpError(429, { 'retry-after': '7' })),
+        )
+        .mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
+
+      const resultPromise = repository.fetchProjectItems('test-project-id');
+      await jest.advanceTimersByTimeAsync(6999);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+      await jest.advanceTimersByTimeAsync(1);
+      const result = await resultPromise;
+
+      expect(result).toHaveLength(1);
+      expect(mockPost).toHaveBeenCalledTimes(2);
+    });
+
+    it('should wait until x-ratelimit-reset when 403 has no retry-after and remaining is 0', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      const resetEpochSeconds = Math.floor(Date.now() / 1000) + 4;
+      mockPost
+        .mockReturnValueOnce(
+          mockRejectedJsonResponse(
+            makeHttpError(403, {
+              'x-ratelimit-remaining': '0',
+              'x-ratelimit-reset': String(resetEpochSeconds),
+            }),
+          ),
+        )
+        .mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
+
+      const resultPromise = repository.fetchProjectItems('test-project-id');
+      await jest.advanceTimersByTimeAsync(5000);
+      const result = await resultPromise;
+
+      expect(result).toHaveLength(1);
+      expect(mockPost).toHaveBeenCalledTimes(2);
+    });
+
+    it('should give up and rethrow after exhausting rate-limit retries', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValue(
+        mockRejectedJsonResponse(makeHttpError(429, { 'retry-after': '1' })),
+      );
+
+      const resultPromise = repository
+        .fetchProjectItems('test-project-id')
+        .catch((error: unknown) => error);
+      await jest.runAllTimersAsync();
+      const caught = await resultPromise;
+
+      expect(caught).toBeInstanceOf(HTTPError);
+      expect(mockPost).toHaveBeenCalledTimes(RATE_LIMIT_MAX_RETRIES + 1);
+    }, 30000);
+
+    it('should not let the page-size halving fallback re-issue a rate-limit request', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValue(
+        mockRejectedJsonResponse(makeHttpError(429, { 'retry-after': '1' })),
+      );
+
+      const resultPromise = repository
+        .fetchProjectItems('test-project-id')
+        .catch((error: unknown) => error);
+      await jest.runAllTimersAsync();
+      await resultPromise;
+
+      const requestedFirstSeries = mockPost.mock.calls.map((call) =>
+        extractRequestedFirstFromMockCall(call),
+      );
+      expect(requestedFirstSeries.every((first) => first === 100)).toBe(true);
+    }, 30000);
+  });
+
+  describe('callWithRateLimitRetry', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('should return the result without retrying when the request succeeds', async () => {
+      const request = jest.fn().mockResolvedValue('ok');
+
+      const result = await callWithRateLimitRetry(request);
+
+      expect(result).toBe('ok');
+      expect(request).toHaveBeenCalledTimes(1);
+    });
+
+    it('should retry on a 429 then return the eventual success value', async () => {
+      const request = jest
+        .fn()
+        .mockRejectedValueOnce(makeHttpError(429, { 'retry-after': '2' }))
+        .mockResolvedValueOnce('recovered');
+
+      const resultPromise = callWithRateLimitRetry(request);
+      await jest.advanceTimersByTimeAsync(2000);
+      const result = await resultPromise;
+
+      expect(result).toBe('recovered');
+      expect(request).toHaveBeenCalledTimes(2);
+    });
+
+    it('should retry on a 403 rate-limit response then succeed', async () => {
+      const resetEpochSeconds = Math.floor(Date.now() / 1000) + 3;
+      const request = jest
+        .fn()
+        .mockRejectedValueOnce(
+          makeHttpError(403, {
+            'x-ratelimit-remaining': '0',
+            'x-ratelimit-reset': String(resetEpochSeconds),
+          }),
+        )
+        .mockResolvedValueOnce('recovered');
+
+      const resultPromise = callWithRateLimitRetry(request);
+      await jest.advanceTimersByTimeAsync(4000);
+      const result = await resultPromise;
+
+      expect(result).toBe('recovered');
+      expect(request).toHaveBeenCalledTimes(2);
+    });
+
+    it('should not retry a non-rate-limit HTTP error such as 500', async () => {
+      const httpError = makeHttpError(500);
+      const request = jest.fn().mockRejectedValue(httpError);
+
+      await expect(callWithRateLimitRetry(request)).rejects.toBe(httpError);
+      expect(request).toHaveBeenCalledTimes(1);
+    });
+
+    it('should rethrow immediately for a non-HTTPError', async () => {
+      const plainError = new Error('boom');
+      const request = jest.fn().mockRejectedValue(plainError);
+
+      await expect(callWithRateLimitRetry(request)).rejects.toBe(plainError);
+      expect(request).toHaveBeenCalledTimes(1);
+    });
+
+    it('should stop after the maximum number of rate-limit retries', async () => {
+      const httpError = makeHttpError(429, { 'retry-after': '1' });
+      const request = jest.fn().mockRejectedValue(httpError);
+
+      const resultPromise = callWithRateLimitRetry(request).catch(
+        (error: unknown) => error,
+      );
+      await jest.runAllTimersAsync();
+      const caught = await resultPromise;
+
+      expect(caught).toBe(httpError);
+      expect(request).toHaveBeenCalledTimes(RATE_LIMIT_MAX_RETRIES + 1);
+    }, 30000);
   });
 
   describe('getProjectItemFields', () => {

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

@@ -1,4 +1,4 @@
-import ky from 'ky';
+import ky, { HTTPError } from 'ky';
 import { BaseGitHubRepository } from '../BaseGitHubRepository';
 import { Project } from '../../../domain/entities/Project';
 import { Issue } from '../../../domain/entities/Issue';
@@ -20,9 +20,94 @@ export type ProjectItem = {
     value: string | null;
   }[];
 };
-export const PAGINATION_DELAY_MS = 5000;
+export const PAGINATION_DELAY_MS = 500;
 export const FETCH_PROJECT_ITEMS_INITIAL_PAGE_SIZE = 100;
 export const FETCH_PROJECT_ITEMS_GRAPHQL_ERROR_PAYLOAD_MAX_LENGTH = 4000;
+export const RATE_LIMIT_MAX_RETRIES = 6;
+export const RATE_LIMIT_MIN_BACKOFF_MS = 1000;
+export const RATE_LIMIT_DEFAULT_BACKOFF_MS = 60000;
+export const RATE_LIMIT_MAX_BACKOFF_MS = 300000;
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+const parseNonNegativeIntegerHeader = (value: string | null): number | null => {
+  if (value === null) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    return null;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const computeRateLimitBackoffMs = (
+  headers: Headers | undefined,
+  attempt: number,
+  nowMs: number,
+): number => {
+  const exponentialMs = Math.min(
+    RATE_LIMIT_MAX_BACKOFF_MS,
+    RATE_LIMIT_DEFAULT_BACKOFF_MS * Math.pow(2, attempt),
+  );
+  const retryAfterSeconds = parseNonNegativeIntegerHeader(
+    headers?.get('retry-after') ?? null,
+  );
+  if (retryAfterSeconds !== null) {
+    return Math.min(
+      RATE_LIMIT_MAX_BACKOFF_MS,
+      Math.max(RATE_LIMIT_MIN_BACKOFF_MS, retryAfterSeconds * 1000),
+    );
+  }
+  const remaining = parseNonNegativeIntegerHeader(
+    headers?.get('x-ratelimit-remaining') ?? null,
+  );
+  const resetEpochSeconds = parseNonNegativeIntegerHeader(
+    headers?.get('x-ratelimit-reset') ?? null,
+  );
+  if (remaining === 0 && resetEpochSeconds !== null) {
+    const waitMs = resetEpochSeconds * 1000 - nowMs;
+    return Math.min(
+      RATE_LIMIT_MAX_BACKOFF_MS,
+      Math.max(RATE_LIMIT_MIN_BACKOFF_MS, waitMs),
+    );
+  }
+  return Math.max(RATE_LIMIT_MIN_BACKOFF_MS, exponentialMs);
+};
+
+const isRateLimitStatus = (status: number): boolean =>
+  status === 429 || status === 403;
+
+export const callWithRateLimitRetry = async <T>(
+  request: () => Promise<T>,
+): Promise<T> => {
+  let attempt = 0;
+  for (;;) {
+    try {
+      return await request();
+    } catch (error) {
+      if (
+        !(error instanceof HTTPError) ||
+        !isRateLimitStatus(error.response.status) ||
+        attempt >= RATE_LIMIT_MAX_RETRIES
+      ) {
+        throw error;
+      }
+      const backoffMs = computeRateLimitBackoffMs(
+        error.response.headers,
+        attempt,
+        Date.now(),
+      );
+      console.log(
+        `fetchProjectItems: GitHub returned ${error.response.status} (rate limit). Backing off ${backoffMs}ms before retry ${attempt + 1}/${RATE_LIMIT_MAX_RETRIES}.`,
+      );
+      await sleep(backoffMs);
+      attempt++;
+    }
+  }
+};
 
 const stringifyGraphqlErrorsForLog = (
   errors: { message: string }[],
@@ -277,53 +362,55 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
           first: first,
         },
       };
-      const response = await ky
-        .post('https://api.github.com/graphql', {
-          json: graphqlQuery,
-          headers: {
-            Authorization: `Bearer ${this.ghToken}`,
-          },
-        })
-        .json<{
-          data: {
-            node: {
-              items: {
-                totalCount: number;
-                pageInfo: {
-                  endCursor: string;
-                  startCursor: string;
-                  hasNextPage: boolean;
-                };
-                nodes: {
-                  id: string;
-                  fieldValues: {
-                    nodes: {
-                      text: string;
-                      number: number;
-                      date: string;
-                      field: {
-                        name: string;
-                      };
-                    }[];
+      const response = await callWithRateLimitRetry(() =>
+        ky
+          .post('https://api.github.com/graphql', {
+            json: graphqlQuery,
+            headers: {
+              Authorization: `Bearer ${this.ghToken}`,
+            },
+          })
+          .json<{
+            data: {
+              node: {
+                items: {
+                  totalCount: number;
+                  pageInfo: {
+                    endCursor: string;
+                    startCursor: string;
+                    hasNextPage: boolean;
                   };
-                  content: {
-                    repository: { nameWithOwner: string };
-                    number: number;
-                    title: string;
-                    state: string;
-                    url: string;
-                    createdAt: string;
-                    author: { login: string } | null;
-                    labels: { nodes: { name: string }[] };
-                    assignees: { nodes: { login: string }[] };
-                    closingIssuesReferences?: { nodes: { url: string }[] };
-                  };
-                }[];
-              };
+                  nodes: {
+                    id: string;
+                    fieldValues: {
+                      nodes: {
+                        text: string;
+                        number: number;
+                        date: string;
+                        field: {
+                          name: string;
+                        };
+                      }[];
+                    };
+                    content: {
+                      repository: { nameWithOwner: string };
+                      number: number;
+                      title: string;
+                      state: string;
+                      url: string;
+                      createdAt: string;
+                      author: { login: string } | null;
+                      labels: { nodes: { name: string }[] };
+                      assignees: { nodes: { login: string }[] };
+                      closingIssuesReferences?: { nodes: { url: string }[] };
+                    };
+                  }[];
+                };
+              } | null;
             } | null;
-          } | null;
-          errors?: { message: string }[];
-        }>();
+            errors?: { message: string }[];
+          }>(),
+      );
       if (response.errors && response.errors.length > 0) {
         throw new Error(
           `GitHub GraphQL errors: ${stringifyGraphqlErrorsForLog(response.errors)}`,
@@ -385,6 +472,12 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
           return await callGraphql(projectId, after, attemptFirst);
         } catch (error) {
           lastError = error;
+          if (
+            error instanceof HTTPError &&
+            isRateLimitStatus(error.response.status)
+          ) {
+            throw error;
+          }
           if (attemptFirst === 1) {
             throw error;
           }

package/src/domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository.ts

@@ -0,0 +1,8 @@
+export type TakeOwnershipSpawn = {
+  token: string;
+  logPath: string;
+};
+
+export interface TakeOwnershipSpawnRepository {
+  listSpawns: () => TakeOwnershipSpawn[];
+}