git-chopstick-core 0.1.2 → 0.1.4

package/src/git/environment.ts

@@ -1,116 +0,0 @@
-import { envForAuthentication } from './authentication.js'
-import { resolveGitProxy as resolveGitProxyFn } from '../lib/resolve-git-proxy.js'
-import { getHTMLURL } from '../lib/api.js'
-import { Repository } from '../models/repository.js'
-import { IRemote } from '../models/remote.js'
-
-/**
- * For many remote operations it's well known what the primary remote
- * url is (clone, push, fetch etc). But in some cases it's not as easy.
- *
- * Two examples are checkout, and revert where neither would need to
- * hit the network in vanilla Git usage but do need to when LFS gets
- * involved.
- *
- * What's the primary url when using LFS then? Most likely it's gonna
- * be on the same as the default remote but it could theoretically
- * be on a different server as well. That's too advanced for our usage
- * at the moment though so we'll just need to figure out some reasonable
- * url to fall back on.
- *
- * @param branchName If the operation we're about to undertake is related to a
- *                   local ref (i.e branch) then we can use that to resolve its
- *                   upstream tracking branch (and thereby its remote) and use
- *                   that as the probable url to resolve a proxy for.
- */
-export function getFallbackUrlForProxyResolve(
-  _repository: Repository,
-  currentRemote: IRemote | null
-) {
-  if (currentRemote) {
-    return currentRemote.url
-  }
-  return 'https://github.com'
-}
-
-/**
- * Create a set of environment variables to use when invoking a Git
- * subcommand that needs to communicate with a remote (i.e. fetch, clone,
- * push, pull, ls-remote, etc etc).
- *
- * The environment variables deal with setting up sane defaults, configuring
- * authentication, and resolving proxy urls if necessary.
- *
- * @param account   The authentication information (if available) to provide
- *                  to Git for use when connecting to the remote
- * @param remoteUrl The primary remote URL for this operation. Note that Git
- *                  might connect to other remotes in order to fulfill the
- *                  operation. As an example, a clone of
- *                  https://github.com/desktop/desktop could contain a submodule
- *                  pointing to another host entirely. Used to resolve which
- *                  proxy (if any) should be used for the operation.
- */
-export async function envForRemoteOperation(remoteUrl: string | null): Promise<Record<string, string | undefined>> {
-  return {
-    ...envForAuthentication(),
-    ...(await envForProxy(remoteUrl ?? 'https://github.com')),
-  }
-}
-
-/**
- * Not intended to be used directly. Exported only in order to
- * allow for testing.
- *
- * @param remoteUrl The remote url to resolve a proxy for.
- * @param env       The current environment variables, defaults
- *                  to `process.env`
- * @param resolve   The method to use when resolving the proxy url,
- *                  defaults to `resolveGitProxy`
- */
-export async function envForProxy(
-  remoteUrl: string,
-  env: NodeJS.ProcessEnv = process.env,
-  resolve: (url: string) => Promise<string | undefined> = async (url: string) => resolveGitProxyFn() ?? undefined
-): Promise<Record<string, string | undefined> | undefined> {
-  const protocolMatch = /^(https?):\/\//i.exec(remoteUrl)
-
-  // We can only resolve and use a proxy for the protocols where cURL
-  // would be involved (i.e http and https). git:// relies on ssh.
-  if (protocolMatch === null) {
-    return
-  }
-
-  // Note that HTTPS here doesn't mean that the proxy is HTTPS, only
-  // that all requests to HTTPS protocols should be proxied. The
-  // proxy protocol is defined by the url returned by `this.resolve()`
-  const proto = protocolMatch[1].toLowerCase() // http or https
-
-  // We'll play it safe and say that if the user has configured
-  // the ALL_PROXY environment variable they probably know what
-  // they're doing and wouldn't want us to override it with a
-  // protocol-specific proxy. cURL supports both lower and upper
-  // case, see:
-  // https://github.com/curl/curl/blob/14916a82e/lib/url.c#L2180-L2185
-  if ('ALL_PROXY' in env || 'all_proxy' in env) {
-    console.info(`proxy url not resolved, ALL_PROXY already set`)
-    return
-  }
-
-  // Lower case environment variables due to
-  // https://ec.haxx.se/usingcurl/usingcurl-proxies#http_proxy-in-lower-case-only
-  const envKey = `${proto}_proxy` // http_proxy or https_proxy
-
-  // If the user has already configured a proxy in the environment
-  // for the protocol we're not gonna override it.
-  if (envKey in env || (proto === 'https' && 'HTTPS_PROXY' in env)) {
-    console.info(`proxy url not resolved, ${envKey} already set`)
-    return
-  }
-
-  const proxyUrl = await resolve(remoteUrl).catch(err => {
-    console.error('Failed resolving Git proxy', err)
-    return undefined
-  })
-
-  return proxyUrl === undefined ? undefined : { [envKey]: proxyUrl }
-}

