git-drive 0.1.5 → 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/archive.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archive = archive;
+const fs_1 = require("fs");
+const config_js_1 = require("../config.js");
+const git_js_1 = require("../git.js");
+const push_js_1 = require("./push.js");
+const errors_js_1 = require("../errors.js");
+function archive(args) {
+    if (!(0, git_js_1.isGitRepo)()) {
+        throw new errors_js_1.GitDriveError("Not in a git repository.");
+    }
+    const force = args.includes("--force");
+    // Check for uncommitted changes
+    if (!force) {
+        const status = (0, git_js_1.git)("status --porcelain");
+        if (status) {
+            throw new errors_js_1.GitDriveError("Working tree has uncommitted changes.\nCommit first or use --force to archive anyway.");
+        }
+    }
+    const config = (0, config_js_1.requireConfig)();
+    (0, config_js_1.assertDriveMounted)(config.drivePath);
+    const projectName = (0, git_js_1.getProjectName)();
+    const repoRoot = (0, git_js_1.getRepoRoot)();
+    // Push first
+    (0, push_js_1.push)([]);
+    // Remove local copy
+    process.chdir("..");
+    (0, fs_1.rmSync)(repoRoot, { recursive: true, force: true });
+    console.log(`Archived: ${projectName}`);
+    console.log(`Restore with: git drive restore ${projectName}`);
+}

package/dist/commands/init.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const prompts_1 = __importDefault(require("prompts"));
+const config_js_1 = require("../config.js");
+const git_js_1 = require("../git.js");
+const errors_js_1 = require("../errors.js");
+async function init(args) {
+    let drivePath;
+    const rawPath = args[0];
+    if (!rawPath) {
+        // No argument provided - prompt user to select a drive
+        const drives = await (0, git_js_1.listDrives)();
+        if (drives.length === 0) {
+            throw new errors_js_1.GitDriveError("No external drives found. Please connect a drive and try again.");
+        }
+        const { selectedDrive } = await (0, prompts_1.default)({
+            type: "select",
+            name: "selectedDrive",
+            message: "Select a drive to initialize git-drive:",
+            choices: drives.map((d) => ({
+                title: `${d.filesystem} (${d.mounted}) - ${Math.round((d.available / d.blocks) * 100)}% free`,
+                value: d.mounted,
+            })),
+        });
+        if (!selectedDrive) {
+            console.log("Operation cancelled.");
+            return;
+        }
+        drivePath = (0, path_1.resolve)(selectedDrive);
+    }
+    else {
+        drivePath = (0, path_1.resolve)(rawPath);
+    }
+    if (!(0, fs_1.existsSync)(drivePath)) {
+        throw new errors_js_1.GitDriveError(`Path not found: ${drivePath}\nIs the drive mounted?`);
+    }
+    const stat = (0, fs_1.statSync)(drivePath);
+    if (!stat.isDirectory()) {
+        throw new errors_js_1.GitDriveError(`Path is not a directory: ${drivePath}`);
+    }
+    const storePath = (0, config_js_1.getDriveStorePath)(drivePath);
+    if (!(0, fs_1.existsSync)(storePath)) {
+        (0, fs_1.mkdirSync)(storePath, { recursive: true });
+    }
+    (0, config_js_1.saveConfig)({ drivePath });
+    console.log(`\n✅ Git Drive initialized!`);
+    console.log(`   Drive: ${drivePath}`);
+    console.log(`   Store: ${storePath}`);
+}

