lsh-framework 3.1.24 → 3.1.26

package/dist/cli.js

@@ -13,6 +13,7 @@ import { registerSyncHistoryCommands } from './commands/sync-history.js';
 import { registerSyncCommands } from './commands/sync.js';
 import { registerMigrateCommand } from './commands/migrate.js';
 import { registerContextCommand } from './commands/context.js';
+import { registerIPFSCommands } from './commands/ipfs.js';
 import { init_secrets } from './services/secrets/secrets.js';
 import { loadGlobalConfigSync } from './lib/config-manager.js';
 import { CLI_TEXT, CLI_HELP } from './constants/ui.js';
@@ -62,6 +63,7 @@ program
     console.log(CLI_HELP.CMD_GET);
     console.log(CLI_HELP.CMD_SET);
     console.log(CLI_HELP.CMD_DELETE);
+    console.log(CLI_HELP.CMD_CP);
     console.log(CLI_HELP.CMD_STATUS);
     console.log('');
     console.log(CLI_HELP.SECTION_IPFS);
@@ -146,6 +148,7 @@ function findSimilarCommands(input, validCommands) {
     registerSyncCommands(program);
     registerMigrateCommand(program);
     registerContextCommand(program);
+    registerIPFSCommands(program);
     // Secrets management (primary feature)
     await init_secrets(program);
     // Shell completion

package/dist/constants/ui.js

@@ -232,6 +232,7 @@ export const CLI_HELP = {
     CMD_GET: '  get <key>               Get a specific secret value (--all for all)',
     CMD_SET: '  set <key> <value>       Set a specific secret value',
     CMD_DELETE: '  delete                  Delete .env file',
+    CMD_CP: '  cp <from> <to>          Copy env variables between files (--name to copy one variable)',
     CMD_STATUS: '  status                  Get detailed secrets status',
     // IPFS commands
     CMD_SYNC_INIT: '  sync init               Full IPFS setup (install, init, start)',

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

@@ -171,6 +171,12 @@ export class IPFSClientManager {
             throw error;
         }
     }
+    /**
+     * Get the IPFS repo path used by lsh
+     */
+    getRepoPath() {
+        return path.join(this.ipfsDir, 'repo');
+    }
     /**
      * Start IPFS daemon
      */
@@ -179,9 +185,23 @@ export class IPFSClientManager {
         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 ipfsRepoPath = this.getRepoPath();
         const ipfsCmd = clientInfo.path || 'ipfs';
+        // Auto-initialize repo if it doesn't exist
+        if (!fs.existsSync(path.join(ipfsRepoPath, 'config'))) {
+            logger.info('🔧 IPFS repository not found, initializing...');
+            try {
+                await execAsync(`${ipfsCmd} init`, {
+                    env: { ...process.env, IPFS_PATH: ipfsRepoPath },
+                });
+                logger.info('✅ IPFS repository initialized');
+            }
+            catch (initError) {
+                const err = initError;
+                throw new Error(`Failed to auto-initialize IPFS repo: ${err.message}`);
+            }
+        }
+        logger.info('🚀 Starting IPFS daemon...');
         try {
             // Start daemon as fully detached background process
             // Using spawn with detached:true and stdio:'ignore' allows parent to exit
@@ -197,6 +217,17 @@ export class IPFSClientManager {
             if (daemon.pid) {
                 fs.writeFileSync(pidPath, daemon.pid.toString(), 'utf8');
             }
+            // Wait for daemon to actually be ready (poll the API)
+            const ready = await this.waitForDaemon(10000);
+            if (!ready) {
+                // Clean up PID file since daemon didn't start
+                if (fs.existsSync(pidPath)) {
+                    fs.unlinkSync(pidPath);
+                }
+                throw new Error('IPFS daemon process started but API is not responding. ' +
+                    'The daemon may have crashed. Check if IPFS repo is properly initialized: ' +
+                    `IPFS_PATH=${ipfsRepoPath}`);
+            }
             logger.info('✅ IPFS daemon started');
             logger.info(`   PID: ${daemon.pid}`);
             logger.info('   API: http://localhost:5001');
@@ -208,6 +239,27 @@ export class IPFSClientManager {
             throw error;
         }
     }
+    /**
+     * Wait for daemon API to become ready
+     */
+    async waitForDaemon(timeoutMs) {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            try {
+                const response = await fetch('http://127.0.0.1:5001/api/v0/id', {
+                    method: 'POST',
+                    signal: AbortSignal.timeout(2000),
+                });
+                if (response.ok)
+                    return true;
+            }
+            catch {
+                // Daemon not ready yet, keep polling
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        return false;
+    }
     /**
      * Stop IPFS daemon
      */

package/dist/lib/ipfs-sync.js

@@ -130,14 +130,16 @@ export class IPFSSync {
     }
     /**
      * Download data from IPFS
-     * Tries local daemon first, then falls back to public gateways
+     * Tries local daemon first (with longer timeout for DHT discovery),
+     * then falls back to public gateways
      */
     async download(cid) {
-        // Try local daemon first (fastest if available)
+        // Try local daemon first — use a longer timeout (60s) because
+        // the local node may need time for DHT content discovery
         try {
             const localResponse = await fetch(`${this.LOCAL_IPFS_API}/cat?arg=${cid}`, {
                 method: 'POST',
-                signal: AbortSignal.timeout(30000),
+                signal: AbortSignal.timeout(60000),
             });
             if (localResponse.ok) {
                 const arrayBuffer = await localResponse.arrayBuffer();

package/dist/services/secrets/secrets.js

@@ -1090,5 +1090,130 @@ API_KEY=
             process.exit(1);
         }
     });
+    // Copy env variables from one file to another
+    program
+        .command('cp <from> <to>')
+        .description('Copy env variables from <from> to <to> (like cp, but for .env files)')
+        .option('--merge', 'Merge into destination instead of overwriting; source takes precedence on conflicts')
+        .option('--no-overwrite', 'With --merge, skip keys that already exist in destination')
+        .option('-n, --name <key>', 'Copy only the specified variable (implies --merge into destination)')
+        .action(async (from, to, options) => {
+        try {
+            const fromPath = path.resolve(from);
+            const toPath = path.resolve(to);
+            if (!fs.existsSync(fromPath)) {
+                console.error(`❌ Source file not found: ${fromPath}`);
+                process.exit(1);
+            }
+            // Parse source file
+            const srcContent = fs.readFileSync(fromPath, 'utf8');
+            const srcLines = srcContent.split('\n');
+            const srcVars = new Map();
+            for (const line of srcLines) {
+                if (line.trim().startsWith('#') || !line.trim())
+                    continue;
+                const match = line.match(/^(?:export\s+)?([^=]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    let value = match[2].trim();
+                    if ((value.startsWith('"') && value.endsWith('"')) ||
+                        (value.startsWith("'") && value.endsWith("'"))) {
+                        value = value.slice(1, -1);
+                    }
+                    srcVars.set(key, value);
+                }
+            }
+            if (srcVars.size === 0) {
+                console.error(`❌ No env variables found in: ${fromPath}`);
+                process.exit(1);
+            }
+            // --name: copy only a single named variable (always merges into destination)
+            if (options.name) {
+                const targetKey = options.name;
+                if (!srcVars.has(targetKey)) {
+                    console.error(`❌ Variable '${targetKey}' not found in ${from}`);
+                    process.exit(1);
+                }
+                const targetValue = srcVars.get(targetKey);
+                await setSingleSecret(toPath, targetKey, targetValue);
+                console.log(`✅ Copied ${targetKey} from ${from} to ${to}`);
+                return;
+            }
+            if (!options.merge) {
+                // Default: overwrite destination entirely (like regular cp)
+                const newLines = [];
+                for (const [key, value] of srcVars.entries()) {
+                    newLines.push(formatEnvLine(key, value, toPath));
+                }
+                fs.writeFileSync(toPath, newLines.join('\n') + '\n', 'utf8');
+                console.log(`✅ Copied ${srcVars.size} variable(s) from ${from} to ${to}`);
+                return;
+            }
+            // Merge mode: apply source vars into destination
+            const noOverwrite = options.overwrite === false;
+            const destLines = [];
+            if (fs.existsSync(toPath)) {
+                const destContent = fs.readFileSync(toPath, 'utf8');
+                for (const line of destContent.split('\n')) {
+                    destLines.push(line);
+                }
+            }
+            // Build merged content: walk destination lines, update/keep keys
+            const processedKeys = new Set();
+            const mergedLines = [];
+            for (const line of destLines) {
+                if (line.trim().startsWith('#') || !line.trim()) {
+                    mergedLines.push(line);
+                    continue;
+                }
+                const match = line.match(/^(?:export\s+)?([^=]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    if (srcVars.has(key)) {
+                        if (noOverwrite) {
+                            mergedLines.push(line);
+                        }
+                        else {
+                            mergedLines.push(formatEnvLine(key, srcVars.get(key), toPath));
+                        }
+                        processedKeys.add(key);
+                    }
+                    else {
+                        mergedLines.push(line);
+                    }
+                }
+                else {
+                    mergedLines.push(line);
+                }
+            }
+            // Append new keys from source not in destination
+            let added = 0;
+            for (const [key, value] of srcVars.entries()) {
+                if (!processedKeys.has(key)) {
+                    mergedLines.push(formatEnvLine(key, value, toPath));
+                    added++;
+                }
+            }
+            let finalContent = mergedLines.join('\n');
+            if (!finalContent.endsWith('\n'))
+                finalContent += '\n';
+            fs.writeFileSync(toPath, finalContent, 'utf8');
+            const updated = srcVars.size - added;
+            const skipped = noOverwrite ? updated : 0;
+            const overwritten = noOverwrite ? 0 : updated;
+            console.log(`✅ Merged ${from} into ${to}:`);
+            if (added > 0)
+                console.log(`   Added:      ${added} new variable(s)`);
+            if (overwritten > 0)
+                console.log(`   Overwritten: ${overwritten} existing variable(s)`);
+            if (skipped > 0)
+                console.log(`   Skipped:    ${skipped} existing variable(s) (--no-overwrite)`);
+        }
+        catch (error) {
+            const err = error;
+            console.error('❌ Failed to copy env file:', err.message);
+            process.exit(1);
+        }
+    });
 }
 export default init_secrets;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lsh-framework",
-  "version": "3.1.24",
+  "version": "3.1.26",
   "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": {