package/src/git/exec.ts

@@ -1,285 +0,0 @@
-import { spawn, SpawnOptions } from 'child_process'
-
-/**
- * Git error types parsed from stderr output.
- * This is a simplified version of dugite's GitError enum.
- */
-export enum GitError {
-  // Authentication
-  SSHAuthenticationFailed = 'SSHAuthenticationFailed',
-  SSHPermissionDenied = 'SSHPermissionDenied',
-  HTTPSAuthenticationFailed = 'HTTPSAuthenticationFailed',
-  SSHKeyAuditUnverified = 'SSHKeyAuditUnverified',
-
-  // Remote
-  RemoteDisconnection = 'RemoteDisconnection',
-  HostDown = 'HostDown',
-  HTTPSRepositoryNotFound = 'HTTPSRepositoryNotFound',
-  SSHRepositoryNotFound = 'SSHRepositoryNotFound',
-
-  // Push / Pull
-  PushNotFastForward = 'PushNotFastForward',
-  PushWithFileSizeExceedingLimit = 'PushWithFileSizeExceedingLimit',
-  PushWithPrivateEmail = 'PushWithPrivateEmail',
-  PushWithSecretDetected = 'PushWithSecretDetected',
-  ForcePushRejected = 'ForcePushRejected',
-  ProtectedBranchForcePush = 'ProtectedBranchForcePush',
-  ProtectedBranchRequiresReview = 'ProtectedBranchRequiresReview',
-  ProtectedBranchDeleteRejected = 'ProtectedBranchDeleteRejected',
-  ProtectedBranchRequiredStatus = 'ProtectedBranchRequiredStatus',
-
-  // Branch
-  BranchDeletionFailed = 'BranchDeletionFailed',
-  DefaultBranchDeletionFailed = 'DefaultBranchDeletionFailed',
-  BranchAlreadyExists = 'BranchAlreadyExists',
-  BranchRenameFailed = 'BranchRenameFailed',
-  HexBranchNameRejected = 'HexBranchNameRejected',
-  InvalidRefLength = 'InvalidRefLength',
-
-  // Merge / Rebase
-  MergeConflicts = 'MergeConflicts',
-  RebaseConflicts = 'RebaseConflicts',
-  MergeWithLocalChanges = 'MergeWithLocalChanges',
-  RebaseWithLocalChanges = 'RebaseWithLocalChanges',
-  InvalidMerge = 'InvalidMerge',
-  InvalidRebase = 'InvalidRebase',
-  NonFastForwardMergeIntoEmptyHead = 'NonFastForwardMergeIntoEmptyHead',
-  CannotMergeUnrelatedHistories = 'CannotMergeUnrelatedHistories',
-  NoMergeToAbort = 'NoMergeToAbort',
-  RevertConflicts = 'RevertConflicts',
-
-  // Rebase
-  EmptyRebasePatch = 'EmptyRebasePatch',
-
-  // Commit
-  NothingToCommit = 'NothingToCommit',
-  GPGFailedToSignData = 'GPGFailedToSignData',
-
-  // Bad config
-  BadConfigValue = 'BadConfigValue',
-  ConfigLockFileAlreadyExists = 'ConfigLockFileAlreadyExists',
-
-  // Misc
-  NotAGitRepository = 'NotAGitRepository',
-  BadRevision = 'BadRevision',
-  LocalPermissionDenied = 'LocalPermissionDenied',
-  NoMatchingRemoteBranch = 'NoMatchingRemoteBranch',
-  NoExistingRemoteBranch = 'NoExistingRemoteBranch',
-  PatchDoesNotApply = 'PatchDoesNotApply',
-  NoSubmoduleMapping = 'NoSubmoduleMapping',
-  SubmoduleRepositoryDoesNotExist = 'SubmoduleRepositoryDoesNotExist',
-  InvalidSubmoduleSHA = 'InvalidSubmoduleSHA',
-  LockFileAlreadyExists = 'LockFileAlreadyExists',
-  UnresolvedConflicts = 'UnresolvedConflicts',
-  LocalChangesOverwritten = 'LocalChangesOverwritten',
-  RemoteAlreadyExists = 'RemoteAlreadyExists',
-  TagAlreadyExists = 'TagAlreadyExists',
-  PathDoesNotExist = 'PathDoesNotExist',
-  InvalidObjectName = 'InvalidObjectName',
-  OutsideRepository = 'OutsideRepository',
-  ConflictModifyDeletedInBranch = 'ConflictModifyDeletedInBranch',
-  MergeCommitNoMainlineOption = 'MergeCommitNoMainlineOption',
-  UnsafeDirectory = 'UnsafeDirectory',
-  PathExistsButNotInRef = 'PathExistsButNotInRef',
-  LFSAttributeDoesNotMatch = 'LFSAttributeDoesNotMatch',
-}
-
-export class ExecError extends Error {
-  public readonly code: string
-  public readonly stdout: string | Buffer
-  public readonly stderr: string | Buffer
-  public readonly cause?: Error
-
-  constructor(
-    message: string,
-    stdout: string | Buffer,
-    stderr: string | Buffer,
-    cause?: Error
-  ) {
-    super(message)
-    this.name = 'ExecError'
-    this.code = 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER'
-    this.stdout = stdout
-    this.stderr = stderr
-    this.cause = cause
-  }
-}
-
-export interface IGitResult {
-  readonly stdout: string | Buffer
-  readonly stderr: string | Buffer
-  readonly exitCode: number
-}
-
-export interface IGitExecutionOptions {
-  readonly env?: Record<string, string | undefined>
-  readonly cwd?: string
-  readonly stdin?: string
-  readonly maxBuffer?: number
-  readonly processCallback?: (process: any) => void
-  readonly encoding?: BufferEncoding
-}
-
-export interface IGitSpawnOptions extends SpawnOptions {
-  readonly stdin?: string
-}
-
-/**
- * Execute a git command and return the result.
- */
-export async function exec(
-  args: string[],
-  path: string,
-  options?: IGitExecutionOptions
-): Promise<IGitResult> {
-  return new Promise((resolve, reject) => {
-    const child = spawn('git', args, {
-      cwd: path,
-      env: {
-        ...process.env,
-        TERM: 'dumb',
-        ...options?.env,
-      } as Record<string, string>,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    })
-
-    const stdoutChunks: Buffer[] = []
-    const stderrChunks: Buffer[] = []
-
-    child.stdout?.on('data', (chunk: Buffer) => stdoutChunks.push(chunk))
-    child.stderr?.on('data', (chunk: Buffer) => stderrChunks.push(chunk))
-
-    if (options?.processCallback) {
-      options.processCallback(child)
-    }
-
-    if (options?.stdin) {
-      child.stdin?.write(options.stdin)
-      child.stdin?.end()
-    }
-
-    child.on('close', (exitCode) => {
-      const stdoutBuf = Buffer.concat(stdoutChunks)
-      const stderrBuf = Buffer.concat(stderrChunks)
-
-      const enc = (options as any)?.encoding
-      const isBuffer = enc === 'buffer'
-
-      resolve({
-        stdout: isBuffer ? stdoutBuf : stdoutBuf.toString(options?.encoding || 'utf-8'),
-        stderr: isBuffer ? stderrBuf : stderrBuf.toString(options?.encoding || 'utf-8'),
-        exitCode: exitCode ?? -1,
-      })
-    })
-
-    child.on('error', (err: Error) => {
-      reject(err)
-    })
-  })
-}
-
-/**
- * Spawn a git process, returning the ChildProcess for streaming access.
- */
-export function spawnGit(
-  args: string[],
-  path: string,
-  options?: IGitSpawnOptions
-) {
-  return spawn('git', args, {
-    ...options,
-    cwd: path,
-    env: {
-      ...process.env,
-      TERM: 'dumb',
-      ...options?.env,
-    } as Record<string, string>,
-  })
-}
-
-/**
- * Parse git stderr output into a GitError enum value.
- */
-export function parseError(stderr: string): GitError | null {
-  if (!stderr) return null
-
-  // Authentication errors
-  if (stderr.includes('Permission denied (publickey)'))
-    return GitError.SSHPermissionDenied
-  if (stderr.includes('fatal: Could not read from remote repository'))
-    return GitError.SSHAuthenticationFailed
-  if (stderr.includes('Authentication failed'))
-    return GitError.HTTPSAuthenticationFailed
-
-  // Merge conflicts
-  if (stderr.includes('Automatic merge failed'))
-    return GitError.MergeConflicts
-  if (stderr.includes('merge failed')) return GitError.MergeConflicts
-  if (stderr.includes('conflict')) return GitError.MergeConflicts
-
-  // Rebase
-  if (stderr.includes('could not apply'))
-    return GitError.RebaseConflicts
-  if (stderr.includes('interactive rebase already started'))
-    return GitError.RebaseConflicts
-
-  // Push
-  if (stderr.includes('push is not fast forward') || stderr.includes('[rejected]'))
-    return GitError.PushNotFastForward
-  if (stderr.includes('failed to push'))
-    return GitError.PushNotFastForward
-
-  // Remote
-  if (stderr.includes('Could not resolve host'))
-    return GitError.RemoteDisconnection
-  if (stderr.includes('host down')) return GitError.HostDown
-  if (stderr.includes('Repository not found'))
-    return GitError.HTTPSRepositoryNotFound
-  if (stderr.includes('not found')) return GitError.HTTPSRepositoryNotFound
-
-  // Branch
-  if (stderr.includes('branch .* already exists'))
-    return GitError.BranchAlreadyExists
-  if (stderr.includes('not a valid branch'))
-    return GitError.BranchDeletionFailed
-  if (stderr.includes('could not delete'))
-    return GitError.BranchDeletionFailed
-
-  // Config
-  if (stderr.includes('bad config value'))
-    return GitError.BadConfigValue
-  if (stderr.includes('bad numeric config value'))
-    return GitError.BadConfigValue
-  if (stderr.includes('config file lock'))
-    return GitError.ConfigLockFileAlreadyExists
-
-  // Misc
-  if (stderr.includes('fatal: not a git repository'))
-    return GitError.NotAGitRepository
-  if (stderr.includes('bad revision'))
-    return GitError.BadRevision
-  if (stderr.includes('nothing to commit'))
-    return GitError.NothingToCommit
-  if (stderr.includes('Permission denied'))
-    return GitError.LocalPermissionDenied
-  if (stderr.includes('pathspec .* did not match'))
-    return GitError.PathDoesNotExist
-  if (stderr.includes('did not match any files'))
-    return GitError.PathDoesNotExist
-
-  return null
-}
-
-/**
- * Parse information about a bad config value error.
- */
-export function parseBadConfigValueErrorInfo(
-  stderr: string
-): { key: string; value: string } | null {
-  const match = stderr.match(
-    /bad config value for '([^']+)' in ([^:]+):?\s*(.*)/
-  )
-  if (!match) return null
-
-  return { key: match[1], value: match[3]?.trim() || '' }
-}

