git-drive 0.1.3 → 0.1.6

package/dist/__tests__/server.test.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const supertest_1 = __importDefault(require("supertest"));
+const express_1 = __importDefault(require("express"));
+const memfs_1 = require("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(),
+}));
+const child_process_1 = require("child_process");
+const node_disk_info_1 = require("node-disk-info");
+const mockExecSync = child_process_1.execSync;
+const mockGetDiskInfo = node_disk_info_1.getDiskInfo;
+// Create a test app with the same routes as server.ts
+function createTestApp() {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.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) => {
+                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) => ({
+                device: d.filesystem,
+                description: d.mounted,
+                size: d.blocks ? parseInt(d.blocks) * 1024 : 0,
+                isRemovable: true,
+                isSystem: d.mounted === '/',
+                mountpoints: [d.mounted],
+                hasGitDrive: memfs_1.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 (!memfs_1.vol.existsSync(mountpoint)) {
+                res.status(404).json({ error: 'Drive not found or not mounted' });
+                return;
+            }
+            const entries = memfs_1.vol.existsSync(gitDrivePath) ? memfs_1.vol.readdirSync(gitDrivePath) : [];
+            const repos = entries
+                .filter((entry) => {
+                const entryPath = `${gitDrivePath}/${entry}`;
+                const stat = memfs_1.vol.statSync(entryPath);
+                const isDir = stat.isDirectory();
+                return isDir && (entry.endsWith('.git') || memfs_1.vol.existsSync(`${entryPath}/HEAD`));
+            })
+                .map((entry) => {
+                const entryPath = `${gitDrivePath}/${entry}`;
+                const stat = memfs_1.vol.statSync(entryPath);
+                return {
+                    name: entry.replace(/\.git$/, ''),
+                    path: entryPath,
+                    lastModified: stat.mtime.toISOString(),
+                };
+            });
+            res.json({
+                mountpoint,
+                gitDrivePath,
+                initialized: memfs_1.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 (!memfs_1.vol.existsSync(mountpoint)) {
+                res.status(404).json({ error: 'Drive not found or not mounted' });
+                return;
+            }
+            const gitDrivePath = `${mountpoint}/.git-drive`;
+            memfs_1.vol.mkdirSync(gitDrivePath, { recursive: true });
+            res.json({
+                mountpoint,
+                gitDrivePath,
+                message: 'Git Drive initialized on this drive',
+            });
+        }
+        catch (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, 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 (!memfs_1.vol.existsSync(mountpoint)) {
+                res.status(404).json({ error: 'Drive not found or not mounted' });
+                return;
+            }
+            const gitDrivePath = `${mountpoint}/.git-drive`;
+            if (!memfs_1.vol.existsSync(gitDrivePath)) {
+                memfs_1.vol.mkdirSync(gitDrivePath, { recursive: true });
+            }
+            const repoName = safeName.endsWith('.git') ? safeName : `${safeName}.git`;
+            const repoPath = `${gitDrivePath}/${repoName}`;
+            if (memfs_1.vol.existsSync(repoPath)) {
+                res.status(409).json({ error: 'Repository already exists' });
+                return;
+            }
+            // Mock git init --bare
+            memfs_1.vol.mkdirSync(repoPath, { recursive: true });
+            memfs_1.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 (!memfs_1.vol.existsSync(repoPath)) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+            // Delete the repo directory
+            memfs_1.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;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        memfs_1.vol.reset();
+        app = createTestApp();
+    });
+    describe('GET /api/health', () => {
+        it('should return health status', async () => {
+            const response = await (0, supertest_1.default)(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 },
+            ]);
+            memfs_1.vol.fromJSON({
+                '/Volumes/MyUSB/.git-drive': '',
+                '/Volumes/External': '',
+            });
+            const response = await (0, supertest_1.default)(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 (0, supertest_1.default)(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 () => {
+            memfs_1.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 (0, supertest_1.default)(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 (0, supertest_1.default)(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 () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/MyUSB': '',
+            });
+            const response = await (0, supertest_1.default)(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 (0, supertest_1.default)(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 () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/MyUSB/.git-drive': '',
+            });
+            const response = await (0, supertest_1.default)(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 () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/MyUSB/.git-drive': '',
+            });
+            const response = await (0, supertest_1.default)(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 (0, supertest_1.default)(app)
+                .post('/api/drives/%2FVolumes%2FMyUSB/repos')
+                .send({});
+            expect(response.status).toBe(400);
+        });
+        it('should return 409 if repository already exists', async () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/MyUSB/.git-drive/existing-project.git/HEAD': '',
+            });
+            const response = await (0, supertest_1.default)(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 () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+            });
+            const response = await (0, supertest_1.default)(app).delete('/api/drives/%2FVolumes%2FMyUSB/repos/my-project');
+            expect(response.status).toBe(200);
+        });
+        it('should return 404 for non-existent repository', async () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/MyUSB/.git-drive': '',
+            });
+            const response = await (0, supertest_1.default)(app).delete('/api/drives/%2FVolumes%2FMyUSB/repos/nonexistent');
+            expect(response.status).toBe(404);
+        });
+    });
+});

