@codraoss/provider-github 0.9.4

package/dist/index.js

@@ -0,0 +1,653 @@
+import {
+  exchangeGitHubOAuthCode,
+  fetchGitHubOAuthProfile,
+  toDashboardSessionUser
+} from "./chunk-OACX7HPZ.js";
+import {
+  normalizeGitHubWebhook
+} from "./chunk-JIVK2ZFL.js";
+
+// src/client.ts
+import { withTimeout as withTimeout2 } from "@codraoss/core/timeout";
+
+// src/http.ts
+import { logger } from "@codraoss/core/logger";
+var GitHubError = class extends Error {
+  constructor(status, body, path, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.path = path;
+    this.name = "GitHubError";
+  }
+  status;
+  body;
+  path;
+};
+async function assertResponseOk(response, path, action) {
+  if (!response.ok) {
+    let errText;
+    try {
+      errText = await response.text();
+    } catch {
+      errText = "<unreadable>";
+    }
+    throw new GitHubError(response.status, errText, path, `${action} failed with ${response.status}: ${errText}`);
+  }
+}
+function isDiffTooLargeError(error) {
+  return error instanceof GitHubError && error.status === 406 && /too_large|maximum number of lines/i.test(error.body ?? "");
+}
+async function withRetry(operation, fn, maxRetries = 2) {
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      attempt++;
+      const isSecondaryRateLimit = error instanceof GitHubError && error.status === 403 && error.body?.toLowerCase().includes("secondary rate limit");
+      const isRetryable = isSecondaryRateLimit || error instanceof GitHubError && (error.status === 429 || error.status >= 500) || error.name === "TimeoutError" || error.message.includes("timeout");
+      if (!isRetryable || attempt > maxRetries) {
+        throw error;
+      }
+      const delay = isSecondaryRateLimit ? Math.pow(2, attempt) * 3e4 : Math.pow(2, attempt) * 1e3;
+      logger.warn(`Retrying GitHub operation ${operation} (attempt ${attempt}/${maxRetries}) in ${delay}ms`, {
+        status: error instanceof GitHubError ? error.status : void 0,
+        error: error.message
+      });
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}
+function installationCacheKey(installationId) {
+  return `install:${installationId}`;
+}
+function encodeGitHubContentPath(path) {
+  return path.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function repoApiPath(owner, repo) {
+  return `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+}
+
+// src/constants.ts
+var GITHUB_TIMEOUT_MS = 3e4;
+var GITHUB_APP_INSTALL_URL_CACHE_KEY = "github:app_installation_url";
+var GITHUB_REPOSITORIES_PER_PAGE = 100;
+var GITHUB_REPOSITORY_PAGE_LIMIT = 100;
+var DIFF_FILES_PER_PAGE = 100;
+var MAX_DIFF_FILE_PAGES = 5;
+
+// src/app-auth.ts
+import { withTimeout } from "@codraoss/core/timeout";
+function pemToArrayBuffer(pem) {
+  const base64 = pem.replace(/-----BEGIN (RSA )?PRIVATE KEY-----/g, "").replace(/-----END (RSA )?PRIVATE KEY-----/g, "").replace(/\\n/g, "").replace(/\s+/g, "");
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes.buffer;
+}
+function base64UrlEncode(input) {
+  return btoa(input).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+async function createGitHubJwt(appId, privateKeyPem) {
+  const now = Math.floor(Date.now() / 1e3);
+  const header = base64UrlEncode(JSON.stringify({ alg: "RS256", typ: "JWT" }));
+  const payload = base64UrlEncode(
+    JSON.stringify({
+      iat: now - 60,
+      exp: now + 9 * 60,
+      iss: appId
+    })
+  );
+  const key = await crypto.subtle.importKey(
+    "pkcs8",
+    pemToArrayBuffer(privateKeyPem),
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", key, new TextEncoder().encode(`${header}.${payload}`));
+  const signatureString = btoa(String.fromCharCode(...new Uint8Array(signature))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  return `${header}.${payload}.${signatureString}`;
+}
+async function appJwtHeaders(env) {
+  const jwt = await createGitHubJwt(env.GITHUB_APP_ID, env.APP_PRIVATE_KEY);
+  return {
+    Accept: "application/vnd.github+json",
+    Authorization: `Bearer ${jwt}`,
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": env.BOT_USERNAME ?? "codra-bot"
+  };
+}
+function normalizeGitHubAppSlug(slug) {
+  const normalized = slug?.trim().replace(/\[bot\]$/i, "");
+  return normalized || null;
+}
+function installUrlFromSlug(slug) {
+  return `https://github.com/apps/${encodeURIComponent(slug)}/installations/new`;
+}
+async function readCachedInstallationToken(env, installationId, tracker) {
+  if (tracker) tracker.incrementSubrequests(1);
+  const cached = await env.APP_KV.get(installationCacheKey(installationId), "json");
+  return cached;
+}
+async function writeCachedInstallationToken(env, installationId, record, tracker) {
+  const expiresAt = new Date(record.expiresAt).getTime();
+  const ttl = Math.max(60, Math.floor((expiresAt - Date.now()) / 1e3) - 300);
+  if (tracker) tracker.incrementSubrequests(1);
+  await env.APP_KV.put(installationCacheKey(installationId), JSON.stringify(record), { expirationTtl: ttl });
+}
+async function fetchInstallationToken(env, installationId) {
+  const headers = await appJwtHeaders(env);
+  const response = await withTimeout(
+    "GitHub installation token",
+    GITHUB_TIMEOUT_MS,
+    (signal) => fetch(`https://api.github.com/app/installations/${installationId}/access_tokens`, {
+      method: "POST",
+      signal,
+      headers
+    })
+  );
+  await assertResponseOk(response, "/app/installations/.../access_tokens", "GitHub installation token request");
+  const data = await response.json();
+  return { token: data.token, expiresAt: data.expires_at };
+}
+async function fetchInstallations(env) {
+  return withRetry("listInstallations", async () => {
+    const headers = await appJwtHeaders(env);
+    const response = await withTimeout(
+      "GitHub list installations",
+      GITHUB_TIMEOUT_MS,
+      (signal) => fetch("https://api.github.com/app/installations", { signal, headers })
+    );
+    await assertResponseOk(response, "/app/installations", "GitHub list installations");
+    return await response.json();
+  });
+}
+async function fetchAppInstallationUrl(env) {
+  const configuredSlug = normalizeGitHubAppSlug(env.GITHUB_APP_SLUG);
+  if (configuredSlug) {
+    return installUrlFromSlug(configuredSlug);
+  }
+  const cached = await env.APP_KV.get(GITHUB_APP_INSTALL_URL_CACHE_KEY);
+  if (cached) {
+    return cached;
+  }
+  return withRetry("getAppInstallationUrl", async () => {
+    const headers = await appJwtHeaders(env);
+    const response = await withTimeout(
+      "GitHub app lookup",
+      GITHUB_TIMEOUT_MS,
+      (signal) => fetch("https://api.github.com/app", { signal, headers })
+    );
+    await assertResponseOk(response, "/app", "GitHub app lookup");
+    const app = await response.json();
+    const fallbackSlug = normalizeGitHubAppSlug(app.slug);
+    const installUrl = app.html_url ? `${app.html_url.replace(/\/$/, "")}/installations/new` : fallbackSlug ? installUrlFromSlug(fallbackSlug) : null;
+    if (!installUrl) {
+      throw new Error("GitHub app lookup did not return a usable app URL.");
+    }
+    await env.APP_KV.put(GITHUB_APP_INSTALL_URL_CACHE_KEY, installUrl, { expirationTtl: 60 * 60 * 24 });
+    return installUrl;
+  });
+}
+
+// src/diff-fetch.ts
+import { logger as logger2 } from "@codraoss/core/logger";
+import { buildUnifiedDiffFromFiles } from "@codraoss/core/diff";
+async function fetchPullRequestDiffFromFiles(ctx, owner, repo, pullNumber) {
+  const files = [];
+  for (let page = 1; page <= MAX_DIFF_FILE_PAGES; page++) {
+    const pageFiles = await withRetry(`getPullRequestFiles ${owner}/${repo}#${pullNumber} p${page}`, async () => {
+      const response = await ctx.requestAndCheck(
+        `${repoApiPath(owner, repo)}/pulls/${pullNumber}/files?per_page=${DIFF_FILES_PER_PAGE}&page=${page}`
+      );
+      return await response.json();
+    });
+    files.push(...pageFiles);
+    if (pageFiles.length < DIFF_FILES_PER_PAGE) break;
+    if (page === MAX_DIFF_FILE_PAGES) {
+      logger2.warn(
+        `Stopped rebuilding the diff for ${owner}/${repo}#${pullNumber} at ${files.length} files; later files are not reviewed`
+      );
+    }
+  }
+  return buildUnifiedDiffFromFiles(files);
+}
+async function fetchPullRequestDiff(ctx, owner, repo, pullNumber) {
+  try {
+    return await withRetry(`getPullRequestDiff ${owner}/${repo}#${pullNumber}`, async () => {
+      const response = await ctx.requestAndCheck(
+        `${repoApiPath(owner, repo)}/pulls/${pullNumber}`,
+        {},
+        "application/vnd.github.v3.diff"
+      );
+      return response.text();
+    });
+  } catch (error) {
+    if (!isDiffTooLargeError(error)) throw error;
+    logger2.warn(
+      `Diff for ${owner}/${repo}#${pullNumber} exceeds GitHub's 20,000-line media-type cap; rebuilding it from the per-file endpoint`
+    );
+    return fetchPullRequestDiffFromFiles(ctx, owner, repo, pullNumber);
+  }
+}
+async function fetchCompareDiff(ctx, owner, repo, base, head) {
+  const comparePath = `${repoApiPath(owner, repo)}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`;
+  try {
+    return await withRetry(`getCompareDiff ${owner}/${repo} ${base}...${head}`, async () => {
+      const response = await ctx.requestAndCheck(comparePath, {}, "application/vnd.github.v3.diff");
+      return response.text();
+    });
+  } catch (error) {
+    if (!isDiffTooLargeError(error)) throw error;
+    logger2.warn(`Compare diff ${owner}/${repo} ${base}...${head} is over the line cap; rebuilding from the JSON file list`);
+    return withRetry(`getCompareFiles ${owner}/${repo} ${base}...${head}`, async () => {
+      const response = await ctx.requestAndCheck(comparePath);
+      const payload = await response.json();
+      return buildUnifiedDiffFromFiles(payload.files ?? []);
+    });
+  }
+}
+
+// src/review-post.ts
+import { logger as logger3 } from "@codraoss/core/logger";
+async function postReview(ctx, owner, repo, pullNumber, input) {
+  return withRetry(`createReview ${owner}/${repo}#${pullNumber}`, async () => {
+    const mapped = input.comments.map((comment) => {
+      if (typeof comment.line === "number" && comment.line > 0) {
+        return {
+          path: comment.path,
+          line: comment.line,
+          side: comment.side ?? "RIGHT",
+          body: comment.body
+        };
+      }
+      if (typeof comment.position === "number" && comment.position > 0) {
+        return { path: comment.path, position: comment.position, body: comment.body };
+      }
+      return null;
+    });
+    let postedIndices = mapped.flatMap((c, index) => c === null ? [] : [index]);
+    const comments = mapped.filter((c) => c !== null);
+    const unaddressable = mapped.length - comments.length;
+    if (unaddressable > 0) {
+      logger3.warn("Dropping review comments with no usable line/position", {
+        owner,
+        repo,
+        pullNumber,
+        unaddressable,
+        total: mapped.length
+      });
+    }
+    const body = {
+      commit_id: input.commitSha,
+      event: input.event,
+      body: input.body,
+      comments
+    };
+    const reviewPath = `${repoApiPath(owner, repo)}/pulls/${pullNumber}/reviews`;
+    let response = await ctx.request(reviewPath, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 422 && body.comments.length > 0) {
+      const reason = await response.clone().text().catch(() => "<unreadable>");
+      logger3.warn(`GitHub review creation failed with 422, retrying without inline comments`, {
+        owner,
+        repo,
+        pullNumber,
+        droppedComments: body.comments.length,
+        reason: reason.slice(0, 500)
+      });
+      response = await ctx.request(reviewPath, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          commit_id: input.commitSha,
+          event: input.event,
+          body: input.body,
+          comments: []
+        })
+      });
+      postedIndices = [];
+    }
+    await assertResponseOk(response, reviewPath, "GitHub review creation");
+    const review = await response.json();
+    return { id: review.id, postedIndices };
+  });
+}
+async function findBotReviewForCommit(ctx, owner, repo, pullNumber, commitSha, botLogin) {
+  return withRetry(`findBotReviewForCommit ${owner}/${repo}#${pullNumber}`, async () => {
+    const response = await ctx.requestAndCheck(
+      `${repoApiPath(owner, repo)}/pulls/${pullNumber}/reviews?per_page=100`
+    );
+    const reviews = await response.json();
+    const login = botLogin.toLowerCase();
+    const match = reviews.find(
+      (review) => review.commit_id === commitSha && (review.user?.login ?? "").toLowerCase().startsWith(login)
+    );
+    return match ? { id: match.id } : null;
+  });
+}
+
+// src/labels.ts
+async function ensureLabel(ctx, owner, repo, name, color) {
+  return withRetry(`ensureLabel ${owner}/${repo} ${name}`, async () => {
+    const listResponse = await ctx.request(`${repoApiPath(owner, repo)}/labels/${encodeURIComponent(name)}`);
+    if (listResponse.ok) return;
+    if (listResponse.status !== 404) {
+      await assertResponseOk(listResponse, name, "GitHub label lookup");
+    }
+    const createResponse = await ctx.request(`${repoApiPath(owner, repo)}/labels`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ name, color })
+    });
+    if (!createResponse.ok && createResponse.status !== 422) {
+      await assertResponseOk(createResponse, name, "GitHub label creation");
+    }
+  });
+}
+async function addIssueLabels(ctx, owner, repo, issueNumber, labels) {
+  return withRetry(`addIssueLabels ${owner}/${repo}#${issueNumber}`, async () => {
+    await ctx.requestAndCheck(`${repoApiPath(owner, repo)}/issues/${issueNumber}/labels`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ labels })
+    });
+  });
+}
+async function listIssueLabels(ctx, owner, repo, issueNumber) {
+  return withRetry(`listIssueLabels ${owner}/${repo}#${issueNumber}`, async () => {
+    const response = await ctx.requestAndCheck(`${repoApiPath(owner, repo)}/issues/${issueNumber}/labels?per_page=100`);
+    const labels = await response.json();
+    if (!Array.isArray(labels)) {
+      throw new Error("Expected an array of labels from GitHub API.");
+    }
+    return labels.map((label) => label.name).filter((name) => typeof name === "string" && name.length > 0);
+  });
+}
+async function removeIssueLabel(ctx, owner, repo, issueNumber, label) {
+  return withRetry(`removeIssueLabel ${owner}/${repo}#${issueNumber} ${label}`, async () => {
+    const response = await ctx.request(
+      `${repoApiPath(owner, repo)}/issues/${issueNumber}/labels/${encodeURIComponent(label)}`,
+      {
+        method: "DELETE"
+      }
+    );
+    if (!response.ok && response.status !== 404) {
+      await assertResponseOk(response, label, "GitHub label removal");
+    }
+  });
+}
+
+// src/client.ts
+var GitHubClient = class {
+  constructor(env, installationId, tracker) {
+    this.env = env;
+    this.installationId = installationId;
+    this.tracker = tracker;
+  }
+  env;
+  installationId;
+  tracker;
+  // Scoped per invocation to avoid KV hits & 50-subrequest cap.
+  memoToken = null;
+  async getInstallationToken() {
+    if (this.memoToken?.token && new Date(this.memoToken.expiresAt).getTime() > Date.now() + 6e4) {
+      return this.memoToken.token;
+    }
+    const cached = await readCachedInstallationToken(this.env, this.installationId, this.tracker);
+    if (cached?.token) {
+      this.memoToken = cached;
+      return cached.token;
+    }
+    return withRetry("getInstallationToken", async () => {
+      const record = await fetchInstallationToken(this.env, this.installationId);
+      await writeCachedInstallationToken(this.env, this.installationId, record, this.tracker);
+      this.memoToken = record;
+      return record.token;
+    });
+  }
+  static async listInstallations(env) {
+    return fetchInstallations(env);
+  }
+  static async getAppInstallationUrl(env) {
+    return fetchAppInstallationUrl(env);
+  }
+  async listRepositories() {
+    return withRetry("listRepositories", async () => {
+      const repositories = [];
+      for (let page = 1; page <= GITHUB_REPOSITORY_PAGE_LIMIT; page += 1) {
+        const response = await this.requestAndCheck(`/installation/repositories?per_page=${GITHUB_REPOSITORIES_PER_PAGE}&page=${page}`);
+        const data = await response.json();
+        repositories.push(...data.repositories);
+        if (data.repositories.length < GITHUB_REPOSITORIES_PER_PAGE) {
+          return repositories;
+        }
+      }
+      throw new Error(
+        `GitHub repository listing exceeded ${GITHUB_REPOSITORY_PAGE_LIMIT} pages without a terminating page.`
+      );
+    });
+  }
+  async request(path, init = {}, accept = "application/vnd.github+json") {
+    const token = await this.getInstallationToken();
+    if (this.tracker) this.tracker.incrementSubrequests(1);
+    return withTimeout2(
+      `GitHub ${init.method ?? "GET"} ${path}`,
+      GITHUB_TIMEOUT_MS,
+      (signal) => fetch(`https://api.github.com${path}`, {
+        ...init,
+        signal,
+        headers: {
+          Accept: accept,
+          Authorization: `Bearer ${token}`,
+          "X-GitHub-Api-Version": "2022-11-28",
+          "User-Agent": this.env.BOT_USERNAME ?? "codra-bot",
+          ...init.headers
+        }
+      })
+    );
+  }
+  async requestAndCheck(path, init = {}, accept = "application/vnd.github+json") {
+    const response = await this.request(path, init, accept);
+    await assertResponseOk(response, path, `GitHub API ${init.method ?? "GET"} ${path}`);
+    return response;
+  }
+  // Hands the extracted helpers the authenticated-request surface.
+  ctx() {
+    return {
+      request: (path, init, accept) => this.request(path, init, accept),
+      requestAndCheck: (path, init, accept) => this.requestAndCheck(path, init, accept)
+    };
+  }
+  async graphql(query, variables) {
+    return withRetry("graphql", async () => {
+      const token = await this.getInstallationToken();
+      if (this.tracker) this.tracker.incrementSubrequests(1);
+      const response = await withTimeout2(
+        "GitHub GraphQL",
+        GITHUB_TIMEOUT_MS,
+        (signal) => fetch("https://api.github.com/graphql", {
+          method: "POST",
+          signal,
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "User-Agent": this.env.BOT_USERNAME ?? "codra-bot",
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({ query, variables })
+        })
+      );
+      await assertResponseOk(response, "/graphql", "GitHub GraphQL request");
+      const payload = await response.json();
+      if (payload.errors?.length) {
+        throw new GitHubError(
+          422,
+          JSON.stringify(payload.errors),
+          "/graphql",
+          `GitHub GraphQL error: ${payload.errors[0].message}`
+        );
+      }
+      return payload.data;
+    });
+  }
+  async getPullRequest(owner, repo, pullNumber) {
+    return withRetry(`getPullRequest ${owner}/${repo}#${pullNumber}`, async () => {
+      const response = await this.requestAndCheck(`${repoApiPath(owner, repo)}/pulls/${pullNumber}`);
+      return await response.json();
+    });
+  }
+  async getPullRequestDiff(owner, repo, pullNumber) {
+    return fetchPullRequestDiff(this.ctx(), owner, repo, pullNumber);
+  }
+  async getCompareDiff(owner, repo, base, head) {
+    return fetchCompareDiff(this.ctx(), owner, repo, base, head);
+  }
+  async getRepoFileOrNull(owner, repo, path) {
+    return withRetry(`getRepoFileOrNull ${owner}/${repo}/${path}`, async () => {
+      const response = await this.request(`${repoApiPath(owner, repo)}/contents/${encodeGitHubContentPath(path)}`);
+      if (response.status === 404) return null;
+      await assertResponseOk(response, path, "GitHub repo file fetch");
+      const data = await response.json();
+      if (!data.content) {
+        return null;
+      }
+      return data.encoding === "base64" ? atob(data.content.replace(/\n/g, "")) : data.content;
+    });
+  }
+  async createCheckRun(owner, repo, input) {
+    return withRetry(`createCheckRun ${owner}/${repo}`, async () => {
+      const response = await this.requestAndCheck(`${repoApiPath(owner, repo)}/check-runs`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          name: "Codra",
+          head_sha: input.headSha,
+          status: "in_progress",
+          details_url: input.detailsUrl,
+          output: {
+            title: input.title,
+            summary: input.summary
+          }
+        })
+      });
+      return await response.json();
+    });
+  }
+  async updateCheckRun(owner, repo, checkRunId, input) {
+    return withRetry(`updateCheckRun ${owner}/${repo} ${checkRunId}`, async () => {
+      await this.requestAndCheck(`${repoApiPath(owner, repo)}/check-runs/${checkRunId}`, {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          status: input.status ?? "in_progress",
+          conclusion: input.conclusion,
+          completed_at: input.status === "completed" ? (/* @__PURE__ */ new Date()).toISOString() : void 0,
+          output: {
+            title: input.title,
+            summary: input.summary
+          }
+        })
+      });
+    });
+  }
+  async createReview(owner, repo, pullNumber, input) {
+    return postReview(this.ctx(), owner, repo, pullNumber, input);
+  }
+  async findBotReviewForCommit(owner, repo, pullNumber, commitSha, botLogin) {
+    return findBotReviewForCommit(this.ctx(), owner, repo, pullNumber, commitSha, botLogin);
+  }
+  async ensureLabel(owner, repo, name, color) {
+    return ensureLabel(this.ctx(), owner, repo, name, color);
+  }
+  async addIssueLabels(owner, repo, issueNumber, labels) {
+    return addIssueLabels(this.ctx(), owner, repo, issueNumber, labels);
+  }
+  async listIssueLabels(owner, repo, issueNumber) {
+    return listIssueLabels(this.ctx(), owner, repo, issueNumber);
+  }
+  // Case-insensitive removal using stored casing.
+  async removeIssueLabelsIfPresent(owner, repo, issueNumber, labels) {
+    const currentLabels = await this.listIssueLabels(owner, repo, issueNumber);
+    const currentByLowerName = new Map(currentLabels.map((label) => [label.toLowerCase(), label]));
+    const uniqueLabels = Array.from(new Set(labels.map((label) => label.toLowerCase())));
+    for (const label of uniqueLabels) {
+      const currentLabel = currentByLowerName.get(label);
+      if (currentLabel) {
+        await this.removeIssueLabel(owner, repo, issueNumber, currentLabel);
+      }
+    }
+  }
+  async removeIssueLabel(owner, repo, issueNumber, label) {
+    return removeIssueLabel(this.ctx(), owner, repo, issueNumber, label);
+  }
+};
+
+// src/service.ts
+var GitHubService = class {
+  client;
+  constructor(env, installationId, tracker) {
+    this.client = new GitHubClient(env, installationId, tracker);
+  }
+  async getPullRequest(owner, repo, prNumber) {
+    return this.client.getPullRequest(owner, repo, prNumber);
+  }
+  async getPullRequestDiff(owner, repo, prNumber) {
+    return this.client.getPullRequestDiff(owner, repo, prNumber);
+  }
+  async getCompareDiff(owner, repo, base, head) {
+    return this.client.getCompareDiff(owner, repo, base, head);
+  }
+  async createCheckRun(owner, repo, params) {
+    return this.client.createCheckRun(owner, repo, params);
+  }
+  async updateCheckRun(owner, repo, checkRunId, params) {
+    return this.client.updateCheckRun(owner, repo, checkRunId, params);
+  }
+  async createReview(owner, repo, prNumber, params) {
+    return this.client.createReview(owner, repo, prNumber, params);
+  }
+  async findBotReviewForCommit(owner, repo, prNumber, commitSha, botLogin) {
+    return this.client.findBotReviewForCommit(owner, repo, prNumber, commitSha, botLogin);
+  }
+  async ensureLabel(owner, repo, name, color) {
+    return this.client.ensureLabel(owner, repo, name, color);
+  }
+  async addIssueLabels(owner, repo, prNumber, labels) {
+    return this.client.addIssueLabels(owner, repo, prNumber, labels);
+  }
+  async removeIssueLabelsIfPresent(owner, repo, prNumber, labels) {
+    return this.client.removeIssueLabelsIfPresent(owner, repo, prNumber, labels);
+  }
+  async removeIssueLabel(owner, repo, prNumber, label) {
+    return this.client.removeIssueLabel(owner, repo, prNumber, label);
+  }
+};
+export {
+  GitHubClient,
+  GitHubError,
+  GitHubService,
+  exchangeGitHubOAuthCode,
+  fetchGitHubOAuthProfile,
+  normalizeGitHubWebhook,
+  toDashboardSessionUser
+};
+//# sourceMappingURL=index.js.map