git-drive 0.1.5 → 0.1.6

package/dist/server.js

@@ -0,0 +1,535 @@
+"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;
+            // Exclude temporary and system paths on all platforms
+            if (mp.startsWith("/var/") || mp.startsWith("/private/var/") || mp.startsWith("/tmp") || mp.startsWith("/private/tmp"))
+                return false;
+            if (mp.includes("TemporaryItems") || mp.includes("NSIRD_"))
+                return false;
+            if (mp.startsWith("/System/") || mp.startsWith("/Library/"))
+                return false;
+            if (process.platform === "darwin") {
+                return mp.startsWith("/Volumes/") && !mp.startsWith("/Volumes/Recovery");
+            }
+            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 only when run directly (not when imported)
+if (require.main === module) {
+    app.listen(port, () => {
+        console.log(`\n  🚀 Git Drive is running at http://localhost:${port}\n`);
+    });
+}

package/package.json

@@ -1,29 +1,64 @@
 {
   "name": "git-drive",
-  "version": "0.1.5",
-  "description": "Use an external drive as a git bare repository remote",
-  "workspaces": [
-    "packages/*"
+  "version": "0.1.6",
+  "description": "Turn any external drive into a git remote backup for your code - CLI, server, and web UI",
+  "keywords": [
+    "git",
+    "backup",
+    "external-drive",
+    "usb",
+    "remote",
+    "cli",
+    "docker"
   ],
-  "scripts": {
-    "build": "pnpm build:cli && pnpm build:ui && pnpm build:server",
-    "build:cli": "tsc -p packages/cli/tsconfig.json",
-    "build:ui": "cd packages/ui && pnpm run build",
-    "build:server": "tsc -p packages/server/tsconfig.json",
-    "dev": "tsc --watch",
-    "test": "pnpm -r test",
-    "test:cli": "cd packages/cli && pnpm test",
-    "test:ui": "cd packages/ui && pnpm test",
-    "test:coverage": "pnpm -r test:coverage"
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/josmanvis/git-drive.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/josmanvis/git-drive/issues"
+  },
+  "homepage": "https://github.com/josmanvis/git-drive#readme",
+  "type": "commonjs",
+  "bin": {
+    "git-drive": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "ui"
+  ],
+  "dependencies": {
+    "express": "^4.19.2",
+    "node-disk-info": "^1.3.0",
+    "prompts": "^2.4.2"
   },
   "devDependencies": {
+    "@types/express": "^4.17.21",
     "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "@types/jest": "^29.5.14",
+    "@types/supertest": "^6.0.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "supertest": "^6.3.4",
+    "memfs": "^4.14.0",
     "typescript": "^5.7.0"
   },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "drivelist",
-      "esbuild"
-    ]
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "start:server": "node dist/server.js",
+    "docker:build": "docker build -t git-drive .",
+    "docker:run": "docker run -it --rm -v /Volumes:/Volumes -p 4483:4483 git-drive",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   }
-}
+}

package/.github/workflows/ci.yml

@@ -1,77 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main, master]
-  pull_request:
-    branches: [main, master]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v2
-        with:
-          version: 9
-
-      - name: Get pnpm store directory
-        shell: bash
-        run: |
-          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_OUTPUT
-        id: pnpm-cache
-
-      - name: Setup pnpm cache
-        uses: actions/cache@v4
-        with:
-          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
-          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-store-
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build
-        run: pnpm build
-
-  publish-cli:
-    needs: build
-    runs-on: ubuntu-latest
-    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v2
-        with:
-          version: 9
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build CLI
-        run: pnpm build:cli
-
-      - name: Publish to npm
-        working-directory: packages/cli
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}