git-drive 0.1.0

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

package/packages/cli/src/index.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { push } from "./commands/push.js";
+import { list } from "./commands/list.js";
+import { status } from "./commands/status.js";
+import { link } from "./commands/link.js";
+import { handleError } from "./errors.js";
+
+const commands: Record<string, (args: string[]) => void | Promise<void>> = {
+  push,
+  list,
+  status,
+  link,
+  server: startServer,
+  start: startServer,
+  ui: startServer,
+};
+
+function printUsage(): void {
+  console.log(`
+git-drive - Turn any external drive into a git remote backup for your code
+
+Usage:
+  git-drive <command> [options]
+
+Commands:
+  link                 Link current repo to a drive
+  push                 Push current repo to drive
+  list                 Show connected drives and their status
+  status               Show detailed status of drives and repos
+  server, start, ui    Start the git-drive web UI server
+
+Options:
+  -h, --help           Show this help message
+
+Examples:
+  git-drive link                    Link current repo to a drive
+  git-drive push                    Push current repo to drive
+  git-drive list                    List connected drives
+  git-drive status                  Show detailed status
+  git-drive server                  Start the web UI at http://localhost:4483
+
+Environment Variables:
+  GIT_DRIVE_PORT       Port for the web server (default: 4483)
+
+Docker:
+  docker run -it --rm -v /Volumes:/Volumes -p 4483:4483 git-drive
+
+Documentation:
+  https://github.com/josmanvis/git-drive
+`);
+}
+
+function startServer(_args: string[]): void {
+  console.log('\n  🚀 Starting Git Drive server...\n');
+  console.log('  Web UI: http://localhost:4483\n');
+  console.log('  Press Ctrl+C to stop\n');
+  
+  const serverPath = require.resolve('./server.js');
+  const child = spawn(process.execPath, [serverPath], {
+    stdio: 'inherit',
+    env: process.env
+  });
+  
+  child.on('error', (err) => {
+    console.error('Failed to start server:', err.message);
+    process.exit(1);
+  });
+  
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+}
+
+const [command, ...args] = process.argv.slice(2);
+
+(async () => {
+  try {
+    if (!command || command === "--help" || command === "-h") {
+      printUsage();
+      process.exit(0);
+    }
+
+    const handler = commands[command];
+    if (!handler) {
+      console.error(`Unknown command: ${command}\n`);
+      printUsage();
+      process.exit(1);
+    }
+
+    await handler(args);
+  } catch (err) {
+    handleError(err);
+    process.exit(1);
+  }
+})();