package/dist/commands/link.js

@@ -54,17 +54,34 @@ async function link(args) {
             console.log("No initialized git-drives found. Please initialize a drive first.");
             return;
         }
-        const { drive } = await (0, prompts_1.default)({
-            type: "select",
-            name: "drive",
-            message: "Select a configured git-drive:",
-            choices: configuredDrives.map((d) => ({
-                title: `${d.filesystem} (${d.mounted})`,
-                value: d,
-            })),
-        });
-        if (!drive)
-            return;
+        // Check for --drive flag for non-interactive mode
+        const driveFlagIndex = args.findIndex((a) => a === "--drive" || a === "-d");
+        const drivePath = driveFlagIndex !== -1 ? args[driveFlagIndex + 1] : null;
+        const createNew = args.includes("--create") || args.includes("-c");
+        let drive;
+        if (drivePath) {
+            // Non-interactive mode: find the drive by path
+            drive = configuredDrives.find((d) => d.mounted === drivePath);
+            if (!drive) {
+                console.log(`Drive not found at: ${drivePath}`);
+                return;
+            }
+        }
+        else {
+            // Interactive mode
+            const result = await (0, prompts_1.default)({
+                type: "select",
+                name: "drive",
+                message: "Select a configured git-drive:",
+                choices: configuredDrives.map((d) => ({
+                    title: `${d.filesystem} (${d.mounted})`,
+                    value: d,
+                })),
+            });
+            if (!result.drive)
+                return;
+            drive = result.drive;
+        }
         const gitDrivePath = path.join(drive.mounted, ".git-drive");
         const existingRepos = fs.readdirSync(gitDrivePath).filter((entry) => {
             const entryPath = path.join(gitDrivePath, entry);
@@ -72,40 +89,59 @@ async function link(args) {
                 (entry.endsWith(".git") || fs.existsSync(path.join(entryPath, "HEAD"))));
         });
         const CREATE_NEW = "__CREATE_NEW__";