package/src/git/fetch.ts

@@ -1,141 +0,0 @@
-import { git, IGitStringExecutionOptions } from './core.js'
-import { Repository } from '../models/repository.js'
-import { IFetchProgress } from '../models/progress.js'
-import { FetchProgressParser, executionOptionsWithProgress } from '../lib/progress/index.js'
-import { IRemote } from '../models/remote.js'
-import { ITrackingBranch } from '../models/branch.js'
-import { envForRemoteOperation } from './environment.js'
-
-async function getFetchArgs(
-  remote: string,
-  progressCallback?: (progress: IFetchProgress) => void
-) {
-  return [
-    'fetch',
-    ...(progressCallback ? ['--progress'] : []),
-    '--prune',
-    '--recurse-submodules=on-demand',
-    remote,
-  ]
-}
-
-/**
- * Fetch from the given remote.
- *
- * @param repository - The repository to fetch into
- *
- * @param account    - The account to use when authenticating with the remote
- *
- * @param remote     - The remote to fetch from
- *
- * @param progressCallback - An optional function which will be invoked
- *                           with information about the current progress
- *                           of the fetch operation. When provided this enables
- *                           the '--progress' command line flag for
- *                           'git fetch'.
- * @param isBackgroundTask  - Whether the fetch is being performed as a
- *                            background task as opposed to being user initiated
- */
-export async function fetch(
-  repository: Repository,
-  remote: IRemote,
-  progressCallback?: (progress: IFetchProgress) => void,
-  isBackgroundTask = false
-): Promise<void> {
-  let opts: IGitStringExecutionOptions = {
-    successExitCodes: new Set([0]),
-    env: await envForRemoteOperation(remote.url),
-  }
-
-  if (progressCallback) {
-    const title = `Fetching ${remote.name}`
-    const kind = 'fetch'
-
-    opts = await executionOptionsWithProgress(
-      { ...opts, trackLFSProgress: true, isBackgroundTask },
-      new FetchProgressParser(),
-      progress => {
-        // In addition to progress output from the remote end and from
-        // git itself, the stderr output from pull contains information
-        // about ref updates. We don't need to bring those into the progress
-        // stream so we'll just punt on anything we don't know about for now.
-        if (progress.kind === 'context') {
-          if (!progress.text.startsWith('remote: Counting objects')) {
-            return
-          }
-        }
-
-        const description =
-          progress.kind === 'progress' ? progress.details.text : progress.text
-        const value = progress.percent
-
-        progressCallback({
-          kind,
-          title,
-          description,
-          value,
-          remote: remote.name,
-        })
-      }
-    )
-
-    // Initial progress
-    progressCallback({ kind, title, value: 0, remote: remote.name })
-  }
-
-  const args = await getFetchArgs(remote.name, progressCallback)
-
-  await git(args, repository.path, 'fetch', opts)
-}
-
-/** Fetch a given refspec from the given remote. */
-export async function fetchRefspec(
-  repository: Repository,
-  remote: IRemote,
-  refspec: string
-): Promise<void> {
-  await git(['fetch', remote.name, refspec], repository.path, 'fetchRefspec', {
-    successExitCodes: new Set([0, 128]),
-    env: await envForRemoteOperation(remote.url),
-  })
-}
-
-export async function fastForwardBranches(
-  repository: Repository,
-  branches: ReadonlyArray<ITrackingBranch>
-): Promise<void> {
-  if (branches.length === 0) {
-    return
-  }
-
-  const refPairs = branches.map(branch => `${branch.upstreamRef}:${branch.ref}`)
-
-  await git(
-    [
-      'fetch',
-      '.',
-      // Make sure we don't try to update branches that can't be fast-forwarded
-      // even if the user disabled this via the git config option
-      // `fetch.showForcedUpdates`
-      '--show-forced-updates',
-      // Prevent `git fetch` from touching the `FETCH_HEAD`
-      '--no-write-fetch-head',
-      // Take branch refs from stdin to circumvent shell max line length
-      // limitations (mainly on Windows)
-      '--stdin',
-    ],
-    repository.path,
-    'fastForwardBranches',
-    {
-      // Fetch exits with an exit code of 1 if one or more refs failed to update
-      // which is what we expect will happen
-      successExitCodes: new Set([0, 1]),
-      env: {
-        // This will make sure the reflog entries are correct after
-        // fast-forwarding the branches.
-        GIT_REFLOG_ACTION: 'pull',
-      },
-      stdin: refPairs.join('\n'),
-    }
-  )
-}

