git-drive 0.1.2 → 0.1.5

package/packages/cli/Dockerfile

@@ -0,0 +1,26 @@
+# Git Drive - Docker Image
+# Includes CLI, server, and web UI
+
+FROM node:20-alpine
+
+# Install git and util-linux (for lsblk)
+RUN apk add --no-cache git util-linux
+
+WORKDIR /app
+
+# Copy package files
+COPY package.json ./
+COPY dist ./dist/
+COPY ui ./ui/
+
+# Install production dependencies only
+RUN npm install --omit=dev
+
+# Expose the web UI port
+EXPOSE 4483
+
+# Set environment
+ENV GIT_DRIVE_PORT=4483
+
+# Default command starts the server
+CMD ["node", "dist/server.js"]

package/packages/cli/jest.config.js

@@ -0,0 +1,26 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.ts', '**/*.test.ts', '**/*.spec.ts'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/__tests__/**',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  verbose: true,
+  clearMocks: true,
+  restoreMocks: true,
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.tsx?$': ['ts-jest', {
+      useESM: false,
+    }],
+  },
+};

package/packages/cli/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "git-drive",
+  "version": "0.1.4",
+  "description": "Turn any external drive into a git remote backup for your code - CLI, server, and web UI",
+  "keywords": [
+    "git",
+    "backup",
+    "external-drive",
+    "usb",
+    "remote",
+    "cli",
+    "docker"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/josmanvis/git-drive.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/josmanvis/git-drive/issues"
+  },
+  "homepage": "https://github.com/josmanvis/git-drive#readme",
+  "type": "commonjs",
+  "bin": {
+    "git-drive": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "ui"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "start:server": "node dist/server.js",
+    "docker:build": "docker build -t git-drive .",
+    "docker:run": "docker run -it --rm -v /Volumes:/Volumes -p 4483:4483 git-drive",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "dependencies": {
+    "express": "^4.19.2",
+    "node-disk-info": "^1.3.0",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "@types/jest": "^29.5.14",
+    "@types/supertest": "^6.0.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "supertest": "^6.3.4",
+    "memfs": "^4.14.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

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

@@ -0,0 +1,154 @@
+import { init } from '../../commands/init.js';
+import { GitDriveError } from '../../errors.js';
+import { vol } from 'memfs';
+
+// Mock fs and path modules
+jest.mock('fs', () => {
+  const { fs } = require('memfs');
+  return fs;
+});
+
+// Mock prompts
+jest.mock('prompts', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+// Mock config
+jest.mock('../../config.js', () => ({
+  saveConfig: jest.fn(),
+  getDriveStorePath: jest.fn((drivePath: string) => `${drivePath}/.git-drive`),
+}));
+
+// Mock git
+jest.mock('../../git.js', () => ({
+  listDrives: jest.fn(),
+}));
+
+import prompts from 'prompts';
+import { listDrives } from '../../git.js';
+import { saveConfig, getDriveStorePath } from '../../config.js';
+
+const mockPrompts = prompts as unknown as jest.Mock;
+const mockListDrives = listDrives as jest.Mock;
+const mockSaveConfig = saveConfig as jest.Mock;
+const mockGetDriveStorePath = getDriveStorePath as jest.Mock;
+
+describe('init command', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    vol.reset();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    mockGetDriveStorePath.mockImplementation((drivePath: string) => `${drivePath}/.git-drive`);
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  describe('with path argument', () => {
+    it('should initialize git-drive on specified path', async () => {
+      const drivePath = '/Volumes/TestDrive';
+      vol.fromJSON({
+        [drivePath]: '',
+      });
+
+      await init([drivePath]);
+
+      expect(mockSaveConfig).toHaveBeenCalledWith({ drivePath: expect.stringContaining('TestDrive') });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Git Drive initialized'));
+    });
+
+    it('should throw error if path does not exist', async () => {
+      await expect(init(['/Volumes/NonExistent'])).rejects.toThrow(GitDriveError);
+      await expect(init(['/Volumes/NonExistent'])).rejects.toThrow('Path not found');
+    });
+
+    it('should throw error if path is not a directory', async () => {
+      vol.fromJSON({
+        '/Volumes/SomeFile': 'file content',
+      });
+
+      await expect(init(['/Volumes/SomeFile'])).rejects.toThrow('Path is not a directory');
+    });
+
+    it('should resolve relative paths', async () => {
+      vol.fromJSON({
+        '/current/dir/TestDrive': '',
+      });
+
+      // Mock cwd to return a specific directory
+      const originalCwd = process.cwd;
+      process.cwd = jest.fn(() => '/current/dir');
+
+      await init(['./TestDrive']);
+
+      expect(mockSaveConfig).toHaveBeenCalled();
+
+      process.cwd = originalCwd;
+    });
+  });
+
+  describe('without path argument (interactive)', () => {
+    it('should throw error when no drives found', async () => {
+      mockListDrives.mockResolvedValue([]);
+
+      await expect(init([])).rejects.toThrow('No external drives found');
+    });
+
+    it('should prompt user to select a drive', async () => {
+      mockListDrives.mockResolvedValue([
+        { mounted: '/Volumes/Drive1', filesystem: 'Drive1', blocks: 1000000, available: 500000 },
+        { mounted: '/Volumes/Drive2', filesystem: 'Drive2', blocks: 2000000, available: 1000000 },
+      ]);
+
+      mockPrompts.mockResolvedValue({
+        selectedDrive: '/Volumes/Drive1',
+      });
+
+      vol.fromJSON({
+        '/Volumes/Drive1': '',
+      });
+
+      await init([]);
+
+      expect(mockPrompts).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'select',
+          name: 'selectedDrive',
+        })
+      );
+    });
+
+    it('should handle user cancellation', async () => {
+      mockListDrives.mockResolvedValue([
+        { mounted: '/Volumes/Drive1', filesystem: 'Drive1', blocks: 1000000, available: 500000 },
+      ]);
+
+      mockPrompts.mockResolvedValue({
+        selectedDrive: undefined,
+      });
+
+      await init([]);
+
+      expect(consoleSpy).toHaveBeenCalledWith('Operation cancelled.');
+      expect(mockSaveConfig).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('store directory creation', () => {
+    it('should create .git-drive directory if it does not exist', async () => {
+      const drivePath = '/Volumes/TestDrive';
+      vol.fromJSON({
+        [drivePath]: '',
+      });
+
+      await init([drivePath]);
+
+      // The store path should have been requested
+      expect(mockGetDriveStorePath).toHaveBeenCalled();
+    });
+  });
+});

package/packages/cli/src/__tests__/commands/list.test.ts

@@ -0,0 +1,118 @@
+import { vol } from 'memfs';
+
+// Mock fs
+jest.mock('fs', () => {
+  const { fs } = require('memfs');
+  return fs;
+});
+
+// Mock node-disk-info
+jest.mock('node-disk-info', () => ({
+  getDiskInfo: jest.fn(),
+}));
+
+// Mock server
+jest.mock('../../server.js', () => ({
+  ensureServerRunning: jest.fn(),
+}));
+
+// Mock os
+jest.mock('os', () => ({
+  homedir: () => '/home/testuser',
+}));
+
+import { getDiskInfo } from 'node-disk-info';
+import { list } from '../../commands/list.js';
+
+const mockGetDiskInfo = getDiskInfo as jest.Mock;
+
+describe('list command', () => {
+  let consoleSpy: jest.SpyInstance;
+  const originalPlatform = process.platform;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    vol.reset();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    Object.defineProperty(process, 'platform', { value: 'darwin', writable: true });
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true });
+  });
+
+  it('should display no drives message when no external drives found', async () => {
+    mockGetDiskInfo.mockResolvedValue([]);
+
+    vol.fromJSON({
+      '/home/testuser/.config/git-drive/links.json': '{}',
+    });
+
+    await list([]);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No external drives detected'));
+  });
+
+  it('should list connected drives with git-drive status', async () => {
+    mockGetDiskInfo.mockResolvedValue([
+      { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
+      { mounted: '/Volumes/External', filesystem: 'External', blocks: 1000000000, available: 500000000 },
+    ]);
+
+    vol.fromJSON({
+      '/home/testuser/.config/git-drive/links.json': '{}',
+      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+      '/Volumes/External': '',
+    });
+
+    await list([]);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/Volumes/MyUSB'));
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/Volumes/External'));
+  });
+
+  it('should count repositories on initialized drives', async () => {
+    mockGetDiskInfo.mockResolvedValue([
+      { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
+    ]);
+
+    vol.fromJSON({
+      '/home/testuser/.config/git-drive/links.json': '{}',
+      '/Volumes/MyUSB/.git-drive/project1.git/HEAD': '',
+      '/Volumes/MyUSB/.git-drive/project2.git/HEAD': '',
+      '/Volumes/MyUSB/.git-drive/project3.git/HEAD': '',
+    });
+
+    await list([]);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Repositories: 3'));
+  });
+
+  it('should display drive size in GB', async () => {
+    mockGetDiskInfo.mockResolvedValue([
+      { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 97656250, available: 50000000 },
+    ]);
+
+    vol.fromJSON({
+      '/home/testuser/.config/git-drive/links.json': '{}',
+      '/Volumes/MyUSB': '',
+    });
+
+    await list([]);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('GB'));
+  });
+
+  it('should handle errors when detecting drives', async () => {
+    mockGetDiskInfo.mockRejectedValue(new Error('Failed to detect drives'));
+
+    vol.fromJSON({
+      '/home/testuser/.config/git-drive/links.json': '{}',
+    });
+
+    await list([]);
+
+    expect(consoleSpy).toHaveBeenCalledWith('Error detecting drives:', expect.any(Error));
+  });
+});