-        const { selectedRepo } = await (0, prompts_1.default)({
-            type: "select",
-            name: "selectedRepo",
-            message: "Select an existing repository to link, or create a new one:",
-            choices: [
-                { title: "✨ Create new repository...", value: CREATE_NEW },
-                ...existingRepos.map((repo) => ({
-                    title: `📁 ${repo.replace(/\.git$/, "")}`,
-                    value: repo,
-                })),
-            ],
-        });
-        if (!selectedRepo)
-            return;
-        let targetRepoName = selectedRepo;
-        if (selectedRepo === CREATE_NEW) {
+        let targetRepoName = null;
+        if (createNew) {
+            // Non-interactive mode: create new repo with project name
             const defaultName = (0, git_js_1.getProjectName)();
-            const { newRepoName } = await (0, prompts_1.default)({
-                type: "text",
-                name: "newRepoName",
-                message: "Enter the new repository name:",
-                initial: defaultName,
-            });
-            if (!newRepoName)
-                return;
-            targetRepoName = newRepoName.endsWith(".git") ? newRepoName : `${newRepoName}.git`;
+            targetRepoName = defaultName.endsWith(".git") ? defaultName : `${defaultName}.git`;
             const repoPath = path.join(gitDrivePath, targetRepoName);
             if (fs.existsSync(repoPath)) {
-                console.log(`Repository ${targetRepoName} already exists in this drive.`);
+                console.log(`Repository ${targetRepoName} already exists in this drive. Linking to existing.`);
+            }
+            else {
+                (0, git_js_1.git)(`init --bare "${repoPath}"`);
+                console.log(`Created new bare repository: ${targetRepoName}`);
+            }
+        }
+        else {
+            // Interactive mode
+            const { selectedRepo } = await (0, prompts_1.default)({
+                type: "select",
+                name: "selectedRepo",
+                message: "Select an existing repository to link, or create a new one:",
+                choices: [
+                    { title: "✨ Create new repository...", value: CREATE_NEW },
+                    ...existingRepos.map((repo) => ({
+                        title: `📁 ${repo.replace(/\.git$/, "")}`,
+                        value: repo,
+                    })),
+                ],
+            });
+            if (!selectedRepo)
                 return;
+            targetRepoName = selectedRepo;
+            if (selectedRepo === CREATE_NEW) {
+                const defaultName = (0, git_js_1.getProjectName)();
+                const { newRepoName } = await (0, prompts_1.default)({
+                    type: "text",
+                    name: "newRepoName",
+                    message: "Enter the new repository name:",
+                    initial: defaultName,
+                });
+                if (!newRepoName)
+                    return;
+                targetRepoName = newRepoName.endsWith(".git") ? newRepoName : `${newRepoName}.git`;
+                const repoPath = path.join(gitDrivePath, targetRepoName);
+                if (fs.existsSync(repoPath)) {
+                    console.log(`Repository ${targetRepoName} already exists in this drive.`);
+                    return;
+                }
+                (0, git_js_1.git)(`init --bare "${repoPath}"`);
+                console.log(`Created new bare repository: ${targetRepoName}`);
             }
-            (0, git_js_1.git)(`init --bare "${repoPath}"`);
-            console.log(`Created new bare repository: ${targetRepoName}`);
         }
+        if (!targetRepoName)
+            return;
         const repoRoot = (0, git_js_1.getRepoRoot)();
         const finalRepoPath = path.join(gitDrivePath, targetRepoName);
         // Check if remote 'gd' already exists

package/dist/commands/push.js

@@ -43,7 +43,7 @@ const prompts_1 = __importDefault(require("prompts"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
-async function push(_args) {
+async function push(args) {
     if (!(0, git_js_1.isGitRepo)()) {
         throw new errors_js_1.GitDriveError("Not in a git repository.");
     }
@@ -53,15 +53,28 @@ async function push(_args) {
     }
     try {
         const currentBranch = (0, git_js_1.git)("branch --show-current") || "HEAD";
-        const { pushMode } = await (0, prompts_1.default)({
-            type: "select",
-            name: "pushMode",
-            message: `Pushing to ${existingUrl}\nSelect what to branch to push:`,
-            choices: [
-                { title: `Current branch only (${currentBranch})`, value: "current" },
-                { title: "All branches & tags", value: "all" }
-            ]
-        });
+        // Check for --all or --current flags for non-interactive mode
+        const pushAll = args.includes("--all");
+        const pushCurrent = args.includes("--current");
+        let pushMode = null;
+        if (pushAll) {
+            pushMode = "all";
+        }
+        else if (pushCurrent) {
+            pushMode = "current";
+        }
+        else {
+            const result = await (0, prompts_1.default)({
+                type: "select",
+                name: "pushMode",
+                message: `Pushing to ${existingUrl}\nSelect what to branch to push:`,
+                choices: [
+                    { title: `Current branch only (${currentBranch})`, value: "current" },
+                    { title: "All branches & tags", value: "all" }
+                ]
+            });
+            pushMode = result.pushMode;
+        }
         if (!pushMode)
             return;
         if (pushMode === "current") {

package/dist/git.js

@@ -24,6 +24,13 @@ async function listDrives() {
             return false;
         if (mp === "/" || mp === "100%")
             return false;
+        // Exclude temporary and system paths on all platforms
+        if (mp.startsWith("/var/") || mp.startsWith("/private/var/") || mp.startsWith("/tmp") || mp.startsWith("/private/tmp"))
+            return false;
+        if (mp.includes("TemporaryItems") || mp.includes("NSIRD_"))
+            return false;
+        if (mp.startsWith("/System/") || mp.startsWith("/Library/"))
+            return false;
         if (process.platform === "darwin") {
             return mp.startsWith("/Volumes/") && !mp.startsWith("/Volumes/Recovery");
         }

package/dist/server.js

@@ -134,6 +134,13 @@ app.get('/api/drives', async (_req, res) => {
                 return false;
             if (mp === "/" || mp === "100%")
                 return false;
+            // Exclude temporary and system paths on all platforms
+            if (mp.startsWith("/var/") || mp.startsWith("/private/var/") || mp.startsWith("/tmp") || mp.startsWith("/private/tmp"))
+                return false;
+            if (mp.includes("TemporaryItems") || mp.includes("NSIRD_"))
+                return false;
+            if (mp.startsWith("/System/") || mp.startsWith("/Library/"))
+                return false;
             if (process.platform === "darwin") {
                 return mp.startsWith("/Volumes/") && !mp.startsWith("/Volumes/Recovery");
             }
@@ -520,7 +527,9 @@ app.get('*', (_req, res) => {
         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`);
-});
+// Start server only when run directly (not when imported)
+if (require.main === module) {
+    app.listen(port, () => {
+        console.log(`\n  🚀 Git Drive is running at http://localhost:${port}\n`);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-drive",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "Turn any external drive into a git remote backup for your code - CLI, server, and web UI",
   "keywords": [
     "git",
@@ -31,14 +31,6 @@
     "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"
-  },
   "dependencies": {
     "express": "^4.19.2",
     "node-disk-info": "^1.3.0",
@@ -48,9 +40,25 @@
     "@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"
   }
-}
+}