gitwatch

gitwatch

A bash script to watch a file or folder and commit changes to a git repo

What to use it for?

That's really up to you, but here are some examples:

config files: some programs auto-write their config files, without waiting for you to click an 'Apply' button; or even if there is such a button, most programs offer you no way of going back to an earlier version of your settings. If you commit your config file(s) to a git repo, you can track changes and go back to older versions. This script makes it convenient, to have all changes recorded automatically.
document files: if you use an editor that does not have built-in git support (or maybe if you don't like the git support it has), you can use gitwatch to automatically commit your files when you save them, or combine it with the editor's auto-save feature to fully automatically and regularly track your changes
more stuff! If you have any other uses, or can think of ones, please let us know, and we can add them to this list!

Installation

gitwatch can be installed in various ways.

From Source

gitwatch can be installed from source by simply cloning the repository and putting the shell script into your $PATH. The commands below will do that for you if /usr/local/bin is in your $PATH. You may need to invoke install with sudo.

git clone https://github.com/gitwatch/gitwatch.git
cd gitwatch
[sudo] install -b gitwatch.sh /usr/local/bin/gitwatch

Update

If you installed gitwatch from source, you can update it by following the exact same steps (or git pull rather than clone if you kept the repository around).

bpkg

gitwatch can be installed with bpkg. Make sure you have bpkg installed before running the command below. You may need to invoke bpkg with sudo when using the -g flag.

[sudo] bpkg install -g gitwatch/gitwatch

Archlinux

There is an AUR package for Archlinux. Install it with you favorite aur helper.

NixOS

Starting from NixOS 24.11 this package available in mainline. Additionally, you can use receipts from this repository.

As Module

Each watching path should be described in submodule services.gitwatch.* like next:

services.gitwatch.<service name> = {
    enable = true;
    path = "/home/me/my-repo";
    remote = "git@github.com:me/my-repo.git";
    user = "me";
    message = "Auto-commit by gitwatch on %d";
};

This will make NixOS to create systemd service named gitwatch-<service name>. More details you can see at man configuration.nix.

As Package

The gitwatch script available as package in nixpkgs;

Docker

You can also run gitwatch inside a Docker container. This is useful for isolating dependencies and ensuring a consistent environment.

Docker Compose (Recommended)

The easiest way to run gitwatch with Docker is by using the provided docker-compose.yml file.

1. Prerequisites:

Docker and Docker Compose: Make sure you have both installed.
- Install Docker
- Install Docker Compose
A Git Repository: You need a local directory that is a Git repository you want to watch.
SSH Key: For pushing to a remote repository, the container needs access to an SSH key that is authorized with your Git provider.

2. Docker Image Tags:

This project publishes multiple Docker tags so you can choose the one that best fits your use case.

The following image tags are available:

:<full-sha>, :<short-sha>
Always published for every build (immutable).
:master
Moving tag for the latest image from master branch.
:vX.Y, :X.Y
Published when a release tag vX.Y is pushed.
:latest
Updated when a vX.Y tag is pushed, pointing to the newest release image.

3. Configuration:

The docker-compose.yml file is configured using environment variables. You can either edit the environment section directly in the file or create a .env file in the same directory to set the values.

Here's a breakdown of the important parts of the docker-compose.yml file:

volumes: This is the most critical section to configure.
- ./watched-repo:/app/watched-repo: This maps a directory from your computer (the "host") into the container.
  - You must change ./watched-repo to the path of the local Git repository you want gitwatch to monitor.
- ~/.ssh/id_rsa:/root/.ssh/id_rsa:ro: This securely mounts your SSH private key into the container in read-only mode (ro). This is necessary for gitwatch to push changes to your remote repository.
- ~/.gitconfig:/root/.gitconfig:ro: This mounts your Git configuration into the container. This ensures that the commits made by gitwatch are attributed to you with the correct name and email.
environment: This section controls how gitwatch behaves.

4. Environment Variables

The following environment variables are available for configuring the gitwatch container:

5. Running gitwatch:

Start the container in the background (detached mode):
```
docker-compose up -d
```
View the logs to see what gitwatch is doing:
```
docker-compose logs -f
```
Stop the container:
```
docker-compose down
```

Using the Dockerfile

If you prefer to build the Docker image yourself, you can use the provided Dockerfile. This is useful if you want to customize the image with additional tools or dependencies.

1. Build the image:

From the root of the gitwatch repository, run:

docker build -t gitwatch .

2. Run the container:

Gitwatch

Install / Use

README