@oneuptime/common 11.5.7 → 11.5.9

package/Server/Utils/CodeRepository/GitHub/GitHub.ts

@@ -4,6 +4,7 @@ import HostedCodeRepository from "../HostedCodeRepository/HostedCodeRepository";
 import HTTPErrorResponse from "../../../../Types/API/HTTPErrorResponse";
 import HTTPResponse from "../../../../Types/API/HTTPResponse";
 import URL from "../../../../Types/API/URL";
+import Headers from "../../../../Types/API/Headers";
 import PullRequest from "../../../../Types/CodeRepository/PullRequest";
 import PullRequestState from "../../../../Types/CodeRepository/PullRequestState";
 import FixPullRequestCiStatus, {
@@ -55,6 +56,34 @@ export interface GitHubCheckRunsSummary extends FixPullRequestCiCheckRunCounts {
   conclusion: FixPullRequestCiStatus;
 }
 
+// One file's contents read over the Contents API (no clone).
+export interface GitHubFileContent {
+  content: string;
+  filePath: string;
+  sizeInBytes: number;
+  totalLines: number;
+  htmlUrl: string;
+}
+
+// One branch's head, plus whether GitHub considers it protected.
+export interface GitHubBranchInfo {
+  name: string;
+  headSha: string;
+  isProtected: boolean;
+}
+
+// A file to write in a commit. content is the FULL new file body.
+export interface GitHubFileChange {
+  filePath: string;
+  content: string;
+}
+
+export interface GitHubCommitResult {
+  commitSha: string;
+  branchName: string;
+  htmlUrl: string;
+}
+
 export default class GitHubUtil extends HostedCodeRepository {
   private getPullRequestFromJSONObject(data: {
     pullRequest: JSONObject;
@@ -805,6 +834,577 @@ export default class GitHubUtil extends HostedCodeRepository {
     return paths;
   }
 
+  /**
+   * Reads one file's contents from a repository over the Contents API, with no
+   * clone. This is what makes reading code viable from a request-scoped caller
+   * (e.g. the chat toolbox, which has a 45s per-tool timeout a clone cannot
+   * fit).
+   *
+   * Returns null when the path does not exist on the branch, so callers can
+   * tell "no such file" apart from a transport failure without catching.
+   * @returns The file's text plus its total line count, or null if not found
+   */
+  @CaptureSpan()
+  public static async getFileContent(data: {
+    installationId: string;
+    organizationName: string;
+    repositoryName: string;
+    branchName: string;
+    filePath: string;
+  }): Promise<GitHubFileContent | null> {
+    /*
+     * Each path segment is encoded separately: encodeURIComponent would turn
+     * the directory separators into %2F, which the Contents API treats as part
+     * of a (nonexistent) filename rather than as a path.
+     */
+    const encodedPath: string = data.filePath
+      .split("/")
+      .map((segment: string) => {
+        return encodeURIComponent(segment);
+      })
+      .join("/");
+
+    const url: URL = URL.fromString(
+      `https://api.github.com/repos/${data.organizationName}/${data.repositoryName}/contents/${encodedPath}?ref=${encodeURIComponent(data.branchName)}`,
+    );
+
+    const tokenData: GitHubInstallationToken =
+      await GitHubUtil.getInstallationAccessToken(data.installationId, {
+        permissions: {
+          contents: "read",
+          metadata: "read",
+        },
+      });
+
+    const result: HTTPErrorResponse | HTTPResponse<JSONObject> = await API.get({
+      url: url,
+      headers: {
+        Authorization: `Bearer ${tokenData.token}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+    });
+
+    if (result instanceof HTTPErrorResponse) {
+      if (result.statusCode === 404) {
+        return null;
+      }
+      throw result;
+    }
+
+    /*
+     * A directory returns a JSON array, not an object. Treat it as "not a
+     * readable file" rather than erroring — the model routinely guesses a
+     * directory path, and a null lets it self-correct via search_code.
+     */
+    if (Array.isArray(result.data)) {
+      return null;
+    }
+
+    if (result.data["type"] !== "file") {
+      return null;
+    }
+
+    const sizeInBytes: number = (result.data["size"] as number) || 0;
+    const encodedContent: string = (result.data["content"] as string) || "";
+
+    /*
+     * `encoding` — not an empty `content` — is what distinguishes an oversized
+     * blob from an empty one. Over ~1MB the API declines to inline the blob and
+     * returns encoding "none" with content ""; a legitimately empty 0-byte file
+     * returns encoding "base64" with content "" too. Keying off the empty
+     * string alone would report every empty file as too large.
+     */
+    const encoding: string = (result.data["encoding"] as string) || "";
+
+    if (encoding === "none") {
+      throw new BadDataException(
+        `${data.filePath} is ${sizeInBytes} bytes, which is too large for GitHub to return inline (the limit is 1MB). Read a specific region of it is not possible via this tool.`,
+      );
+    }
+
+    if (encoding && encoding !== "base64") {
+      throw new BadDataException(
+        `${data.filePath} came back in an unsupported encoding ("${encoding}").`,
+      );
+    }
+
+    const content: string = encodedContent
+      ? Buffer.from(encodedContent.replace(/\n/g, ""), "base64").toString(
+          "utf8",
+        )
+      : "";
+
+    /*
+     * Binary files decode into mojibake that wastes context and can never
+     * answer a question. A NUL byte is the cheapest reliable discriminator.
+     */
+    if (content.includes("\0")) {
+      return null;
+    }
+
+    return {
+      content: content,
+      filePath: data.filePath,
+      sizeInBytes: sizeInBytes,
+      totalLines: GitHubUtil.countLines(content),
+      htmlUrl: (result.data["html_url"] as string) || "",
+    };
+  }
+
+  /*
+   * Line count that does not invent a phantom blank line for the trailing
+   * newline virtually every source file ends with (a plain split("\n") counts
+   * the empty string after it).
+   */
+  private static countLines(content: string): number {
+    if (content === "") {
+      return 0;
+    }
+
+    const lines: number = content.split("\n").length;
+
+    return content.endsWith("\n") ? lines - 1 : lines;
+  }
+
+  /*
+   * The repository's real default branch, read from GitHub rather than from
+   * our stored mainBranchName. Callers refusing to write to the default branch
+   * must ask GitHub: our column is a copy made at import time and drifts when
+   * the repository is renamed or its default is changed.
+   */
+  @CaptureSpan()
+  public static async getDefaultBranchName(data: {
+    installationId: string;
+    organizationName: string;
+    repositoryName: string;
+  }): Promise<string> {
+    const tokenData: GitHubInstallationToken =
+      await GitHubUtil.getInstallationAccessToken(data.installationId, {
+        permissions: { metadata: "read" },
+      });
+
+    const result: HTTPErrorResponse | HTTPResponse<JSONObject> = await API.get({
+      url: URL.fromString(
+        `https://api.github.com/repos/${data.organizationName}/${data.repositoryName}`,
+      ),
+      headers: GitHubUtil.buildApiHeaders(tokenData.token),
+    });
+
+    if (result instanceof HTTPErrorResponse) {
+      throw result;
+    }
+
+    return (result.data["default_branch"] as string) || "";
+  }
+
+  /*
+   * One branch's head sha and protection flag, or null when the branch does
+   * not exist. Protection is part of the same payload, so a caller enforcing
+   * "never write to a protected branch" needs no second round-trip.
+   */
+  @CaptureSpan()
+  public static async getBranch(data: {
+    installationId: string;
+    organizationName: string;
+    repositoryName: string;
+    branchName: string;
+  }): Promise<GitHubBranchInfo | null> {
+    const tokenData: GitHubInstallationToken =
+      await GitHubUtil.getInstallationAccessToken(data.installationId, {
+        permissions: { contents: "read", metadata: "read" },
+      });
+
+    const result: HTTPErrorResponse | HTTPResponse<JSONObject> = await API.get({
+      url: URL.fromString(
+        `https://api.github.com/repos/${data.organizationName}/${data.repositoryName}/branches/${encodeURIComponent(data.branchName)}`,
+      ),
+      headers: GitHubUtil.buildApiHeaders(tokenData.token),
+    });
+
+    if (result instanceof HTTPErrorResponse) {
+      if (result.statusCode === 404) {
+        return null;
+      }
+      throw result;
+    }
+
+    const commit: JSONObject = (result.data["commit"] as JSONObject) || {};
+
+    return {
+      name: (result.data["name"] as string) || data.branchName,
+      headSha: (commit["sha"] as string) || "",
+      isProtected: result.data["protected"] === true,
+    };
+  }
+
+  /*
+   * Commit a set of whole-file changes onto an EXISTING branch, with no clone,
+   * via the Git Data API (blobs → tree → commit → move ref).
+   *
+   * The tree is built on the branch head's tree, so files not named here are
+   * untouched, and all changes land as ONE commit — a partial write cannot be
+   * left behind if a later step fails.
+   *
+   * This deliberately does NOT decide what may be written to: enforcing the
+   * default/protected-branch refusal is the caller's job, because only the
+   * caller knows the trust context of the change.
+   */
+  @CaptureSpan()
+  public static async commitFilesToBranch(data: {
+    installationId: string;
+    organizationName: string;
+    repositoryName: string;
+    branchName: string;
+    changes: Array<GitHubFileChange>;
+    commitMessage: string;
+  }): Promise<GitHubCommitResult> {
+    if (data.changes.length === 0) {
+      throw new BadDataException("No file changes were provided to commit.");
+    }
+
+    const tokenData: GitHubInstallationToken =
+      await GitHubUtil.getInstallationAccessToken(data.installationId, {
+        permissions: { contents: "write", metadata: "read" },
+      });
+
+    const headers: Headers = GitHubUtil.buildApiHeaders(tokenData.token);
+    const repoApiUrl: string = `https://api.github.com/repos/${data.organizationName}/${data.repositoryName}`;
+
+    // 1. Where the branch currently points.
+    const refResult: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.get({
+        url: URL.fromString(
+          `${repoApiUrl}/git/ref/heads/${encodeURIComponent(data.branchName)}`,
+        ),
+        headers: headers,
+      });
+
+    if (refResult instanceof HTTPErrorResponse) {
+      throw refResult;
+    }
+
+    const baseCommitSha: string = ((refResult.data["object"] as JSONObject) ||
+      {})["sha"] as string;
+
+    // 2. That commit's tree, so unnamed files carry over untouched.
+    const baseCommitResult: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.get({
+        url: URL.fromString(`${repoApiUrl}/git/commits/${baseCommitSha}`),
+        headers: headers,
+      });
+
+    if (baseCommitResult instanceof HTTPErrorResponse) {
+      throw baseCommitResult;
+    }
+
+    const baseTreeSha: string = ((baseCommitResult.data[
+      "tree"
+    ] as JSONObject) || {})["sha"] as string;
+
+    /*
+     * 3. The existing mode of every path we are about to rewrite.
+     *
+     * A tree entry is (mode, type, path, sha) and an entry we supply REPLACES
+     * the base_tree's entry wholesale — there is no "keep the existing mode"
+     * option. Hardcoding 100644 would therefore silently demote executables
+     * (100755 -> not executable) and turn symlinks (120000) into regular files
+     * holding the link text. Both render as a one-line mode header in a diff
+     * that reviewers skim past, so it must be right here rather than caught in
+     * review.
+     */
+    const existingModes: Map<string, string> =
+      await GitHubUtil.getTreeEntryModes({
+        repoApiUrl,
+        headers,
+        treeSha: baseTreeSha,
+      });
+
+    // 4. A blob per changed file, carrying the path's existing mode forward.
+    const treeEntries: JSONArray = [];
+
+    for (const change of data.changes) {
+      const blobResult: HTTPErrorResponse | HTTPResponse<JSONObject> =
+        await API.post({
+          url: URL.fromString(`${repoApiUrl}/git/blobs`),
+          data: {
+            content: Buffer.from(change.content, "utf8").toString("base64"),
+            encoding: "base64",
+          },
+          headers: headers,
+        });
+
+      if (blobResult instanceof HTTPErrorResponse) {
+        throw blobResult;
+      }
+
+      const existingMode: string | undefined = existingModes.get(
+        change.filePath,
+      );
+
+      /*
+       * A symlink or submodule is not something a whole-file text write can
+       * safely replace: writing a blob at a 120000 path would silently turn the
+       * link into a file. Refuse rather than corrupt the tree.
+       */
+      if (existingMode === "120000" || existingMode === "160000") {
+        throw new BadDataException(
+          `"${change.filePath}" is a ${existingMode === "120000" ? "symlink" : "submodule"}, which cannot be rewritten as a text file.`,
+        );
+      }
+
+      treeEntries.push({
+        path: change.filePath,
+        // New files default to a regular non-executable file.
+        mode: existingMode || "100644",
+        type: "blob",
+        sha: blobResult.data["sha"] as string,
+      });
+    }
+
+    // 5. A tree layering those blobs over the base tree.
+    const treeResult: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.post({
+        url: URL.fromString(`${repoApiUrl}/git/trees`),
+        data: {
+          base_tree: baseTreeSha,
+          tree: treeEntries,
+        },
+        headers: headers,
+      });
+
+    if (treeResult instanceof HTTPErrorResponse) {
+      throw treeResult;
+    }
+
+    // 6. The commit itself.
+    const commitResult: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.post({
+        url: URL.fromString(`${repoApiUrl}/git/commits`),
+        data: {
+          message: data.commitMessage,
+          tree: treeResult.data["sha"] as string,
+          parents: [baseCommitSha],
+        },
+        headers: headers,
+      });
+
+    if (commitResult instanceof HTTPErrorResponse) {
+      throw commitResult;
+    }
+
+    const newCommitSha: string = commitResult.data["sha"] as string;
+
+    /*
+     * 7. Move the branch. Not forced: a fast-forward-only update means a
+     * concurrent push to this branch makes us fail loudly rather than silently
+     * discarding someone else's commit.
+     */
+    const updateResult: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.patch({
+        url: URL.fromString(
+          `${repoApiUrl}/git/refs/heads/${encodeURIComponent(data.branchName)}`,
+        ),
+        data: {
+          sha: newCommitSha,
+          force: false,
+        },
+        headers: headers,
+      });
+
+    if (updateResult instanceof HTTPErrorResponse) {
+      throw updateResult;
+    }
+
+    return {
+      commitSha: newCommitSha,
+      branchName: data.branchName,
+      htmlUrl: `https://github.com/${data.organizationName}/${data.repositoryName}/commit/${newCommitSha}`,
+    };
+  }
+
+  /*
+   * Create a branch pointing at another branch's head. Returns false when the
+   * branch already exists (GitHub answers 422), so callers can pick a fresh
+   * name rather than treating it as a hard failure.
+   */
+  @CaptureSpan()
+  public static async createBranch(data: {
+    installationId: string;
+    organizationName: string;
+    repositoryName: string;
+    newBranchName: string;
+    fromBranchName: string;
+  }): Promise<boolean> {
+    const source: GitHubBranchInfo | null = await GitHubUtil.getBranch({
+      installationId: data.installationId,
+      organizationName: data.organizationName,
+      repositoryName: data.repositoryName,
+      branchName: data.fromBranchName,
+    });
+
+    if (!source) {
+      throw new BadDataException(
+        `Cannot branch from "${data.fromBranchName}" — no such branch in ${data.organizationName}/${data.repositoryName}.`,
+      );
+    }
+
+    const tokenData: GitHubInstallationToken =
+      await GitHubUtil.getInstallationAccessToken(data.installationId, {
+        permissions: { contents: "write", metadata: "read" },
+      });
+
+    const result: HTTPErrorResponse | HTTPResponse<JSONObject> = await API.post(
+      {
+        url: URL.fromString(
+          `https://api.github.com/repos/${data.organizationName}/${data.repositoryName}/git/refs`,
+        ),
+        data: {
+          ref: `refs/heads/${data.newBranchName}`,
+          sha: source.headSha,
+        },
+        headers: GitHubUtil.buildApiHeaders(tokenData.token),
+      },
+    );
+
+    if (result instanceof HTTPErrorResponse) {
+      if (result.statusCode === 422) {
+        return false;
+      }
+      throw result;
+    }
+
+    return true;
+  }
+
+  /*
+   * Open a pull request using an installation token — the App-authenticated
+   * sibling of the instance-method createPullRequest, which authenticates from
+   * a clone's own token.
+   *
+   * Opened as a DRAFT by default; GitHub answers 422 for repositories whose
+   * plan lacks drafts, and we retry as non-draft rather than losing the work.
+   */
+  @CaptureSpan()
+  public static async createPullRequestWithToken(data: {
+    installationId: string;
+    organizationName: string;
+    repositoryName: string;
+    baseBranchName: string;
+    headBranchName: string;
+    title: string;
+    body: string;
+    isDraft?: boolean | undefined;
+  }): Promise<PullRequest> {
+    const tokenData: GitHubInstallationToken =
+      await GitHubUtil.getInstallationAccessToken(data.installationId, {
+        permissions: { pull_requests: "write", contents: "write" },
+      });
+
+    const headers: Headers = GitHubUtil.buildApiHeaders(tokenData.token);
+    const url: URL = URL.fromString(
+      `https://api.github.com/repos/${data.organizationName}/${data.repositoryName}/pulls`,
+    );
+
+    const wantsDraft: boolean = data.isDraft !== false;
+
+    let result: HTTPErrorResponse | HTTPResponse<JSONObject> = await API.post({
+      url: url,
+      data: {
+        base: data.baseBranchName,
+        head: data.headBranchName,
+        title: data.title,
+        body: data.body,
+        draft: wantsDraft,
+      },
+      headers: headers,
+    });
+
+    if (
+      result instanceof HTTPErrorResponse &&
+      wantsDraft &&
+      result.statusCode === 422
+    ) {
+      logger.debug(
+        `GitHub rejected the draft pull request for ${data.organizationName}/${data.repositoryName}; retrying as non-draft.`,
+      );
+
+      result = await API.post({
+        url: url,
+        data: {
+          base: data.baseBranchName,
+          head: data.headBranchName,
+          title: data.title,
+          body: data.body,
+        },
+        headers: headers,
+      });
+    }
+
+    if (result instanceof HTTPErrorResponse) {
+      throw result;
+    }
+
+    return new GitHubUtil({
+      authToken: tokenData.token,
+      username: "oneuptime",
+    }).getPullRequestFromJSONObject({
+      pullRequest: result.data,
+      organizationName: data.organizationName,
+      repositoryName: data.repositoryName,
+    });
+  }
+
+  /*
+   * Every blob path in a tree mapped to its git file mode, so a rewrite can
+   * preserve the mode instead of flattening everything to 100644. Recursive
+   * because the caller writes nested paths.
+   *
+   * A truncated response (a tree too large for one page) is not an error here:
+   * a path we cannot see its mode for simply falls back to the 100644 default,
+   * which is the same behaviour as treating it as a new file.
+   */
+  private static async getTreeEntryModes(data: {
+    repoApiUrl: string;
+    headers: Headers;
+    treeSha: string;
+  }): Promise<Map<string, string>> {
+    const modes: Map<string, string> = new Map<string, string>();
+
+    const result: HTTPErrorResponse | HTTPResponse<JSONObject> = await API.get({
+      url: URL.fromString(
+        `${data.repoApiUrl}/git/trees/${data.treeSha}?recursive=1`,
+      ),
+      headers: data.headers,
+    });
+
+    if (result instanceof HTTPErrorResponse) {
+      throw result;
+    }
+
+    const tree: JSONArray = (result.data["tree"] as JSONArray) || [];
+
+    for (const entry of tree) {
+      const entryData: JSONObject = entry as JSONObject;
+      const path: string = entryData["path"] as string;
+      const mode: string = entryData["mode"] as string;
+
+      if (path && mode) {
+        modes.set(path, mode);
+      }
+    }
+
+    return modes;
+  }
+
+  private static buildApiHeaders(token: string): Headers {
+    return {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+    };
+  }
+
   /**
    * Verifies a GitHub webhook signature
    * @param payload - The raw request body

package/Server/Utils/CodeRepository/StackTraceRepoResolver.ts

@@ -86,10 +86,15 @@ const PYTHON_FRAME_REGEX: RegExp = /File\s+"([^"]+)"\s*,\s*line\s+\d+/g;
 /*
  * Normalizes one raw path plucked from a stack frame into a relative,
  * forward-slash path — or null when the frame is dependency/runtime noise.
+ *
+ * Exported because a runtime path from a stack frame (`/app/src/billing.ts`)
+ * is not a repository path (`src/billing.ts`): anything that hands a frame's
+ * file to a repository API must strip the container prefix first, or every
+ * lookup 404s.
  */
-type NormalizeCandidatePathFunction = (rawPath: string) => string | null;
+export type NormalizeCandidatePathFunction = (rawPath: string) => string | null;
 
-const normalizeCandidatePath: NormalizeCandidatePathFunction = (
+export const normalizeCandidatePath: NormalizeCandidatePathFunction = (
   rawPath: string,
 ): string | null => {
   let path: string = rawPath.trim().replace(/\\/g, "/");