package/packages/cli/src/server.ts

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+
+import express, { Request, Response } from 'express';
+import path from 'path';
+import { readdirSync, existsSync, mkdirSync, statSync, readFileSync, appendFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { getDiskInfo } from 'node-disk-info';
+import { homedir } from 'os';
+
+const __dirname = path.dirname(__filename);
+
+const app = express();
+const port = process.env.GIT_DRIVE_PORT || 4483;
+
+app.use(express.json());
+
+// Serve static UI files from the ui directory
+const uiPath = path.join(__dirname, '..', 'ui');
+app.use(express.static(uiPath));
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function git(args: string, cwd?: string): string {
+  return execSync(`git ${args}`, {
+    cwd,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+}
+
+function getGitDrivePath(mountpoint: string): string {
+  return path.join(mountpoint, '.git-drive');
+}
+
+function ensureGitDriveDir(mountpoint: string): string {
+  const gitDrivePath = getGitDrivePath(mountpoint);
+  if (!existsSync(gitDrivePath)) {
+    try {
+      mkdirSync(gitDrivePath, { recursive: true });
+    } catch (err: any) {
+      throw new Error(`Failed to write to drive. Please ensure Terminal/Node has "Removable Volumes" access in macOS Privacy settings. Details: ${err.message}`);
+    }
+  }
+  return gitDrivePath;
+}
+
+function listRepos(gitDrivePath: string): Array<{ name: string; path: string; lastModified: string }> {
+  if (!existsSync(gitDrivePath)) return [];
+
+  return readdirSync(gitDrivePath)
+    .filter((entry) => {
+      const entryPath = path.join(gitDrivePath, entry);
+      return (
+        statSync(entryPath).isDirectory() &&
+        (entry.endsWith('.git') || existsSync(path.join(entryPath, 'HEAD')))
+      );
+    })
+    .map((entry) => {
+      const entryPath = path.join(gitDrivePath, entry);
+      const stat = statSync(entryPath);
+      return {
+        name: entry.replace(/\.git$/, ''),
+        path: entryPath,
+        lastModified: stat.mtime.toISOString(),
+      };
+    });
+}
+
+function loadLinks(): Record<string, { mountpoint: string; repoName: string; linkedAt: string }> {
+  const linksFile = path.join(homedir(), '.config', 'git-drive', 'links.json');
+  if (!existsSync(linksFile)) return {};
+  try {
+    return JSON.parse(readFileSync(linksFile, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+// ── API Routes ───────────────────────────────────────────────────────
+
+// List all connected drives
+app.get('/api/drives', async (_req: Request, res: Response) => {
+  try {
+    const drives = await getDiskInfo();
+    const result = 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;
+      })
+      .map((d: any) => ({
+        device: d.filesystem,
+        description: d.mounted,
+        size: d.blocks ? parseInt(d.blocks) * 1024 : 0,
+        isRemovable: true,
+        isSystem: d.mounted === '/',
+        mountpoints: [d.mounted],
+        hasGitDrive: existsSync(getGitDrivePath(d.mounted)),
+      }));
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to list drives' });
+  }
+});
+
+// List repos on a specific drive
+app.get('/api/drives/:mountpoint/repos', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const gitDrivePath = getGitDrivePath(mountpoint);
+
+    if (!existsSync(mountpoint)) {
+      res.status(404).json({ error: 'Drive not found or not mounted' });
+      return;
+    }
+
+    const repos = listRepos(gitDrivePath);
+    res.json({
+      mountpoint,
+      gitDrivePath,
+      initialized: existsSync(gitDrivePath),
+      repos,
+    });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to list repos' });
+  }
+});
+
+// Initialize git-drive on a drive
+app.post('/api/drives/:mountpoint/init', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+
+    if (!existsSync(mountpoint)) {
+      res.status(404).json({ error: 'Drive not found or not mounted' });
+      return;
+    }
+
+    const gitDrivePath = ensureGitDriveDir(mountpoint);
+    res.json({
+      mountpoint,
+      gitDrivePath,
+      message: 'Git Drive initialized on this drive',
+    });
+  } catch (err: any) {
+    console.error("Init Error:", err);
+    res.status(500).json({ error: err.message || 'Failed to initialize drive' });
+  }
+});
+
+// Create a new bare repo on a drive
+app.post('/api/drives/:mountpoint/repos', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const { name } = req.body;
+
+    if (!name || typeof name !== 'string') {
+      res.status(400).json({ error: 'Repo name is required' });
+      return;
+    }
+
+    const safeName = name.replace(/[^a-zA-Z0-9._-]/g, '-');
+
+    if (!existsSync(mountpoint)) {
+      res.status(404).json({ error: 'Drive not found or not mounted' });
+      return;
+    }
+
+    const gitDrivePath = ensureGitDriveDir(mountpoint);
+    const repoName = safeName.endsWith('.git') ? safeName : `${safeName}.git`;
+    const repoPath = path.join(gitDrivePath, repoName);
+
+    if (existsSync(repoPath)) {
+      res.status(409).json({ error: 'Repository already exists' });
+      return;
+    }
+
+    git(`init --bare "${repoPath}"`);
+
+    res.status(201).json({
+      name: safeName.replace(/\.git$/, ''),
+      path: repoPath,
+      message: `Bare repository created: ${repoName}`,
+      remoteUrl: repoPath,
+    });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to create repository' });
+  }
+});
+
+// Delete a repo from a drive
+app.delete('/api/drives/:mountpoint/repos/:repoName', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const repoName = decodeURIComponent(req.params.repoName);
+    const gitDrivePath = getGitDrivePath(mountpoint);
+
+    const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+    const repoPath = path.join(gitDrivePath, bareRepoName);
+
+    if (!existsSync(repoPath)) {
+      const altPath = path.join(gitDrivePath, repoName);
+      if (!existsSync(altPath)) {
+        res.status(404).json({ error: 'Repository not found' });
+        return;
+      }
+      execSync(`rm -rf "${altPath}"`);
+    } else {
+      execSync(`rm -rf "${repoPath}"`);
+    }
+
+    res.json({ message: `Repository '${repoName}' deleted` });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to delete repository' });
+  }
+});
+
+// Get info about a specific repo
+app.get('/api/drives/:mountpoint/repos/:repoName', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const repoName = decodeURIComponent(req.params.repoName);
+    const gitDrivePath = getGitDrivePath(mountpoint);
+
+    const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+    let repoPath = path.join(gitDrivePath, bareRepoName);
+
+    if (!existsSync(repoPath)) {
+      repoPath = path.join(gitDrivePath, repoName);
+      if (!existsSync(repoPath)) {
+        res.status(404).json({ error: 'Repository not found' });
+        return;
+      }
+    }
+
+    let branches: string[] = [];
+    try {
+      const branchOutput = git("branch --format='%(refname:short)'", repoPath);
+      branches = branchOutput
+        .split('\n')
+        .map((b) => b.trim().replace(/^'|'$/g, ''))
+        .filter(Boolean);
+    } catch {}
+
+    let tags: string[] = [];
+    try {
+      const tagOutput = git("tag", repoPath);
+      tags = tagOutput.split('\n').map((t) => t.trim()).filter(Boolean);
+    } catch {}
+
+    let lastCommit: { hash: string; message: string; date: string } | null = null;
+    try {
+      const log = git('log -1 --format="%H|%s|%ci" --all', repoPath);
+      if (log) {
+        const [hash, message, date] = log.replace(/^"|"$/g, '').split('|');
+        lastCommit = { hash, message, date };
+      }
+    } catch {}
+
+    const stat = statSync(repoPath);
+
+    res.json({
+      name: repoName.replace(/\.git$/, ''),
+      path: repoPath,
+      branches,
+      tags,
+      lastCommit,
+      lastModified: stat.mtime.toISOString(),
+      remoteUrl: repoPath,
+    });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to get repo info' });
+  }
+});
+
+// Local status check
+app.get('/api/drives/:mountpoint/repos/:repoName/local-status', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    let repoName = decodeURIComponent(req.params.repoName);
+    repoName = repoName.replace(/\.git$/, '');
+
+    const links = loadLinks();
+    let localPath: string | null = null;
+
+    for (const [p, data] of Object.entries(links)) {
+      if (data.mountpoint === mountpoint && data.repoName.replace(/\.git$/, '') === repoName) {
+        if (existsSync(p)) {
+          localPath = p;
+          break;
+        }
+      }
+    }
+
+    if (!localPath) {
+      res.json({ linked: false });
+      return;
+    }
+
+    let hasChanges = false;
+    let unpushed = false;
+    try {
+      const statusOutput = git('status --porcelain', localPath);
+      hasChanges = statusOutput.trim().length > 0;
+      const unpushedOutput = git('log gd/main..HEAD --oneline', localPath);
+      unpushed = unpushedOutput.trim().length > 0;
+    } catch {}
+
+    res.json({ linked: true, localPath, hasChanges, unpushed });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to check local status' });
+  }
+});
+
+// Push to git-drive
+app.post('/api/drives/:mountpoint/repos/:repoName/push', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    let repoName = decodeURIComponent(req.params.repoName);
+    repoName = repoName.replace(/\.git$/, '');
+
+    const links = loadLinks();
+    let localPath: string | null = null;
+    for (const [p, data] of Object.entries(links)) {
+      if (data.mountpoint === mountpoint && data.repoName.replace(/\.git$/, '') === repoName) {
+        if (existsSync(p)) {
+          localPath = p;
+          break;
+        }
+      }
+    }
+
+    if (!localPath) {
+      res.status(404).json({ error: 'Local linked repository not found.' });
+      return;
+    }
+
+    git('push gd --all', localPath);
+    git('push gd --tags', localPath);
+
+    try {
+      const gitDrivePath = getGitDrivePath(mountpoint);
+      const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+      let repoPath = path.join(gitDrivePath, bareRepoName);
+      if (!existsSync(repoPath)) repoPath = path.join(gitDrivePath, repoName);
+
+      const payload = {
+        date: new Date().toISOString(),
+        computer: homedir(),
+        user: process.env.USER || 'local-user',
+        localDir: localPath,
+        mode: 'web-ui',
+      };
+      const logFile = path.join(repoPath, "git-drive-pushlog.json");
+      appendFileSync(logFile, JSON.stringify(payload) + "\n", "utf-8");
+    } catch {}
+
+    res.json({ success: true, message: 'Successfully backed up local code to Git Drive!' });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message || 'Failed to push' });
+  }
+});
+
+// Browse repository files tree
+app.get('/api/drives/:mountpoint/repos/:repoName/tree', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const repoName = decodeURIComponent(req.params.repoName);
+    const branch = (req.query.branch as string) || 'main';
+    const treePath = (req.query.path as string) || '';
+
+    const gitDrivePath = getGitDrivePath(mountpoint);
+    const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+    let repoPath = path.join(gitDrivePath, bareRepoName);
+
+    if (!existsSync(repoPath)) {
+      repoPath = path.join(gitDrivePath, repoName);
+    }
+
+    const target = treePath ? `${branch}:${treePath}` : branch;
+    const output = git(`ls-tree ${target}`, repoPath);
+
+    const files = output.split('\n').filter(Boolean).map((line) => {
+      const parts = line.split('\t');
+      const meta = parts[0].split(' ');
+      return {
+        mode: meta[0],
+        type: meta[1],
+        hash: meta[2],
+        path: parts[1],
+        name: parts[1].split('/').pop(),
+      };
+    });
+
+    res.json({ files });
+  } catch (err) {
+    res.json({ files: [] });
+  }
+});
+
+// Get commit history
+app.get('/api/drives/:mountpoint/repos/:repoName/commits', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const repoName = decodeURIComponent(req.params.repoName);
+    const branch = (req.query.branch as string) || 'main';
+
+    const gitDrivePath = getGitDrivePath(mountpoint);
+    const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+    let repoPath = path.join(gitDrivePath, bareRepoName);
+
+    if (!existsSync(repoPath)) {
+      repoPath = path.join(gitDrivePath, repoName);
+    }
+
+    let commits: any[] = [];
+    try {
+      const logOutput = git(`log ${branch} -n 100 --format="%H|%an|%ae|%s|%ci"`, repoPath);
+      commits = logOutput
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => {
+          const [hash, author, email, message, date] = line.split('|');
+          return { hash, author, email, message, date };
+        });
+    } catch {}
+
+    let pushLogs: any[] = [];
+    try {
+      const logFile = path.join(repoPath, "git-drive-pushlog.json");
+      if (existsSync(logFile)) {
+        const rawLogs = readFileSync(logFile, "utf-8").trim().split('\n');
+        pushLogs = rawLogs.map((l) => {
+          try { return JSON.parse(l); } catch { return null; }
+        }).filter(Boolean);
+        pushLogs.reverse();
+      }
+    } catch {}
+
+    res.json({ commits, pushLogs });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to retrieve history' });
+  }
+});
+
+// Get single commit details
+app.get('/api/drives/:mountpoint/repos/:repoName/commits/:hash', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const repoName = decodeURIComponent(req.params.repoName);
+    const hash = req.params.hash;
+
+    const gitDrivePath = getGitDrivePath(mountpoint);
+    const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+    let repoPath = path.join(gitDrivePath, bareRepoName);
+    if (!existsSync(repoPath)) repoPath = path.join(gitDrivePath, repoName);
+
+    const logOutput = git(`log -1 --format="%H|%an|%ae|%s|%ci" ${hash}`, repoPath);
+    const [commitHash, author, email, message, date] = logOutput.split('|');
+
+    const patch = git(`show --format="" ${hash}`, repoPath);
+
+    res.json({ hash: commitHash, author, email, message, date, patch });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to retrieve commit details' });
+  }
+});
+
+// Read raw file content
+app.get('/api/drives/:mountpoint/repos/:repoName/blob', (req: Request, res: Response) => {
+  try {
+    const mountpoint = decodeURIComponent(req.params.mountpoint);
+    const repoName = decodeURIComponent(req.params.repoName);
+    const branch = (req.query.branch as string) || 'main';
+    const filePath = req.query.path as string;
+
+    const gitDrivePath = getGitDrivePath(mountpoint);
+    const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+    let repoPath = path.join(gitDrivePath, bareRepoName);
+
+    if (!existsSync(repoPath)) {
+      repoPath = path.join(gitDrivePath, repoName);
+    }
+
+    const content = git(`show ${branch}:${filePath}`, repoPath);
+    res.send(content);
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to read file' });
+  }
+});
+
+// SPA fallback
+app.get('*', (_req: Request, res: Response) => {
+  const indexPath = path.join(uiPath, 'index.html');
+  if (existsSync(indexPath)) {
+    res.sendFile(indexPath);
+  } else {
+    res.status(404).send('UI not built. The package may need to be rebuilt.');
+  }
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(`\n  🚀 Git Drive is running at http://localhost:${port}\n`);
+});

package/packages/cli/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}