@snapcommit/cli 1.0.0

package/dist/lib/multi-repo.js

@@ -0,0 +1,276 @@
+"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.loadRepos = loadRepos;
+exports.getCurrentRepoPath = getCurrentRepoPath;
+exports.getRepoName = getRepoName;
+exports.saveCurrentRepo = saveCurrentRepo;
+exports.listRepos = listRepos;
+exports.switchToRepo = switchToRepo;
+exports.getRepoContext = getRepoContext;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const REPOS_CONFIG_PATH = path.join(os.homedir(), '.snapcommit', 'repos.json');
+/**
+ * Load saved repositories
+ */
+function loadRepos() {
+    try {
+        if (!fs.existsSync(REPOS_CONFIG_PATH)) {
+            return [];
+        }
+        const data = fs.readFileSync(REPOS_CONFIG_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Save repositories
+ */
+function saveRepos(repos) {
+    try {
+        const dir = path.dirname(REPOS_CONFIG_PATH);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(REPOS_CONFIG_PATH, JSON.stringify(repos, null, 2));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to save repo config'));
+    }
+}
+/**
+ * Get current repository path
+ */
+function getCurrentRepoPath() {
+    try {
+        const repoPath = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore']
+        }).trim();
+        return repoPath;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Get repository name from path
+ */
+function getRepoName(repoPath) {
+    return path.basename(repoPath);
+}
+/**
+ * Add current repository to saved repos
+ */
+function saveCurrentRepo() {
+    const repoPath = getCurrentRepoPath();
+    if (!repoPath) {
+        return;
+    }
+    const repos = loadRepos();
+    const name = getRepoName(repoPath);
+    // Get current branch
+    let branch;
+    try {
+        branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf-8',
+            cwd: repoPath,
+            stdio: ['pipe', 'pipe', 'ignore']
+        }).trim();
+    }
+    catch (error) {
+        branch = 'unknown';
+    }
+    // Update or add repo
+    const existingIndex = repos.findIndex(r => r.path === repoPath);
+    if (existingIndex >= 0) {
+        repos[existingIndex].lastUsed = Date.now();
+        repos[existingIndex].branch = branch;
+    }
+    else {
+        repos.push({
+            name,
+            path: repoPath,
+            lastUsed: Date.now(),
+            branch,
+        });
+    }
+    saveRepos(repos);
+}
+/**
+ * List all saved repositories
+ */
+function listRepos() {
+    const repos = loadRepos();
+    if (repos.length === 0) {
+        console.log(chalk_1.default.gray('\n   No saved repositories\n'));
+        return;
+    }
+    // Sort by last used
+    repos.sort((a, b) => b.lastUsed - a.lastUsed);
+    console.log(chalk_1.default.bold('\n📁 Saved Repositories:\n'));
+    const currentPath = getCurrentRepoPath();
+    repos.forEach((repo, index) => {
+        const isCurrent = repo.path === currentPath;
+        const icon = isCurrent ? chalk_1.default.green('→') : ' ';
+        const nameColor = isCurrent ? chalk_1.default.green.bold : chalk_1.default.cyan;
+        console.log(`   ${icon} ${nameColor(repo.name)}`);
+        console.log(chalk_1.default.gray(`      ${repo.path}`));
+        if (repo.branch) {
+            console.log(chalk_1.default.gray(`      Branch: ${repo.branch}`));
+        }
+        console.log('');
+    });
+}
+/**
+ * Switch to a repository by name or index
+ */
+async function switchToRepo(nameOrIndex) {
+    const repos = loadRepos();
+    if (repos.length === 0) {
+        console.log(chalk_1.default.red('\n❌ No saved repositories\n'));
+        return false;
+    }
+    // Sort by last used
+    repos.sort((a, b) => b.lastUsed - a.lastUsed);
+    let targetRepo;
+    if (typeof nameOrIndex === 'number') {
+        targetRepo = repos[nameOrIndex];
+    }
+    else {
+        // Try to match by name (case-insensitive)
+        const search = nameOrIndex.toLowerCase();
+        targetRepo = repos.find(r => r.name.toLowerCase().includes(search) ||
+            r.path.toLowerCase().includes(search));
+    }
+    if (!targetRepo) {
+        console.log(chalk_1.default.red(`\n❌ Repository "${nameOrIndex}" not found\n`));
+        return false;
+    }
+    // Check if repo path still exists
+    if (!fs.existsSync(targetRepo.path)) {
+        console.log(chalk_1.default.red(`\n❌ Repository path no longer exists: ${targetRepo.path}\n`));
+        console.log(chalk_1.default.yellow('   Removing from saved repos...\n'));
+        // Remove from saved repos
+        const filtered = repos.filter(r => r.path !== targetRepo.path);
+        saveRepos(filtered);
+        return false;
+    }
+    // Check if it's a git repo
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', {
+            cwd: targetRepo.path,
+            stdio: ['pipe', 'pipe', 'ignore']
+        });
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Not a valid git repository: ${targetRepo.path}\n`));
+        return false;
+    }
+    // Change to the directory
+    try {
+        process.chdir(targetRepo.path);
+        // Update last used
+        targetRepo.lastUsed = Date.now();
+        saveRepos(repos);
+        // Get current branch
+        let branch = 'unknown';
+        try {
+            branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore']
+            }).trim();
+        }
+        catch (error) {
+            // Ignore
+        }
+        // Get status
+        let statusLine = '';
+        try {
+            const status = (0, child_process_1.execSync)('git status --short', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore']
+            }).trim();
+            const changedFiles = status.split('\n').filter(line => line.trim()).length;
+            if (changedFiles > 0) {
+                statusLine = chalk_1.default.yellow(` | ${changedFiles} file${changedFiles > 1 ? 's' : ''} changed`);
+            }
+            else {
+                statusLine = chalk_1.default.green(' | Clean');
+            }
+        }
+        catch (error) {
+            // Ignore
+        }
+        console.log(chalk_1.default.green(`\n✅ Switched to ${chalk_1.default.bold(targetRepo.name)}`));
+        console.log(chalk_1.default.gray(`   Branch: ${branch}${statusLine}`));
+        console.log(chalk_1.default.gray(`   Path: ${targetRepo.path}\n`));
+        return true;
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to switch: ${error.message}\n`));
+        return false;
+    }
+}
+/**
+ * Get repo context for display
+ */
+function getRepoContext() {
+    const repoPath = getCurrentRepoPath();
+    if (!repoPath) {
+        return chalk_1.default.gray('(not in a git repo)');
+    }
+    const name = getRepoName(repoPath);
+    let branch = 'unknown';
+    try {
+        branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore']
+        }).trim();
+    }
+    catch (error) {
+        // Ignore
+    }
+    return chalk_1.default.cyan(`${name}`) + chalk_1.default.gray(` (${branch})`);
+}

