git-drive 0.1.6 → 0.1.7

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

@@ -0,0 +1,130 @@
+import { existsSync, statSync, mkdirSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
+import { resolve, join } from "path";
+import prompts from "prompts";
+import { saveConfig, getDriveStorePath } from "../config.js";
+import { listDrives } from "../git.js";
+import { GitDriveError } from "../errors.js";
+
+// Companion repository URL
+const COMPANION_REPO_URL = "https://github.com/josmanvis/git-drive.git";
+
+// Get the current version from package.json
+function getCurrentVersion(): string {
+  try {
+    const packageJsonPath = join(__dirname, '..', '..', 'package.json');
+    const packageJson = require(packageJsonPath);
+    return packageJson.version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+// Install the companion (clone git-drive repo to the drive)
+function installCompanion(storePath: string): { installed: boolean; version: string; error?: string } {
+  const companionRepoPath = join(storePath, 'git-drive.git');
+  const companionVersionPath = join(storePath, 'companion.json');
+  const currentVersion = getCurrentVersion();
+
+  try {
+    // If companion already exists, update it
+    if (existsSync(companionRepoPath)) {
+      try {
+        execSync(`git -C "${companionRepoPath}" fetch origin`, { stdio: 'pipe' });
+        execSync(`git -C "${companionRepoPath}" reset --hard origin/main`, { stdio: 'pipe' });
+      } catch {
+        // If update fails, remove and re-clone
+        execSync(`rm -rf "${companionRepoPath}"`, { stdio: 'pipe' });
+        execSync(`git clone --bare "${COMPANION_REPO_URL}" "${companionRepoPath}"`, { stdio: 'pipe' });
+      }
+    } else {
+      // Clone the companion
+      execSync(`git clone --bare "${COMPANION_REPO_URL}" "${companionRepoPath}"`, { stdio: 'pipe' });
+    }
+
+    // Write companion version info
+    const companionInfo = {
+      version: currentVersion,
+      installedAt: new Date().toISOString(),
+      repoUrl: COMPANION_REPO_URL,
+    };
+    writeFileSync(companionVersionPath, JSON.stringify(companionInfo, null, 2));
+
+    return { installed: true, version: currentVersion };
+  } catch (err: any) {
+    return { installed: false, version: currentVersion, error: err.message };
+  }
+}
+
+export async function init(args: string[]): Promise<void> {
+  let drivePath: string;
+
+  const rawPath = args[0];
+
+  if (!rawPath) {
+    // No argument provided - prompt user to select a drive
+    const drives = await listDrives();
+
+    if (drives.length === 0) {
+      throw new GitDriveError(
+        "No external drives found. Please connect a drive and try again."
+      );
+    }
+
+    const { selectedDrive } = await prompts({
+      type: "select",
+      name: "selectedDrive",
+      message: "Select a drive to initialize git-drive:",
+      choices: drives.map((d: any) => ({
+        title: `${d.filesystem} (${d.mounted}) - ${Math.round((d.available / d.blocks) * 100)}% free`,
+        value: d.mounted,
+      })),
+    });
+
+    if (!selectedDrive) {
+      console.log("Operation cancelled.");
+      return;
+    }
+
+    drivePath = resolve(selectedDrive);
+  } else {
+    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(`\n✅ Git Drive initialized!`);
+  console.log(`   Drive: ${drivePath}`);
+  console.log(`   Store: ${storePath}`);
+
+  // Install companion
+  console.log(`\n📦 Installing Drive Companion...`);
+  const companionResult = installCompanion(storePath);
+  
+  if (companionResult.installed) {
+    console.log(`   ✅ Companion v${companionResult.version} installed!`);
+    console.log(`\n   You can now use 'git-drive companion ${drivePath}' on any machine.`);
+  } else {
+    console.log(`   ⚠️  Failed to install companion: ${companionResult.error}`);
+    console.log(`   You can still use git-drive, but companion mode is not available.`);
+  }
+}
+
+// Export for use in other modules
+export { installCompanion, getCurrentVersion };

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

@@ -0,0 +1,151 @@
+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;
+    }
+
+    // Check for --drive flag for non-interactive mode
+    const driveFlagIndex = args.findIndex((a) => a === "--drive" || a === "-d");
+    const drivePath = driveFlagIndex !== -1 ? args[driveFlagIndex + 1] : null;
+    const createNew = args.includes("--create") || args.includes("-c");
+
+    let drive;
+
+    if (drivePath) {
+      // Non-interactive mode: find the drive by path
+      drive = configuredDrives.find((d) => d.mounted === drivePath);
+      if (!drive) {
+        console.log(`Drive not found at: ${drivePath}`);
+        return;
+      }
+    } else {
+      // Interactive mode
+      const result = await prompts({
+        type: "select",
+        name: "drive",
+        message: "Select a configured git-drive:",
+        choices: configuredDrives.map((d) => ({
+          title: `${d.filesystem} (${d.mounted})`,
+          value: d,
+        })),
+      });
+
+      if (!result.drive) return;
+      drive = result.drive;
+    }
+
+    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__";
+    let targetRepoName: string | null = null;
+
+    if (createNew) {
+      // Non-interactive mode: create new repo with project name
+      const defaultName = getProjectName();
+      targetRepoName = defaultName.endsWith(".git") ? defaultName : `${defaultName}.git`;
+
+      const repoPath = path.join(gitDrivePath, targetRepoName);
+      if (fs.existsSync(repoPath)) {
+        console.log(`Repository ${targetRepoName} already exists in this drive. Linking to existing.`);
+      } else {
+        git(`init --bare "${repoPath}"`);
+        console.log(`Created new bare repository: ${targetRepoName}`);
+      }
+    } else {
+      // Interactive mode
+      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;
+      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 as string);
+        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}`);
+      }
+    }
+
+    if (!targetRepoName) return;
+
+    const repoRoot = getRepoRoot();
+    const finalRepoPath = path.join(gitDrivePath, targetRepoName as string);
+
+    // 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 as string);
+
+    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,77 @@
+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";
+
+    // Check for --all or --current flags for non-interactive mode
+    const pushAll = args.includes("--all");
+    const pushCurrent = args.includes("--current");
+    
+    let pushMode: "current" | "all" | null = null;
+    
+    if (pushAll) {
+      pushMode = "all";
+    } else if (pushCurrent) {
+      pushMode = "current";
+    } else {
+      const result = 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" }
+        ]
+      });
+      pushMode = result.pushMode;
+    }
+
+    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");
+}