git-drive 0.1.3 → 0.1.5

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");
+}

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.");
+  }
+}

package/packages/cli/src/git.ts

@@ -0,0 +1,55 @@
+import { execSync } from "child_process";
+import { basename } from "path";
+import { getDiskInfo } from "node-disk-info";
+
+export function git(args: string, cwd?: string): string {
+  return execSync(`git ${args}`, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+  }).trim();
+}
+
+export async function listDrives(): Promise<any[]> {
+  const drives = await getDiskInfo();
+  return 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;
+  });
+}
+
+export function getRepoRoot(): string {
+  return git("rev-parse --show-toplevel");
+}
+
+export function getProjectName(): string {
+  const root = getRepoRoot();
+  return basename(root);
+}
+
+export function getRemoteUrl(remoteName: string): string | null {
+  try {
+    return git(`remote get-url ${remoteName}`);
+  } catch {
+    return null;
+  }
+}
+
+export function isGitRepo(): boolean {
+  try {
+    git("rev-parse --is-inside-work-tree");
+    return true;
+  } catch {
+    return false;
+  }
+}