lsh-framework 1.6.0 → 1.7.0

package/README.md

@@ -815,6 +815,9 @@ lsh daemon start
 - **[SECRETS_QUICK_REFERENCE.md](docs/features/secrets/SECRETS_QUICK_REFERENCE.md)** - Quick reference for daily use
 - **[SECRETS_CHEATSHEET.txt](SECRETS_CHEATSHEET.txt)** - Command cheatsheet
 
+### IPFS Integration
+- **[IPFS_CLIENT_GUIDE.md](docs/features/ipfs/IPFS_CLIENT_GUIDE.md)** - 🆕 IPFS client installation and management (v1.6.0+)
+
 ### Installation & Development
 - **[INSTALL.md](docs/deployment/INSTALL.md)** - Detailed installation instructions
 - **[CLAUDE.md](CLAUDE.md)** - Developer guide for contributors

package/dist/cli.js

@@ -10,6 +10,7 @@ import { registerDoctorCommands } from './commands/doctor.js';
 import { registerCompletionCommands } from './commands/completion.js';
 import { registerConfigCommands } from './commands/config.js';
 import { registerSyncHistoryCommands } from './commands/sync-history.js';
+import { registerIPFSCommands } from './commands/ipfs.js';
 import { init_daemon } from './services/daemon/daemon.js';
 import { init_supabase } from './services/supabase/supabase.js';
 import { init_cron } from './services/cron/cron.js';
@@ -144,6 +145,7 @@ function findSimilarCommands(input, validCommands) {
     registerDoctorCommands(program);
     registerConfigCommands(program);
     registerSyncHistoryCommands(program);
+    registerIPFSCommands(program);
     // Secrets management (primary feature)
     await init_secrets(program);
     // Supporting services

package/dist/commands/doctor.js

@@ -7,6 +7,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { createClient } from '@supabase/supabase-js';
 import { getPlatformPaths, getPlatformInfo } from '../lib/platform-utils.js';
+import { IPFSClientManager } from '../lib/ipfs-client-manager.js';
 /**
  * Register doctor commands
  */
@@ -48,6 +49,8 @@ async function runHealthCheck(options) {
     checks.push(...storageChecks);
     // Git repository check
     checks.push(await checkGitRepository(options.verbose));
+    // IPFS client check
+    checks.push(await checkIPFSClient(options.verbose));
     // Permissions check
     checks.push(await checkPermissions(options.verbose));
     // Display results
@@ -294,6 +297,38 @@ async function checkGitRepository(verbose) {
         };
     }
 }
+/**
+ * Check IPFS client installation
+ */
+async function checkIPFSClient(verbose) {
+    try {
+        const manager = new IPFSClientManager();
+        const info = await manager.detect();
+        if (info.installed) {
+            return {
+                name: 'IPFS Client',
+                status: 'pass',
+                message: `${info.type} v${info.version} installed`,
+                details: verbose ? `Path: ${info.path}` : undefined,
+            };
+        }
+        return {
+            name: 'IPFS Client',
+            status: 'warn',
+            message: 'Not installed (optional for local storage)',
+            details: 'Install with: lsh ipfs install',
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            name: 'IPFS Client',
+            status: 'warn',
+            message: 'Could not check IPFS client',
+            details: err.message,
+        };
+    }
+}
 /**
  * Check file permissions
  */

package/dist/commands/ipfs.js

