git-drive 0.1.2 → 0.1.5

package/packages/cli/src/__tests__/git.test.ts

@@ -0,0 +1,226 @@
+import { git, listDrives, getRepoRoot, getProjectName, getRemoteUrl, isGitRepo } from '../git.js';
+
+// Mock child_process
+jest.mock('child_process', () => ({
+  execSync: jest.fn(),
+}));
+
+// Mock node-disk-info
+jest.mock('node-disk-info', () => ({
+  getDiskInfo: jest.fn(),
+}));
+
+import { execSync } from 'child_process';
+import { getDiskInfo } from 'node-disk-info';
+
+const mockExecSync = execSync as jest.Mock;
+const mockGetDiskInfo = getDiskInfo as jest.Mock;
+
+describe('git', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('git function', () => {
+    it('should execute git command and return trimmed output', () => {
+      mockExecSync.mockReturnValue('  output from git  \n');
+
+      const result = git('status --short');
+
+      expect(mockExecSync).toHaveBeenCalledWith('git status --short', {
+        cwd: undefined,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      expect(result).toBe('output from git');
+    });
+
+    it('should execute git command with cwd option', () => {
+      mockExecSync.mockReturnValue('output');
+
+      const result = git('status', '/path/to/repo');
+
+      expect(mockExecSync).toHaveBeenCalledWith('git status', {
+        cwd: '/path/to/repo',
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      expect(result).toBe('output');
+    });
+
+    it('should propagate errors from git command', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('fatal: not a git repository');
+      });
+
+      expect(() => git('status')).toThrow('fatal: not a git repository');
+    });
+  });
+
+  describe('listDrives', () => {
+    const originalPlatform = process.platform;
+
+    afterEach(() => {
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+    });
+
+    it('should filter drives correctly on macOS', async () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      mockGetDiskInfo.mockResolvedValue([
+        { mounted: '/', filesystem: 'Macintosh HD', blocks: 500000000, available: 100000000 },
+        { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
+        { mounted: '/Volumes/Recovery', filesystem: 'Recovery', blocks: 1000000, available: 500000 },
+        { mounted: '/Volumes/External', filesystem: 'External', blocks: 1000000000, available: 500000000 },
+      ]);
+
+      const result = await listDrives();
+
+      expect(result).toHaveLength(2);
+      expect(result.map((d: any) => d.mounted)).toEqual(['/Volumes/MyUSB', '/Volumes/External']);
+    });
+
+    it('should filter drives correctly on Linux', async () => {
+      Object.defineProperty(process, 'platform', { value: 'linux' });
+
+      mockGetDiskInfo.mockResolvedValue([
+        { mounted: '/', filesystem: 'root', blocks: 500000000, available: 100000000 },
+        { mounted: '/mnt/usb', filesystem: 'usbdrive', blocks: 32000000, available: 16000000 },
+        { mounted: '/sys', filesystem: 'sysfs', blocks: 0, available: 0 },
+        { mounted: '/proc', filesystem: 'proc', blocks: 0, available: 0 },
+        { mounted: '/run', filesystem: 'tmpfs', blocks: 1000000, available: 500000 },
+        { mounted: '/media/user/external', filesystem: 'external', blocks: 1000000000, available: 500000000 },
+      ]);
+
+      const result = await listDrives();
+
+      expect(result).toHaveLength(2);
+      expect(result.map((d: any) => d.mounted)).toEqual(['/mnt/usb', '/media/user/external']);
+    });
+
+    it('should filter out tmpfs and overlay filesystems', async () => {
+      Object.defineProperty(process, 'platform', { value: 'linux' });
+
+      mockGetDiskInfo.mockResolvedValue([
+        { mounted: '/mnt/real', filesystem: 'ext4', blocks: 1000000, available: 500000 },
+        { mounted: '/mnt/tmpfs', filesystem: 'tmpfs', blocks: 1000000, available: 500000 },
+        { mounted: '/mnt/devtmpfs', filesystem: 'devtmpfs', blocks: 1000000, available: 500000 },
+        { mounted: '/mnt/overlay', filesystem: 'overlay', blocks: 1000000, available: 500000 },
+        { mounted: '/mnt/udev', filesystem: 'udev', blocks: 1000000, available: 500000 },
+      ]);
+
+      const result = await listDrives();
+
+      expect(result).toHaveLength(1);
+      expect(result[0].mounted).toBe('/mnt/real');
+    });
+
+    it('should filter out drives without mountpoint', async () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      mockGetDiskInfo.mockResolvedValue([
+        { mounted: null, filesystem: 'nomount', blocks: 1000000, available: 500000 },
+        { mounted: '/Volumes/Valid', filesystem: 'valid', blocks: 1000000, available: 500000 },
+      ]);
+
+      const result = await listDrives();
+
+      expect(result).toHaveLength(1);
+    });
+
+    it('should filter out drives with mounted value of "100%"', async () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      mockGetDiskInfo.mockResolvedValue([
+        { mounted: '100%', filesystem: 'weird', blocks: 1000000, available: 500000 },
+        { mounted: '/Volumes/Valid', filesystem: 'valid', blocks: 1000000, available: 500000 },
+      ]);
+
+      const result = await listDrives();
+
+      expect(result).toHaveLength(1);
+    });
+
+    it('should return empty array when no drives match', async () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      mockGetDiskInfo.mockResolvedValue([
+        { mounted: '/', filesystem: 'system', blocks: 500000000, available: 100000000 },
+      ]);
+
+      const result = await listDrives();
+
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('getRepoRoot', () => {
+    it('should return the repo root path', () => {
+      mockExecSync.mockReturnValue('/path/to/repo\n');
+
+      const result = getRepoRoot();
+
+      expect(mockExecSync).toHaveBeenCalledWith('git rev-parse --show-toplevel', expect.any(Object));
+      expect(result).toBe('/path/to/repo');
+    });
+  });
+
+  describe('getProjectName', () => {
+    it('should return the basename of the repo root', () => {
+      mockExecSync.mockReturnValue('/path/to/my-project');
+
+      const result = getProjectName();
+
+      expect(result).toBe('my-project');
+    });
+
+    it('should handle nested paths', () => {
+      mockExecSync.mockReturnValue('/Users/developer/projects/awesome-app');
+
+      const result = getProjectName();
+
+      expect(result).toBe('awesome-app');
+    });
+  });
+
+  describe('getRemoteUrl', () => {
+    it('should return the remote URL if it exists', () => {
+      mockExecSync.mockReturnValue('/Volumes/MyDrive/.git-drive/my-project.git');
+
+      const result = getRemoteUrl('gd');
+
+      expect(mockExecSync).toHaveBeenCalledWith('git remote get-url gd', expect.any(Object));
+      expect(result).toBe('/Volumes/MyDrive/.git-drive/my-project.git');
+    });
+
+    it('should return null if remote does not exist', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('fatal: No such remote');
+      });
+
+      const result = getRemoteUrl('nonexistent');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('isGitRepo', () => {
+    it('should return true when in a git repository', () => {
+      mockExecSync.mockReturnValue('true');
+
+      const result = isGitRepo();
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when not in a git repository', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('fatal: not a git repository');
+      });
+
+      const result = isGitRepo();
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/packages/cli/src/__tests__/server.test.ts

@@ -0,0 +1,368 @@
+import request from 'supertest';
+import express, { Application } from 'express';
+import { vol } from 'memfs';
+
+// Mock fs
+jest.mock('fs', () => {
+  const { fs } = require('memfs');
+  return fs;
+});
+
+// Mock child_process
+jest.mock('child_process', () => ({
+  execSync: jest.fn(),
+}));
+
+// Mock node-disk-info
+jest.mock('node-disk-info', () => ({
+  getDiskInfo: jest.fn(),
+}));
+
+import { execSync } from 'child_process';
+import { getDiskInfo } from 'node-disk-info';
+
+const mockExecSync = execSync as jest.Mock;
+const mockGetDiskInfo = getDiskInfo as jest.Mock;
+
+// Create a test app with the same routes as server.ts
+function createTestApp(): Application {
+  const app = express();
+  app.use(express.json());
+
+  // Health check endpoint
+  app.get('/api/health', (_req, res) => {
+    res.json({ status: 'ok', timestamp: new Date().toISOString() });
+  });
+
+  // List all connected drives
+  app.get('/api/drives', async (_req, res) => {
+    try {
+      const drives = await mockGetDiskInfo();
+      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: vol.existsSync(`${d.mounted}/.git-drive`),
+        }));
+      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, res) => {
+    try {
+      const mountpoint = decodeURIComponent(req.params.mountpoint);
+      const gitDrivePath = `${mountpoint}/.git-drive`;
+
+      if (!vol.existsSync(mountpoint)) {
+        res.status(404).json({ error: 'Drive not found or not mounted' });
+        return;
+      }
+
+      const entries = vol.existsSync(gitDrivePath) ? vol.readdirSync(gitDrivePath) as string[] : [];
+      const repos = entries
+        .filter((entry: string) => {
+          const entryPath = `${gitDrivePath}/${entry}`;
+          const stat = vol.statSync(entryPath);
+          const isDir = stat.isDirectory();
+          return isDir && (entry.endsWith('.git') || vol.existsSync(`${entryPath}/HEAD`));
+        })
+        .map((entry: string) => {
+          const entryPath = `${gitDrivePath}/${entry}`;
+          const stat = vol.statSync(entryPath);
+          return {
+            name: entry.replace(/\.git$/, ''),
+            path: entryPath,
+            lastModified: stat.mtime.toISOString(),
+          };
+        });
+
+      res.json({
+        mountpoint,
+        gitDrivePath,
+        initialized: vol.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, res) => {
+    try {
+      const mountpoint = decodeURIComponent(req.params.mountpoint);
+
+      if (!vol.existsSync(mountpoint)) {
+        res.status(404).json({ error: 'Drive not found or not mounted' });
+        return;
+      }
+
+      const gitDrivePath = `${mountpoint}/.git-drive`;
+      vol.mkdirSync(gitDrivePath, { recursive: true });
+
+      res.json({
+        mountpoint,
+        gitDrivePath,
+        message: 'Git Drive initialized on this drive',
+      });
+    } catch (err: any) {
+      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, res) => {
+    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 (!vol.existsSync(mountpoint)) {
+        res.status(404).json({ error: 'Drive not found or not mounted' });
+        return;
+      }
+
+      const gitDrivePath = `${mountpoint}/.git-drive`;
+      if (!vol.existsSync(gitDrivePath)) {
+        vol.mkdirSync(gitDrivePath, { recursive: true });
+      }
+
+      const repoName = safeName.endsWith('.git') ? safeName : `${safeName}.git`;
+      const repoPath = `${gitDrivePath}/${repoName}`;
+
+      if (vol.existsSync(repoPath)) {
+        res.status(409).json({ error: 'Repository already exists' });
+        return;
+      }
+
+      // Mock git init --bare
+      vol.mkdirSync(repoPath, { recursive: true });
+      vol.writeFileSync(`${repoPath}/HEAD`, 'ref: refs/heads/main');
+
+      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, res) => {
+    try {
+      const mountpoint = decodeURIComponent(req.params.mountpoint);
+      const repoName = decodeURIComponent(req.params.repoName);
+      const gitDrivePath = `${mountpoint}/.git-drive`;
+
+      const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+      const repoPath = `${gitDrivePath}/${bareRepoName}`;
+
+      if (!vol.existsSync(repoPath)) {
+        res.status(404).json({ error: 'Repository not found' });
+        return;
+      }
+
+      // Delete the repo directory
+      vol.rmSync(repoPath, { recursive: true, force: true });
+
+      res.json({ message: `Repository '${repoName}' deleted` });
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to delete repository' });
+    }
+  });
+
+  return app;
+}
+
+describe('Server API', () => {
+  let app: Application;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    vol.reset();
+    app = createTestApp();
+  });
+
+  describe('GET /api/health', () => {
+    it('should return health status', async () => {
+      const response = await request(app).get('/api/health');
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty('status', 'ok');
+      expect(response.body).toHaveProperty('timestamp');
+    });
+  });
+
+  describe('GET /api/drives', () => {
+    it('should return list of drives', async () => {
+      mockGetDiskInfo.mockResolvedValue([
+        { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
+        { mounted: '/Volumes/External', filesystem: 'External', blocks: 1000000000, available: 500000000 },
+      ]);
+
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive': '',
+        '/Volumes/External': '',
+      });
+
+      const response = await request(app).get('/api/drives');
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveLength(2);
+      expect(response.body[0]).toHaveProperty('device');
+      expect(response.body[0]).toHaveProperty('mountpoints');
+      expect(response.body[0]).toHaveProperty('hasGitDrive');
+    });
+
+    it('should handle errors gracefully', async () => {
+      mockGetDiskInfo.mockRejectedValue(new Error('Failed to get drives'));
+
+      const response = await request(app).get('/api/drives');
+
+      expect(response.status).toBe(500);
+      expect(response.body).toHaveProperty('error', 'Failed to list drives');
+    });
+  });
+
+  describe('GET /api/drives/:mountpoint/repos', () => {
+    it('should return repos on a drive', async () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': 'ref: refs/heads/main',
+        '/Volumes/MyUSB/.git-drive/another-repo.git/HEAD': 'ref: refs/heads/main',
+      });
+
+      const response = await request(app).get('/api/drives/%2FVolumes%2FMyUSB/repos');
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty('mountpoint', '/Volumes/MyUSB');
+      expect(response.body).toHaveProperty('initialized', true);
+      expect(response.body.repos).toHaveLength(2);
+    });
+
+    it('should return 404 for non-existent drive', async () => {
+      const response = await request(app).get('/api/drives/%2FVolumes%2FNonExistent/repos');
+
+      expect(response.status).toBe(404);
+      expect(response.body).toHaveProperty('error', 'Drive not found or not mounted');
+    });
+  });
+
+  describe('POST /api/drives/:mountpoint/init', () => {
+    it('should initialize git-drive on a drive', async () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB': '',
+      });
+
+      const response = await request(app).post('/api/drives/%2FVolumes%2FMyUSB/init');
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty('message', 'Git Drive initialized on this drive');
+    });
+
+    it('should return 404 for non-existent drive', async () => {
+      const response = await request(app).post('/api/drives/%2FVolumes%2FNonExistent/init');
+
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe('POST /api/drives/:mountpoint/repos', () => {
+    it('should create a new repository', async () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive': '',
+      });
+
+      const response = await request(app)
+        .post('/api/drives/%2FVolumes%2FMyUSB/repos')
+        .send({ name: 'new-project' });
+
+      expect(response.status).toBe(201);
+      expect(response.body).toHaveProperty('name', 'new-project');
+    });
+
+    it('should sanitize repository name', async () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive': '',
+      });
+
+      const response = await request(app)
+        .post('/api/drives/%2FVolumes%2FMyUSB/repos')
+        .send({ name: 'my project with spaces!' });
+
+      expect(response.status).toBe(201);
+      expect(response.body.name).toBe('my-project-with-spaces-');
+    });
+
+    it('should return 400 if name is missing', async () => {
+      const response = await request(app)
+        .post('/api/drives/%2FVolumes%2FMyUSB/repos')
+        .send({});
+
+      expect(response.status).toBe(400);
+    });
+
+    it('should return 409 if repository already exists', async () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive/existing-project.git/HEAD': '',
+      });
+
+      const response = await request(app)
+        .post('/api/drives/%2FVolumes%2FMyUSB/repos')
+        .send({ name: 'existing-project' });
+
+      expect(response.status).toBe(409);
+    });
+  });
+
+  describe('DELETE /api/drives/:mountpoint/repos/:repoName', () => {
+    it('should delete a repository', async () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+      });
+
+      const response = await request(app).delete('/api/drives/%2FVolumes%2FMyUSB/repos/my-project');
+
+      expect(response.status).toBe(200);
+    });
+
+    it('should return 404 for non-existent repository', async () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive': '',
+      });
+
+      const response = await request(app).delete('/api/drives/%2FVolumes%2FMyUSB/repos/nonexistent');
+
+      expect(response.status).toBe(404);
+    });
+  });
+});

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,64 @@
+import { existsSync, statSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import prompts from "prompts";
+import { saveConfig, getDriveStorePath } from "../config.js";
+import { listDrives } from "../git.js";
+import { GitDriveError } from "../errors.js";
+
+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}`);
+}