git-syncr 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Darren Allatt
+
+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,191 @@
+# git-syncr
+
+Automatically keep all your local git repos in sync with their remotes. Designed for developers who work across many repositories and want passive, reliable background syncing.
+
+Works on **macOS** and **Linux**. Handles laptop sleep/wake gracefully — no syncs are ever missed.
+
+## Features
+
+- Scans a directory for all git repos and pulls remote changes
+- Interactive CLI with setup wizard and directory browser
+- Background service that syncs on a configurable schedule (default: every 24 hours)
+- Safe by design: uses `git pull --ff-only`, skips dirty working trees
+- Desktop notifications with sync summary
+- Detailed logging with per-repo status tracking
+
+## Install
+
+```bash
+npm install -g git-syncr
+```
+
+Requires [Node.js](https://nodejs.org/) 18+ and [git](https://git-scm.com/).
+
+## Quick Start
+
+```bash
+git-syncr
+```
+
+On first run, the interactive setup wizard will guide you through:
+
+1. **Select your sync directory** — navigate with arrow keys to pick the folder containing your repos
+2. **Set sync interval** — how often to check for remote changes (default: 24h)
+3. **Enable notifications** — desktop alerts after each sync run
+
+After setup, the background service is installed automatically and the main menu appears.
+
+## Usage
+
+### Interactive Mode
+
+```bash
+git-syncr
+```
+
+Opens the main menu with options to:
+
+- **Sync now** — pull remote changes for all repos immediately
+- **Sync (dry run)** — check what would be synced without pulling
+- **Setup** — change your configuration
+- **View last log** — see the most recent sync results
+- **Quit** — exit with the option to keep or stop the background service
+
+### Non-Interactive Mode
+
+For scripting or background service use:
+
+```bash
+# Sync with terminal output
+git-syncr --verbose
+
+# Check for changes without pulling
+git-syncr --dry-run --verbose
+
+# Both flags
+git-syncr --verbose --dry-run
+```
+
+## How It Works
+
+### Sync Logic
+
+For each git repo found in your sync directory:
+
+1. **Check working tree** — if there are uncommitted changes, the repo is skipped (never risks your work)
+2. **Check branch** — skips repos in detached HEAD state or without a tracking branch
+3. **Fetch** — pulls the latest refs from the tracking remote
+4. **Compare** — checks if remote has new commits
+5. **Pull** — uses `--ff-only` to apply changes (fails safely if history has diverged)
+
+### Background Service
+
+- **macOS**: Uses `launchd` with `StartInterval`. If your laptop is asleep when a sync is due, it runs immediately on wake.
+- **Linux**: Uses `systemd` user timers with `Persistent=true`. Catches up on missed runs after resume.
+
+### Status Codes
+
+Each repo gets one of these statuses per sync run:
+
+| Status | Meaning |
+|---|---|
+| `[SYNCED]` | New commits pulled successfully |
+| `[UNCHANGED]` | Already up to date |
+| `[SKIPPED]` | Dirty working tree, detached HEAD, or no tracking branch |
+| `[ERROR]` | Fetch failed, ff-only failed, or other git error |
+
+## Configuration
+
+Config is stored at `~/.config/git-syncr/config.json`:
+
+```json
+{
+  "syncDir": "/Users/you/Development",
+  "intervalSeconds": 86400,
+  "notificationsEnabled": true
+}
+```
+
+You can edit this file directly or use `git-syncr` to change settings interactively.
+
+### Interval Examples
+
+| Value | Seconds |
+|---|---|
+| 1h | 3600 |
+| 6h | 21600 |
+| 12h | 43200 |
+| 24h | 86400 |
+| 7d | 604800 |
+
+## Logs
+
+Logs are written to:
+
+- **macOS**: `~/Library/Logs/git-syncr/git-syncr.log`
+- **Linux**: `~/.local/share/git-syncr/logs/git-syncr.log`
+
+Each run produces a block like:
+
+```
+========================================
+git-syncr run: 2026-04-04T09:15:32.000Z
+========================================
+[UNCHANGED] my-app (main)
+[SYNCED]    api-server (main) abc1234..def5678
+[SKIPPED]   docs (develop) -- dirty working tree
+[ERROR]     fork-repo (main) -- ff-only failed
+----------------------------------------
+Summary: 1 synced, 1 unchanged, 1 skipped, 1 errored (4 total)
+========================================
+```
+
+## Troubleshooting
+
+### "No network connectivity"
+
+The sync checks connectivity to github.com before running. If you're offline, it skips gracefully and retries on the next scheduled run.
+
+### Repos showing as [SKIPPED]
+
+- **dirty working tree** — you have uncommitted changes. Commit or stash them.
+- **detached HEAD** — check out a branch with `git checkout main`.
+- **no tracking branch** — set one with `git branch -u origin/main`.
+
+### Repos showing as [ERROR]
+
+- **fetch failed** — usually an auth issue. Check your git credentials or SSH keys.
+- **ff-only failed** — local and remote have diverged. Manually merge or rebase to resolve.
+
+### Service not running
+
+```bash
+# macOS — check if loaded
+launchctl list | grep git-syncr
+
+# Linux — check timer status
+systemctl --user status git-syncr.timer
+```
+
+Re-run `git-syncr` and select **Setup** to reinstall the service.
+
+### git not found by background service
+
+The service includes `/opt/homebrew/bin`, `/usr/local/bin`, and `/usr/bin` in PATH. If your git is installed elsewhere, you may need to adjust the service configuration.
+
+## Uninstalling
+
+Run `git-syncr`, select **Quit**, then choose **Quit & stop background sync** to remove the service.
+
+To fully uninstall:
+
+```bash
+npm uninstall -g git-syncr
+rm -rf ~/.config/git-syncr
+```
+
+Logs are preserved. Remove them manually if desired.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,916 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/platform.ts
+import os from "os";
+import path from "path";
+function getPlatform() {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "linux":
+      return "linux";
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}. git-syncr supports macOS and Linux.`);
+  }
+}
+function getPaths() {
+  const home = os.homedir();
+  const platform = getPlatform();
+  const configDir = path.join(home, ".config", "git-syncr");
+  const configFile = path.join(configDir, "config.json");
+  if (platform === "macos") {
+    const logDir2 = path.join(home, "Library", "Logs", "git-syncr");
+    return {
+      configDir,
+      configFile,
+      logDir: logDir2,
+      lockFile: path.join(logDir2, ".git-syncr.lock"),
+      serviceDir: path.join(home, "Library", "LaunchAgents"),
+      serviceFile: path.join(home, "Library", "LaunchAgents", "com.user.git-syncr.plist")
+    };
+  }
+  const logDir = path.join(home, ".local", "share", "git-syncr", "logs");
+  return {
+    configDir,
+    configFile,
+    logDir,
+    lockFile: path.join(logDir, ".git-syncr.lock"),
+    serviceDir: path.join(home, ".config", "systemd", "user"),
+    serviceFile: path.join(home, ".config", "systemd", "user", "git-syncr.service")
+  };
+}
+var init_platform = __esm({
+  "src/platform.ts"() {
+    "use strict";
+  }
+});
+
+// src/config.ts
+import fs from "fs";
+function configExists() {
+  return fs.existsSync(paths.configFile);
+}
+function loadConfig() {
+  if (!configExists()) return null;
+  const raw = fs.readFileSync(paths.configFile, "utf-8");
+  return JSON.parse(raw);
+}
+function saveConfig(config) {
+  fs.mkdirSync(paths.configDir, { recursive: true });
+  fs.writeFileSync(paths.configFile, JSON.stringify(config, null, 2) + "\n");
+}
+var paths;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_platform();
+    paths = getPaths();
+  }
+});
+
+// src/templates/launchd.ts
+function generatePlist(opts) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.user.git-syncr</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${opts.nodePath}</string>
+        <string>${opts.scriptPath}</string>
+    </array>
+
+    <key>StartInterval</key>
+    <integer>${opts.intervalSeconds}</integer>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+        <key>HOME</key>
+        <string>${opts.home}</string>
+    </dict>
+
+    <key>StandardOutPath</key>
+    <string>${opts.logDir}/launchd-stdout.log</string>
+    <key>StandardErrorPath</key>
+    <string>${opts.logDir}/launchd-stderr.log</string>
+
+    <key>RunAtLoad</key>
+    <false/>
+
+    <key>Nice</key>
+    <integer>10</integer>
+</dict>
+</plist>
+`;
+}
+var init_launchd = __esm({
+  "src/templates/launchd.ts"() {
+    "use strict";
+  }
+});
+
+// src/templates/systemd.ts
+function generateServiceUnit(opts) {
+  return `[Unit]
+Description=git-syncr - Sync git repos with remotes
+
+[Service]
+Type=oneshot
+ExecStart=${opts.nodePath} ${opts.scriptPath}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target
+`;
+}
+function generateTimerUnit(opts) {
+  return `[Unit]
+Description=git-syncr timer - Run git-syncr periodically
+
+[Timer]
+OnBootSec=5min
+OnUnitActiveSec=${opts.intervalSeconds}s
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+var init_systemd = __esm({
+  "src/templates/systemd.ts"() {
+    "use strict";
+  }
+});
+
+// src/service.ts
+import fs5 from "fs";
+import os2 from "os";
+import { execSync } from "child_process";
+function resolveScriptPath() {
+  try {
+    const result = execSync("which git-syncr", { encoding: "utf-8" }).trim();
+    return fs5.realpathSync(result);
+  } catch {
+    return process.argv[1];
+  }
+}
+function installService(config) {
+  const platform = getPlatform();
+  const paths2 = getPaths();
+  const nodePath = process.execPath;
+  const scriptPath = resolveScriptPath();
+  fs5.mkdirSync(paths2.logDir, { recursive: true });
+  if (platform === "macos") {
+    installLaunchd(nodePath, scriptPath, config, paths2);
+  } else {
+    installSystemd(nodePath, scriptPath, config, paths2);
+  }
+}
+function uninstallService() {
+  const platform = getPlatform();
+  const paths2 = getPaths();
+  if (platform === "macos") {
+    uninstallLaunchd(paths2);
+  } else {
+    uninstallSystemd(paths2);
+  }
+}
+function installLaunchd(nodePath, scriptPath, config, paths2) {
+  const plist = generatePlist({
+    nodePath,
+    scriptPath,
+    syncDir: config.syncDir,
+    logDir: paths2.logDir,
+    home: os2.homedir(),
+    intervalSeconds: config.intervalSeconds
+  });
+  fs5.mkdirSync(paths2.serviceDir, { recursive: true });
+  if (fs5.existsSync(paths2.serviceFile)) {
+    try {
+      execSync(`launchctl unload "${paths2.serviceFile}" 2>/dev/null`, { encoding: "utf-8" });
+    } catch {
+    }
+  }
+  fs5.writeFileSync(paths2.serviceFile, plist);
+  execSync(`launchctl load "${paths2.serviceFile}"`, { encoding: "utf-8" });
+}
+function uninstallLaunchd(paths2) {
+  if (fs5.existsSync(paths2.serviceFile)) {
+    try {
+      execSync(`launchctl unload "${paths2.serviceFile}" 2>/dev/null`, { encoding: "utf-8" });
+    } catch {
+    }
+    fs5.unlinkSync(paths2.serviceFile);
+  }
+}
+function installSystemd(nodePath, scriptPath, config, paths2) {
+  const serviceUnit = generateServiceUnit({ nodePath, scriptPath, intervalSeconds: config.intervalSeconds });
+  const timerUnit = generateTimerUnit({ nodePath, scriptPath, intervalSeconds: config.intervalSeconds });
+  fs5.mkdirSync(paths2.serviceDir, { recursive: true });
+  const timerFile = paths2.serviceFile.replace(".service", ".timer");
+  fs5.writeFileSync(paths2.serviceFile, serviceUnit);
+  fs5.writeFileSync(timerFile, timerUnit);
+  execSync("systemctl --user daemon-reload", { encoding: "utf-8" });
+  execSync("systemctl --user enable --now git-syncr.timer", { encoding: "utf-8" });
+}
+function uninstallSystemd(paths2) {
+  const timerFile = paths2.serviceFile.replace(".service", ".timer");
+  try {
+    execSync("systemctl --user disable --now git-syncr.timer 2>/dev/null", { encoding: "utf-8" });
+  } catch {
+  }
+  for (const f of [paths2.serviceFile, timerFile]) {
+    if (fs5.existsSync(f)) fs5.unlinkSync(f);
+  }
+  try {
+    execSync("systemctl --user daemon-reload", { encoding: "utf-8" });
+  } catch {
+  }
+}
+var init_service = __esm({
+  "src/service.ts"() {
+    "use strict";
+    init_platform();
+    init_launchd();
+    init_systemd();
+  }
+});
+
+// src/setup/directory-prompt.ts
+import fs6 from "fs";
+import path5 from "path";
+import os3 from "os";
+import { createPrompt, useState, useKeypress, isUpKey, isDownKey, isEnterKey, isBackspaceKey } from "@inquirer/core";
+import pc from "picocolors";
+var directoryPrompt;
+var init_directory_prompt = __esm({
+  "src/setup/directory-prompt.ts"() {
+    "use strict";
+    directoryPrompt = createPrompt(
+      (config, done) => {
+        const [currentDir, setCurrentDir] = useState(config.default ?? os3.homedir());
+        const [cursor, setCursor] = useState(0);
+        const [selected, setSelected] = useState(false);
+        let entries;
+        try {
+          entries = fs6.readdirSync(currentDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name).sort((a, b) => a.localeCompare(b));
+        } catch {
+          entries = [];
+        }
+        const totalItems = entries.length + 1;
+        useKeypress((key) => {
+          if (selected) return;
+          if (isUpKey(key)) {
+            setCursor((cursor - 1 + totalItems) % totalItems);
+          } else if (isDownKey(key)) {
+            setCursor((cursor + 1) % totalItems);
+          } else if (isEnterKey(key) || key.name === "right") {
+            if (cursor === 0) {
+              setSelected(true);
+              done(currentDir);
+            } else {
+              const target = path5.join(currentDir, entries[cursor - 1]);
+              setCurrentDir(target);
+              setCursor(0);
+            }
+          } else if (isBackspaceKey(key) || key.name === "left") {
+            const parent = path5.dirname(currentDir);
+            if (parent !== currentDir) {
+              setCurrentDir(parent);
+              setCursor(0);
+            }
+          }
+        });
+        if (selected) {
+          return `${pc.green("?")} ${config.message} ${pc.cyan(currentDir)}`;
+        }
+        const lines = [];
+        lines.push(`${pc.green("?")} ${config.message}`);
+        lines.push(pc.dim(`  ${currentDir}`));
+        lines.push("");
+        if (cursor === 0) {
+          lines.push(`  ${pc.cyan(">")} ${pc.bold(pc.green("[ Select this directory ]"))}`);
+        } else {
+          lines.push(`    ${pc.dim("[ Select this directory ]")}`);
+        }
+        const maxVisible = 15;
+        const startIdx = Math.max(0, Math.min(cursor - 1 - Math.floor(maxVisible / 2), entries.length - maxVisible));
+        const endIdx = Math.min(entries.length, startIdx + maxVisible);
+        if (startIdx > 0) {
+          lines.push(pc.dim(`    ... ${startIdx} more above`));
+        }
+        for (let i = startIdx; i < endIdx; i++) {
+          const itemIdx = i + 1;
+          if (itemIdx === cursor) {
+            lines.push(`  ${pc.cyan(">")} ${pc.bold(entries[i])}/`);
+          } else {
+            lines.push(`    ${entries[i]}/`);
+          }
+        }
+        if (endIdx < entries.length) {
+          lines.push(pc.dim(`    ... ${entries.length - endIdx} more below`));
+        }
+        lines.push("");
+        lines.push(pc.dim("  Use arrow keys to navigate, Enter to select, Backspace to go up"));
+        return lines.join("\n");
+      }
+    );
+  }
+});
+
+// src/setup/wizard.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  runWizard: () => runWizard
+});
+import os4 from "os";
+import path6 from "path";
+import { input, confirm } from "@inquirer/prompts";
+import pc2 from "picocolors";
+function parseInterval(value) {
+  const match = value.trim().match(/^(\d+)\s*(h|d|m|s)?$/i);
+  if (!match) return null;
+  const num = parseInt(match[1], 10);
+  const unit = (match[2] ?? "h").toLowerCase();
+  switch (unit) {
+    case "s":
+      return num;
+    case "m":
+      return num * 60;
+    case "h":
+      return num * 3600;
+    case "d":
+      return num * 86400;
+    default:
+      return null;
+  }
+}
+function formatInterval(seconds) {
+  if (seconds % 86400 === 0) return `${seconds / 86400}d`;
+  if (seconds % 3600 === 0) return `${seconds / 3600}h`;
+  if (seconds % 60 === 0) return `${seconds / 60}m`;
+  return `${seconds}s`;
+}
+async function runWizard() {
+  const existing = loadConfig();
+  const isReconfig = existing !== null;
+  console.log("");
+  console.log(pc2.bold("  git-syncr setup"));
+  console.log(pc2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (isReconfig) {
+    console.log("");
+    console.log(pc2.dim("  Current configuration:"));
+    console.log(`    Sync directory:  ${pc2.cyan(existing.syncDir)}`);
+    console.log(`    Sync interval:   ${pc2.cyan(formatInterval(existing.intervalSeconds))}`);
+    console.log(`    Notifications:   ${pc2.cyan(existing.notificationsEnabled ? "on" : "off")}`);
+    console.log("");
+  }
+  let syncDir = existing?.syncDir ?? path6.join(os4.homedir(), "Development");
+  let intervalSeconds = existing?.intervalSeconds ?? 86400;
+  let notificationsEnabled = existing?.notificationsEnabled ?? true;
+  if (isReconfig) {
+    const changeSyncDir = await confirm({
+      message: `Change sync directory? (currently ${pc2.cyan(syncDir)})`,
+      default: false
+    });
+    if (changeSyncDir) {
+      syncDir = await directoryPrompt({
+        message: "Select sync directory:",
+        default: syncDir
+      });
+    }
+  } else {
+    syncDir = await directoryPrompt({
+      message: "Select the directory to sync:",
+      default: syncDir
+    });
+  }
+  if (isReconfig) {
+    const changeInterval = await confirm({
+      message: `Change sync interval? (currently ${pc2.cyan(formatInterval(intervalSeconds))})`,
+      default: false
+    });
+    if (changeInterval) {
+      intervalSeconds = await promptInterval(intervalSeconds);
+    }
+  } else {
+    intervalSeconds = await promptInterval(intervalSeconds);
+  }
+  if (isReconfig) {
+    const changeNotify = await confirm({
+      message: `Change notifications? (currently ${pc2.cyan(notificationsEnabled ? "on" : "off")})`,
+      default: false
+    });
+    if (changeNotify) {
+      notificationsEnabled = await confirm({
+        message: "Enable desktop notifications?",
+        default: notificationsEnabled
+      });
+    }
+  } else {
+    notificationsEnabled = await confirm({
+      message: "Enable desktop notifications?",
+      default: true
+    });
+  }
+  const config = { syncDir, intervalSeconds, notificationsEnabled };
+  saveConfig(config);
+  console.log("");
+  console.log(pc2.dim("  Installing background service..."));
+  try {
+    installService(config);
+    console.log(pc2.green("  Service installed successfully."));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(pc2.yellow(`  Could not install service: ${msg}`));
+    console.log(pc2.dim("  You can run git-syncr manually or try again later."));
+  }
+  console.log("");
+  console.log(pc2.green("  Setup complete!"));
+  console.log("");
+}
+async function promptInterval(defaultSeconds) {
+  const result = await input({
+    message: "Sync interval (e.g., 1h, 6h, 12h, 24h, 7d):",
+    default: formatInterval(defaultSeconds),
+    validate: (value) => {
+      const parsed = parseInterval(value);
+      if (parsed === null || parsed < 60) {
+        return "Enter a valid interval (e.g., 1h, 6h, 24h, 7d). Minimum 1m.";
+      }
+      return true;
+    }
+  });
+  return parseInterval(result);
+}
+var init_wizard = __esm({
+  "src/setup/wizard.ts"() {
+    "use strict";
+    init_config();
+    init_service();
+    init_directory_prompt();
+  }
+});
+
+// src/cli.ts
+init_config();
+import fs7 from "fs";
+import { select } from "@inquirer/prompts";
+import pc3 from "picocolors";
+
+// src/sync.ts
+init_config();
+init_platform();
+import fs4 from "fs";
+import path4 from "path";
+
+// src/logger.ts
+import fs2 from "fs";
+import path2 from "path";
+var Logger = class {
+  constructor(logFile, verbose) {
+    this.logFile = logFile;
+    this.verbose = verbose;
+    fs2.mkdirSync(path2.dirname(logFile), { recursive: true });
+  }
+  logFile;
+  verbose;
+  log(message) {
+    fs2.appendFileSync(this.logFile, message + "\n");
+    if (this.verbose) {
+      console.log(message);
+    }
+  }
+};
+
+// src/lock.ts
+import fs3 from "fs";
+import path3 from "path";
+function acquireLock(lockPath) {
+  fs3.mkdirSync(path3.dirname(lockPath), { recursive: true });
+  if (fs3.existsSync(lockPath)) {
+    const raw = fs3.readFileSync(lockPath, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    if (!isNaN(pid)) {
+      try {
+        process.kill(pid, 0);
+        return false;
+      } catch {
+        fs3.unlinkSync(lockPath);
+      }
+    } else {
+      fs3.unlinkSync(lockPath);
+    }
+  }
+  fs3.writeFileSync(lockPath, String(process.pid));
+  return true;
+}
+function releaseLock(lockPath) {
+  try {
+    fs3.unlinkSync(lockPath);
+  } catch {
+  }
+}
+
+// src/network.ts
+async function checkNetwork() {
+  try {
+    const response = await fetch("https://github.com", {
+      method: "HEAD",
+      signal: AbortSignal.timeout(1e4)
+    });
+    return response.ok || response.status === 301;
+  } catch {
+    return false;
+  }
+}
+
+// src/repo.ts
+import { simpleGit } from "simple-git";
+async function processRepo(repoPath, repoName, dryRun) {
+  const git = simpleGit(repoPath, {
+    timeout: { block: 3e4 }
+  });
+  process.env["GIT_HTTP_LOW_SPEED_LIMIT"] = "1000";
+  process.env["GIT_HTTP_LOW_SPEED_TIME"] = "15";
+  try {
+    const status = await git.status();
+    if (!status.isClean()) {
+      return { status: "SKIPPED", name: repoName, detail: "dirty working tree" };
+    }
+    let branch;
+    try {
+      branch = (await git.raw(["symbolic-ref", "--short", "HEAD"])).trim();
+    } catch {
+      return { status: "SKIPPED", name: repoName, detail: "detached HEAD" };
+    }
+    if (!branch) {
+      return { status: "SKIPPED", name: repoName, detail: "detached HEAD" };
+    }
+    let upstream;
+    try {
+      upstream = (await git.raw(["rev-parse", "--abbrev-ref", "@{upstream}"])).trim();
+    } catch {
+      return { status: "SKIPPED", name: `${repoName} (${branch})`, detail: "no tracking branch" };
+    }
+    const remoteName = upstream.split("/")[0];
+    const nameWithBranch = `${repoName} (${branch})`;
+    try {
+      await git.fetch(remoteName);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { status: "ERROR", name: nameWithBranch, detail: `fetch failed: ${msg}` };
+    }
+    const localSha = (await git.revparse(["HEAD"])).trim();
+    const remoteSha = (await git.revparse([upstream])).trim();
+    if (localSha === remoteSha) {
+      return { status: "UNCHANGED", name: nameWithBranch };
+    }
+    const shortLocal = localSha.slice(0, 7);
+    const shortRemote = remoteSha.slice(0, 7);
+    if (dryRun) {
+      return { status: "WOULD_SYNC", name: nameWithBranch, detail: `${shortLocal}..${shortRemote}` };
+    }
+    try {
+      await git.pull(["--ff-only"]);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { status: "ERROR", name: nameWithBranch, detail: `ff-only failed: ${msg}` };
+    }
+    return { status: "SYNCED", name: nameWithBranch, detail: `${shortLocal}..${shortRemote}` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { status: "ERROR", name: repoName, detail: msg };
+  }
+}
+
+// src/notify.ts
+init_platform();
+import { execFile } from "child_process";
+function sendNotification(title, subtitle, body) {
+  const platform = getPlatform();
+  try {
+    if (platform === "macos") {
+      const script = `display notification "${body}" with title "${title}" subtitle "${subtitle}"`;
+      execFile("osascript", ["-e", script], (err) => {
+        if (err) {
+        }
+      });
+    } else {
+      execFile("notify-send", [title, `${subtitle}
+${body}`], (err) => {
+        if (err) {
+        }
+      });
+    }
+  } catch {
+  }
+}
+
+// src/sync.ts
+async function runSync(opts) {
+  const config = loadConfig();
+  if (!config) {
+    return { synced: 0, unchanged: 0, skipped: 0, errored: 0, total: 0, abortReason: "No configuration found." };
+  }
+  const paths2 = getPaths();
+  const logFile = path4.join(paths2.logDir, "git-syncr.log");
+  const logger = new Logger(logFile, opts.verbose);
+  if (!acquireLock(paths2.lockFile)) {
+    logger.log("Another git-syncr is running. Exiting.");
+    sendNotification("git-syncr", "Already running", "Another instance is running.");
+    return { synced: 0, unchanged: 0, skipped: 0, errored: 0, total: 0, abortReason: "Another instance is running." };
+  }
+  try {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    logger.log("========================================");
+    logger.log(`git-syncr run: ${timestamp}`);
+    if (opts.dryRun) {
+      logger.log("MODE: dry-run (no pulls)");
+    }
+    logger.log("========================================");
+    const online = await checkNetwork();
+    if (!online) {
+      logger.log("No network connectivity. Aborting.");
+      sendNotification("git-syncr", "No network", "Could not reach github.com");
+      logger.log("========================================");
+      return { synced: 0, unchanged: 0, skipped: 0, errored: 0, total: 0, abortReason: "No network connectivity." };
+    }
+    const repos = discoverRepos(config.syncDir);
+    let synced = 0;
+    let unchanged = 0;
+    let skipped = 0;
+    let errored = 0;
+    for (const repoPath of repos) {
+      const repoName = path4.basename(repoPath);
+      const result = await processRepo(repoPath, repoName, opts.dryRun);
+      switch (result.status) {
+        case "SYNCED":
+          logger.log(`[SYNCED]    ${result.name} ${result.detail ?? ""}`);
+          synced++;
+          break;
+        case "WOULD_SYNC":
+          logger.log(`[WOULD_SYNC] ${result.name} ${result.detail ?? ""}`);
+          synced++;
+          break;
+        case "UNCHANGED":
+          logger.log(`[UNCHANGED] ${result.name}`);
+          unchanged++;
+          break;
+        case "SKIPPED":
+          logger.log(`[SKIPPED]   ${result.name} -- ${result.detail ?? ""}`);
+          skipped++;
+          break;
+        case "ERROR":
+          logger.log(`[ERROR]     ${result.name} -- ${result.detail ?? ""}`);
+          errored++;
+          break;
+      }
+    }
+    const total = synced + unchanged + skipped + errored;
+    logger.log("----------------------------------------");
+    const syncLabel = opts.dryRun ? "would sync" : "synced";
+    const summary = `${synced} ${syncLabel}, ${unchanged} unchanged, ${skipped} skipped, ${errored} errored (${total} total)`;
+    logger.log(`Summary: ${summary}`);
+    logger.log("========================================");
+    sendNotification(
+      "git-syncr",
+      `${total} repos processed`,
+      `${synced} ${syncLabel}, ${unchanged} unchanged, ${skipped} skipped, ${errored} errored`
+    );
+    return { synced, unchanged, skipped, errored, total };
+  } finally {
+    releaseLock(paths2.lockFile);
+  }
+}
+function discoverRepos(syncDir) {
+  if (!fs4.existsSync(syncDir)) {
+    return [];
+  }
+  const entries = fs4.readdirSync(syncDir, { withFileTypes: true });
+  const repos = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const fullPath = path4.join(syncDir, entry.name);
+    const gitDir = path4.join(fullPath, ".git");
+    if (fs4.existsSync(gitDir)) {
+      repos.push(fullPath);
+    }
+  }
+  return repos.sort((a, b) => path4.basename(a).localeCompare(path4.basename(b)));
+}
+
+// src/cli.ts
+init_service();
+init_platform();
+function printUsage() {
+  console.log(`
+Usage: git-syncr [options]
+
+Options:
+  --help         Show this help message
+
+When run without options, opens the interactive menu.
+`);
+}
+function printHeader() {
+  console.log("");
+  console.log(pc3.bold("  git-syncr"));
+  console.log(pc3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+}
+function printStatus() {
+  const config = loadConfig();
+  const paths2 = getPaths();
+  if (config) {
+    console.log("");
+    console.log(`    Sync directory:  ${pc3.cyan(config.syncDir)}`);
+    console.log(`    Sync interval:   ${pc3.cyan(formatInterval2(config.intervalSeconds))}`);
+    console.log(`    Notifications:   ${pc3.cyan(config.notificationsEnabled ? "on" : "off")}`);
+    console.log(`    Logs:            ${pc3.dim(paths2.logDir)}`);
+  } else {
+    console.log("");
+    console.log(pc3.yellow('    Not configured. Select "Setup" to get started.'));
+  }
+  console.log("");
+}
+function formatInterval2(seconds) {
+  if (seconds % 86400 === 0) return `${seconds / 86400}d`;
+  if (seconds % 3600 === 0) return `${seconds / 3600}h`;
+  if (seconds % 60 === 0) return `${seconds / 60}m`;
+  return `${seconds}s`;
+}
+async function mainMenu() {
+  if (!configExists()) {
+    printHeader();
+    console.log("");
+    console.log(pc3.dim("  Welcome! Let's set up git-syncr."));
+    const { runWizard: runWizard2 } = await Promise.resolve().then(() => (init_wizard(), wizard_exports));
+    await runWizard2();
+  }
+  while (true) {
+    printHeader();
+    printStatus();
+    const action = await select({
+      message: "What would you like to do?",
+      choices: [
+        { name: "Sync now", value: "sync", description: "Pull remote changes for all repos" },
+        { name: "Sync (dry run)", value: "dry-run", description: "Check for changes without pulling" },
+        { name: "Setup", value: "setup", description: "Change sync directory, interval, or notifications" },
+        { name: "View last log", value: "log", description: "Show the most recent sync log" },
+        { name: "Quit", value: "quit", description: "Exit git-syncr" }
+      ]
+    });
+    switch (action) {
+      case "sync": {
+        console.log("");
+        const result = await runSync({ verbose: true, dryRun: false });
+        if (result.abortReason) {
+          console.log(pc3.yellow(`
+  ${result.abortReason}`));
+        }
+        console.log("");
+        await pressEnterToContinue();
+        break;
+      }
+      case "dry-run": {
+        console.log("");
+        const result = await runSync({ verbose: true, dryRun: true });
+        if (result.abortReason) {
+          console.log(pc3.yellow(`
+  ${result.abortReason}`));
+        }
+        console.log("");
+        await pressEnterToContinue();
+        break;
+      }
+      case "setup": {
+        const { runWizard: runWizard2 } = await Promise.resolve().then(() => (init_wizard(), wizard_exports));
+        await runWizard2();
+        break;
+      }
+      case "log": {
+        showLastLog();
+        await pressEnterToContinue();
+        break;
+      }
+      case "quit": {
+        await handleQuit();
+        return;
+      }
+    }
+  }
+}
+async function handleQuit() {
+  const action = await select({
+    message: "How would you like to quit?",
+    choices: [
+      {
+        name: "Quit & keep syncing in background",
+        value: "keep",
+        description: "Background service continues to sync on schedule"
+      },
+      {
+        name: "Quit & stop background sync",
+        value: "stop",
+        description: "Uninstall the background service"
+      },
+      {
+        name: "Cancel",
+        value: "cancel",
+        description: "Return to main menu"
+      }
+    ]
+  });
+  switch (action) {
+    case "keep":
+      console.log("");
+      console.log(pc3.dim("  Background sync will continue on schedule."));
+      console.log("");
+      process.exit(0);
+      break;
+    case "stop":
+      try {
+        uninstallService();
+        console.log("");
+        console.log(pc3.dim("  Background service stopped and removed."));
+        console.log(pc3.dim("  Run git-syncr again to re-enable."));
+        console.log("");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(pc3.yellow(`
+  Could not stop service: ${msg}`));
+        console.log("");
+      }
+      process.exit(0);
+      break;
+    case "cancel":
+      break;
+  }
+}
+function showLastLog() {
+  const paths2 = getPaths();
+  const logFile = `${paths2.logDir}/git-syncr.log`;
+  try {
+    const content = fs7.readFileSync(logFile, "utf-8");
+    const lines = content.trimEnd().split("\n");
+    let startIdx = lines.length - 1;
+    let foundEnd = false;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i].startsWith("====")) {
+        if (foundEnd) {
+          startIdx = i;
+          break;
+        }
+        foundEnd = true;
+      }
+    }
+    console.log("");
+    for (let i = startIdx; i < lines.length; i++) {
+      console.log(`  ${lines[i]}`);
+    }
+    console.log("");
+  } catch {
+    console.log("");
+    console.log(pc3.dim("  No log file found. Run a sync first."));
+    console.log("");
+  }
+}
+async function pressEnterToContinue() {
+  const { input: input2 } = await import("@inquirer/prompts");
+  await input2({ message: pc3.dim("Press Enter to continue...") });
+}
+async function run(args) {
+  if (args.includes("--help")) {
+    printUsage();
+    return;
+  }
+  if (args.includes("--verbose") || args.includes("--dry-run")) {
+    if (!configExists()) {
+      console.error('No configuration found. Run "git-syncr" to set up.');
+      process.exit(1);
+    }
+    const verbose = args.includes("--verbose");
+    const dryRun = args.includes("--dry-run");
+    const result = await runSync({ verbose, dryRun });
+    process.exit(result.errored > 0 ? 1 : 0);
+  }
+  await mainMenu();
+}
+
+// src/index.ts
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "git-syncr",
+  "version": "1.0.0",
+  "description": "Automatically sync all git repos in a directory with their remotes",
+  "type": "module",
+  "bin": {
+    "git-syncr": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "postinstall": "node -e \"console.log('\\n  Run \\x1b[1mgit-syncr\\x1b[0m to complete setup.\\n');\""
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "git",
+    "sync",
+    "repository",
+    "auto-sync",
+    "launchd",
+    "systemd"
+  ],
+  "author": "Darren Allatt",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Darren-A11att/git-sync.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Darren-A11att/git-sync/issues"
+  },
+  "homepage": "https://github.com/Darren-A11att/git-sync#readme",
+  "dependencies": {
+    "@inquirer/core": "^11.1.7",
+    "@inquirer/prompts": "^8.3.2",
+    "picocolors": "^1.1.1",
+    "simple-git": "^3.33.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}