@@ -0,0 +1,146 @@
+/**
+ * IPFS Commands
+ * Manage IPFS client installation and configuration
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { IPFSClientManager } from '../lib/ipfs-client-manager.js';
+/**
+ * Register IPFS commands
+ */
+export function registerIPFSCommands(program) {
+    const ipfsCommand = program
+        .command('ipfs')
+        .description('Manage IPFS client installation and configuration');
+    // lsh ipfs status
+    ipfsCommand
+        .command('status')
+        .description('Check IPFS client installation status')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const manager = new IPFSClientManager();
+            const info = await manager.detect();
+            if (options.json) {
+                console.log(JSON.stringify(info, null, 2));
+                return;
+            }
+            console.log(chalk.bold.cyan('\n📦 IPFS Client Status'));
+            console.log(chalk.gray('━'.repeat(50)));
+            console.log('');
+            if (info.installed) {
+                console.log(chalk.green('✅ IPFS client installed'));
+                console.log(`   Type: ${info.type}`);
+                console.log(`   Version: ${info.version}`);
+                console.log(`   Path: ${info.path}`);
+            }
+            else {
+                console.log(chalk.yellow('⚠️  IPFS client not installed'));
+                console.log('');
+                console.log(chalk.gray('   Install with: lsh ipfs install'));
+            }
+            console.log('');
+        }
+        catch (error) {
+            const err = error;
+            console.error(chalk.red('\n❌ Failed to check status:'), err.message);
+            process.exit(1);
+        }
+    });
+    // lsh ipfs install
+    ipfsCommand
+        .command('install')
+        .description('Install IPFS client (Kubo)')
+        .option('-f, --force', 'Force reinstall even if already installed')
+        .option('-v, --version <version>', 'Install specific version')
+        .action(async (options) => {
+        const spinner = ora('Installing IPFS client...').start();
+        try {
+            const manager = new IPFSClientManager();
+            await manager.install({
+                force: options.force,
+                version: options.version,
+            });
+            spinner.succeed(chalk.green('IPFS client installed successfully!'));
+            console.log('');
+            console.log(chalk.gray('Next steps:'));
+            console.log(chalk.cyan('  lsh ipfs init    # Initialize IPFS repository'));
+            console.log(chalk.cyan('  lsh ipfs start   # Start IPFS daemon'));
+            console.log('');
+        }
+        catch (error) {
+            const err = error;
+            spinner.fail(chalk.red('Installation failed'));
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    // lsh ipfs uninstall
+    ipfsCommand
+        .command('uninstall')
+        .description('Uninstall LSH-managed IPFS client')
+        .action(async () => {
+        try {
+            const manager = new IPFSClientManager();
+            await manager.uninstall();
+        }
+        catch (error) {
+            const err = error;
+            console.error(chalk.red('\n❌ Uninstallation failed:'), err.message);
+            process.exit(1);
+        }
+    });
+    // lsh ipfs init
+    ipfsCommand
+        .command('init')
+        .description('Initialize IPFS repository')
+        .action(async () => {
+        const spinner = ora('Initializing IPFS repository...').start();
+        try {
+            const manager = new IPFSClientManager();
+            await manager.init();
+            spinner.succeed(chalk.green('IPFS repository initialized!'));
+            console.log('');
+            console.log(chalk.gray('Next step:'));
+            console.log(chalk.cyan('  lsh ipfs start   # Start IPFS daemon'));
+            console.log('');
+        }
+        catch (error) {
+            const err = error;
+            spinner.fail(chalk.red('Initialization failed'));
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    // lsh ipfs start
+    ipfsCommand
+        .command('start')
+        .description('Start IPFS daemon')
+        .action(async () => {
+        try {
+            const manager = new IPFSClientManager();
+            await manager.start();
+        }
+        catch (error) {
+            const err = error;
+            console.error(chalk.red('\n❌ Failed to start daemon:'), err.message);
+            process.exit(1);
+        }
+    });
+    // lsh ipfs stop
+    ipfsCommand
+        .command('stop')
+        .description('Stop IPFS daemon')
+        .action(async () => {
+        try {
+            const manager = new IPFSClientManager();
+            await manager.stop();
+        }
+        catch (error) {
+            const err = error;
+            console.error(chalk.red('\n❌ Failed to stop daemon:'), err.message);
+            process.exit(1);
+        }
+    });
+}
+export default registerIPFSCommands;

package/dist/lib/ipfs-client-manager.js

@@ -0,0 +1,321 @@
+/**
+ * IPFS Client Manager
+ * Detects, installs, and manages IPFS clients across platforms
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { createLogger } from './logger.js';
+import { getPlatformInfo } from './platform-utils.js';
+const execAsync = promisify(exec);
+const logger = createLogger('IPFSClientManager');
+/**
+ * IPFS Client Manager
+ *
+ * Manages IPFS client installation and configuration:
+ * 1. Kubo (formerly go-ipfs) - Official Go implementation
+ * 2. Helia - Modern JavaScript implementation
+ * 3. js-ipfs - Legacy JavaScript implementation (deprecated)
+ */
+export class IPFSClientManager {
+    lshDir;
+    ipfsDir;
+    binDir;
+    constructor() {
+        this.lshDir = path.join(os.homedir(), '.lsh');
+        this.ipfsDir = path.join(this.lshDir, 'ipfs');
+        this.binDir = path.join(this.ipfsDir, 'bin');
+        // Ensure directories exist
+        this.ensureDirectories();
+    }
+    /**
+     * Detect if IPFS client is installed
+     */
+    async detect() {
+        // Check for system-wide Kubo installation
+        try {
+            const { stdout: kuboVersion } = await execAsync('ipfs version');
+            const versionMatch = kuboVersion.match(/ipfs version ([0-9.]+)/);
+            if (versionMatch) {
+                const { stdout: kuboPath } = await execAsync('which ipfs');
+                return {
+                    installed: true,
+                    version: versionMatch[1],
+                    path: kuboPath.trim(),
+                    type: 'kubo',
+                };
+            }
+        }
+        catch {
+            // Kubo not found in system PATH
+        }
+        // Check for local LSH-managed installation
+        const localIpfsPath = path.join(this.binDir, 'ipfs');
+        if (fs.existsSync(localIpfsPath)) {
+            try {
+                const { stdout: localVersion } = await execAsync(`${localIpfsPath} version`);
+                const versionMatch = localVersion.match(/ipfs version ([0-9.]+)/);
+                if (versionMatch) {
+                    return {
+                        installed: true,
+                        version: versionMatch[1],
+                        path: localIpfsPath,
+                        type: 'kubo',
+                    };
+                }
+            }
+            catch {
+                // Local binary exists but not working
+            }
+        }
+        return {
+            installed: false,
+        };
+    }
+    /**
+     * Install IPFS client
+     */
+    async install(options = {}) {
+        const platformInfo = getPlatformInfo();
+        const clientInfo = await this.detect();
+        // Check if already installed
+        if (clientInfo.installed && !options.force) {
+            logger.info(`✅ IPFS already installed: ${clientInfo.type} v${clientInfo.version}`);
+            logger.info(`   Path: ${clientInfo.path}`);
+            return;
+        }
+        logger.info('📦 Installing IPFS client (Kubo)...');
+        // Determine version to install
+        const version = options.version || await this.getLatestKuboVersion();
+        logger.info(`   Version: ${version}`);
+        logger.info(`   Platform: ${platformInfo.platformName} ${platformInfo.arch}`);
+        // Download and install based on platform
+        try {
+            if (platformInfo.platform === 'darwin') {
+                await this.installKuboMacOS(version);
+            }
+            else if (platformInfo.platform === 'linux') {
+                await this.installKuboLinux(version);
+            }
+            else if (platformInfo.platform === 'win32') {
+                await this.installKuboWindows(version);
+            }
+            else {
+                throw new Error(`Unsupported platform: ${platformInfo.platform}`);
+            }
+            logger.info('✅ IPFS client installed successfully!');
+            // Verify installation
+            const verifyInfo = await this.detect();
+            if (verifyInfo.installed) {
+                logger.info(`   Version: ${verifyInfo.version}`);
+                logger.info(`   Path: ${verifyInfo.path}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            logger.error(`❌ Installation failed: ${err.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Uninstall LSH-managed IPFS client
+     */
+    async uninstall() {
+        const clientInfo = await this.detect();
+        if (!clientInfo.installed) {
+            logger.info('ℹ️  No IPFS client installed');
+            return;
+        }
+        // Only uninstall if it's LSH-managed
+        if (clientInfo.path?.startsWith(this.binDir)) {
+            logger.info('🗑️  Uninstalling LSH-managed IPFS client...');
+            if (fs.existsSync(this.ipfsDir)) {
+                fs.rmSync(this.ipfsDir, { recursive: true });
+            }
+            logger.info('✅ IPFS client uninstalled');
+        }
+        else {
+            logger.info('ℹ️  System-wide IPFS installation detected');
+            logger.info('   LSH cannot uninstall system packages');
+            logger.info(`   Path: ${clientInfo.path}`);
+        }
+    }
+    /**
+     * Initialize IPFS repository
+     */
+    async init() {
+        const clientInfo = await this.detect();
+        if (!clientInfo.installed) {
+            throw new Error('IPFS client not installed. Run: lsh ipfs install');
+        }
+        const ipfsRepoPath = path.join(this.ipfsDir, 'repo');
+        // Check if already initialized
+        if (fs.existsSync(path.join(ipfsRepoPath, 'config'))) {
+            logger.info('✅ IPFS repository already initialized');
+            return;
+        }
+        logger.info('🔧 Initializing IPFS repository...');
+        try {
+            const ipfsCmd = clientInfo.path || 'ipfs';
+            await execAsync(`${ipfsCmd} init`, {
+                env: { ...process.env, IPFS_PATH: ipfsRepoPath },
+            });
+            logger.info('✅ IPFS repository initialized');
+            logger.info(`   Path: ${ipfsRepoPath}`);
+        }
+        catch (error) {
+            const err = error;
+            logger.error(`❌ Initialization failed: ${err.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Start IPFS daemon
+     */
+    async start() {
+        const clientInfo = await this.detect();
+        if (!clientInfo.installed) {
+            throw new Error('IPFS client not installed. Run: lsh ipfs install');
+        }
+        logger.info('🚀 Starting IPFS daemon...');
+        const ipfsRepoPath = path.join(this.ipfsDir, 'repo');
+        const ipfsCmd = clientInfo.path || 'ipfs';
+        try {
+            // Start daemon in background
+            const daemon = exec(`${ipfsCmd} daemon`, {
+                env: { ...process.env, IPFS_PATH: ipfsRepoPath },
+            });
+            // Log PID for management
+            const pidPath = path.join(this.ipfsDir, 'daemon.pid');
+            if (daemon.pid) {
+                fs.writeFileSync(pidPath, daemon.pid.toString(), 'utf8');
+            }
+            logger.info('✅ IPFS daemon started');
+            logger.info(`   PID: ${daemon.pid}`);
+            logger.info('   API: http://localhost:5001');
+            logger.info('   Gateway: http://localhost:8080');
+        }
+        catch (error) {
+            const err = error;
+            logger.error(`❌ Failed to start daemon: ${err.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Stop IPFS daemon
+     */
+    async stop() {
+        const pidPath = path.join(this.ipfsDir, 'daemon.pid');
+        if (!fs.existsSync(pidPath)) {
+            logger.info('ℹ️  IPFS daemon not running (no PID file)');
+            return;
+        }
+        const pid = parseInt(fs.readFileSync(pidPath, 'utf8'), 10);
+        logger.info(`🛑 Stopping IPFS daemon (PID: ${pid})...`);
+        try {
+            process.kill(pid, 'SIGTERM');
+            fs.unlinkSync(pidPath);
+            logger.info('✅ IPFS daemon stopped');
+        }
+        catch (error) {
+            const err = error;
+            logger.error(`❌ Failed to stop daemon: ${err.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Get latest Kubo version from GitHub releases
+     */
+    async getLatestKuboVersion() {
+        try {
+            // Use GitHub API to get latest release
+            const response = await fetch('https://api.github.com/repos/ipfs/kubo/releases/latest');
+            const data = await response.json();
+            // Remove 'v' prefix if present
+            return data.tag_name.replace(/^v/, '');
+        }
+        catch {
+            // Fallback to known stable version
+            return '0.26.0';
+        }
+    }
+    /**
+     * Install Kubo on macOS
+     */
+    async installKuboMacOS(version) {
+        const arch = os.arch() === 'arm64' ? 'arm64' : 'amd64';
+        const downloadUrl = `https://dist.ipfs.tech/kubo/v${version}/kubo_v${version}_darwin-${arch}.tar.gz`;
+        const tarPath = path.join(this.ipfsDir, 'kubo.tar.gz');
+        logger.info('   Downloading Kubo...');
+        // Download
+        await execAsync(`curl -L -o ${tarPath} ${downloadUrl}`);
+        logger.info('   Extracting...');
+        // Extract
+        await execAsync(`tar -xzf ${tarPath} -C ${this.ipfsDir}`);
+        // Move binary
+        const extractedBinPath = path.join(this.ipfsDir, 'kubo', 'ipfs');
+        fs.mkdirSync(this.binDir, { recursive: true });
+        fs.renameSync(extractedBinPath, path.join(this.binDir, 'ipfs'));
+        // Make executable
+        fs.chmodSync(path.join(this.binDir, 'ipfs'), 0o755);
+        // Cleanup
+        fs.unlinkSync(tarPath);
+        fs.rmSync(path.join(this.ipfsDir, 'kubo'), { recursive: true });
+    }
+    /**
+     * Install Kubo on Linux
+     */
+    async installKuboLinux(version) {
+        const arch = os.arch() === 'arm64' ? 'arm64' : 'amd64';
+        const downloadUrl = `https://dist.ipfs.tech/kubo/v${version}/kubo_v${version}_linux-${arch}.tar.gz`;
+        const tarPath = path.join(this.ipfsDir, 'kubo.tar.gz');
+        logger.info('   Downloading Kubo...');
+        // Download
+        await execAsync(`curl -L -o ${tarPath} ${downloadUrl}`);
+        logger.info('   Extracting...');
+        // Extract
+        await execAsync(`tar -xzf ${tarPath} -C ${this.ipfsDir}`);
+        // Move binary
+        const extractedBinPath = path.join(this.ipfsDir, 'kubo', 'ipfs');
+        fs.mkdirSync(this.binDir, { recursive: true });
+        fs.renameSync(extractedBinPath, path.join(this.binDir, 'ipfs'));
+        // Make executable
+        fs.chmodSync(path.join(this.binDir, 'ipfs'), 0o755);
+        // Cleanup
+        fs.unlinkSync(tarPath);
+        fs.rmSync(path.join(this.ipfsDir, 'kubo'), { recursive: true });
+    }
+    /**
+     * Install Kubo on Windows
+     */
+    async installKuboWindows(version) {
+        const downloadUrl = `https://dist.ipfs.tech/kubo/v${version}/kubo_v${version}_windows-amd64.zip`;
+        const zipPath = path.join(this.ipfsDir, 'kubo.zip');
+        logger.info('   Downloading Kubo...');
+        // Download
+        await execAsync(`curl -L -o ${zipPath} ${downloadUrl}`);
+        logger.info('   Extracting...');
+        // Extract (Windows has built-in tar that supports zip)
+        await execAsync(`tar -xf ${zipPath} -C ${this.ipfsDir}`);
+        // Move binary
+        const extractedBinPath = path.join(this.ipfsDir, 'kubo', 'ipfs.exe');
+        fs.mkdirSync(this.binDir, { recursive: true });
+        fs.renameSync(extractedBinPath, path.join(this.binDir, 'ipfs.exe'));
+        // Cleanup
+        fs.unlinkSync(zipPath);
+        fs.rmSync(path.join(this.ipfsDir, 'kubo'), { recursive: true });
+    }
+    /**
+     * Ensure required directories exist
+     */
+    ensureDirectories() {
+        if (!fs.existsSync(this.lshDir)) {
+            fs.mkdirSync(this.lshDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.ipfsDir)) {
+            fs.mkdirSync(this.ipfsDir, { recursive: true });
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lsh-framework",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Simple, cross-platform encrypted secrets manager with automatic sync, IPFS audit logs, and multi-environment support. Just run lsh sync and start managing your secrets.",
   "main": "dist/app.js",
   "bin": {