@shipfox/api-integration-github 12.3.0 → 12.6.0

package/src/core/agent-tools.ts

@@ -8,11 +8,12 @@ import type {
   OpenAgentToolsSessionInput,
 } from '@shipfox/api-integration-spi';
 import {Octokit} from 'octokit';
+import {mapGithubError} from '#api/client.js';
 import {
   createGithubInstallationTokenProvider,
   type GithubInstallationTokenProvider,
 } from '#api/installation-token-provider.js';
-import {normalizedGithubApiBaseUrl} from '#config.js';
+import {config, normalizedGithubApiBaseUrl} from '#config.js';
 import type {GithubInstallation} from '#db/installations.js';
 import {GithubIntegrationProviderError} from './errors.js';
 import {
@@ -48,6 +49,35 @@ type GithubToolCallResult = {
   structuredContent?: Record<string, unknown> | undefined;
 };
 
+type GithubToolErrorCode =
+  | 'invalid-request'
+  | 'access-denied'
+  | 'provider-rejected'
+  | 'malformed-provider-response';
+
+const GITHUB_GRAPHQL_ROUTE = 'POST /graphql';
+const GITHUB_ARTIFACT_ARCHIVE_FORMAT = 'zip';
+const GITHUB_ARTIFACT_DOWNLOAD_ROUTE = `GET /repos/{owner}/{repo}/actions/artifacts/{resource_id}/${GITHUB_ARTIFACT_ARCHIVE_FORMAT}`;
+const GITHUB_ARTIFACT_DOWNLOAD_TIMEOUT_MS = 30_000;
+const GITHUB_APP_BOT_SUFFIX = '[bot]';
+const PENDING_REVIEW_PAGE_SIZE = 100;
+const PENDING_REVIEW_MAX_PAGE_REQUESTS = 5;
+const PENDING_REVIEW_LOOKUP_TIMEOUT_MS = 15_000;
+const PENDING_REVIEW_PAGE_TIMEOUT_MS = 5_000;
+const PENDING_REVIEW_PAGE_PATTERN = /[?&]page=(\d+)/u;
+const NO_PENDING_REVIEW_MESSAGE =
+  'No pending pull request review found for the authenticated GitHub user.';
+
+const ADD_PENDING_REVIEW_COMMENT_MUTATION = `
+  mutation AddCommentToPendingReview($input: AddPullRequestReviewThreadInput!) {
+    addPullRequestReviewThread(input: $input) {
+      thread {
+        id
+      }
+    }
+  }
+`;
+
 export class GithubAgentToolsProvider
   implements
     AgentToolsProvider<
@@ -95,28 +125,54 @@ export class GithubAgentToolsProvider
     return {
       call: async (call) => {
         const tool = input.tools.find((candidate) => candidate.id === call.toolId);
-        if (!tool) return githubToolError(`Unknown GitHub tool: ${call.toolId}`);
+        if (!tool) return githubToolError(`Unknown GitHub tool: ${call.toolId}`, 'invalid-request');
         const operation = resolveGithubOperation(tool, call);
-        if (operation === undefined) return githubToolError('Unknown GitHub tool operation');
+        if (operation === undefined)
+          return githubToolError('Unknown GitHub tool operation', 'invalid-request');
         const validationError = validateGithubToolArguments(tool, call.arguments);
-        if (validationError) return githubToolError(validationError);
+        if (validationError) return githubToolError(validationError, 'invalid-request');
         tokenPromise ??= this.tokenProvider.getInstallationAccessToken(installationId);
         const token = await tokenPromise;
         if (!hasGrantedPermissions(token.permissions ?? {}, tool, call)) {
           return githubToolError(
             'GitHub installation token is missing permission for this operation',
+            'access-denied',
           );
         }
         const client = (this.options.createClient ?? createOctokitClient)(token.token);
+        const method =
+          typeof call.arguments.method === 'string' ? call.arguments.method : undefined;
+
+        if (operation.kind === 'graphql') {
+          const data = await mapGithubError(() =>
+            addCommentToPendingReview(client, operation.parameters),
+          );
+          return data === undefined
+            ? githubToolError(NO_PENDING_REVIEW_MESSAGE, 'provider-rejected')
+            : githubToolResult(tool.id as GithubAgentToolId, data);
+        }
 
-        try {
-          const response = await client.request(operation.route, operation.parameters);
-          return githubToolResult(tool.id as GithubAgentToolId, response.data);
-        } catch (error) {
-          if (error instanceof GithubIntegrationProviderError)
-            return githubToolError(error.message);
-          throw error;
+        const operationParameters = await mapGithubError(() =>
+          resolvePendingReviewParameters(
+            client,
+            operation.parameters,
+            tool.id as GithubAgentToolId,
+            method,
+          ),
+        );
+        if (operationParameters === undefined) {
+          return githubToolError(NO_PENDING_REVIEW_MESSAGE, 'provider-rejected');
         }
+        const response = await mapGithubError(() =>
+          client.request(operation.route, operationParameters),
+        );
+        return githubToolResult(
+          tool.id as GithubAgentToolId,
+          response.data,
+          response,
+          operationParameters,
+          operation.route,
+        );
       },
     };
   }
@@ -130,8 +186,16 @@ export interface GithubAgentToolsProviderOptions {
   createClient?: GithubToolClientFactory | undefined;
 }
 
+export interface GithubToolResponse {
+  data: unknown;
+  headers?: Record<string, string | number | undefined> | undefined;
+  status?: number | undefined;
+  url?: string | undefined;
+}
+
 export interface GithubToolClient {
-  request(route: string, parameters: Record<string, unknown>): Promise<{data: unknown}>;
+  request(route: string, parameters: Record<string, unknown>): Promise<GithubToolResponse>;
+  graphql?: ((query: string, variables: Record<string, unknown>) => Promise<unknown>) | undefined;
 }
 
 export type GithubToolClientFactory = (token: string) => GithubToolClient;
@@ -139,6 +203,7 @@ export type GithubToolClientFactory = (token: string) => GithubToolClient;
 interface GithubToolOperation {
   route: string;
   parameters: Record<string, unknown>;
+  kind: 'rest' | 'graphql';
 }
 
 function createOctokitClient(token: string): GithubToolClient {
@@ -148,7 +213,30 @@ function createOctokitClient(token: string): GithubToolClient {
     retry: {enabled: false},
   });
   return {
-    request: async (route, parameters) => await octokit.request(route, parameters),
+    request: async (route, parameters) => {
+      if (route !== GITHUB_ARTIFACT_DOWNLOAD_ROUTE) {
+        return await octokit.request(route, parameters);
+      }
+
+      const abortController = new AbortController();
+      const timeout = setTimeout(
+        () => abortController.abort(),
+        GITHUB_ARTIFACT_DOWNLOAD_TIMEOUT_MS,
+      );
+      try {
+        return await octokit.request(route, {
+          ...parameters,
+          request: {
+            redirect: 'manual',
+            parseSuccessResponseBody: false,
+            signal: abortController.signal,
+          },
+        });
+      } finally {
+        clearTimeout(timeout);
+      }
+    },
+    graphql: async (query, variables) => await octokit.graphql(query, variables),
   };
 }
 