package/dist/commands/link.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.link = link;
+const errors_js_1 = require("../errors.js");
+const config_js_1 = require("../config.js");
+const git_js_1 = require("../git.js");
+const prompts_1 = __importDefault(require("prompts"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function link(args) {
+    try {
+        const drives = await (0, git_js_1.listDrives)();
+        // Only fetch drives that actually have .git-drive configured
+        const configuredDrives = drives
+            .filter((drive) => drive.mounted && drive.mounted !== "/")
+            .filter((drive) => fs.existsSync(path.join(drive.mounted, ".git-drive")));
+        if (configuredDrives.length === 0) {
+            console.log("No initialized git-drives found. Please initialize a drive first.");
+            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);
+            return (fs.statSync(entryPath).isDirectory() &&
+                (entry.endsWith(".git") || fs.existsSync(path.join(entryPath, "HEAD"))));
+        });
+        const CREATE_NEW = "__CREATE_NEW__";
+        let targetRepoName = null;
+        if (createNew) {
+            // Non-interactive mode: create new repo with project name
+            const defaultName = (0, git_js_1.getProjectName)();
+            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. 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}`);
+            }
+        }
+        if (!targetRepoName)
+            return;
+        const repoRoot = (0, git_js_1.getRepoRoot)();
+        const finalRepoPath = path.join(gitDrivePath, targetRepoName);
+        // Check if remote 'gd' already exists
+        let gdExists = false;
+        try {
+            (0, git_js_1.git)(`remote get-url gd`, repoRoot);
+            gdExists = true;
+        }
+        catch {
+            // Remote does not exist
+        }
+        if (gdExists) {
+            console.log("Remote 'gd' already exists. Updating it to point to the new drive.");
+            (0, git_js_1.git)(`remote set-url gd "${finalRepoPath}"`, repoRoot);
+        }
+        else {
+            (0, git_js_1.git)(`remote add gd "${finalRepoPath}"`, repoRoot);
+        }
+        // Persist to global git-drive registry for the Web UI
+        (0, config_js_1.saveLink)(repoRoot, drive.mounted, targetRepoName);
+        console.log(`\n✅ Successfully linked!`);
+        console.log(`Repository: ${targetRepoName.replace(/\.git$/, "")}`);
+        console.log(`Drive: ${drive.mounted}`);
+        console.log(`\nYou can now push to this remote using:`);
+        console.log(`  git push gd main`);
+    }
+    catch (err) {
+        (0, errors_js_1.handleError)(err);
+        process.exit(1);
+    }
+}

package/dist/commands/list.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list = list;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const node_disk_info_1 = require("node-disk-info");
+function loadLinks() {
+    const linksFile = (0, path_1.join)((0, os_1.homedir)(), ".config", "git-drive", "links.json");
+    if (!(0, fs_1.existsSync)(linksFile))
+        return {};
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(linksFile, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function getGitDrivePath(mountpoint) {
+    return (0, path_1.join)(mountpoint, ".git-drive");
+}
+async function list(_args) {
+    console.log("Git Drive - Connected Drives\n");
+    // Get all connected drives
+    let drives = [];
+    try {
+        drives = await (0, node_disk_info_1.getDiskInfo)();
+    }
+    catch (err) {
+        console.error("Error detecting drives:", err);
+        return;
+    }
+    // Filter to external/removable drives
+    const externalDrives = 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;
+    });
+    if (externalDrives.length === 0) {
+        console.log("No external drives detected.");
+        console.log("\nConnect an external drive and try again.");
+        return;
+    }
+    // Load links to show which drives are registered
+    const links = loadLinks();
+    const registeredMountpoints = new Set(Object.values(links).map(l => l.mountpoint));
+    for (const drive of externalDrives) {
+        const mp = drive.mounted;
+        const gitDrivePath = getGitDrivePath(mp);
+        const hasGitDrive = (0, fs_1.existsSync)(gitDrivePath);
+        const isRegistered = registeredMountpoints.has(mp);
+        // Count repos on this drive
+        let repoCount = 0;
+        if (hasGitDrive) {
+            try {
+                const entries = (0, fs_1.readdirSync)(gitDrivePath).filter(n => n.endsWith(".git") || (0, fs_1.existsSync)((0, path_1.join)(gitDrivePath, n, "HEAD")));
+                repoCount = entries.length;
+            }
+            catch { }
+        }
+        // Format size
+        const sizeGB = drive.blocks ? ((parseInt(drive.blocks) * 1024) / (1024 * 1024 * 1024)).toFixed(1) : "?";
+        // Status indicator
+        const status = hasGitDrive ? "✓ registered" : "○ not registered";
+        console.log(`  ${mp}`);
+        console.log(`    Size: ${sizeGB} GB`);
+        console.log(`    Status: ${status}`);
+        console.log(`    Repositories: ${repoCount}`);
+        console.log();
+    }
+    console.log(`\n${externalDrives.length} drive${externalDrives.length === 1 ? "" : "s"} detected.`);
+    console.log("\nRun 'git-drive link' to link a repo to a drive.");
+}