package/dist/lib/supabase.js

@@ -0,0 +1,153 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supabase = void 0;
+exports.storeAuthTokens = storeAuthTokens;
+exports.getStoredAuth = getStoredAuth;
+exports.clearStoredAuth = clearStoredAuth;
+exports.isAuthenticated = isAuthenticated;
+exports.getCurrentUser = getCurrentUser;
+exports.checkLicenseStatus = checkLicenseStatus;
+exports.syncStatsToCloud = syncStatsToCloud;
+const supabase_js_1 = require("@supabase/supabase-js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+if (!supabaseUrl || !supabaseAnonKey) {
+    throw new Error('Missing Supabase environment variables. Please check your .env file.');
+}
+exports.supabase = (0, supabase_js_1.createClient)(supabaseUrl, supabaseAnonKey);
+// Token storage path
+const TOKEN_DIR = path.join(os.homedir(), '.snapcommit');
+const TOKEN_FILE = path.join(TOKEN_DIR, 'auth_token.json');
+/**
+ * Store authentication tokens locally
+ */
+function storeAuthTokens(auth) {
+    if (!fs.existsSync(TOKEN_DIR)) {
+        fs.mkdirSync(TOKEN_DIR, { recursive: true });
+    }
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify(auth, null, 2));
+}
+/**
+ * Get stored authentication tokens
+ */
+function getStoredAuth() {
+    try {
+        if (!fs.existsSync(TOKEN_FILE)) {
+            return null;
+        }
+        const data = fs.readFileSync(TOKEN_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Clear stored authentication tokens
+ */
+function clearStoredAuth() {
+    try {
+        if (fs.existsSync(TOKEN_FILE)) {
+            fs.unlinkSync(TOKEN_FILE);
+        }
+    }
+    catch (error) {
+        // Silent fail
+    }
+}
+/**
+ * Check if user is authenticated
+ */
+async function isAuthenticated() {
+    const stored = getStoredAuth();
+    if (!stored) {
+        return false;
+    }
+    // Check if token is expired
+    if (Date.now() >= stored.expires_at) {
+        clearStoredAuth();
+        return false;
+    }
+    return true;
+}
+/**
+ * Get current user
+ */
+async function getCurrentUser() {
+    const stored = getStoredAuth();
+    if (!stored) {
+        return null;
+    }
+    const { data, error } = await exports.supabase.auth.getUser(stored.access_token);
+    if (error || !data.user) {
+        clearStoredAuth();
+        return null;
+    }
+    return data.user;
+}
+/**
+ * Check license status
+ */
+async function checkLicenseStatus(userId) {
+    const { data, error } = await exports.supabase.rpc('check_license_status', {
+        user_id_param: userId,
+    });
+    if (error) {
+        console.error('Error checking license:', error);
+        return null;
+    }
+    return data && data.length > 0 ? data[0] : null;
+}
+/**
+ * Sync stats to cloud
+ */
+async function syncStatsToCloud(userId, date, commits, commands, insertions, deletions, filesChanged) {
+    const { error } = await exports.supabase.rpc('update_daily_stats', {
+        user_id_param: userId,
+        date_param: date,
+        commits_delta: commits,
+        commands_delta: commands,
+        insertions_delta: insertions,
+        deletions_delta: deletions,
+        files_changed_delta: filesChanged,
+    });
+    if (error) {
+        console.error('Error syncing stats:', error);
+    }
+}

package/dist/license/manager.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentLicense = getCurrentLicense;
+exports.activateLicense = activateLicense;
+exports.activateFreeTier = activateFreeTier;
+exports.deactivateLicense = deactivateLicense;
+exports.isProUser = isProUser;
+exports.isTrialActive = isTrialActive;
+exports.canUseCommit = canUseCommit;
+exports.trackCommit = trackCommit;
+exports.getTrialStatus = getTrialStatus;
+exports.getLicenseInfo = getLicenseInfo;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const LICENSE_DIR = path_1.default.join(os_1.default.homedir(), '.builderos');
+const LICENSE_DB = path_1.default.join(LICENSE_DIR, 'license.db');
+// Ensure directory exists
+if (!fs_1.default.existsSync(LICENSE_DIR)) {
+    fs_1.default.mkdirSync(LICENSE_DIR, { recursive: true });
+}
+const db = new better_sqlite3_1.default(LICENSE_DB);
+// Initialize license database
+db.exec(`
+  CREATE TABLE IF NOT EXISTS license (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    key TEXT UNIQUE NOT NULL,
+    email TEXT,
+    plan TEXT NOT NULL,
+    status TEXT NOT NULL,
+    activated_at INTEGER NOT NULL,
+    expires_at INTEGER,
+    device_id TEXT NOT NULL,
+    last_validated INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS usage (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    month TEXT NOT NULL,
+    commits INTEGER DEFAULT 0,
+    UNIQUE(month)
+  );
+`);
+// Free trial: 7 days
+const TRIAL_DAYS = 7;
+const TRIAL_DURATION_MS = TRIAL_DAYS * 24 * 60 * 60 * 1000;
+function getCurrentLicense() {
+    const result = db.prepare('SELECT * FROM license ORDER BY id DESC LIMIT 1').get();
+    if (!result) {
+        return null;
+    }
+    return {
+        key: result.key,
+        email: result.email,
+        plan: result.plan,
+        status: result.status,
+        activated_at: result.activated_at,
+        expires_at: result.expires_at,
+        device_id: result.device_id,
+    };
+}
+function activateLicense(licenseKey, email, plan = 'pro_monthly') {
+    const deviceId = getDeviceId();
+    const now = Date.now();
+    // Calculate expiration
+    let expires_at;
+    if (plan === 'pro_monthly') {
+        expires_at = now + 30 * 24 * 60 * 60 * 1000; // 30 days
+    }
+    else if (plan === 'pro_yearly') {
+        expires_at = now + 365 * 24 * 60 * 60 * 1000; // 365 days
+    }
+    // Deactivate any existing license
+    db.prepare('DELETE FROM license').run();
+    // Insert new license
+    db.prepare(`
+    INSERT INTO license (key, email, plan, status, activated_at, expires_at, device_id, last_validated)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(licenseKey, email || null, plan, 'active', now, expires_at || null, deviceId, now);
+}
+function activateFreeTier() {
+    const deviceId = getDeviceId();
+    const now = Date.now();
+    const trialEnd = now + TRIAL_DURATION_MS;
+    const freeKey = `trial_${deviceId}_${now}`;
+    // Deactivate any existing license
+    db.prepare('DELETE FROM license').run();
+    // Insert trial (7 days)
+    db.prepare(`
+    INSERT INTO license (key, email, plan, status, activated_at, expires_at, device_id, last_validated)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(freeKey, null, 'free', 'active', now, trialEnd, deviceId, now);
+}
+function deactivateLicense() {
+    db.prepare('DELETE FROM license').run();
+}
+function isProUser() {
+    const license = getCurrentLicense();
+    if (!license) {
+        return false;
+    }
+    // Check if expired
+    if (license.expires_at && Date.now() > license.expires_at) {
+        return false;
+    }
+    return license.status === 'active' && license.plan !== 'free';
+}
+function isTrialActive() {
+    const license = getCurrentLicense();
+    if (!license || license.plan !== 'free') {
+        return false;
+    }
+    // Check if trial expired
+    if (license.expires_at && Date.now() > license.expires_at) {
+        return false;
+    }
+    return true;
+}
+function canUseCommit() {
+    const license = getCurrentLicense();
+    // No license = start trial
+    if (!license) {
+        activateFreeTier();
+        return canUseCommit(); // Retry
+    }
+    // Pro users = unlimited
+    if (isProUser()) {
+        return { allowed: true };
+    }
+    // Trial users = check if expired
+    const usage = getTrialStatus();
+    if (usage.isExpired) {
+        return {
+            allowed: false,
+            reason: '7-day trial expired',
+            usage,
+        };
+    }
+    return { allowed: true, usage };
+}
+function trackCommit() {
+    const currentMonth = getCurrentMonth();
+    const existing = db.prepare('SELECT * FROM usage WHERE month = ?').get(currentMonth);
+    if (existing) {
+        db.prepare('UPDATE usage SET commits = commits + 1 WHERE month = ?').run(currentMonth);
+    }
+    else {
+        db.prepare('INSERT INTO usage (month, commits) VALUES (?, 1)').run(currentMonth);
+    }
+}
+function getTrialStatus() {
+    const license = getCurrentLicense();
+    if (!license || license.plan !== 'free' || !license.expires_at) {
+        return {
+            trialStarted: 0,
+            trialEndsAt: 0,
+            daysRemaining: 0,
+            isExpired: true,
+        };
+    }
+    const now = Date.now();
+    const daysRemaining = Math.max(0, Math.ceil((license.expires_at - now) / (24 * 60 * 60 * 1000)));
+    const isExpired = now > license.expires_at;
+    return {
+        trialStarted: license.activated_at,
+        trialEndsAt: license.expires_at,
+        daysRemaining,
+        isExpired,
+    };
+}
+function getCurrentMonth() {
+    const now = new Date();
+    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+}
+function getDeviceId() {
+    // Create a unique device ID based on hostname and username
+    const hostname = os_1.default.hostname();
+    const username = os_1.default.userInfo().username;
+    return Buffer.from(`${hostname}_${username}`).toString('base64').substring(0, 16);
+}
+function getLicenseInfo() {
+    const license = getCurrentLicense();
+    if (!license) {
+        return 'No license';
+    }
+    if (license.plan === 'free') {
+        const usage = getTrialStatus();
+        if (usage.isExpired) {
+            return 'Trial expired';
+        }
+        return `Trial (${usage.daysRemaining} day${usage.daysRemaining === 1 ? '' : 's'} remaining)`;
+    }
+    const planName = license.plan === 'pro_monthly' ? 'Pro Monthly' : 'Pro Yearly';
+    if (license.expires_at) {
+        const daysRemaining = Math.ceil((license.expires_at - Date.now()) / (24 * 60 * 60 * 1000));
+        return `${planName} (${daysRemaining} days remaining)`;
+    }
+    return planName;
+}