git-drive 0.1.6 → 0.1.7

package/dist/__tests__/server.test.js

@@ -1,310 +0,0 @@
-"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

@@ -1,32 +0,0 @@
-"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

@@ -1,55 +0,0 @@
-"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

@@ -1,175 +0,0 @@
-"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

@@ -1,83 +0,0 @@
-"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.");
-}