git-drive 0.1.0

package/packages/cli/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "git-drive",
+  "version": "0.1.0",
+  "description": "Turn any external drive into a git remote backup for your code - CLI, server, and web UI",
+  "keywords": [
+    "git",
+    "backup",
+    "external-drive",
+    "usb",
+    "remote",
+    "cli",
+    "docker"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/josmanvis/git-drive.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/josmanvis/git-drive/issues"
+  },
+  "homepage": "https://github.com/josmanvis/git-drive#readme",
+  "type": "commonjs",
+  "bin": {
+    "git-drive": "./dist/index.js",
+    "git-drive-server": "./dist/server.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "ui"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "start:server": "node dist/server.js",
+    "docker:build": "docker build -t git-drive .",
+    "docker:run": "docker run -it --rm -v /Volumes:/Volumes -p 4483:4483 git-drive",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "express": "^4.19.2",
+    "node-disk-info": "^1.3.0",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/packages/cli/src/commands/archive.ts

@@ -0,0 +1,39 @@
+import { rmSync } from "fs";
+import { requireConfig, assertDriveMounted } from "../config.js";
+import { git, getRepoRoot, getProjectName, isGitRepo } from "../git.js";
+import { push } from "./push.js";
+import { GitDriveError } from "../errors.js";
+
+export function archive(args: string[]): void {
+  if (!isGitRepo()) {
+    throw new GitDriveError("Not in a git repository.");
+  }
+
+  const force = args.includes("--force");
+
+  // Check for uncommitted changes
+  if (!force) {
+    const status = git("status --porcelain");
+    if (status) {
+      throw new GitDriveError(
+        "Working tree has uncommitted changes.\nCommit first or use --force to archive anyway."
+      );
+    }
+  }
+
+  const config = requireConfig();
+  assertDriveMounted(config.drivePath);
+
+  const projectName = getProjectName();
+  const repoRoot = getRepoRoot();
+
+  // Push first
+  push([]);
+
+  // Remove local copy
+  process.chdir("..");
+  rmSync(repoRoot, { recursive: true, force: true });
+
+  console.log(`Archived: ${projectName}`);
+  console.log(`Restore with: git drive restore ${projectName}`);
+}

package/packages/cli/src/commands/init.ts

@@ -0,0 +1,34 @@
+import { existsSync, statSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { saveConfig, getDriveStorePath } from "../config.js";
+import { GitDriveError } from "../errors.js";
+
+export function init(args: string[]): void {
+  const rawPath = args[0];
+
+  if (!rawPath) {
+    throw new GitDriveError("Usage: git drive init <path>");
+  }
+
+  const drivePath = resolve(rawPath);
+
+  if (!existsSync(drivePath)) {
+    throw new GitDriveError(
+      `Path not found: ${drivePath}\nIs the drive mounted?`
+    );
+  }
+
+  const stat = statSync(drivePath);
+  if (!stat.isDirectory()) {
+    throw new GitDriveError(`Path is not a directory: ${drivePath}`);
+  }
+
+  const storePath = getDriveStorePath(drivePath);
+  if (!existsSync(storePath)) {
+    mkdirSync(storePath, { recursive: true });
+  }
+
+  saveConfig({ drivePath });
+
+  console.log(`Drive configured: ${storePath}`);
+}

package/packages/cli/src/commands/link.ts

@@ -0,0 +1,115 @@
+import { handleError } from "../errors.js";
+import { saveLink } from "../config.js";
+import { git, getProjectName, getRepoRoot, listDrives } from "../git.js";
+import prompts from "prompts";
+import * as fs from "fs";
+import * as path from "path";
+
+export async function link(args: string[]): Promise<void> {
+  try {
+    const drives = await listDrives();
+
+    // Only fetch drives that actually have .git-drive configured
+    const configuredDrives = drives
+      .filter((drive) => drive.mounted && drive.mounted !== "/")
+      .filter((drive) => fs.existsSync(path.join(drive.mounted, ".git-drive")));
+
+    if (configuredDrives.length === 0) {
+      console.log("No initialized git-drives found. Please initialize a drive first.");
+      return;
+    }
+
+    const { drive } = await prompts({
+      type: "select",
+      name: "drive",
+      message: "Select a configured git-drive:",
+      choices: configuredDrives.map((d) => ({
+        title: `${d.filesystem} (${d.mounted})`,
+        value: d,
+      })),
+    });
+
+    if (!drive) return;
+
+    const gitDrivePath = path.join(drive.mounted, ".git-drive");
+    const existingRepos = fs.readdirSync(gitDrivePath).filter((entry) => {
+      const entryPath = path.join(gitDrivePath, entry);
+      return (
+        fs.statSync(entryPath).isDirectory() &&
+        (entry.endsWith(".git") || fs.existsSync(path.join(entryPath, "HEAD")))
+      );
+    });
+
+    const CREATE_NEW = "__CREATE_NEW__";
+    const { selectedRepo } = await prompts({
+      type: "select",
+      name: "selectedRepo",
+      message: "Select an existing repository to link, or create a new one:",
+      choices: [
+        { title: "✨ Create new repository...", value: CREATE_NEW },
+        ...existingRepos.map((repo) => ({
+          title: `📁 ${repo.replace(/\.git$/, "")}`,
+          value: repo,
+        })),
+      ],
+    });
+
+    if (!selectedRepo) return;
+
+    let targetRepoName = selectedRepo;
+
+    if (selectedRepo === CREATE_NEW) {
+      const defaultName = getProjectName();
+      const { newRepoName } = await prompts({
+        type: "text",
+        name: "newRepoName",
+        message: "Enter the new repository name:",
+        initial: defaultName,
+      });
+
+      if (!newRepoName) return;
+      targetRepoName = newRepoName.endsWith(".git") ? newRepoName : `${newRepoName}.git`;
+
+      const repoPath = path.join(gitDrivePath, targetRepoName);
+      if (fs.existsSync(repoPath)) {
+        console.log(`Repository ${targetRepoName} already exists in this drive.`);
+        return;
+      }
+
+      git(`init --bare "${repoPath}"`);
+      console.log(`Created new bare repository: ${targetRepoName}`);
+    }
+
+    const repoRoot = getRepoRoot();
+    const finalRepoPath = path.join(gitDrivePath, targetRepoName);
+
+    // Check if remote 'gd' already exists
+    let gdExists = false;
+    try {
+      git(`remote get-url gd`, repoRoot);
+      gdExists = true;
+    } catch {
+      // Remote does not exist
+    }
+
+    if (gdExists) {
+      console.log("Remote 'gd' already exists. Updating it to point to the new drive.");
+      git(`remote set-url gd "${finalRepoPath}"`, repoRoot);
+    } else {
+      git(`remote add gd "${finalRepoPath}"`, repoRoot);
+    }
+
+    // Persist to global git-drive registry for the Web UI
+    saveLink(repoRoot, drive.mounted, targetRepoName);
+
+    console.log(`\n✅ Successfully linked!`);
+    console.log(`Repository: ${targetRepoName.replace(/\.git$/, "")}`);
+    console.log(`Drive: ${drive.mounted}`);
+    console.log(`\nYou can now push to this remote using:`);
+    console.log(`  git push gd main`);
+
+  } catch (err) {
+    handleError(err);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/list.ts

@@ -0,0 +1,94 @@
+import { readdirSync, statSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { getDiskInfo } from "node-disk-info";
+
+interface LinkConfig {
+  mountpoint: string;
+  repoName: string;
+  linkedAt: string;
+}
+
+function loadLinks(): Record<string, LinkConfig> {
+  const linksFile = join(homedir(), ".config", "git-drive", "links.json");
+  if (!existsSync(linksFile)) return {};
+  try {
+    return JSON.parse(readFileSync(linksFile, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function getGitDrivePath(mountpoint: string): string {
+  return join(mountpoint, ".git-drive");
+}
+
+export async function list(_args: string[]): Promise<void> {
+  console.log("Git Drive - Connected Drives\n");
+
+  // Get all connected drives
+  let drives: any[] = [];
+  try {
+    drives = await getDiskInfo();
+  } catch (err) {
+    console.error("Error detecting drives:", err);
+    return;
+  }
+
+  // Filter to external/removable drives
+  const externalDrives = drives.filter((d: any) => {
+    const mp = d.mounted;
+    if (!mp) return false;
+    if (mp === "/" || mp === "100%") return false;
+
+    if (process.platform === "darwin") {
+      return mp.startsWith("/Volumes/") && !mp.startsWith("/Volumes/Recovery");
+    }
+
+    if (mp.startsWith("/sys") || mp.startsWith("/proc") || mp.startsWith("/run") || mp.startsWith("/snap") || mp.startsWith("/boot")) return false;
+    if (d.filesystem === "tmpfs" || d.filesystem === "devtmpfs" || d.filesystem === "udev" || d.filesystem === "overlay") return false;
+
+    return true;
+  });
+
+  if (externalDrives.length === 0) {
+    console.log("No external drives detected.");
+    console.log("\nConnect an external drive and try again.");
+    return;
+  }
+
+  // Load links to show which drives are registered
+  const links = loadLinks();
+  const registeredMountpoints = new Set(Object.values(links).map(l => l.mountpoint));
+
+  for (const drive of externalDrives) {
+    const mp = drive.mounted;
+    const gitDrivePath = getGitDrivePath(mp);
+    const hasGitDrive = existsSync(gitDrivePath);
+    const isRegistered = registeredMountpoints.has(mp);
+
+    // Count repos on this drive
+    let repoCount = 0;
+    if (hasGitDrive) {
+      try {
+        const entries = readdirSync(gitDrivePath).filter(n => n.endsWith(".git") || existsSync(join(gitDrivePath, n, "HEAD")));
+        repoCount = entries.length;
+      } catch {}
+    }
+
+    // Format size
+    const sizeGB = drive.blocks ? ((parseInt(drive.blocks) * 1024) / (1024 * 1024 * 1024)).toFixed(1) : "?";
+    
+    // Status indicator
+    const status = hasGitDrive ? "✓ registered" : "○ not registered";
+    
+    console.log(`  ${mp}`);
+    console.log(`    Size: ${sizeGB} GB`);
+    console.log(`    Status: ${status}`);
+    console.log(`    Repositories: ${repoCount}`);
+    console.log();
+  }
+
+  console.log(`\n${externalDrives.length} drive${externalDrives.length === 1 ? "" : "s"} detected.`);
+  console.log("\nRun 'git-drive link' to link a repo to a drive.");
+}

package/packages/cli/src/commands/push.ts

@@ -0,0 +1,64 @@
+import { git, getRemoteUrl, isGitRepo } from "../git.js";
+import { GitDriveError } from "../errors.js";
+import prompts from "prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+export async function push(_args: string[]): Promise<void> {
+  if (!isGitRepo()) {
+    throw new GitDriveError("Not in a git repository.");
+  }
+
+  const existingUrl = getRemoteUrl("gd");
+  if (!existingUrl) {
+    throw new GitDriveError("No git-drive linked for this project. Please run 'git-drive link' first.");
+  }
+
+  try {
+    const currentBranch = git("branch --show-current") || "HEAD";
+
+    const { pushMode } = await prompts({
+      type: "select",
+      name: "pushMode",
+      message: `Pushing to ${existingUrl}\nSelect what to branch to push:`,
+      choices: [
+        { title: `Current branch only (${currentBranch})`, value: "current" },
+        { title: "All branches & tags", value: "all" }
+      ]
+    });
+
+    if (!pushMode) return;
+
+    if (pushMode === "current") {
+      console.log(`\nPushing ${currentBranch}...`);
+      git(`push gd ${currentBranch}`);
+      console.log(`✅ Successfully pushed ${currentBranch} to git-drive.`);
+    } else {
+      console.log("\nPushing all branches and tags...");
+      git("push gd --all");
+      git("push gd --tags");
+      console.log(`✅ Successfully pushed all branches and tags to git-drive.`);
+    }
+
+    // Write context to a central pushlog safely inside the git-drive repo folder
+    try {
+      if (fs.existsSync(existingUrl)) {
+        const payload = {
+          date: new Date().toISOString(),
+          computer: os.hostname(),
+          user: os.userInfo().username,
+          localDir: process.cwd(),
+          mode: pushMode,
+        };
+        const logFile = path.join(existingUrl, "git-drive-pushlog.json");
+        fs.appendFileSync(logFile, JSON.stringify(payload) + "\n", "utf-8");
+      }
+    } catch {
+      // Intentionally swallow telemetry tracking errors
+    }
+
+  } catch (err: any) {
+    throw new GitDriveError(`Failed to push to drive. Make sure the drive is connected.\n${err.message}`);
+  }
+}

package/packages/cli/src/commands/restore.ts

@@ -0,0 +1,36 @@
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import { requireConfig, assertDriveMounted, getDriveStorePath } from "../config.js";
+import { git } from "../git.js";
+import { GitDriveError } from "../errors.js";
+
+export function restore(args: string[]): void {
+  const projectName = args[0];
+  const targetDir = args[1] || projectName;
+
+  if (!projectName) {
+    throw new GitDriveError("Usage: git drive restore <project-name> [target-dir]");
+  }
+
+  const config = requireConfig();
+  assertDriveMounted(config.drivePath);
+
+  const storePath = getDriveStorePath(config.drivePath);
+  const bareRepoPath = join(storePath, `${projectName}.git`);
+
+  if (!existsSync(bareRepoPath)) {
+    throw new GitDriveError(`Project '${projectName}' not found on drive.`);
+  }
+
+  const targetPath = resolve(targetDir);
+  if (existsSync(targetPath)) {
+    throw new GitDriveError(`Directory already exists: ${targetPath}`);
+  }
+
+  git(`clone ${bareRepoPath} ${targetPath}`);
+
+  // Rename origin to drive so the remote stays consistent
+  git("remote rename origin drive", targetPath);
+
+  console.log(`Restored ${projectName} into ${targetPath}`);
+}

package/packages/cli/src/commands/status.ts

@@ -0,0 +1,127 @@
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { getDiskInfo } from "node-disk-info";
+import { isGitRepo, getProjectName, getRemoteUrl } from "../git.js";
+
+interface LinkConfig {
+  mountpoint: string;
+  repoName: string;
+  linkedAt: string;
+}
+
+function loadLinks(): Record<string, LinkConfig> {
+  const linksFile = join(homedir(), ".config", "git-drive", "links.json");
+  if (!existsSync(linksFile)) return {};
+  try {
+    return JSON.parse(readFileSync(linksFile, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function getGitDrivePath(mountpoint: string): string {
+  return join(mountpoint, ".git-drive");
+}
+
+export async function status(_args: string[]): Promise<void> {
+  console.log("Git Drive Status\n");
+
+  // Get all connected drives
+  let drives: any[] = [];
+  try {
+    drives = await getDiskInfo();
+  } catch (err) {
+    console.error("Error detecting drives:", err);
+    return;
+  }
+
+  // Filter to external/removable drives
+  const externalDrives = drives.filter((d: any) => {
+    const mp = d.mounted;
+    if (!mp) return false;
+    if (mp === "/" || mp === "100%") return false;
+
+    if (process.platform === "darwin") {
+      return mp.startsWith("/Volumes/") && !mp.startsWith("/Volumes/Recovery");
+    }
+
+    if (mp.startsWith("/sys") || mp.startsWith("/proc") || mp.startsWith("/run") || mp.startsWith("/snap") || mp.startsWith("/boot")) return false;
+    if (d.filesystem === "tmpfs" || d.filesystem === "devtmpfs" || d.filesystem === "udev" || d.filesystem === "overlay") return false;
+
+    return true;
+  });
+
+  // Load links
+  const links = loadLinks();
+  const linkEntries = Object.entries(links);
+
+  // Show connected drives with git-drive
+  console.log("=== Connected Drives ===\n");
+  
+  if (externalDrives.length === 0) {
+    console.log("No external drives connected.\n");
+  } else {
+    for (const drive of externalDrives) {
+      const mp = drive.mounted;
+      const gitDrivePath = getGitDrivePath(mp);
+      const hasGitDrive = existsSync(gitDrivePath);
+
+      if (hasGitDrive) {
+        const entries = readdirSync(gitDrivePath).filter(n => n.endsWith(".git") || existsSync(join(gitDrivePath, n, "HEAD")));
+        console.log(`✓ ${mp}`);
+        console.log(`  ${entries.length} repo${entries.length === 1 ? "" : "s"} backed up`);
+      } else {
+        console.log(`○ ${mp} (not initialized)`);
+      }
+    }
+    console.log();
+  }
+
+  // Show registered drives (from links)
+  console.log("=== Registered Repositories ===\n");
+  
+  if (linkEntries.length === 0) {
+    console.log("No repositories linked to drives yet.");
+    console.log("Run 'git-drive link' to link a repository.\n");
+  } else {
+    for (const [localPath, link] of linkEntries) {
+      const stillConnected = existsSync(link.mountpoint);
+      const localExists = existsSync(localPath);
+      
+      console.log(`${localPath}`);
+      console.log(`  → ${link.mountpoint} (${link.repoName})`);
+      console.log(`  Drive: ${stillConnected ? "connected" : "NOT CONNECTED"}`);
+      console.log(`  Local: ${localExists ? "exists" : "NOT FOUND"}`);
+      console.log();
+    }
+  }
+
+  // Show current repo status if in a git repo
+  if (isGitRepo()) {
+    console.log("=== Current Repository ===\n");
+    const name = getProjectName();
+    const remoteUrl = getRemoteUrl("gd");
+    
+    console.log(`Repository: ${name}`);
+    if (remoteUrl) {
+      console.log(`Remote 'gd': ${remoteUrl}`);
+      
+      // Check if this repo is linked
+      const cwd = process.cwd();
+      const link = links[cwd];
+      if (link) {
+        console.log(`Linked to: ${link.mountpoint}`);
+      }
+    } else {
+      console.log(`No 'gd' remote configured.`);
+      console.log("Run 'git-drive link' to set up backup.");
+    }
+    console.log();
+  }
+
+  // Server status hint
+  console.log("=== Server ===\n");
+  console.log("Web UI: http://localhost:4483");
+  console.log("Run 'git-drive server' to start the web interface.\n");
+}

package/packages/cli/src/config.ts

@@ -0,0 +1,73 @@
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { GitDriveError } from "./errors.js";
+
+const CONFIG_DIR = join(homedir(), ".config", "git-drive");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export interface Config {
+  drivePath: string;
+}
+
+export function loadConfig(): Config | null {
+  if (!existsSync(CONFIG_FILE)) return null;
+  const raw = readFileSync(CONFIG_FILE, "utf-8");
+  return JSON.parse(raw) as Config;
+}
+
+export function saveConfig(config: Config): void {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function requireConfig(): Config {
+  const config = loadConfig();
+  if (!config) {
+    throw new GitDriveError("No drive configured. Run: git drive init <path>");
+  }
+  return config;
+}
+
+export function assertDriveMounted(drivePath: string): void {
+  if (!existsSync(drivePath)) {
+    throw new GitDriveError(
+      `Drive not found at ${drivePath}. Is it connected?`
+    );
+  }
+}
+
+export function getDriveStorePath(drivePath: string): string {
+  return join(drivePath, "git-drive");
+}
+
+export interface LinkRegistry {
+  [localPath: string]: {
+    mountpoint: string;
+    repoName: string;
+    linkedAt: string;
+  };
+}
+
+const LINKS_FILE = join(CONFIG_DIR, "links.json");
+
+export function loadLinks(): LinkRegistry {
+  if (!existsSync(LINKS_FILE)) return {};
+  try {
+    const raw = readFileSync(LINKS_FILE, "utf-8");
+    return JSON.parse(raw) as LinkRegistry;
+  } catch {
+    return {};
+  }
+}
+
+export function saveLink(localPath: string, mountpoint: string, repoName: string): void {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  const links = loadLinks();
+  links[localPath] = {
+    mountpoint,
+    repoName,
+    linkedAt: new Date().toISOString(),
+  };
+  writeFileSync(LINKS_FILE, JSON.stringify(links, null, 2) + "\n");
+}

package/packages/cli/src/errors.ts

@@ -0,0 +1,23 @@
+export class GitDriveError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "GitDriveError";
+  }
+}
+
+export function handleError(err: unknown): void {
+  if (err instanceof GitDriveError) {
+    console.error(`error: ${err.message}`);
+  } else if (err instanceof Error) {
+    const msg = err.message;
+    // execSync errors include stderr in the message
+    const stderrMatch = msg.match(/stderr:\s*([\s\S]*)/);
+    if (stderrMatch) {
+      console.error(`error: ${stderrMatch[1].trim()}`);
+    } else {
+      console.error(`error: ${msg}`);
+    }
+  } else {
+    console.error("An unexpected error occurred.");
+  }
+}