package/src/git/for-each-ref.ts

@@ -1,160 +0,0 @@
-import { git } from './core.js'
-import { GitError } from './exec.js'
-import { Repository } from '../models/repository.js'
-import {
-  Branch,
-  BranchType,
-  IBranchTip,
-  ITrackingBranch,
-} from '../models/branch.js'
-import { createForEachRefParser } from './git-delimiter-parser.js'
-
-/** Get all the branches. */
-export async function getBranches(
-  repository: Repository,
-  ...prefixes: string[]
-): Promise<ReadonlyArray<Branch>> {
-  const { formatArgs, parse } = createForEachRefParser({
-    fullName: '%(refname)',
-    shortName: '%(refname:short)',
-    upstreamShortName: '%(upstream:short)',
-    upstreamTrackingBranch: '%(upstream:track)',
-    sha: '%(objectname)',
-    symRef: '%(symref)',
-    authorDate: '%(authordate:iso8601)',
-  })
-
-  if (!prefixes || !prefixes.length) {
-    prefixes = ['refs/heads', 'refs/remotes']
-  }
-
-  // TODO: use expectedErrors here to handle a specific error
-  // see https://github.com/desktop/desktop/pull/5299#discussion_r206603442 for
-  // discussion about what needs to change
-  const result = await git(
-    ['for-each-ref', ...formatArgs, ...prefixes],
-    repository.path,
-    'getBranches',
-    { expectedErrors: new Set([GitError.NotAGitRepository]) }
-  )
-
-  if (result.gitError === GitError.NotAGitRepository) {
-    return []
-  }
-
-  const branches = []
-
-  for (const ref of parse(result.stdout)) {
-    // excude symbolic refs from the branch list
-    if (ref.symRef.length > 0) {
-      continue
-    }
-
-    const tip: IBranchTip = {
-      sha: ref.sha,
-      author: {
-        date: new Date(ref.authorDate),
-      },
-    }
-
-    const type = ref.fullName.startsWith('refs/heads')
-      ? BranchType.Local
-      : BranchType.Remote
-
-    const upstream =
-      ref.upstreamShortName.length > 0 ? ref.upstreamShortName : null
-
-    const isGone = ['[gone]', '(gone)'].includes(ref.upstreamTrackingBranch)
-
-    branches.push(
-      new Branch(ref.shortName, upstream, tip, type, ref.fullName, isGone)
-    )
-  }
-
-  return branches
-}
-
-/**
- * Gets all branches that differ from their upstream (i.e. they're ahead,
- * behind or both), excluding the current branch.
- * Useful to narrow down a list of branches that could potentially be fast
- * forwarded.
- *
- * @param repository Repository to get the branches from.
- */
-export async function getBranchesDifferingFromUpstream(
-  repository: Repository
-): Promise<ReadonlyArray<ITrackingBranch>> {
-  const { formatArgs, parse } = createForEachRefParser({
-    fullName: '%(refname)',
-    sha: '%(objectname)', // SHA
-    upstream: '%(upstream)',
-    symref: '%(symref)',
-    head: '%(HEAD)',
-    worktreePath: '%(worktreepath)',
-  })
-
-  const prefixes = ['refs/heads', 'refs/remotes']
-
-  const result = await git(
-    ['for-each-ref', ...formatArgs, ...prefixes],
-    repository.path,
-    'getBranchesDifferingFromUpstream',
-    { expectedErrors: new Set([GitError.NotAGitRepository]) }
-  )
-
-  if (result.gitError === GitError.NotAGitRepository) {
-    return []
-  }
-
-  const localBranches = []
-  const remoteBranchShas = new Map<string, string>()
-
-  // First we need to collect the relevant info from the command output:
-  // - For local branches with upstream: name, ref, SHA and the upstream.
-  // - For remote branches we only need the sha (and the ref as key).
-  for (const ref of parse(result.stdout)) {
-    if (ref.symref.length > 0 || ref.head === '*') {
-      // Exclude symbolic refs and the current branch
-      continue
-    }
-    if (ref.worktreePath.length > 0 && ref.worktreePath !== repository.path) {
-      // Exclude branches checked out in other worktrees, since they can't be fast-forwarded from here
-      continue
-    }
-
-    if (ref.fullName.startsWith('refs/heads')) {
-      if (ref.upstream.length === 0) {
-        // Exclude local branches without upstream
-        continue
-      }
-
-      localBranches.push({
-        ref: ref.fullName,
-        sha: ref.sha,
-        upstream: ref.upstream,
-      })
-    } else {
-      remoteBranchShas.set(ref.fullName, ref.sha)
-    }
-  }
-
-  const eligibleBranches = new Array<ITrackingBranch>()
-
-  // Compare the SHA of every local branch with the SHA of its upstream and
-  // collect the names of local branches that differ from their upstream.
-  for (const branch of localBranches) {
-    const remoteSha = remoteBranchShas.get(branch.upstream)
-
-    if (remoteSha !== undefined && remoteSha !== branch.sha) {
-      eligibleBranches.push({
-        ref: branch.ref,
-        sha: branch.sha,
-        upstreamRef: branch.upstream,
-        upstreamSha: remoteSha,
-      })
-    }
-  }
-
-  return eligibleBranches
-}