package/packages/cli/src/__tests__/commands/push.test.ts

@@ -0,0 +1,155 @@
+import { push } from '../../commands/push.js';
+import { GitDriveError } from '../../errors.js';
+import { vol } from 'memfs';
+
+// Mock fs
+jest.mock('fs', () => {
+  const { fs } = require('memfs');
+  return fs;
+});
+
+// Mock prompts
+jest.mock('prompts', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+// Mock git
+jest.mock('../../git.js', () => ({
+  git: jest.fn(),
+  getRemoteUrl: jest.fn(),
+  isGitRepo: jest.fn(),
+}));
+
+// Mock server
+jest.mock('../../server.js', () => ({
+  ensureServerRunning: jest.fn(),
+}));
+
+import prompts from 'prompts';
+import { git, getRemoteUrl, isGitRepo } from '../../git.js';
+
+const mockPrompts = prompts as unknown as jest.Mock;
+const mockGit = git as jest.Mock;
+const mockGetRemoteUrl = getRemoteUrl as jest.Mock;
+const mockIsGitRepo = isGitRepo as jest.Mock;
+
+describe('push command', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    vol.reset();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    mockIsGitRepo.mockReturnValue(true);
+    mockGetRemoteUrl.mockReturnValue('/Volumes/TestDrive/.git-drive/my-repo.git');
+    mockGit.mockImplementation((cmd: string) => {
+      if (cmd.includes('branch --show-current')) return 'main';
+      return '';
+    });
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it('should throw error when not in a git repository', async () => {
+    mockIsGitRepo.mockReturnValue(false);
+
+    await expect(push([])).rejects.toThrow(GitDriveError);
+    await expect(push([])).rejects.toThrow('Not in a git repository');
+  });
+
+  it('should throw error when no git-drive linked', async () => {
+    mockIsGitRepo.mockReturnValue(true);
+    mockGetRemoteUrl.mockReturnValue(null);
+
+    await expect(push([])).rejects.toThrow("No git-drive linked for this project");
+  });
+
+  describe('push modes', () => {
+    beforeEach(() => {
+      vol.fromJSON({
+        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+      });
+    });
+
+    it('should push current branch with --current flag', async () => {
+      await push(['--current']);
+
+      expect(mockGit).toHaveBeenCalledWith(expect.stringContaining('push gd main'));
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Successfully pushed'));
+    });
+
+    it('should push all branches and tags with --all flag', async () => {
+      await push(['--all']);
+
+      expect(mockGit).toHaveBeenCalledWith('push gd --all');
+      expect(mockGit).toHaveBeenCalledWith('push gd --tags');
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('all branches and tags'));
+    });
+
+    it('should prompt for push mode when no flags provided', async () => {
+      mockPrompts.mockResolvedValue({ pushMode: 'current' });
+
+      await push([]);
+
+      expect(mockPrompts).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'select',
+          name: 'pushMode',
+        })
+      );
+    });
+
+    it('should handle user cancellation in interactive mode', async () => {
+      mockPrompts.mockResolvedValue({ pushMode: undefined });
+
+      await push([]);
+
+      // Should not have pushed anything beyond the prompt
+      expect(mockGit).not.toHaveBeenCalledWith(expect.stringContaining('push gd'));
+    });
+  });
+
+  describe('pushlog', () => {
+    it('should write pushlog on successful push', async () => {
+      vol.fromJSON({
+        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+      });
+
+      await push(['--current']);
+
+      // Check that the pushlog file was created
+      const files = vol.toJSON();
+      const pushlogPath = '/Volumes/TestDrive/.git-drive/my-repo.git/git-drive-pushlog.json';
+      // The pushlog should exist if the remote URL path exists
+      // This is tested indirectly through the code path
+    });
+
+    it('should handle pushlog write errors silently', async () => {
+      // Create a scenario where writing the pushlog would fail
+      vol.fromJSON({
+        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+      });
+
+      // This should not throw even if pushlog writing fails
+      await expect(push(['--current'])).resolves.not.toThrow();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw GitDriveError when git push fails', async () => {
+      vol.fromJSON({
+        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+      });
+
+      mockGit.mockImplementation((cmd: string) => {
+        if (cmd.includes('branch --show-current')) return 'main';
+        throw new Error('fatal: failed to push');
+      });
+
+      await expect(push(['--current'])).rejects.toThrow(GitDriveError);
+    });
+  });
+});