@@ -167,10 +255,14 @@ function resolveGithubOperation(
   const route = githubOperationRoute(toolId, method, params);
   return route === undefined
     ? undefined
-    : {route, parameters: projectGithubOperationParameters(toolId, method, params)};
+    : {
+        route,
+        parameters: projectGithubOperationParameters(toolId, method, params),
+        kind: route === GITHUB_GRAPHQL_ROUTE ? 'graphql' : 'rest',
+      };
 }
 
-function githubOperationRoute(
+export function githubOperationRoute(
   toolId: GithubAgentToolId,
   method: string | undefined,
   args: Record<string, unknown>,
@@ -217,7 +309,7 @@ function githubOperationRoute(
     case 'sub_issue_write.remove':
       return `DELETE ${repoPath}/issues/${issue}/sub_issues/{sub_issue_id}`;
     case 'sub_issue_write.reprioritize':
-      return `PATCH ${repoPath}/issues/${issue}/sub_issues/{sub_issue_id}`;
+      return `PATCH ${repoPath}/issues/${issue}/sub_issues/priority`;
     case 'pull_request_read.get':
       return `GET ${repoPath}/pulls/${pull}`;
     case 'pull_request_read.get_diff':
@@ -245,7 +337,9 @@ function githubOperationRoute(
     case 'update_pull_request.':
       return `PATCH ${repoPath}/pulls/${pull}`;
     case 'add_reply_to_pull_request_comment.':
-      return `POST ${repoPath}/pulls/{comment_id}/replies`;
+      return args.reaction !== undefined && args.body === undefined
+        ? `POST ${repoPath}/pulls/comments/{comment_id}/reactions`
+        : `POST ${repoPath}/pulls/${pull}/comments/{comment_id}/replies`;
     case 'merge_pull_request.':
       return `PUT ${repoPath}/pulls/${pull}/merge`;
     case 'update_pull_request_branch.':
@@ -257,7 +351,7 @@ function githubOperationRoute(
     case 'pull_request_review_write.delete_pending':
       return `DELETE ${repoPath}/pulls/${pull}/reviews/{review_id}`;
     case 'add_comment_to_pending_review.':
-      return `POST ${repoPath}/pulls/${pull}/comments`;
+      return GITHUB_GRAPHQL_ROUTE;
     case 'actions_list.list_workflows':
       return `GET ${repoPath}/actions/workflows`;
     case 'actions_list.list_workflow_runs':
@@ -273,7 +367,7 @@ function githubOperationRoute(
     case 'actions_get.get_workflow_job':
       return `GET ${repoPath}/actions/jobs/${resource}`;
     case 'actions_get.download_workflow_run_artifact':
-      return `GET ${repoPath}/actions/artifacts/${resource}/{archive_format}`;
+      return GITHUB_ARTIFACT_DOWNLOAD_ROUTE;
     case 'actions_get.get_workflow_run_usage':
       return `GET ${repoPath}/actions/runs/${resource}/timing`;
     case 'actions_get.get_workflow_run_logs_url':
@@ -295,7 +389,41 @@ function githubOperationRoute(
   }
 }
 
-function projectGithubOperationParameters(
+async function addCommentToPendingReview(
+  client: GithubToolClient,
+  args: Record<string, unknown>,
+): Promise<unknown | undefined> {
+  if (client.graphql === undefined) {
+    throw new GithubIntegrationProviderError(
+      'malformed-provider-response',
+      'GitHub client does not support GraphQL operations',
+    );
+  }
+
+  const review = await latestPendingReview(client, args, 'nodeId');
+  if (review === undefined) return undefined;
+  if (review.nodeId === undefined) {
+    throw new GithubIntegrationProviderError(
+      'malformed-provider-response',
+      'GitHub pending pull request review did not include a node ID',
+    );
+  }
+
+  const input: Record<string, unknown> = {
+    pullRequestReviewId: review.nodeId,
+    path: args.path,
+    body: args.body,
+    subjectType: args.subject_type,
+  };
+  if (args.line !== undefined) input.line = args.line;
+  if (args.side !== undefined) input.side = args.side;
+  if (args.start_line !== undefined) input.startLine = args.start_line;
+  if (args.start_side !== undefined) input.startSide = args.start_side;
+
+  return await client.graphql(ADD_PENDING_REVIEW_COMMENT_MUTATION, {input});
+}
+
+export function projectGithubOperationParameters(
   toolId: GithubAgentToolId,
   method: string | undefined,
   args: Record<string, unknown>,
@@ -312,8 +440,208 @@ function projectGithubOperationParameters(
   return parameters;
 }
 
-function githubToolResult(toolId: GithubAgentToolId, data: unknown): GithubToolCallResult {
-  const structuredContent = projectGithubToolOutput(toolId, data);
+async function resolvePendingReviewParameters(
+  client: GithubToolClient,
+  parameters: Record<string, unknown>,
+  toolId: GithubAgentToolId,
+  method: string | undefined,
+): Promise<Record<string, unknown> | undefined> {
+  if (!isPendingReviewOperation(toolId, method)) return parameters;
+
+  const review = await latestPendingReview(client, parameters, 'id');
+  if (review === undefined) return undefined;
+  if (review.id === undefined) {
+    throw new GithubIntegrationProviderError(
+      'malformed-provider-response',
+      'GitHub pending pull request review did not include a numeric ID',
+    );
+  }
+  return {...parameters, review_id: review.id};
+}
+
+function isPendingReviewOperation(toolId: GithubAgentToolId, method: string | undefined): boolean {
+  return (
+    toolId === 'pull_request_review_write' &&
+    (method === 'submit_pending' || method === 'delete_pending')
+  );
+}
+
+interface PendingReviewReference {
+  id?: number | undefined;
+  nodeId?: string | undefined;
+}
+
+type PendingReviewIdentifier = keyof PendingReviewReference;
+
+interface PendingReviewPageResult {
+  malformed: boolean;
+  review?: PendingReviewReference | undefined;
+}
+
+async function latestPendingReview(
+  client: GithubToolClient,
+  parameters: Record<string, unknown>,
+  requiredIdentifier: PendingReviewIdentifier,
+): Promise<PendingReviewReference | undefined> {
+  const lookupController = new AbortController();
+  const lookupTimeout = setTimeout(
+    () => lookupController.abort(),
+    PENDING_REVIEW_LOOKUP_TIMEOUT_MS,
+  );
+
+  try {
+    return await latestPendingReviewBeforeDeadline(
+      client,
+      parameters,
+      requiredIdentifier,
+      lookupController.signal,
+    );
+  } finally {
+    clearTimeout(lookupTimeout);
+  }
+}
+
+async function latestPendingReviewBeforeDeadline(
+  client: GithubToolClient,
+  parameters: Record<string, unknown>,
+  requiredIdentifier: PendingReviewIdentifier,
+  lookupSignal: AbortSignal,
+): Promise<PendingReviewReference | undefined> {
+  const firstPage = await requestPendingReviewPage(client, parameters, 1, lookupSignal);
+  const lastPage = pendingReviewLastPage(firstPage.headers);
+  let requests = 1;
+  let malformed = false;
+
+  for (let page = lastPage; page >= 1; page -= 1) {
+    let response = firstPage;
+    if (page !== 1) {
+      if (requests >= PENDING_REVIEW_MAX_PAGE_REQUESTS) {
+        throw new GithubIntegrationProviderError(
+          'content-too-large',
+          'GitHub pull request review history exceeded the pending review lookup limit',
+        );
+      }
+      response = await requestPendingReviewPage(client, parameters, page, lookupSignal);
+      requests += 1;
+    }
+    if (!Array.isArray(response.data)) {
+      throw new GithubIntegrationProviderError(
+        'malformed-provider-response',
+        'GitHub pull request review list response was malformed',
+      );
+    }
+
+    const result = latestPendingReviewOnPage(response.data, requiredIdentifier);
+    if (result.review !== undefined) return result.review;
+    malformed ||= result.malformed;
+  }
+
+  if (malformed) {
+    throw new GithubIntegrationProviderError(
+      'malformed-provider-response',
+      requiredIdentifier === 'nodeId'
+        ? 'GitHub pending pull request review did not include a node ID'
+        : 'GitHub pending pull request review did not include a numeric ID',
+    );
+  }
+  return undefined;
+}
+
+async function requestPendingReviewPage(
+  client: GithubToolClient,
+  parameters: Record<string, unknown>,
+  page: number,
+  lookupSignal: AbortSignal,
+): Promise<GithubToolResponse> {
+  const pageController = new AbortController();
+  const abortPage = () => pageController.abort();
+  if (lookupSignal.aborted) abortPage();
+  else lookupSignal.addEventListener('abort', abortPage, {once: true});
+  const pageTimeout = setTimeout(abortPage, PENDING_REVIEW_PAGE_TIMEOUT_MS);
+
+  try {
+    return await client.request('GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews', {
+      owner: parameters.owner,
+      repo: parameters.repo,
+      pull_number: parameters.pull_number,
+      per_page: PENDING_REVIEW_PAGE_SIZE,
+      page,
+      request: {signal: pageController.signal},
+    });
+  } finally {
+    clearTimeout(pageTimeout);
+    lookupSignal.removeEventListener('abort', abortPage);
+  }
+}
+
+function pendingReviewLastPage(headers: GithubToolResponse['headers']): number {
+  const link = headers?.link;
+  if (typeof link !== 'string') return 1;
+  const lastLink = link.split(',').find((part) => part.includes('rel="last"'));
+  if (lastLink === undefined) return 1;
+  const match = PENDING_REVIEW_PAGE_PATTERN.exec(lastLink);
+  const page = match?.[1] === undefined ? Number.NaN : Number.parseInt(match[1], 10);
+  if (!Number.isSafeInteger(page) || page < 1) {
+    throw new GithubIntegrationProviderError(
+      'malformed-provider-response',
+      'GitHub pull request review pagination response was malformed',
+    );
+  }
+  return page;
+}
+
+function latestPendingReviewOnPage(
+  data: readonly unknown[],
+  requiredIdentifier: PendingReviewIdentifier,
+): PendingReviewPageResult {
+  let malformed = false;
+  const appLogin = githubAppBotLogin().toLowerCase();
+  for (let index = data.length - 1; index >= 0; index -= 1) {
+    const review = data[index];
+    if (!isRecord(review) || review.state !== 'PENDING') continue;
+    const userLogin = isRecord(review.user) ? review.user.login : undefined;
+    if (typeof userLogin !== 'string' || userLogin.trim().length === 0) {
+      malformed = true;
+      continue;
+    }
+    if (userLogin.trim().toLowerCase() !== appLogin) continue;
+    const id =
+      typeof review.id === 'number' && Number.isSafeInteger(review.id) && review.id > 0
+        ? review.id
+        : undefined;
+    const nodeId =
+      typeof review.node_id === 'string' && review.node_id.trim().length > 0
+        ? review.node_id.trim()
+        : undefined;
+    const reference = {id, nodeId};
+    if (reference[requiredIdentifier] !== undefined) return {malformed, review: reference};
+    malformed = true;
+  }
+
+  return {malformed};
+}
+
+function githubAppBotLogin(): string {
+  const configuredUsername = config.GITHUB_APP_USERNAME?.trim() || config.GITHUB_APP_SLUG.trim();
+  return configuredUsername.toLowerCase().endsWith(GITHUB_APP_BOT_SUFFIX)
+    ? configuredUsername
+    : `${configuredUsername}${GITHUB_APP_BOT_SUFFIX}`;
+}
+
+function githubToolResult(
+  toolId: GithubAgentToolId,
+  data: unknown,
+  response?: GithubToolResponse,
+  parameters?: Record<string, unknown>,
+  route?: string,
+): GithubToolCallResult {
+  const structuredContent = projectGithubToolOutput(toolId, data, response, parameters, route);
+  if (structuredContent === undefined) {
+    return githubToolError(
+      'GitHub artifact download did not return a download URL',
+      'malformed-provider-response',
+    );
+  }
   return {
     content: [{type: 'text', text: JSON.stringify(structuredContent)}],
     structuredContent,
@@ -323,7 +651,14 @@ function githubToolResult(toolId: GithubAgentToolId, data: unknown): GithubToolC
 function projectGithubToolOutput(
   toolId: GithubAgentToolId,
   data: unknown,
-): Record<string, unknown> {
+  response?: GithubToolResponse,
+  parameters?: Record<string, unknown>,
+  route?: string,
+): Record<string, unknown> | undefined {
+  if (route === GITHUB_ARTIFACT_DOWNLOAD_ROUTE) {
+    return projectGithubArtifactDownloadOutput(response, parameters);
+  }
+
   switch (toolId) {
     case 'list_issue_types':
       return {issue_types: data};
@@ -345,12 +680,40 @@ function projectGithubToolOutput(
   }
 }
 
+function projectGithubArtifactDownloadOutput(
+  response: GithubToolResponse | undefined,
+  parameters: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  if (response === undefined) return undefined;
+  const downloadUrl = response.headers?.location;
+  if (typeof downloadUrl !== 'string' || downloadUrl.length === 0) return undefined;
+
+  const output: Record<string, unknown> = {
+    archive_format: GITHUB_ARTIFACT_ARCHIVE_FORMAT,
+    download_url: downloadUrl,
+  };
+  if (typeof parameters?.resource_id === 'string') output.artifact_id = parameters.resource_id;
+
+  const contentType = response.headers?.['content-type'];
+  if (typeof contentType === 'string') output.content_type = contentType;
+
+  const contentLength = response.headers?.['content-length'];
+  const sizeBytes = typeof contentLength === 'number' ? contentLength : Number(contentLength);
+  if (Number.isSafeInteger(sizeBytes) && sizeBytes >= 0) output.size_bytes = sizeBytes;
+
+  return output;
+}
+
 function githubSearchItems(data: unknown): unknown {
   return isRecord(data) ? data.items : data;
 }
 
-function githubToolError(message: string): GithubToolCallResult {
-  return {isError: true, content: [{type: 'text', text: message}]};
+function githubToolError(message: string, code: GithubToolErrorCode): GithubToolCallResult {
+  return {
+    isError: true,
+    content: [{type: 'text', text: message}],
+    structuredContent: {code},
+  };
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/src/core/github-agent-tool-catalog.ts

@@ -670,7 +670,7 @@ export const githubAgentToolCatalog = [
     id: 'add_comment_to_pending_review',
     category: 'pull_requests',
     description:
-      "Add review comment to the requester's latest pending pull request review. A pending review needs to already exist to call this.",
+      "Add a review comment to the requester's latest pending pull request review. The comment remains part of that pending review until it is submitted; a pending review needs to already exist to call this.",
     sensitivity: 'write',
     sensitive: false,
     requiredScope: scopes.pullRequestsWrite,

package/src/metrics/instance.ts

@@ -1,6 +1,7 @@
 import type {IntegrationProviderErrorReason} from '@shipfox/api-integration-spi';
 import {instanceMetrics} from '@shipfox/node-opentelemetry';
 import type {MintErrorClass} from '#api/installation-token-envelope.js';
+import {config} from '#config.js';
 
 const meter = instanceMetrics.getMeter('github');
 
@@ -32,6 +33,13 @@ const installationTokenMintDuration = meter.createHistogram<Record<string, never
   },
 );
 
+const installationTokenFormatCount = meter.createCounter<{
+  format: 'stateless' | 'stateful' | 'unknown';
+  override: 'enabled' | 'disabled' | 'absent';
+}>('github_installation_token_format', {
+  description: 'GitHub installation tokens observed by format and requested override',
+});
+
 const installationTokenLockWaitDuration = meter.createHistogram<Record<string, never>>(
   'github_installation_token_lock_wait_duration',
   {
@@ -70,6 +78,15 @@ export function recordInstallationTokenMint(params: {
   });
 }
 
+export function recordInstallationTokenFormat(token: string): void {
+  recordMetric(() => {
+    installationTokenFormatCount.add(1, {
+      format: installationTokenFormat(token),
+      override: config.GITHUB_INSTALLATION_TOKEN_FORMAT_OVERRIDE ?? 'absent',
+    });
+  });
+}
+
 export function recordInstallationTokenLockWait(durationMs: number): void {
   recordMetric(() => installationTokenLockWaitDuration.record(durationMs));
 }
@@ -80,3 +97,11 @@ export function recordInstallationTokenBackoff(params: {
 }): void {
   recordMetric(() => installationTokenBackoffCount.add(1, params));
 }
+
+function installationTokenFormat(token: string): 'stateless' | 'stateful' | 'unknown' {
+  if (!token.startsWith('ghs_')) return 'unknown';
+  const dotCount = token.slice(4).split('.').length - 1;
+  if (dotCount === 2) return 'stateless';
+  if (dotCount === 0) return 'stateful';
+  return 'unknown';
+}

package/test/env.ts

@@ -14,3 +14,4 @@ process.env.GITHUB_APP_SLUG = 'shipfox-test';
 process.env.GITHUB_APP_USERNAME = 'shipfox-test';
 process.env.GITHUB_INSTALL_STATE_SECRET = 'test-install-state-secret';
 process.env.GITHUB_API_BASE_URL = 'https://api.github.com';
+process.env.GITHUB_INSTALLATION_TOKEN_FORMAT_OVERRIDE = 'enabled';

package/test/fixtures/github-installation-token.ts

@@ -0,0 +1,8 @@
+const JWT_SEGMENT_LENGTH = 169;
+
+export const GITHUB_STATELESS_INSTALLATION_TOKEN =
+  `ghs_123456_${'a'.repeat(JWT_SEGMENT_LENGTH)}` +
+  `.${'b'.repeat(JWT_SEGMENT_LENGTH)}` +
+  `.${'c'.repeat(JWT_SEGMENT_LENGTH)}`;
+
+export const GITHUB_STATEFUL_INSTALLATION_TOKEN = `ghs_${'d'.repeat(36)}`;

package/test/index.ts

@@ -1,2 +1,6 @@
 export {githubInstallationFactory} from './factories/github-installation.js';
+export {
+  GITHUB_STATEFUL_INSTALLATION_TOKEN,
+  GITHUB_STATELESS_INSTALLATION_TOKEN,
+} from './fixtures/github-installation-token.js';
 export {type GithubPushPayloadOptions, githubPushPayload} from './fixtures/github-webhook.js';