git-drive 0.1.0 → 0.1.2

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;
+    }
+}

package/dist/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const push_js_1 = require("./commands/push.js");
+const list_js_1 = require("./commands/list.js");
+const status_js_1 = require("./commands/status.js");
+const link_js_1 = require("./commands/link.js");
+const init_js_1 = require("./commands/init.js");
+const errors_js_1 = require("./errors.js");
+const server_js_1 = require("./server.js");
+const commands = {
+    init: init_js_1.init,
+    push: push_js_1.push,
+    list: list_js_1.list,
+    status: status_js_1.status,
+    link: link_js_1.link,
+    server: startServer,
+    start: startServer,
+    ui: startServer,
+};
+// Commands that don't need the server running
+const NO_SERVER_COMMANDS = ['server', 'start', 'ui'];
+function printUsage() {
+    console.log(`
+git-drive - Turn any external drive into a git remote backup for your code
+
+Usage:
+  git-drive <command> [options]
+
+Commands:
+  init                 Initialize git-drive on an external drive
+  link                 Link current repo to a drive
+  push                 Push current repo to drive
+  list                 Show connected drives and their status
+  status               Show detailed status of drives and repos
+  server, start, ui    Start the git-drive web UI server
+
+Options:
+  -h, --help           Show this help message
+
+Examples:
+  git-drive init /Volumes/MyDrive   Initialize git-drive on a drive
+  git-drive link                    Link current repo to a drive
+  git-drive push                    Push current repo to drive
+  git-drive list                    List connected drives
+  git-drive status                  Show detailed status
+  git-drive server                  Start the web UI at http://localhost:4483
+
+Environment Variables:
+  GIT_DRIVE_PORT       Port for the web server (default: 4483)
+
+Docker:
+  docker run -it --rm -v /Volumes:/Volumes -p 4483:4483 git-drive
+
+Documentation:
+  https://github.com/josmanvis/git-drive
+`);
+}
+function startServer(_args) {
+    console.log('\n  🚀 Starting Git Drive server...\n');
+    console.log('  Web UI: http://localhost:4483\n');
+    console.log('  Press Ctrl+C to stop\n');
+    const serverPath = require.resolve('./server.js');
+    const child = (0, child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: 'inherit',
+        env: process.env
+    });
+    child.on('error', (err) => {
+        console.error('Failed to start server:', err.message);
+        process.exit(1);
+    });
+    child.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+}
+const [command, ...args] = process.argv.slice(2);
+(async () => {
+    try {
+        if (!command || command === "--help" || command === "-h") {
+            printUsage();
+            process.exit(0);
+        }
+        const handler = commands[command];
+        if (!handler) {
+            console.error(`Unknown command: ${command}\n`);
+            printUsage();
+            process.exit(1);
+        }
+        // Ensure server is running for commands that need it
+        if (!NO_SERVER_COMMANDS.includes(command)) {
+            await (0, server_js_1.ensureServerRunning)();
+        }
+        await handler(args);
+    }
+    catch (err) {
+        (0, errors_js_1.handleError)(err);
+        process.exit(1);
+    }
+})();

package/dist/server.js

