homebridge-git-backup 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Charles Stephen Thompson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# homebridge-git-backup
+
+[![npm](https://img.shields.io/npm/v/homebridge-git-backup.svg)](https://www.npmjs.com/package/homebridge-git-backup)
+[![verified-by-homebridge](https://badgen.net/badge/homebridge/verified/purple)](https://homebridge.io)
+
+Homebridge plugin that backs up your Homebridge `config.json` to **any Git remote** — GitHub, Forgejo, GitLab, Bitbucket, or a self-hosted git server — every time the config changes and on a schedule.
+
+Built on [isomorphic-git](https://isomorphic-git.org), so it works with no `git` binary on the host. That matters for the official Homebridge Docker image, which doesn't include `git`.
+
+## Why
+
+The previous generation of "backup to GitHub" Homebridge plugins called the GitHub REST API directly. That meant:
+
+- They only worked with GitHub.
+- They wrote one file at a time via REST (no atomic multi-file backups).
+- The "backup" lost the commit graph — every backup was a flat file overwrite.
+
+This plugin does it the right way: it maintains a real Git working tree under Homebridge's storage directory, fast-forwards from the remote before each backup, commits the new config, and pushes via HTTPS. You get a full commit history of every Homebridge config change.
+
+## Install
+
+From the Homebridge UI: **Plugins → search "Git Backup" → Install**.
+
+Or from the command line:
+
+```bash
+npm install -g homebridge-git-backup
+```
+
+## Configure
+
+Add a platform block to your Homebridge `config.json` (or use the Homebridge UI form):
+
+```jsonc
+{
+  "platforms": [
+    {
+      "platform": "GitBackup",
+      "name": "Git Backup",
+      "repository_url": "https://github.com/you/homebridge-backups.git",
+      "branch": "main",
+      "git_username": "git",
+      "git_token": "ghp_yourPersonalAccessToken",
+      "file_path": "homebridge-config.json",
+      "backup_interval": 1440,
+      "commit_name": "Homebridge Git Backup",
+      "commit_email": "homebridge@localhost"
+    }
+  ]
+}
+```
+
+### Required fields
+
+| Field | Description |
+|---|---|
+| `repository_url` | Full HTTPS clone URL of the backup repository |
+| `git_token` | Personal Access Token, deploy key, or password for HTTPS auth |
+
+### Provider-specific token setup
+
+| Provider | `git_username` | `git_token` |
+|---|---|---|
+| GitHub | `git` (any string works) | [Personal Access Token (classic)](https://github.com/settings/tokens) with `repo` scope, or a fine-grained PAT with "Contents: Read and write" |
+| Forgejo / Gitea | your Forgejo username | Access token from **Settings → Applications** with `write:repository` |
+| GitLab | `oauth2` | Personal Access Token with `write_repository` scope |
+| Bitbucket | your username | App password with "Repositories: Write" |
+| Self-hosted (HTTP basic auth) | username | password |
+
+> **Security tip:** create a backup-only repository and a token whose scope is restricted to that single repository. Don't reuse a token that has access to other repos.
+
+### Optional fields
+
+| Field | Default | Description |
+|---|---|---|
+| `branch` | `main` | Branch to push backups to |
+| `file_path` | `homebridge-config.json` | Path within the repository where the config is stored. Subdirectories are created automatically. |
+| `backup_interval` | `1440` (24h) | Scheduled backup cadence in minutes (minimum 5) |
+| `commit_name` | `Homebridge Git Backup` | Author name on backup commits |
+| `commit_email` | `homebridge@localhost` | Author email on backup commits |
+
+## How it works
+
+1. **On startup**, the plugin clones the target repository (shallow, single branch) into `<homebridge-storage>/git-backup-workdir`. If the repository is empty or unreachable, it falls back to initializing a new local repo for the first push.
+2. **On every Homebridge `config.json` change** (debounced 5s) and **on a schedule**, the plugin:
+   - Fast-forwards the local repo from the remote (so concurrent backups from other Homebridge instances don't deadlock the branch).
+   - Copies the current `config.json` to the configured `file_path`.
+   - Stages, commits, and pushes via HTTPS using the configured token.
+   - If nothing changed, no commit is made.
+3. **On shutdown**, watchers and timers are released cleanly.
+
+Backup runs are serialized — if a change arrives while a backup is in flight, it's coalesced and run once the current one finishes.
+
+## Running locally
+
+```bash
+git clone https://github.com/charlestephen/homebridge-git-backup.git
+cd homebridge-git-backup
+npm install
+npm run build
+npm link
+```
+
+Then in your Homebridge install: `npm link homebridge-git-backup` and restart Homebridge.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/config.schema.json

@@ -0,0 +1,70 @@
+{
+  "pluginAlias": "GitBackup",
+  "pluginType": "platform",
+  "singular": true,
+  "headerDisplay": "Backs up your Homebridge configuration to any Git remote (GitHub, Forgejo, GitLab, self-hosted) on every change and on a schedule.",
+  "footerDisplay": "Powered by [isomorphic-git](https://isomorphic-git.org) - no `git` binary required on the host.",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "title": "Name",
+        "type": "string",
+        "default": "Git Backup",
+        "required": true
+      },
+      "repository_url": {
+        "title": "Repository URL",
+        "type": "string",
+        "format": "uri",
+        "required": true,
+        "description": "Full HTTPS clone URL, e.g. https://github.com/you/homebridge-backups.git",
+        "placeholder": "https://github.com/you/homebridge-backups.git"
+      },
+      "branch": {
+        "title": "Branch",
+        "type": "string",
+        "default": "main",
+        "description": "Branch to push backups to. The plugin will fast-forward from this branch before each commit."
+      },
+      "git_username": {
+        "title": "Git Username",
+        "type": "string",
+        "default": "git",
+        "description": "Most token-based providers accept any value here (e.g. 'git' for GitHub PATs; the token-owner username for Forgejo/Gitea)."
+      },
+      "git_token": {
+        "title": "Git Token / Password",
+        "type": "string",
+        "required": true,
+        "format": "password",
+        "description": "Personal Access Token, deploy key, or password used for HTTPS authentication. Needs write access to the target repository.",
+        "minLength": 1
+      },
+      "file_path": {
+        "title": "File path in repository",
+        "type": "string",
+        "default": "homebridge-config.json",
+        "description": "Path within the repository where the Homebridge config.json should be written. Subdirectories are created automatically."
+      },
+      "backup_interval": {
+        "title": "Backup interval (minutes)",
+        "type": "integer",
+        "default": 1440,
+        "minimum": 5,
+        "description": "Scheduled backup cadence. The plugin also commits immediately when the Homebridge config changes on disk."
+      },
+      "commit_name": {
+        "title": "Commit author name",
+        "type": "string",
+        "default": "Homebridge Git Backup"
+      },
+      "commit_email": {
+        "title": "Commit author email",
+        "type": "string",
+        "format": "email",
+        "default": "homebridge@localhost"
+      }
+    }
+  }
+}

package/dist/git-backup.service.d.ts

@@ -0,0 +1,21 @@
+import type { Logging } from 'homebridge';
+export interface GitBackupOptions {
+    repositoryUrl: string;
+    branch: string;
+    username: string;
+    token: string;
+    filePath: string;
+    commitName: string;
+    commitEmail: string;
+    workDir: string;
+    log: Logging;
+}
+export declare class GitBackupService {
+    private readonly opts;
+    private initialized;
+    constructor(opts: GitBackupOptions);
+    backup(sourceConfigPath: string): Promise<void>;
+    private ensureRepo;
+    private fastForward;
+    private exists;
+}

package/dist/git-backup.service.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitBackupService = void 0;
+const node_fs_1 = require("node:fs");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const isomorphic_git_1 = __importDefault(require("isomorphic-git"));
+const node_1 = __importDefault(require("isomorphic-git/http/node"));
+class GitBackupService {
+    opts;
+    initialized = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async backup(sourceConfigPath) {
+        await this.ensureRepo();
+        await this.fastForward();
+        const destAbsolute = path.join(this.opts.workDir, this.opts.filePath);
+        await node_fs_1.promises.mkdir(path.dirname(destAbsolute), { recursive: true });
+        await node_fs_1.promises.copyFile(sourceConfigPath, destAbsolute);
+        const status = await isomorphic_git_1.default.statusMatrix({
+            fs,
+            dir: this.opts.workDir,
+            filepaths: [this.opts.filePath],
+        });
+        const hasChanges = status.some(([, head, workdir, stage]) => head !== workdir || workdir !== stage);
+        if (!hasChanges) {
+            this.opts.log.debug('Homebridge config unchanged — nothing to commit.');
+            return;
+        }
+        await isomorphic_git_1.default.add({ fs, dir: this.opts.workDir, filepath: this.opts.filePath });
+        const sha = await isomorphic_git_1.default.commit({
+            fs,
+            dir: this.opts.workDir,
+            message: `Backup Homebridge config: ${new Date().toISOString()}`,
+            author: { name: this.opts.commitName, email: this.opts.commitEmail },
+        });
+        this.opts.log.info(`Committed backup ${sha.slice(0, 7)} on ${this.opts.branch}.`);
+        await isomorphic_git_1.default.push({
+            fs,
+            http: node_1.default,
+            dir: this.opts.workDir,
+            remote: 'origin',
+            ref: this.opts.branch,
+            onAuth: () => ({ username: this.opts.username, password: this.opts.token }),
+        });
+        this.opts.log.info(`Pushed ${sha.slice(0, 7)} to ${this.opts.repositoryUrl}.`);
+    }
+    async ensureRepo() {
+        if (this.initialized)
+            return;
+        const gitDir = path.join(this.opts.workDir, '.git');
+        const exists = await this.exists(gitDir);
+        if (!exists) {
+            await node_fs_1.promises.mkdir(this.opts.workDir, { recursive: true });
+            this.opts.log.info(`Cloning ${this.opts.repositoryUrl} (branch ${this.opts.branch})...`);
+            try {
+                await isomorphic_git_1.default.clone({
+                    fs,
+                    http: node_1.default,
+                    dir: this.opts.workDir,
+                    url: this.opts.repositoryUrl,
+                    ref: this.opts.branch,
+                    singleBranch: true,
+                    depth: 1,
+                    onAuth: () => ({ username: this.opts.username, password: this.opts.token }),
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.opts.log.warn(`Clone failed (${msg}). Initializing empty repo for first push.`);
+                await isomorphic_git_1.default.init({ fs, dir: this.opts.workDir, defaultBranch: this.opts.branch });
+                await isomorphic_git_1.default.addRemote({
+                    fs,
+                    dir: this.opts.workDir,
+                    remote: 'origin',
+                    url: this.opts.repositoryUrl,
+                });
+            }
+        }
+        this.initialized = true;
+    }
+    async fastForward() {
+        try {
+            await isomorphic_git_1.default.pull({
+                fs,
+                http: node_1.default,
+                dir: this.opts.workDir,
+                ref: this.opts.branch,
+                singleBranch: true,
+                fastForwardOnly: true,
+                author: { name: this.opts.commitName, email: this.opts.commitEmail },
+                onAuth: () => ({ username: this.opts.username, password: this.opts.token }),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.opts.log.debug(`Fast-forward skipped: ${msg}`);
+        }
+    }
+    async exists(p) {
+        try {
+            await node_fs_1.promises.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.GitBackupService = GitBackupService;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { API } from 'homebridge';
+declare const _default: (api: API) => void;
+export default _default;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const platform_1 = require("./platform");
+const settings_1 = require("./settings");
+exports.default = (api) => {
+    api.registerPlatform(settings_1.PLATFORM_NAME, platform_1.GitBackupPlatform);
+};

package/dist/interfaces.d.ts

@@ -0,0 +1,11 @@
+import type { PlatformConfig } from 'homebridge';
+export interface GitBackupConfig extends PlatformConfig {
+    repository_url: string;
+    branch?: string;
+    git_username?: string;
+    git_token: string;
+    file_path?: string;
+    backup_interval?: number;
+    commit_name?: string;
+    commit_email?: string;
+}

package/dist/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/platform.d.ts

@@ -0,0 +1,17 @@
+import type { API, DynamicPlatformPlugin, Logging, PlatformAccessory, PlatformConfig } from 'homebridge';
+export declare class GitBackupPlatform implements DynamicPlatformPlugin {
+    readonly log: Logging;
+    readonly api: API;
+    private readonly cfg;
+    private service?;
+    private watcher?;
+    private intervalTimer?;
+    private inFlight;
+    private pending;
+    constructor(log: Logging, config: PlatformConfig, api: API);
+    configureAccessory(_accessory: PlatformAccessory): void;
+    private validate;
+    private start;
+    private runBackup;
+    private stop;
+}

package/dist/platform.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitBackupPlatform = void 0;
+const path = __importStar(require("node:path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const git_backup_service_1 = require("./git-backup.service");
+const settings_1 = require("./settings");
+const DEFAULT_INTERVAL_MINUTES = 1440;
+const MINIMUM_INTERVAL_MINUTES = 5;
+const WATCHER_DEBOUNCE_MS = 5000;
+class GitBackupPlatform {
+    log;
+    api;
+    cfg;
+    service;
+    watcher;
+    intervalTimer;
+    inFlight = false;
+    pending = false;
+    constructor(log, config, api) {
+        this.log = log;
+        this.api = api;
+        this.cfg = config;
+        if (!this.validate())
+            return;
+        this.api.on("didFinishLaunching" /* APIEvent.DID_FINISH_LAUNCHING */, () => this.start());
+        this.api.on("shutdown" /* APIEvent.SHUTDOWN */, () => this.stop());
+    }
+    configureAccessory(_accessory) {
+        // No accessories - this is a service-only platform plugin.
+    }
+    validate() {
+        if (!this.cfg) {
+            this.log.error(`${settings_1.PLATFORM_NAME}: missing platform config block.`);
+            return false;
+        }
+        if (!this.cfg.repository_url) {
+            this.log.error(`${settings_1.PLATFORM_NAME}: "repository_url" is required.`);
+            return false;
+        }
+        if (!this.cfg.git_token) {
+            this.log.error(`${settings_1.PLATFORM_NAME}: "git_token" is required.`);
+            return false;
+        }
+        return true;
+    }
+    start() {
+        const branch = this.cfg.branch ?? 'main';
+        const username = this.cfg.git_username ?? 'git';
+        const filePath = this.cfg.file_path ?? 'homebridge-config.json';
+        const commitName = this.cfg.commit_name ?? 'Homebridge Git Backup';
+        const commitEmail = this.cfg.commit_email ?? 'homebridge@localhost';
+        const intervalMinutes = Math.max(MINIMUM_INTERVAL_MINUTES, this.cfg.backup_interval ?? DEFAULT_INTERVAL_MINUTES);
+        const workDir = path.join(this.api.user.storagePath(), 'git-backup-workdir');
+        this.service = new git_backup_service_1.GitBackupService({
+            repositoryUrl: this.cfg.repository_url,
+            branch,
+            username,
+            token: this.cfg.git_token,
+            filePath,
+            commitName,
+            commitEmail,
+            workDir,
+            log: this.log,
+        });
+        void this.runBackup('startup');
+        this.watcher = chokidar_1.default.watch(this.api.user.configPath(), {
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: WATCHER_DEBOUNCE_MS,
+                pollInterval: 100,
+            },
+        });
+        this.watcher.on('change', () => void this.runBackup('config change'));
+        this.intervalTimer = setInterval(() => void this.runBackup('scheduled'), intervalMinutes * 60 * 1000);
+        this.log.info(`${settings_1.PLATFORM_NAME} watching ${this.api.user.configPath()}; ` +
+            `scheduled every ${intervalMinutes} minute(s).`);
+    }
+    async runBackup(trigger) {
+        if (!this.service)
+            return;
+        if (this.inFlight) {
+            this.pending = true;
+            this.log.debug(`Backup already running; coalescing trigger "${trigger}".`);
+            return;
+        }
+        this.inFlight = true;
+        try {
+            this.log.debug(`Running backup (trigger: ${trigger}).`);
+            await this.service.backup(this.api.user.configPath());
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log.error(`Backup failed (${trigger}): ${msg}`);
+        }
+        finally {
+            this.inFlight = false;
+            if (this.pending) {
+                this.pending = false;
+                void this.runBackup('coalesced');
+            }
+        }
+    }
+    stop() {
+        this.log.info(`${settings_1.PLATFORM_NAME} shutting down.`);
+        if (this.intervalTimer) {
+            clearInterval(this.intervalTimer);
+            this.intervalTimer = undefined;
+        }
+        if (this.watcher) {
+            void this.watcher.close();
+            this.watcher = undefined;
+        }
+    }
+}
+exports.GitBackupPlatform = GitBackupPlatform;

package/dist/settings.d.ts

@@ -0,0 +1,2 @@
+export declare const PLUGIN_NAME = "homebridge-git-backup";
+export declare const PLATFORM_NAME = "GitBackup";

package/dist/settings.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLATFORM_NAME = exports.PLUGIN_NAME = void 0;
+exports.PLUGIN_NAME = 'homebridge-git-backup';
+exports.PLATFORM_NAME = 'GitBackup';

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "homebridge-git-backup",
+  "displayName": "Git Backup",
+  "version": "1.0.0",
+  "description": "Homebridge plugin that backs up your Homebridge configuration to any Git remote (GitHub, Forgejo, GitLab, self-hosted) on every change.",
+  "license": "MIT",
+  "author": "charlestephen",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "config.schema.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": "^22 || ^24",
+    "homebridge": "^2.0.0"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "homebridge",
+    "backup",
+    "git",
+    "github",
+    "forgejo",
+    "gitlab",
+    "config",
+    "isomorphic-git"
+  ],
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "isomorphic-git": "^1.38.0"
+  },
+  "peerDependencies": {
+    "homebridge": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/charlestephen/homebridge-git-backup.git"
+  },
+  "bugs": {
+    "url": "https://github.com/charlestephen/homebridge-git-backup/issues"
+  },
+  "homepage": "https://github.com/charlestephen/homebridge-git-backup#readme"
+}