git-drive 0.1.6 → 0.1.7

package/package.json

@@ -1,64 +1,29 @@
 {
   "name": "git-drive",
-  "version": "0.1.6",
-  "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"
+  "version": "0.1.7",
+  "description": "Use an external drive as a git bare repository remote",
+  "workspaces": [
+    "packages/*"
   ],
-  "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"
-  ],
-  "dependencies": {
-    "express": "^4.19.2",
-    "node-disk-info": "^1.3.0",
-    "prompts": "^2.4.2"
+  "scripts": {
+    "build": "pnpm build:cli && pnpm build:ui && pnpm build:server",
+    "build:cli": "tsc -p packages/cli/tsconfig.json",
+    "build:ui": "cd packages/ui && pnpm run build",
+    "build:server": "tsc -p packages/server/tsconfig.json",
+    "dev": "tsc --watch",
+    "test": "pnpm -r test",
+    "test:cli": "cd packages/cli && pnpm test",
+    "test:ui": "cd packages/ui && pnpm test",
+    "test:coverage": "pnpm -r test:coverage"
   },
   "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"
-  },
-  "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",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "drivelist",
+      "esbuild"
+    ]
   }
-}
+}

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.6",
+  "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/companion.test.ts

@@ -0,0 +1,152 @@
+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 child_process
+jest.mock('child_process', () => ({
+  spawn: jest.fn(() => ({
+    on: jest.fn(),
+    kill: jest.fn(),
+  })),
+  execSync: jest.fn(),
+}));
+
+// Mock os
+jest.mock('os', () => ({
+  homedir: () => '/home/testuser',
+}));
+
+// Mock readline
+jest.mock('readline', () => ({
+  createInterface: jest.fn(() => ({
+    question: jest.fn((_prompt, callback) => callback()),
+    close: jest.fn(),
+  })),
+}));
+
+// Mock prompts
+jest.mock('prompts', () => jest.fn());
+
+import { getDiskInfo } from 'node-disk-info';
+import { getCompanionInfo, isPortAvailable, findAvailablePort } from '../../commands/companion.js';
+
+const mockGetDiskInfo = getDiskInfo as jest.Mock;
+
+// Mock fetch for port testing
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+
+describe('companion command', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    vol.reset();
+    mockFetch.mockReset();
+  });
+
+  describe('getCompanionInfo', () => {
+    it('should return installed: false when companion repo does not exist', () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive': '',
+      });
+
+      const result = getCompanionInfo('/Volumes/MyUSB');
+
+      expect(result.installed).toBe(false);
+    });
+
+    it('should return installed: true when companion repo exists', () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive/git-drive.git/HEAD': '',
+        '/Volumes/MyUSB/.git-drive/companion.json': JSON.stringify({
+          version: '0.1.6',
+          installedAt: '2026-02-26T00:00:00Z',
+        }),
+      });
+
+      const result = getCompanionInfo('/Volumes/MyUSB');
+
+      expect(result.installed).toBe(true);
+      expect(result.version).toBe('0.1.6');
+    });
+
+    it('should return installed: true even without companion.json', () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive/git-drive.git/HEAD': '',
+      });
+
+      const result = getCompanionInfo('/Volumes/MyUSB');
+
+      expect(result.installed).toBe(true);
+    });
+
+    it('should handle malformed companion.json gracefully', () => {
+      vol.fromJSON({
+        '/Volumes/MyUSB/.git-drive/git-drive.git/HEAD': '',
+        '/Volumes/MyUSB/.git-drive/companion.json': 'invalid json{',
+      });
+
+      const result = getCompanionInfo('/Volumes/MyUSB');
+
+      expect(result.installed).toBe(true);
+      expect(result.version).toBeUndefined();
+    });
+  });
+
+  describe('isPortAvailable', () => {
+    it('should return false when port is in use', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true });
+
+      const result = await isPortAvailable(4484);
+
+      expect(result).toBe(false);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4484/api/health',
+        expect.objectContaining({ method: 'HEAD' })
+      );
+    });
+
+    it('should return true when port is available', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Connection refused'));
+
+      const result = await isPortAvailable(4484);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('findAvailablePort', () => {
+    it('should return the start port if available', async () => {
+      mockFetch.mockRejectedValue(new Error('Connection refused'));
+
+      const result = await findAvailablePort(4484);
+
+      expect(result).toBe(4484);
+    });
+
+    it('should find next available port', async () => {
+      // First port is in use
+      mockFetch.mockResolvedValueOnce({ ok: true });
+      // Second port is available
+      mockFetch.mockRejectedValueOnce(new Error('Connection refused'));
+
+      const result = await findAvailablePort(4484);
+
+      expect(result).toBe(4485);
+    });
+
+    it('should throw after max attempts', async () => {
+      mockFetch.mockResolvedValue({ ok: true });
+
+      await expect(findAvailablePort(4484)).rejects.toThrow('Could not find an available port');
+    });
+  });
+});

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(),
+}));
+
+// Mock child_process for companion installation
+jest.mock('child_process', () => ({
+  execSync: 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]: null,  // null creates a directory in memfs
+      });
+
+      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 () => {
+      // Use an absolute path instead since memfs doesn't interact with process.cwd properly
+      vol.fromJSON({
+        '/Volumes/RelativeDrive': null,  // null creates a directory in memfs
+      });
+
+      await init(['/Volumes/RelativeDrive']);
+
+      expect(mockSaveConfig).toHaveBeenCalled();
+    });
+  });
+
+  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': null,  // null creates a directory in memfs
+      });
+
+      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]: null,  // null creates a directory in memfs
+      });
+
+      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,122 @@
+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': '{}',
+    });
+
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+    await list([]);
+
+    expect(errorSpy).toHaveBeenCalledWith('Error detecting drives:', expect.any(Error));
+    
+    errorSpy.mockRestore();
+  });
+});