package/packages/cli/src/__tests__/commands/restore.test.ts

@@ -0,0 +1,134 @@
+import { restore } from '../../commands/restore.js';
+import { GitDriveError } from '../../errors.js';
+import { vol } from 'memfs';
+
+// Mock fs
+jest.mock('fs', () => {
+  const { fs } = require('memfs');
+  return fs;
+});
+
+// Mock config
+jest.mock('../../config.js', () => ({
+  requireConfig: jest.fn(),
+  assertDriveMounted: jest.fn(),
+  getDriveStorePath: jest.fn((drivePath: string) => `${drivePath}/.git-drive`),
+}));
+
+// Mock git
+jest.mock('../../git.js', () => ({
+  git: jest.fn(),
+}));
+
+// Mock server
+jest.mock('../../server.js', () => ({
+  ensureServerRunning: jest.fn(),
+}));
+
+import { git } from '../../git.js';
+import { requireConfig, assertDriveMounted } from '../../config.js';
+
+const mockGit = git as jest.Mock;
+const mockRequireConfig = requireConfig as jest.Mock;
+const mockAssertDriveMounted = assertDriveMounted as jest.Mock;
+
+describe('restore command', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    vol.reset();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    mockRequireConfig.mockReturnValue({ drivePath: '/Volumes/MyUSB' });
+    mockAssertDriveMounted.mockImplementation(() => {});
+    mockGit.mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it('should throw error when no project name provided', () => {
+    expect(() => restore([])).toThrow(GitDriveError);
+    expect(() => restore([])).toThrow('Usage: git drive restore <project-name> [target-dir]');
+  });
+
+  it('should throw error when project not found on drive', () => {
+    vol.fromJSON({
+      '/Volumes/MyUSB/.git-drive': '',
+    });
+
+    expect(() => restore(['nonexistent-project'])).toThrow(GitDriveError);
+    expect(() => restore(['nonexistent-project'])).toThrow("Project 'nonexistent-project' not found on drive.");
+  });
+
+  it('should throw error when target directory already exists', () => {
+    vol.fromJSON({
+      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+      '/home/user/my-project': '',
+    });
+
+    expect(() => restore(['my-project', '/home/user/my-project'])).toThrow(GitDriveError);
+    expect(() => restore(['my-project', '/home/user/my-project'])).toThrow('Directory already exists');
+  });
+
+  it('should clone the bare repo to target directory', () => {
+    vol.fromJSON({
+      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+    });
+
+    restore(['my-project', '/home/user/restored-project']);
+
+    expect(mockGit).toHaveBeenCalledWith(
+      expect.stringContaining('clone /Volumes/MyUSB/.git-drive/my-project.git')
+    );
+  });
+
+  it('should rename origin remote to drive', () => {
+    vol.fromJSON({
+      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+    });
+
+    restore(['my-project', '/home/user/restored-project']);
+
+    expect(mockGit).toHaveBeenCalledWith(
+      expect.stringContaining('remote rename origin drive'),
+      expect.any(String)
+    );
+  });
+
+  it('should use project name as target directory if not specified', () => {
+    vol.fromJSON({
+      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+    });
+
+    restore(['my-project']);
+
+    // Should call git clone with the project name
+    expect(mockGit).toHaveBeenCalledWith(
+      expect.stringMatching(/clone.*my-project\.git/),
+      undefined
+    );
+  });
+
+  it('should log success message', () => {
+    vol.fromJSON({
+      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+    });
+
+    restore(['my-project']);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Restored'));
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('my-project'));
+  });
+
+  it('should work with custom target directory', () => {
+    vol.fromJSON({
+      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+    });
+
+    restore(['my-project', '/custom/target']);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/custom/target'));
+  });
+});