Can forks be synced automatically in GitHub?

Question

Stash enables automatic fork syncing if selected: https://confluence.atlassian.com/display/STASH/Keeping+forks+synchronized
It will update any branches in your fork that you haven't modified.

I've been unable to find similar automatic functionality in GitHub; all google searches are turning up manual ways to sync forks via your local cache.

Answer 1

For the record, recently I ran into this same problem and addressed it with Github Actions. The solution is rather easy: an scheduled action fetches the upstream repository and merges it into mine.

# .github/workflows/example.yml

name: Merge upstream branches
on:
  schedule:
     # actually, ~5 minutes is the highest
     # effective frequency you will get
    - cron:  '* * * * *'
jobs:
  merge:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Merge upstream
        run: |
          git config --global user.name 'your-name'
          git config --global user.email 'your-username@users.noreply.github.com'

          # "git checkout master" is unnecessary, already here by default
          git pull --unshallow  # this option is very important, you would get
                                # complains about unrelated histories without it.
                                # (but actions/checkout@v2 can also be instructed
                                # to fetch all git depth right from the start)

          git remote add upstream https://github.com/example/test.git
          git fetch upstream

          # Neither forget the -b opt,
          # the feature/x ref is ambiguous at this stage
          git checkout -b feature/x origin/feature/x
          git merge --no-edit upstream/feature/x
          git push origin feature/x

          git checkout master
          git merge --no-edit upstream/master
          git push origin master

          # etc

I run it every Sunday which is more than enough for me. Just schedule this to whatever is fine for you.

Also, it is probably wiser to sync every branch in a different job since they will run in parallel and can independently succeed or fail if conflicts occur.

If you need to merge an arbitrary number of branches, you can refer to questions like How to fetch all Git branches to find shell tricks to do it.

I noticed a public action exists to address this by rebasing. It looked promising but it was fairly undocumented so here is my snippet instead. Hope it helps!

Answer 2

You could define a webhook to listen to upstream (the original repo) changes, and update your fork.

In June 2016, you had the service backstroke.us which listens to those events for you. No need to write your own listener.
See 1egoman/backstroke

But, as commented by chriszo111, in 2020, that would be wei/pull

a GitHub App built with probot that keeps your forks up-to-date with upstream via automated pull requests.

Answer 3

You can create a Github App that use Github API to check the upstream repo periodically. Once an update is found, use Github API to create a pull request then call updateRef to update your branch to match master.

Or, just install this Github App that does exactly that

https://github.com/wei/pull

a GitHub App that keeps your repository up-to-date with upstream changes.

Answer 4

I have a sync-fork Gist with a GitHub Action that keeps the repo up-to-date using the GitHub CLI. This is what it looks like right now (for completeness):

name: sync-fork
on:
  schedule:
    - cron: '0 0 * * *'
  workflow_dispatch: { }
jobs:
  sync:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - run: gh repo sync $REPOSITORY -b $BRANCH_NAME
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          REPOSITORY: ${{ github.repository }}
          BRANCH_NAME: ${{ github.ref_name }}