@edgible-team/cli 1.0.1

package/dist/utils/FileIntegrityManager.js

@@ -0,0 +1,256 @@
+"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.FileIntegrityManager = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+class FileIntegrityManager {
+    /**
+     * Check file integrity with multiple validation methods
+     */
+    static async checkFileIntegrity(filePath) {
+        try {
+            // Check if file exists
+            const stats = await fs.stat(filePath);
+            // Read file content
+            const content = await fs.readFile(filePath, 'utf8');
+            // Validate JSON structure
+            let parsedContent;
+            try {
+                parsedContent = JSON.parse(content);
+            }
+            catch (error) {
+                return {
+                    isValid: false,
+                    checksum: '',
+                    size: stats.size,
+                    lastModified: stats.mtime.getTime(),
+                    error: 'Invalid JSON format'
+                };
+            }
+            // Calculate checksum
+            const checksum = (0, crypto_1.createHash)('sha256').update(content).digest('hex').substring(0, 16);
+            // Check for required fields if it's a status file
+            if (filePath.includes('status.json')) {
+                const requiredFields = ['running', 'health', 'timestamp', 'pid'];
+                for (const field of requiredFields) {
+                    if (parsedContent[field] === undefined) {
+                        return {
+                            isValid: false,
+                            checksum,
+                            size: stats.size,
+                            lastModified: stats.mtime.getTime(),
+                            error: `Missing required field: ${field}`
+                        };
+                    }
+                }
+            }
+            // Check file age (not older than 1 hour)
+            const age = Date.now() - stats.mtime.getTime();
+            if (age > 3600000) { // 1 hour
+                return {
+                    isValid: false,
+                    checksum,
+                    size: stats.size,
+                    lastModified: stats.mtime.getTime(),
+                    error: 'File is too old'
+                };
+            }
+            return {
+                isValid: true,
+                checksum,
+                size: stats.size,
+                lastModified: stats.mtime.getTime()
+            };
+        }
+        catch (error) {
+            return {
+                isValid: false,
+                checksum: '',
+                size: 0,
+                lastModified: 0,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Safely read JSON file with integrity check
+     */
+    static async readJsonFileSafely(filePath) {
+        try {
+            const integrity = await this.checkFileIntegrity(filePath);
+            if (!integrity.isValid) {
+                return {
+                    data: null,
+                    isValid: false,
+                    error: integrity.error
+                };
+            }
+            const content = await fs.readFile(filePath, 'utf8');
+            const data = JSON.parse(content);
+            return {
+                data,
+                isValid: true
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                isValid: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Safely write JSON file with atomic operation
+     */
+    static async writeJsonFileSafely(filePath, data) {
+        try {
+            const tempFile = `${filePath}.tmp`;
+            const backupFile = `${filePath}.backup`;
+            // Create backup if file exists
+            try {
+                await fs.copyFile(filePath, backupFile);
+            }
+            catch (error) {
+                // Backup failed, but continue
+                console.warn('Failed to create backup file:', error);
+            }
+            // Write to temporary file
+            const jsonContent = JSON.stringify(data, null, 2);
+            await fs.writeFile(tempFile, jsonContent, 'utf8');
+            // Atomic move
+            await fs.rename(tempFile, filePath);
+            // Clean up backup after successful write
+            try {
+                await fs.unlink(backupFile);
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+            return { success: true };
+        }
+        catch (error) {
+            // Try to restore from backup if write failed
+            try {
+                const backupFile = `${filePath}.backup`;
+                await fs.copyFile(backupFile, filePath);
+                console.log('Restored file from backup');
+            }
+            catch (restoreError) {
+                console.error('Failed to restore from backup:', restoreError);
+            }
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Clean up corrupted files
+     */
+    static async cleanupCorruptedFiles(directory) {
+        try {
+            const files = await fs.readdir(directory);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(directory, file);
+                    const integrity = await this.checkFileIntegrity(filePath);
+                    if (!integrity.isValid) {
+                        console.warn(`Cleaning up corrupted file: ${file}`);
+                        // Try to restore from backup
+                        const backupFile = `${filePath}.backup`;
+                        try {
+                            await fs.copyFile(backupFile, filePath);
+                            console.log(`Restored ${file} from backup`);
+                        }
+                        catch (error) {
+                            // If no backup, remove corrupted file
+                            await fs.unlink(filePath);
+                            console.log(`Removed corrupted file: ${file}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to cleanup corrupted files:', error);
+        }
+    }
+    /**
+     * Create file lock to prevent concurrent access
+     */
+    static async withFileLock(filePath, operation) {
+        const lockFile = `${filePath}.lock`;
+        const maxWait = 5000; // 5 seconds
+        const checkInterval = 100; // 100ms
+        let waited = 0;
+        // Wait for lock to be released
+        while (waited < maxWait) {
+            try {
+                await fs.access(lockFile);
+                // Lock exists, wait
+                await new Promise(resolve => setTimeout(resolve, checkInterval));
+                waited += checkInterval;
+            }
+            catch {
+                // Lock doesn't exist, we can proceed
+                break;
+            }
+        }
+        if (waited >= maxWait) {
+            throw new Error('File lock timeout - another process may be using the file');
+        }
+        try {
+            // Create lock
+            await fs.writeFile(lockFile, process.pid.toString());
+            // Perform operation
+            const result = await operation();
+            return result;
+        }
+        finally {
+            // Remove lock
+            try {
+                await fs.unlink(lockFile);
+            }
+            catch (error) {
+                // Ignore lock cleanup errors
+            }
+        }
+    }
+}
+exports.FileIntegrityManager = FileIntegrityManager;
+//# sourceMappingURL=FileIntegrityManager.js.map

package/dist/utils/PathMigration.js

@@ -0,0 +1,219 @@
+"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.PathMigration = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const PathResolver_1 = require("./PathResolver");
+/**
+ * PathMigration utility handles migration from legacy ~/.edgible paths
+ * to the new XDG/platform-specific paths.
+ */
+class PathMigration {
+    /**
+     * Check if legacy paths exist
+     */
+    static hasLegacyPaths() {
+        const legacyPath = path.join(os.homedir(), '.edgible');
+        return fs.existsSync(legacyPath);
+    }
+    /**
+     * Get the legacy config path
+     */
+    static getLegacyConfigPath() {
+        return path.join(os.homedir(), '.edgible', 'config.json');
+    }
+    /**
+     * Get the legacy agent path
+     */
+    static getLegacyAgentPath() {
+        return path.join(os.homedir(), '.edgible', 'agent');
+    }
+    /**
+     * Migrate configuration from legacy paths to new paths
+     *
+     * @returns true if migration was successful or not needed, false if migration failed
+     */
+    static async migrateConfig() {
+        try {
+            const legacyConfigPath = this.getLegacyConfigPath();
+            const newConfigPath = PathResolver_1.PathResolver.getCliConfigPath();
+            const newConfigDir = path.dirname(newConfigPath);
+            // Check if legacy config exists
+            if (!fs.existsSync(legacyConfigPath)) {
+                return true; // No migration needed
+            }
+            // Check if new config already exists
+            if (fs.existsSync(newConfigPath)) {
+                // Both exist - check if they're different
+                const legacyContent = fs.readFileSync(legacyConfigPath, 'utf8');
+                const newContent = fs.readFileSync(newConfigPath, 'utf8');
+                if (legacyContent === newContent) {
+                    // Same content, migration already done
+                    return true;
+                }
+                // Different content - backup new and use legacy
+                const backupPath = `${newConfigPath}.backup.${Date.now()}`;
+                fs.copyFileSync(newConfigPath, backupPath);
+            }
+            // Ensure new directory exists
+            if (!fs.existsSync(newConfigDir)) {
+                fs.mkdirSync(newConfigDir, { recursive: true });
+            }
+            // Copy config file
+            fs.copyFileSync(legacyConfigPath, newConfigPath);
+            // Preserve permissions
+            try {
+                const legacyStats = fs.statSync(legacyConfigPath);
+                fs.chmodSync(newConfigPath, legacyStats.mode);
+            }
+            catch {
+                // Ignore permission errors
+            }
+            return true;
+        }
+        catch (error) {
+            console.warn('Failed to migrate config:', error);
+            return false;
+        }
+    }
+    /**
+     * Migrate agent data from legacy paths to new paths
+     *
+     * @returns true if migration was successful or not needed, false if migration failed
+     */
+    static async migrateAgentData() {
+        try {
+            const legacyAgentPath = this.getLegacyAgentPath();
+            const newAgentPath = PathResolver_1.PathResolver.getAgentConfigPath(false); // User path for CLI
+            // Check if legacy agent path exists
+            if (!fs.existsSync(legacyAgentPath)) {
+                return true; // No migration needed
+            }
+            // Check if new agent path already exists
+            if (fs.existsSync(newAgentPath)) {
+                // Both exist - skip migration to avoid overwriting
+                return true;
+            }
+            // Ensure new directory exists
+            if (!fs.existsSync(path.dirname(newAgentPath))) {
+                fs.mkdirSync(path.dirname(newAgentPath), { recursive: true });
+            }
+            // Copy entire agent directory
+            this.copyDirectory(legacyAgentPath, newAgentPath);
+            return true;
+        }
+        catch (error) {
+            console.warn('Failed to migrate agent data:', error);
+            return false;
+        }
+    }
+    /**
+     * Perform full migration from legacy paths to new paths
+     *
+     * @returns Migration result with details
+     */
+    static async migrate() {
+        const result = {
+            success: true,
+            migrated: [],
+            errors: []
+        };
+        if (!this.hasLegacyPaths()) {
+            return result; // No legacy paths to migrate
+        }
+        // Migrate config
+        try {
+            if (await this.migrateConfig()) {
+                result.migrated.push('config');
+            }
+            else {
+                result.errors.push('Failed to migrate config');
+                result.success = false;
+            }
+        }
+        catch (error) {
+            result.errors.push(`Config migration error: ${error instanceof Error ? error.message : String(error)}`);
+            result.success = false;
+        }
+        // Migrate agent data
+        try {
+            if (await this.migrateAgentData()) {
+                result.migrated.push('agent-data');
+            }
+            else {
+                result.errors.push('Failed to migrate agent data');
+                result.success = false;
+            }
+        }
+        catch (error) {
+            result.errors.push(`Agent data migration error: ${error instanceof Error ? error.message : String(error)}`);
+            result.success = false;
+        }
+        return result;
+    }
+    /**
+     * Copy directory recursively
+     */
+    static copyDirectory(src, dest) {
+        // Create destination directory
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+        }
+        // Read source directory
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                this.copyDirectory(srcPath, destPath);
+            }
+            else {
+                fs.copyFileSync(srcPath, destPath);
+                // Preserve permissions
+                try {
+                    const stats = fs.statSync(srcPath);
+                    fs.chmodSync(destPath, stats.mode);
+                }
+                catch {
+                    // Ignore permission errors
+                }
+            }
+        }
+    }
+}
+exports.PathMigration = PathMigration;
+//# sourceMappingURL=PathMigration.js.map