git-drive 0.1.6 → 0.1.7

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

@@ -0,0 +1,371 @@
+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': null,
+      });
+
+      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');
+      expect(response.body).toHaveProperty('gitDrivePath', '/Volumes/MyUSB/.git-drive');
+    });
+
+    it('should return 404 for non-existent drive', async () => {
+      vol.fromJSON({});
+
+      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': null,
+      });
+
+      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': null,
+      });
+
+      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/companion.ts

@@ -0,0 +1,205 @@
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { resolve, join } from "path";
+import { createInterface } from "readline";
+import prompts from "prompts";
+import { listDrives } from "../git.js";
+import { GitDriveError } from "../errors.js";
+import { getDriveStorePath } from "../config.js";
+
+const DEFAULT_PORT = 4484;
+const MAX_PORT_ATTEMPTS = 20;
+
+// Check if a port is available
+async function isPortAvailable(port: number): Promise<boolean> {
+  try {
+    const response = await fetch(`http://localhost:${port}/api/health`, {
+      method: 'HEAD',
+      signal: AbortSignal.timeout(500),
+    });
+    return false; // Port is in use
+  } catch {
+    return true; // Port is available
+  }
+}
+
+// Find the next available port starting from DEFAULT_PORT
+async function findAvailablePort(startPort: number = DEFAULT_PORT): Promise<number> {
+  for (let port = startPort; port < startPort + MAX_PORT_ATTEMPTS; port++) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new GitDriveError(`Could not find an available port after ${MAX_PORT_ATTEMPTS} attempts.`);
+}
+
+// Get companion info from a drive
+function getCompanionInfo(drivePath: string): { installed: boolean; version?: string; installedAt?: string } {
+  const storePath = getDriveStorePath(drivePath);
+  const companionVersionPath = join(storePath, 'companion.json');
+  const companionRepoPath = join(storePath, 'git-drive.git');
+
+  if (!existsSync(companionRepoPath)) {
+    return { installed: false };
+  }
+
+  try {
+    if (existsSync(companionVersionPath)) {
+      const companionInfo = JSON.parse(readFileSync(companionVersionPath, 'utf-8'));
+      return {
+        installed: true,
+        version: companionInfo.version,
+        installedAt: companionInfo.installedAt,
+      };
+    }
+    return { installed: true }; // Repo exists but no version file
+  } catch {
+    return { installed: true };
+  }
+}
+
+// Open browser to URL
+function openBrowser(url: string): void {
+  const platform = process.platform;
+  let command: string;
+
+  if (platform === 'darwin') {
+    command = `open "${url}"`;
+  } else if (platform === 'win32') {
+    command = `start "" "${url}"`;
+  } else {
+    command = `xdg-open "${url}"`;
+  }
+
+  try {
+    spawn(command, { shell: true, detached: true, stdio: 'ignore' });
+  } catch (err) {
+    console.log(`Please open your browser to: ${url}`);
+  }
+}
+
+// Wait for Enter key
+async function waitForEnter(): Promise<void> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('\nPress Enter to stop the companion server...', () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+export async function companion(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();
+
+    // Filter to only drives with git-drive initialized
+    const initializedDrives = drives.filter((d: any) => {
+      const storePath = getDriveStorePath(d.mounted);
+      return existsSync(storePath);
+    });
+
+    if (initializedDrives.length === 0) {
+      throw new GitDriveError(
+        "No drives with git-drive initialized found.\nRun 'git-drive init' on a drive first."
+      );
+    }
+
+    const { selectedDrive } = await prompts({
+      type: "select",
+      name: "selectedDrive",
+      message: "Select a drive to run in companion mode:",
+      choices: initializedDrives.map((d: any) => {
+        const companionInfo = getCompanionInfo(d.mounted);
+        const companionStatus = companionInfo.installed 
+          ? ` (Companion v${companionInfo.version || 'unknown'})` 
+          : ' (No companion)';
+        return {
+          title: `${d.filesystem} (${d.mounted})${companionStatus}`,
+          value: d.mounted,
+        };
+      }),
+    });
+
+    if (!selectedDrive) {
+      console.log("Operation cancelled.");
+      return;
+    }
+
+    drivePath = resolve(selectedDrive);
+  } else {
+    drivePath = resolve(rawPath);
+  }
+
+  // Verify the drive has git-drive initialized
+  const storePath = getDriveStorePath(drivePath);
+  if (!existsSync(storePath)) {
+    throw new GitDriveError(
+      `Git Drive not initialized on ${drivePath}.\nRun 'git-drive init ${drivePath}' first.`
+    );
+  }
+
+  // Check companion status
+  const companionInfo = getCompanionInfo(drivePath);
+  if (!companionInfo.installed) {
+    console.log(`\n⚠️  Warning: Companion not installed on this drive.`);
+    console.log(`   Run 'git-drive init ${drivePath}' to install the companion.`);
+    console.log(`   Continuing in standard mode...\n`);
+  }
+
+  // Find available port
+  const port = await findAvailablePort();
+
+  console.log(`\n🔌 Starting Git Drive in Companion Mode...`);
+  console.log(`   Drive: ${drivePath}`);
+  console.log(`   Port: ${port}`);
+  if (companionInfo.version) {
+    console.log(`   Companion: v${companionInfo.version}`);
+  }
+
+  // Start the server with companion mode environment variables
+  const serverPath = require.resolve('../server.js');
+  const env = {
+    ...process.env,
+    GIT_DRIVE_PORT: String(port),
+    GIT_DRIVE_COMPANION_MODE: 'true',
+    GIT_DRIVE_COMPANION_DRIVE: drivePath,
+  };
+
+  const child = spawn(process.execPath, [serverPath], {
+    stdio: 'inherit',
+    env,
+  });
+
+  child.on('error', (err) => {
+    console.error('Failed to start companion server:', err.message);
+    process.exit(1);
+  });
+
+  // Wait a moment for server to start, then open browser
+  setTimeout(() => {
+    const url = `http://localhost:${port}`;
+    console.log(`\n   🌐 Opening browser: ${url}`);
+    openBrowser(url);
+    console.log(`\n   Companion mode is running.`);
+  }, 1000);
+
+  // Wait for Enter to stop
+  await waitForEnter();
+
+  console.log('\n   Stopping companion server...');
+  child.kill();
+  console.log('   👋 Companion mode stopped.');
+}
+
+// Export helper functions for testing
+export { getCompanionInfo, findAvailablePort, isPortAvailable };