@@ -0,0 +1,526 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerPort = getServerPort;
+exports.isServerRunning = isServerRunning;
+exports.ensureServerRunning = ensureServerRunning;
+const express_1 = __importDefault(require("express"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const child_process_2 = require("child_process");
+const node_disk_info_1 = require("node-disk-info");
+const os_1 = require("os");
+const app = (0, express_1.default)();
+const port = process.env.GIT_DRIVE_PORT || 4483;
+app.use(express_1.default.json());
+// Serve static UI files from the ui directory
+const uiPath = path_1.default.join(__dirname, '..', 'ui');
+app.use(express_1.default.static(uiPath));
+// ── Helpers ──────────────────────────────────────────────────────────
+function git(args, cwd) {
+    return (0, child_process_2.execSync)(`git ${args}`, {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+function getGitDrivePath(mountpoint) {
+    return path_1.default.join(mountpoint, '.git-drive');
+}
+function ensureGitDriveDir(mountpoint) {
+    const gitDrivePath = getGitDrivePath(mountpoint);
+    if (!(0, fs_1.existsSync)(gitDrivePath)) {
+        try {
+            (0, fs_1.mkdirSync)(gitDrivePath, { recursive: true });
+        }
+        catch (err) {
+            throw new Error(`Failed to write to drive. Please ensure Terminal/Node has "Removable Volumes" access in macOS Privacy settings. Details: ${err.message}`);
+        }
+    }
+    return gitDrivePath;
+}
+function listRepos(gitDrivePath) {
+    if (!(0, fs_1.existsSync)(gitDrivePath))
+        return [];
+    return (0, fs_1.readdirSync)(gitDrivePath)
+        .filter((entry) => {
+        const entryPath = path_1.default.join(gitDrivePath, entry);
+        return ((0, fs_1.statSync)(entryPath).isDirectory() &&
+            (entry.endsWith('.git') || (0, fs_1.existsSync)(path_1.default.join(entryPath, 'HEAD'))));
+    })
+        .map((entry) => {
+        const entryPath = path_1.default.join(gitDrivePath, entry);
+        const stat = (0, fs_1.statSync)(entryPath);
+        return {
+            name: entry.replace(/\.git$/, ''),
+            path: entryPath,
+            lastModified: stat.mtime.toISOString(),
+        };
+    });
+}
+function loadLinks() {
+    const linksFile = path_1.default.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 {};
+    }
+}
+// ── Server Health Check Utilities ────────────────────────────────────────────
+const DEFAULT_PORT = 4483;
+function getServerPort() {
+    return parseInt(process.env.GIT_DRIVE_PORT || String(DEFAULT_PORT), 10);
+}
+async function isServerRunning(port) {
+    const serverPort = port || getServerPort();
+    try {
+        const response = await fetch(`http://localhost:${serverPort}/api/drives`, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(1000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureServerRunning() {
+    const port = getServerPort();
+    const running = await isServerRunning(port);
+    if (!running) {
+        console.log('\n  🚀 Starting Git Drive server...\n');
+        // Start server in detached/background mode
+        const serverPath = require.resolve('./server.js');
+        const child = (0, child_process_1.spawn)(process.execPath, [serverPath], {
+            detached: true,
+            stdio: 'ignore',
+            env: process.env,
+        });
+        // Allow the parent process to exit independently
+        child.unref();
+        // Wait a moment for server to start
+        let retries = 10;
+        while (retries > 0) {
+            await new Promise(resolve => setTimeout(resolve, 300));
+            if (await isServerRunning(port)) {
+                break;
+            }
+            retries--;
+        }
+        if (retries === 0) {
+            throw new Error('Failed to start Git Drive server. Please run "git-drive server" manually.');
+        }
+    }
+}
+// ── API Routes ───────────────────────────────────────────────────────
+// 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 (0, node_disk_info_1.getDiskInfo)();
+        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: (0, fs_1.existsSync)(getGitDrivePath(d.mounted)),
+        }));
+        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 = getGitDrivePath(mountpoint);
+        if (!(0, fs_1.existsSync)(mountpoint)) {
+            res.status(404).json({ error: 'Drive not found or not mounted' });
+            return;
+        }
+        const repos = listRepos(gitDrivePath);
+        res.json({
+            mountpoint,
+            gitDrivePath,
+            initialized: (0, fs_1.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 (!(0, fs_1.existsSync)(mountpoint)) {
+            res.status(404).json({ error: 'Drive not found or not mounted' });
+            return;
+        }
+        const gitDrivePath = ensureGitDriveDir(mountpoint);
+        res.json({
+            mountpoint,
+            gitDrivePath,
+            message: 'Git Drive initialized on this drive',
+        });
+    }
+    catch (err) {
+        console.error("Init Error:", 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 (!(0, fs_1.existsSync)(mountpoint)) {
+            res.status(404).json({ error: 'Drive not found or not mounted' });
+            return;
+        }
+        const gitDrivePath = ensureGitDriveDir(mountpoint);
+        const repoName = safeName.endsWith('.git') ? safeName : `${safeName}.git`;
+        const repoPath = path_1.default.join(gitDrivePath, repoName);
+        if ((0, fs_1.existsSync)(repoPath)) {
+            res.status(409).json({ error: 'Repository already exists' });
+            return;
+        }
+        git(`init --bare "${repoPath}"`);
+        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 = getGitDrivePath(mountpoint);
+        const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+        const repoPath = path_1.default.join(gitDrivePath, bareRepoName);
+        if (!(0, fs_1.existsSync)(repoPath)) {
+            const altPath = path_1.default.join(gitDrivePath, repoName);
+            if (!(0, fs_1.existsSync)(altPath)) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+            (0, child_process_2.execSync)(`rm -rf "${altPath}"`);
+        }
+        else {
+            (0, child_process_2.execSync)(`rm -rf "${repoPath}"`);
+        }
+        res.json({ message: `Repository '${repoName}' deleted` });
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Failed to delete repository' });
+    }
+});
+// Get info about a specific repo
+app.get('/api/drives/:mountpoint/repos/:repoName', (req, res) => {
+    try {
+        const mountpoint = decodeURIComponent(req.params.mountpoint);
+        const repoName = decodeURIComponent(req.params.repoName);
+        const gitDrivePath = getGitDrivePath(mountpoint);
+        const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+        let repoPath = path_1.default.join(gitDrivePath, bareRepoName);
+        if (!(0, fs_1.existsSync)(repoPath)) {
+            repoPath = path_1.default.join(gitDrivePath, repoName);
+            if (!(0, fs_1.existsSync)(repoPath)) {
+                res.status(404).json({ error: 'Repository not found' });
+                return;
+            }
+        }
+        let branches = [];
+        try {
+            const branchOutput = git("branch --format='%(refname:short)'", repoPath);
+            branches = branchOutput
+                .split('\n')
+                .map((b) => b.trim().replace(/^'|'$/g, ''))
+                .filter(Boolean);
+        }
+        catch { }
+        let tags = [];
+        try {
+            const tagOutput = git("tag", repoPath);
+            tags = tagOutput.split('\n').map((t) => t.trim()).filter(Boolean);
+        }
+        catch { }
+        let lastCommit = null;
+        try {
+            const log = git('log -1 --format="%H|%s|%ci" --all', repoPath);
+            if (log) {
+                const [hash, message, date] = log.replace(/^"|"$/g, '').split('|');
+                lastCommit = { hash, message, date };
+            }
+        }
+        catch { }
+        const stat = (0, fs_1.statSync)(repoPath);
+        res.json({
+            name: repoName.replace(/\.git$/, ''),
+            path: repoPath,
+            branches,
+            tags,
+            lastCommit,
+            lastModified: stat.mtime.toISOString(),
+            remoteUrl: repoPath,
+        });
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Failed to get repo info' });
+    }
+});
+// Local status check
+app.get('/api/drives/:mountpoint/repos/:repoName/local-status', (req, res) => {
+    try {
+        const mountpoint = decodeURIComponent(req.params.mountpoint);
+        let repoName = decodeURIComponent(req.params.repoName);
+        repoName = repoName.replace(/\.git$/, '');
+        const links = loadLinks();
+        let localPath = null;
+        for (const [p, data] of Object.entries(links)) {
+            if (data.mountpoint === mountpoint && data.repoName.replace(/\.git$/, '') === repoName) {
+                if ((0, fs_1.existsSync)(p)) {
+                    localPath = p;
+                    break;
+                }
+            }
+        }
+        if (!localPath) {
+            res.json({ linked: false });
+            return;
+        }
+        let hasChanges = false;
+        let unpushed = false;
+        try {
+            const statusOutput = git('status --porcelain', localPath);
+            hasChanges = statusOutput.trim().length > 0;
+            const unpushedOutput = git('log gd/main..HEAD --oneline', localPath);
+            unpushed = unpushedOutput.trim().length > 0;
+        }
+        catch { }
+        res.json({ linked: true, localPath, hasChanges, unpushed });
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Failed to check local status' });
+    }
+});
+// Push to git-drive
+app.post('/api/drives/:mountpoint/repos/:repoName/push', (req, res) => {
+    try {
+        const mountpoint = decodeURIComponent(req.params.mountpoint);
+        let repoName = decodeURIComponent(req.params.repoName);
+        repoName = repoName.replace(/\.git$/, '');
+        const links = loadLinks();
+        let localPath = null;
+        for (const [p, data] of Object.entries(links)) {
+            if (data.mountpoint === mountpoint && data.repoName.replace(/\.git$/, '') === repoName) {
+                if ((0, fs_1.existsSync)(p)) {
+                    localPath = p;
+                    break;
+                }
+            }
+        }
+        if (!localPath) {
+            res.status(404).json({ error: 'Local linked repository not found.' });
+            return;
+        }
+        git('push gd --all', localPath);
+        git('push gd --tags', localPath);
+        try {
+            const gitDrivePath = getGitDrivePath(mountpoint);
+            const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+            let repoPath = path_1.default.join(gitDrivePath, bareRepoName);
+            if (!(0, fs_1.existsSync)(repoPath))
+                repoPath = path_1.default.join(gitDrivePath, repoName);
+            const payload = {
+                date: new Date().toISOString(),
+                computer: (0, os_1.homedir)(),
+                user: process.env.USER || 'local-user',
+                localDir: localPath,
+                mode: 'web-ui',
+            };
+            const logFile = path_1.default.join(repoPath, "git-drive-pushlog.json");
+            (0, fs_1.appendFileSync)(logFile, JSON.stringify(payload) + "\n", "utf-8");
+        }
+        catch { }
+        res.json({ success: true, message: 'Successfully backed up local code to Git Drive!' });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message || 'Failed to push' });
+    }
+});
+// Browse repository files tree
+app.get('/api/drives/:mountpoint/repos/:repoName/tree', (req, res) => {
+    try {
+        const mountpoint = decodeURIComponent(req.params.mountpoint);
+        const repoName = decodeURIComponent(req.params.repoName);
+        const branch = req.query.branch || 'main';
+        const treePath = req.query.path || '';
+        const gitDrivePath = getGitDrivePath(mountpoint);
+        const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+        let repoPath = path_1.default.join(gitDrivePath, bareRepoName);
+        if (!(0, fs_1.existsSync)(repoPath)) {
+            repoPath = path_1.default.join(gitDrivePath, repoName);
+        }
+        const target = treePath ? `${branch}:${treePath}` : branch;
+        const output = git(`ls-tree ${target}`, repoPath);
+        const files = output.split('\n').filter(Boolean).map((line) => {
+            const parts = line.split('\t');
+            const meta = parts[0].split(' ');
+            return {
+                mode: meta[0],
+                type: meta[1],
+                hash: meta[2],
+                path: parts[1],
+                name: parts[1].split('/').pop(),
+            };
+        });
+        res.json({ files });
+    }
+    catch (err) {
+        res.json({ files: [] });
+    }
+});
+// Get commit history
+app.get('/api/drives/:mountpoint/repos/:repoName/commits', (req, res) => {
+    try {
+        const mountpoint = decodeURIComponent(req.params.mountpoint);
+        const repoName = decodeURIComponent(req.params.repoName);
+        const branch = req.query.branch || 'main';
+        const gitDrivePath = getGitDrivePath(mountpoint);
+        const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+        let repoPath = path_1.default.join(gitDrivePath, bareRepoName);
+        if (!(0, fs_1.existsSync)(repoPath)) {
+            repoPath = path_1.default.join(gitDrivePath, repoName);
+        }
+        let commits = [];
+        try {
+            const logOutput = git(`log ${branch} -n 100 --format="%H|%an|%ae|%s|%ci"`, repoPath);
+            commits = logOutput
+                .split('\n')
+                .filter(Boolean)
+                .map((line) => {
+                const [hash, author, email, message, date] = line.split('|');
+                return { hash, author, email, message, date };
+            });
+        }
+        catch { }
+        let pushLogs = [];
+        try {
+            const logFile = path_1.default.join(repoPath, "git-drive-pushlog.json");
+            if ((0, fs_1.existsSync)(logFile)) {
+                const rawLogs = (0, fs_1.readFileSync)(logFile, "utf-8").trim().split('\n');
+                pushLogs = rawLogs.map((l) => {
+                    try {
+                        return JSON.parse(l);
+                    }
+                    catch {
+                        return null;
+                    }
+                }).filter(Boolean);
+                pushLogs.reverse();
+            }
+        }
+        catch { }
+        res.json({ commits, pushLogs });
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Failed to retrieve history' });
+    }
+});
+// Get single commit details
+app.get('/api/drives/:mountpoint/repos/:repoName/commits/:hash', (req, res) => {
+    try {
+        const mountpoint = decodeURIComponent(req.params.mountpoint);
+        const repoName = decodeURIComponent(req.params.repoName);
+        const hash = req.params.hash;
+        const gitDrivePath = getGitDrivePath(mountpoint);
+        const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+        let repoPath = path_1.default.join(gitDrivePath, bareRepoName);
+        if (!(0, fs_1.existsSync)(repoPath))
+            repoPath = path_1.default.join(gitDrivePath, repoName);
+        const logOutput = git(`log -1 --format="%H|%an|%ae|%s|%ci" ${hash}`, repoPath);
+        const [commitHash, author, email, message, date] = logOutput.split('|');
+        const patch = git(`show --format="" ${hash}`, repoPath);
+        res.json({ hash: commitHash, author, email, message, date, patch });
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Failed to retrieve commit details' });
+    }
+});
+// Read raw file content
+app.get('/api/drives/:mountpoint/repos/:repoName/blob', (req, res) => {
+    try {
+        const mountpoint = decodeURIComponent(req.params.mountpoint);
+        const repoName = decodeURIComponent(req.params.repoName);
+        const branch = req.query.branch || 'main';
+        const filePath = req.query.path;
+        const gitDrivePath = getGitDrivePath(mountpoint);
+        const bareRepoName = repoName.endsWith('.git') ? repoName : `${repoName}.git`;
+        let repoPath = path_1.default.join(gitDrivePath, bareRepoName);
+        if (!(0, fs_1.existsSync)(repoPath)) {
+            repoPath = path_1.default.join(gitDrivePath, repoName);
+        }
+        const content = git(`show ${branch}:${filePath}`, repoPath);
+        res.send(content);
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Failed to read file' });
+    }
+});
+// SPA fallback
+app.get('*', (_req, res) => {
+    const indexPath = path_1.default.join(uiPath, 'index.html');
+    if ((0, fs_1.existsSync)(indexPath)) {
+        res.sendFile(indexPath);
+    }
+    else {
+        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`);
+});