lsh-framework 3.1.24 → 3.1.25

package/dist/cli.js

@@ -62,6 +62,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);

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/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.25",
   "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": {