git-drive 0.1.0 → 0.1.1

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,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_js_1 = require("../config.js");
+const errors_js_1 = require("../errors.js");
+function init(args) {
+    const rawPath = args[0];
+    if (!rawPath) {
+        throw new errors_js_1.GitDriveError("Usage: git drive init <path>");
+    }
+    const 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(`Drive configured: ${storePath}`);
+}

package/dist/commands/link.js

@@ -0,0 +1,139 @@
+"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;
+        }
+        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;
+        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__";
+        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) {
+            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}`);
+        }
+        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.");
+}

package/dist/commands/push.js

@@ -0,0 +1,99 @@
+"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.push = push;
+const git_js_1 = require("../git.js");
+const errors_js_1 = require("../errors.js");
+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) {
+    if (!(0, git_js_1.isGitRepo)()) {
+        throw new errors_js_1.GitDriveError("Not in a git repository.");
+    }
+    const existingUrl = (0, git_js_1.getRemoteUrl)("gd");
+    if (!existingUrl) {
+        throw new errors_js_1.GitDriveError("No git-drive linked for this project. Please run 'git-drive link' first.");
+    }
+    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" }
+            ]
+        });
+        if (!pushMode)
+            return;
+        if (pushMode === "current") {
+            console.log(`\nPushing ${currentBranch}...`);
+            (0, git_js_1.git)(`push gd ${currentBranch}`);
+            console.log(`✅ Successfully pushed ${currentBranch} to git-drive.`);
+        }
+        else {
+            console.log("\nPushing all branches and tags...");
+            (0, git_js_1.git)("push gd --all");
+            (0, git_js_1.git)("push gd --tags");
+            console.log(`✅ Successfully pushed all branches and tags to git-drive.`);
+        }
+        // Write context to a central pushlog safely inside the git-drive repo folder
+        try {
+            if (fs.existsSync(existingUrl)) {
+                const payload = {
+                    date: new Date().toISOString(),
+                    computer: os.hostname(),
+                    user: os.userInfo().username,
+                    localDir: process.cwd(),
+                    mode: pushMode,
+                };
+                const logFile = path.join(existingUrl, "git-drive-pushlog.json");
+                fs.appendFileSync(logFile, JSON.stringify(payload) + "\n", "utf-8");
+            }
+        }
+        catch {
+            // Intentionally swallow telemetry tracking errors
+        }
+    }
+    catch (err) {
+        throw new errors_js_1.GitDriveError(`Failed to push to drive. Make sure the drive is connected.\n${err.message}`);
+    }
+}

package/dist/commands/restore.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restore = restore;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_js_1 = require("../config.js");
+const git_js_1 = require("../git.js");
+const errors_js_1 = require("../errors.js");
+function restore(args) {
+    const projectName = args[0];
+    const targetDir = args[1] || projectName;
+    if (!projectName) {
+        throw new errors_js_1.GitDriveError("Usage: git drive restore <project-name> [target-dir]");
+    }
+    const config = (0, config_js_1.requireConfig)();
+    (0, config_js_1.assertDriveMounted)(config.drivePath);
+    const storePath = (0, config_js_1.getDriveStorePath)(config.drivePath);
+    const bareRepoPath = (0, path_1.join)(storePath, `${projectName}.git`);
+    if (!(0, fs_1.existsSync)(bareRepoPath)) {
+        throw new errors_js_1.GitDriveError(`Project '${projectName}' not found on drive.`);
+    }
+    const targetPath = (0, path_1.resolve)(targetDir);
+    if ((0, fs_1.existsSync)(targetPath)) {
+        throw new errors_js_1.GitDriveError(`Directory already exists: ${targetPath}`);
+    }
+    (0, git_js_1.git)(`clone ${bareRepoPath} ${targetPath}`);
+    // Rename origin to drive so the remote stays consistent
+    (0, git_js_1.git)("remote rename origin drive", targetPath);
+    console.log(`Restored ${projectName} into ${targetPath}`);
+}

package/dist/commands/status.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const node_disk_info_1 = require("node-disk-info");
+const git_js_1 = require("../git.js");
+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 status(_args) {
+    console.log("Git Drive Status\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;
+    });
+    // Load links
+    const links = loadLinks();
+    const linkEntries = Object.entries(links);
+    // Show connected drives with git-drive
+    console.log("=== Connected Drives ===\n");
+    if (externalDrives.length === 0) {
+        console.log("No external drives connected.\n");
+    }
+    else {
+        for (const drive of externalDrives) {
+            const mp = drive.mounted;
+            const gitDrivePath = getGitDrivePath(mp);
+            const hasGitDrive = (0, fs_1.existsSync)(gitDrivePath);
+            if (hasGitDrive) {
+                const entries = (0, fs_1.readdirSync)(gitDrivePath).filter(n => n.endsWith(".git") || (0, fs_1.existsSync)((0, path_1.join)(gitDrivePath, n, "HEAD")));
+                console.log(`✓ ${mp}`);
+                console.log(`  ${entries.length} repo${entries.length === 1 ? "" : "s"} backed up`);
+            }
+            else {
+                console.log(`○ ${mp} (not initialized)`);
+            }
+        }
+        console.log();
+    }
+    // Show registered drives (from links)
+    console.log("=== Registered Repositories ===\n");
+    if (linkEntries.length === 0) {
+        console.log("No repositories linked to drives yet.");
+        console.log("Run 'git-drive link' to link a repository.\n");
+    }
+    else {
+        for (const [localPath, link] of linkEntries) {
+            const stillConnected = (0, fs_1.existsSync)(link.mountpoint);
+            const localExists = (0, fs_1.existsSync)(localPath);
+            console.log(`${localPath}`);
+            console.log(`  → ${link.mountpoint} (${link.repoName})`);
+            console.log(`  Drive: ${stillConnected ? "connected" : "NOT CONNECTED"}`);
+            console.log(`  Local: ${localExists ? "exists" : "NOT FOUND"}`);
+            console.log();
+        }
+    }
+    // Show current repo status if in a git repo
+    if ((0, git_js_1.isGitRepo)()) {
+        console.log("=== Current Repository ===\n");
+        const name = (0, git_js_1.getProjectName)();
+        const remoteUrl = (0, git_js_1.getRemoteUrl)("gd");
+        console.log(`Repository: ${name}`);
+        if (remoteUrl) {
+            console.log(`Remote 'gd': ${remoteUrl}`);
+            // Check if this repo is linked
+            const cwd = process.cwd();
+            const link = links[cwd];
+            if (link) {
+                console.log(`Linked to: ${link.mountpoint}`);
+            }
+        }
+        else {
+            console.log(`No 'gd' remote configured.`);
+            console.log("Run 'git-drive link' to set up backup.");
+        }
+        console.log();
+    }
+    // Server status hint
+    console.log("=== Server ===\n");
+    console.log("Web UI: http://localhost:4483");
+    console.log("Run 'git-drive server' to start the web interface.\n");
+}

package/dist/config.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.requireConfig = requireConfig;
+exports.assertDriveMounted = assertDriveMounted;
+exports.getDriveStorePath = getDriveStorePath;
+exports.loadLinks = loadLinks;
+exports.saveLink = saveLink;
+const os_1 = require("os");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const errors_js_1 = require("./errors.js");
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), ".config", "git-drive");
+const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, "config.json");
+function loadConfig() {
+    if (!(0, fs_1.existsSync)(CONFIG_FILE))
+        return null;
+    const raw = (0, fs_1.readFileSync)(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+}
+function saveConfig(config) {
+    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function requireConfig() {
+    const config = loadConfig();
+    if (!config) {
+        throw new errors_js_1.GitDriveError("No drive configured. Run: git drive init <path>");
+    }
+    return config;
+}
+function assertDriveMounted(drivePath) {
+    if (!(0, fs_1.existsSync)(drivePath)) {
+        throw new errors_js_1.GitDriveError(`Drive not found at ${drivePath}. Is it connected?`);
+    }
+}
+function getDriveStorePath(drivePath) {
+    return (0, path_1.join)(drivePath, "git-drive");
+}
+const LINKS_FILE = (0, path_1.join)(CONFIG_DIR, "links.json");
+function loadLinks() {
+    if (!(0, fs_1.existsSync)(LINKS_FILE))
+        return {};
+    try {
+        const raw = (0, fs_1.readFileSync)(LINKS_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function saveLink(localPath, mountpoint, repoName) {
+    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    const links = loadLinks();
+    links[localPath] = {
+        mountpoint,
+        repoName,
+        linkedAt: new Date().toISOString(),
+    };
+    (0, fs_1.writeFileSync)(LINKS_FILE, JSON.stringify(links, null, 2) + "\n");
+}

package/dist/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitDriveError = void 0;
+exports.handleError = handleError;
+class GitDriveError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitDriveError";
+    }
+}
+exports.GitDriveError = GitDriveError;
+function handleError(err) {
+    if (err instanceof GitDriveError) {
+        console.error(`error: ${err.message}`);
+    }
+    else if (err instanceof Error) {
+        const msg = err.message;
+        // execSync errors include stderr in the message
+        const stderrMatch = msg.match(/stderr:\s*([\s\S]*)/);
+        if (stderrMatch) {
+            console.error(`error: ${stderrMatch[1].trim()}`);
+        }
+        else {
+            console.error(`error: ${msg}`);
+        }
+    }
+    else {
+        console.error("An unexpected error occurred.");
+    }
+}

package/dist/git.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.git = git;
+exports.listDrives = listDrives;
+exports.getRepoRoot = getRepoRoot;
+exports.getProjectName = getProjectName;
+exports.getRemoteUrl = getRemoteUrl;
+exports.isGitRepo = isGitRepo;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const node_disk_info_1 = require("node-disk-info");
+function git(args, cwd) {
+    return (0, child_process_1.execSync)(`git ${args}`, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+}
+async function listDrives() {
+    const drives = await (0, node_disk_info_1.getDiskInfo)();
+    return 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;
+    });
+}
+function getRepoRoot() {
+    return git("rev-parse --show-toplevel");
+}
+function getProjectName() {
+    const root = getRepoRoot();
+    return (0, path_1.basename)(root);
+}
+function getRemoteUrl(remoteName) {
+    try {
+        return git(`remote get-url ${remoteName}`);
+    }
+    catch {
+        return null;
+    }
+}
+function isGitRepo() {
+    try {
+        git("rev-parse --is-inside-work-tree");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}