filemayor 2.0.3 → 2.0.4

package/LICENSE

@@ -52,7 +52,7 @@ operating as FileMayor, and its contributors.
    - Server / data center deployment
    - SOP AI Engine features
 
-   requires a valid Paid Tier license. Contact licensing@filemayor.app
+   requires a valid Paid Tier license. Contact licensing@filemayor.com
    for commercial licensing inquiries.
 
 5. AI FEATURES
@@ -86,5 +86,5 @@ operating as FileMayor, and its contributors.
 
    This License shall be governed by the laws of the Republic of South Africa.
 
-For licensing inquiries: licensing@filemayor.app
-For support: support@filemayor.app
+For licensing inquiries: licensing@filemayor.com
+For support: support@filemayor.com

package/core/license.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — LICENSE
+ * Offline license key validation, tier management, and feature gating.
+ * Created by Lehlohonolo Goodwill Nchefu (Chevza)
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+// ─── Constants ────────────────────────────────────────────────────
+
+const LICENSE_FILE = path.join(os.homedir(), '.filemayor-license.json');
+const KEY_PREFIX = 'FM';
+const CHECKSUM_SECRET = 'filemayor-chevza-2026';
+
+/**
+ * License tiers with capabilities
+ */
+const TIERS = {
+    free: {
+        name: 'Free',
+        features: ['scan', 'organize', 'clean', 'undo', 'init', 'info'],
+        limits: { bulkOrganize: 50 },
+    },
+    pro: {
+        name: 'Pro',
+        features: ['scan', 'organize', 'clean', 'undo', 'init', 'info',
+            'watch', 'sop-ai', 'bulk-organize', 'csv-export'],
+        limits: { bulkOrganize: Infinity },
+    },
+    enterprise: {
+        name: 'Enterprise',
+        features: ['scan', 'organize', 'clean', 'undo', 'init', 'info',
+            'watch', 'sop-ai', 'bulk-organize', 'csv-export',
+            'api-access', 'custom-categories', 'team-sharing'],
+        limits: { bulkOrganize: Infinity },
+    },
+    owner: {
+        name: 'Owner',
+        features: ['*'],
+        limits: { bulkOrganize: Infinity },
+    },
+};
+
+/**
+ * Built-in keys (hardcoded, never expire)
+ */
+const BUILTIN_KEYS = {
+    'FM-OWN-CHEV-2026-PRMNT': { tier: 'owner', name: 'Owner — Chevza', expires: null },
+    'FM-TST-DEV0-TEST-00000': { tier: 'pro', name: 'Test — Development', expires: null },
+};
+
+// ─── Key Generation & Validation ──────────────────────────────────
+
+/**
+ * Generate a checksum for a key body
+ * @param {string} body - Key body without checksum segment
+ * @returns {string} 5-char checksum
+ */
+function generateChecksum(body) {
+    const hash = crypto.createHmac('sha256', CHECKSUM_SECRET)
+        .update(body)
+        .digest('hex');
+    return hash.substring(0, 5).toUpperCase();
+}
+
+/**
+ * Validate key format: FM-XXX-XXXX-XXXX-XXXXX
+ * Last 5 chars are HMAC checksum of the rest
+ * @param {string} key - License key
+ * @returns {{ valid: boolean, tier: string|null, reason: string }}
+ */
+function validateKeyFormat(key) {
+    if (!key || typeof key !== 'string') {
+        return { valid: false, tier: null, reason: 'No key provided' };
+    }
+
+    const k = key.trim().toUpperCase();
+
+    // Check built-in keys first
+    if (BUILTIN_KEYS[k]) {
+        return { valid: true, tier: BUILTIN_KEYS[k].tier, reason: 'Built-in key' };
+    }
+
+    // Format: FM-XXX-XXXX-XXXX-XXXXX
+    const pattern = /^FM-(PRO|ENT|OWN|TST)-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{5}$/;
+    if (!pattern.test(k)) {
+        return { valid: false, tier: null, reason: 'Invalid key format' };
+    }
+
+    // Extract parts
+    const parts = k.split('-');
+    const tierCode = parts[1];
+    const body = parts.slice(0, 4).join('-'); // FM-XXX-XXXX-XXXX
+    const checksum = parts[4];                // XXXXX
+
+    // Verify checksum
+    const expectedChecksum = generateChecksum(body);
+    if (checksum !== expectedChecksum) {
+        return { valid: false, tier: null, reason: 'Invalid key (checksum failed)' };
+    }
+
+    // Map tier code
+    const tierMap = { PRO: 'pro', ENT: 'enterprise', OWN: 'owner', TST: 'pro' };
+    const tier = tierMap[tierCode] || 'free';
+
+    return { valid: true, tier, reason: 'Valid' };
+}
+
+/**
+ * Generate a new license key
+ * @param {'pro'|'enterprise'|'owner'} tier 
+ * @returns {string} Generated key
+ */
+function generateKey(tier = 'pro') {
+    const tierMap = { pro: 'PRO', enterprise: 'ENT', owner: 'OWN' };
+    const code = tierMap[tier] || 'PRO';
+
+    const seg1 = crypto.randomBytes(2).toString('hex').toUpperCase().substring(0, 4);
+    const seg2 = crypto.randomBytes(2).toString('hex').toUpperCase().substring(0, 4);
+    const body = `FM-${code}-${seg1}-${seg2}`;
+    const checksum = generateChecksum(body);
+
+    return `${body}-${checksum}`;
+}
+
+// ─── License Storage ──────────────────────────────────────────────
+
+/**
+ * Read stored license from disk
+ * @returns {{ key: string, tier: string, activatedAt: string, name: string }|null}
+ */
+function readLicense() {
+    try {
+        if (!fs.existsSync(LICENSE_FILE)) return null;
+        const data = JSON.parse(fs.readFileSync(LICENSE_FILE, 'utf8'));
+        return data;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Write license to disk
+ * @param {Object} licenseData 
+ */
+function writeLicense(licenseData) {
+    fs.writeFileSync(LICENSE_FILE, JSON.stringify(licenseData, null, 2), 'utf8');
+}
+
+/**
+ * Remove stored license
+ */
+function removeLicense() {
+    if (fs.existsSync(LICENSE_FILE)) {
+        fs.unlinkSync(LICENSE_FILE);
+    }
+}
+
+// ─── License Management ──────────────────────────────────────────
+
+/**
+ * Activate a license key
+ * @param {string} key - License key to activate
+ * @returns {{ success: boolean, message: string, tier: string|null }}
+ */
+function activateLicense(key) {
+    const validation = validateKeyFormat(key);
+
+    if (!validation.valid) {
+        return { success: false, message: validation.reason, tier: null };
+    }
+
+    const k = key.trim().toUpperCase();
+    const builtin = BUILTIN_KEYS[k];
+
+    const licenseData = {
+        key: k,
+        tier: validation.tier,
+        name: builtin ? builtin.name : `${TIERS[validation.tier].name} License`,
+        activatedAt: new Date().toISOString(),
+        expires: builtin ? null : null, // LemonSqueezy keys can add expiry later
+    };
+
+    writeLicense(licenseData);
+
+    return {
+        success: true,
+        message: `${TIERS[validation.tier].name} license activated successfully`,
+        tier: validation.tier,
+    };
+}
+
+/**
+ * Deactivate the current license
+ * @returns {{ success: boolean, message: string }}
+ */
+function deactivateLicense() {
+    const current = readLicense();
+    if (!current) {
+        return { success: false, message: 'No active license found' };
+    }
+    removeLicense();
+    return { success: true, message: 'License deactivated. Reverted to Free tier.' };
+}
+
+/**
+ * Get current license info
+ * @returns {{ tier: string, name: string, features: string[], limits: Object, key: string|null, active: boolean }}
+ */
+function getLicenseInfo() {
+    const stored = readLicense();
+
+    if (!stored) {
+        return {
+            tier: 'free',
+            name: 'Free',
+            features: TIERS.free.features,
+            limits: TIERS.free.limits,
+            key: null,
+            active: false,
+        };
+    }
+
+    // Re-validate stored key
+    const validation = validateKeyFormat(stored.key);
+    if (!validation.valid) {
+        removeLicense();
+        return {
+            tier: 'free',
+            name: 'Free (invalid key removed)',
+            features: TIERS.free.features,
+            limits: TIERS.free.limits,
+            key: null,
+            active: false,
+        };
+    }
+
+    const tier = TIERS[stored.tier] || TIERS.free;
+
+    return {
+        tier: stored.tier,
+        name: stored.name,
+        features: tier.features,
+        limits: tier.limits,
+        key: stored.key,
+        active: true,
+        activatedAt: stored.activatedAt,
+    };
+}
+
+// ─── Feature Gating ──────────────────────────────────────────────
+
+/**
+ * Check if a feature is available in the current license
+ * @param {string} feature - Feature identifier
+ * @returns {boolean}
+ */
+function hasFeature(feature) {
+    const info = getLicenseInfo();
+    if (info.features.includes('*')) return true; // Owner has everything
+    return info.features.includes(feature);
+}
+
+/**
+ * Check if a Pro feature is gated and return appropriate message
+ * @param {string} feature - Feature identifier
+ * @param {string} featureLabel - Human-readable feature name
+ * @returns {{ allowed: boolean, message: string|null }}
+ */
+function checkProFeature(feature, featureLabel) {
+    if (hasFeature(feature)) {
+        return { allowed: true, message: null };
+    }
+
+    return {
+        allowed: false,
+        message: [
+            `⚡ ${featureLabel} is a Pro feature`,
+            '',
+            '  Upgrade to Pro to unlock:',
+            '  • Real-time file watching & auto-organize',
+            '  • AI-powered SOP parsing (Gemini)',
+            '  • Bulk organize (unlimited files)',
+            '  • CSV export for all reports',
+            '',
+            '  Get your license: https://filemayor.lemonsqueezy.com/checkout/buy/d2795526-eb05-4272-8084-98b6c7a118bb',
+            '  Then run: filemayor license activate YOUR-KEY',
+            '',
+        ].join('\n'),
+    };
+}
+
+/**
+ * Check bulk organize limit
+ * @param {number} fileCount - Number of files to organize
+ * @returns {{ allowed: boolean, message: string|null }}
+ */
+function checkBulkLimit(fileCount) {
+    const info = getLicenseInfo();
+    if (info.limits.bulkOrganize >= fileCount) {
+        return { allowed: true, message: null };
+    }
+
+    return {
+        allowed: false,
+        message: [
+            `⚡ Bulk organize (${fileCount} files) requires a Pro license`,
+            `   Free tier is limited to ${info.limits.bulkOrganize} files per operation.`,
+            '',
+            '  Upgrade: https://filemayor.lemonsqueezy.com/checkout/buy/d2795526-eb05-4272-8084-98b6c7a118bb',
+            '  Then run: filemayor license activate YOUR-KEY',
+        ].join('\n'),
+    };
+}
+
+// ─── Exports ─────────────────────────────────────────────────────
+
+module.exports = {
+    TIERS,
+    BUILTIN_KEYS,
+    validateKeyFormat,
+    generateKey,
+    readLicense,
+    activateLicense,
+    deactivateLicense,
+    getLicenseInfo,
+    hasFeature,
+    checkProFeature,
+    checkBulkLimit,
+    LICENSE_FILE,
+};

package/index.js

@@ -33,11 +33,28 @@ const reporter = require('./core/reporter');
 const { formatBytes } = require('./core/scanner');
 const { getCategories } = require('./core/categories');
 const { checkPermissions } = require('./core/security');
+const { activateLicense, deactivateLicense, getLicenseInfo, checkProFeature, checkBulkLimit } = require('./core/license');
 
 const { c, banner, Spinner, success, error, warn, info } = reporter;
 
 // ─── Version ──────────────────────────────────────────────────────
-const VERSION = '2.0.0';
+const VERSION = '2.0.4';
+
+// ─── Path Helpers ─────────────────────────────────────────────────
+
+/**
+ * Expand ~ to user home directory (cross-platform).
+ * On Unix shells, ~ is expanded by the shell before reaching Node.
+ * On Windows PowerShell, it is NOT — so we handle it here.
+ */
+function expandTilde(p) {
+    if (!p) return p;
+    if (p === '~') return os.homedir();
+    if (p.startsWith('~/') || p.startsWith('~\\')) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
 
 // ─── Argument Parser ──────────────────────────────────────────────
 
@@ -108,7 +125,7 @@ function parseArgs(argv) {
         } else if (!args.command) {
             args.command = arg;
         } else if (!args.target) {
-            args.target = arg;
+            args.target = expandTilde(arg);
         } else {
             args.positional.push(arg);
         }
@@ -140,10 +157,11 @@ ${banner()}
     ${c('yellow', 'scan')}      ${c('dim', '<path>')}    Scan directory and report contents
     ${c('yellow', 'organize')}  ${c('dim', '<path>')}    Organize files into categories
     ${c('yellow', 'clean')}     ${c('dim', '<path>')}    Find and remove junk files
-    ${c('yellow', 'watch')}     ${c('dim', '<path>')}    Watch directory for changes (daemon)
+    ${c('yellow', 'watch')}     ${c('dim', '<path>')}    Watch directory for changes ${c('magenta', '[PRO]')}
     ${c('yellow', 'init')}                Create .filemayor.yml config
     ${c('yellow', 'undo')}      ${c('dim', '<path>')}    Undo last organization
     ${c('yellow', 'info')}                System info and version
+    ${c('yellow', 'license')}  ${c('dim', '<action>')}  Manage license (activate|status|deactivate)
 
   ${c('bold', 'OPTIONS')}
     ${c('dim', '--dry-run')}           Preview changes without executing
@@ -178,7 +196,7 @@ ${banner()}
   ${c('bold', 'INSTALL')}
     ${c('dim', '$')} npm install -g filemayor
 
-  ${c('dim', `FileMayor v${VERSION} — https://filemayor.app`)}
+  ${c('dim', `FileMayor v${VERSION} — https://filemayor.com`)}
 `);
 }
 
@@ -301,6 +319,13 @@ async function cmdClean(target, flags, config) {
 }
 
 async function cmdWatch(target, flags, config) {
+    // Pro feature gate
+    const gate = checkProFeature('watch', 'Watch Mode');
+    if (!gate.allowed) {
+        console.log(gate.message);
+        process.exit(0);
+    }
+
     const targetPath = path.resolve(target || '.');
     const format = flags.format || config.output.format;
 
@@ -429,6 +454,87 @@ async function cmdInfo(config) {
     console.log('');
 }
 
+// ─── License Command ──────────────────────────────────────────────
+
+async function cmdLicense(action, positional, flags) {
+    const subAction = action || 'status';
+
+    switch (subAction) {
+        case 'activate': {
+            const key = positional[0] || flags.key;
+            if (!key) {
+                console.error(error('Usage: filemayor license activate <key>'));
+                console.log(c('dim', '  Example: filemayor license activate FM-PRO-XXXX-XXXX-XXXXX'));
+                process.exit(1);
+            }
+            const result = activateLicense(key);
+            if (result.success) {
+                console.log(success(result.message));
+                console.log(c('dim', `  Tier: ${result.tier}`));
+            } else {
+                console.error(error(result.message));
+                process.exit(1);
+            }
+            break;
+        }
+
+        case 'deactivate':
+        case 'remove': {
+            const result = deactivateLicense();
+            if (result.success) {
+                console.log(success(result.message));
+            } else {
+                console.log(info(result.message));
+            }
+            break;
+        }
+
+        case 'status':
+        default: {
+            const li = getLicenseInfo();
+            console.log(banner());
+            console.log(c('bold', '  License Status'));
+            console.log(c('dim', `  ${'─'.repeat(40)}`));
+            console.log(`  ${c('bold', 'Tier:')}        ${li.active ? c('green', li.name) : c('yellow', 'Free')}`);
+            console.log(`  ${c('bold', 'Status:')}      ${li.active ? c('green', '● Active') : c('dim', '○ No license')}`);
+            if (li.key) {
+                const masked = li.key.substring(0, 7) + '****' + li.key.substring(li.key.length - 5);
+                console.log(`  ${c('bold', 'Key:')}         ${c('dim', masked)}`);
+            }
+            if (li.activatedAt) {
+                console.log(`  ${c('bold', 'Activated:')}   ${c('dim', new Date(li.activatedAt).toLocaleDateString())}`);
+            }
+            console.log('');
+            console.log(c('bold', '  Features'));
+            console.log(c('dim', `  ${'─'.repeat(40)}`));
+            const allFeatures = [
+                { id: 'scan', label: 'Directory Scanning', free: true },
+                { id: 'organize', label: 'File Organization', free: true },
+                { id: 'clean', label: 'Junk Cleanup', free: true },
+                { id: 'undo', label: 'Undo Operations', free: true },
+                { id: 'watch', label: 'Watch Mode', free: false },
+                { id: 'sop-ai', label: 'AI SOP Parsing', free: false },
+                { id: 'bulk-organize', label: 'Bulk Organize (50+ files)', free: false },
+                { id: 'csv-export', label: 'CSV Export', free: false },
+            ];
+            for (const feat of allFeatures) {
+                const has = li.features.includes('*') || li.features.includes(feat.id);
+                const icon = has ? c('green', '✓') : c('dim', '○');
+                const label = has ? feat.label : c('dim', feat.label);
+                const tag = !feat.free && !has ? c('magenta', ' [PRO]') : '';
+                console.log(`  ${icon}  ${label}${tag}`);
+            }
+            console.log('');
+            if (!li.active) {
+                console.log(c('dim', '  Get a license: https://filemayor.lemonsqueezy.com/checkout/buy/d2795526-eb05-4272-8084-98b6c7a118bb'));
+                console.log(c('dim', '  Activate: filemayor license activate <key>'));
+                console.log('');
+            }
+            break;
+        }
+    }
+}
+
 // ─── Main Entry Point ─────────────────────────────────────────────
 
 async function main() {
@@ -515,6 +621,12 @@ async function main() {
             await cmdInfo(config);
             break;
 
+        case 'license':
+        case 'lic':
+        case 'l':
+            await cmdLicense(args.target, args.positional, args.flags);
+            break;
+
         case 'help':
             printHelp();
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "filemayor",
-    "version": "2.0.3",
+    "version": "2.0.4",
     "description": "Enterprise file management engine — scan, organize, clean, and watch your filesystem from any terminal",
     "main": "index.js",
     "bin": {
@@ -26,6 +26,7 @@
     ],
     "author": {
         "name": "Lehlohonolo Goodwill Nchefu (Chevza)",
+        "email": "nchefuh@gmail.com",
         "url": "https://github.com/Hrypopo"
     },
     "license": "PROPRIETARY",
@@ -36,7 +37,7 @@
     "bugs": {
         "url": "https://github.com/Hrypopo/FileMayor/issues"
     },
-    "homepage": "https://github.com/Hrypopo/FileMayor#readme",
+    "homepage": "https://filemayor.com",
     "engines": {
         "node": ">=18.0.0"
     },