lsh-framework 1.0.0 → 1.2.0

package/README.md

@@ -104,6 +104,34 @@ lsh sync  # Stored as: app1_dev
 
 cd ~/repos/app2
 lsh sync  # Stored as: app2_dev (separate!)
+
+# See what's tracked in the current directory
+lsh info
+```
+
+**Example `lsh info` output:**
+```
+📍 Current Directory Context
+
+📁 Git Repository:
+   Name: myapp
+   Branch: main
+
+🔐 Environment Tracking:
+   Base environment: dev
+   Cloud storage name: myapp_dev
+   Namespace: myapp
+   ℹ️  Repo-based isolation enabled
+
+📄 Local .env File:
+   Keys: 12
+   Has encryption key: ✅
+
+☁️  Cloud Storage:
+   Environment: myapp_dev
+   Keys stored: 12
+   Last updated: 11/6/2025, 10:15:23 PM
+   Key matches: ✅
 ```
 
 No more conflicts between projects using the same environment names!
@@ -179,6 +207,38 @@ lsh pull --env staging  # for testing
 lsh pull --env prod     # for production debugging
 ```
 
+### 📝 Batch Upsert Secrets
+
+**New in v1.1.0:** Pipe environment variables directly into your `.env` file!
+
+```bash
+# Copy all current environment variables
+printenv | lsh set
+
+# Import from another .env file
+cat .env.backup | lsh set
+
+# Import specific variables
+printenv | grep "^AWS_" | lsh set
+
+# Merge multiple sources
+cat .env.base .env.local | lsh set
+
+# From file with --stdin flag
+lsh set --stdin < .env.production
+
+# Single key-value still works
+lsh set API_KEY sk_live_12345
+lsh set DATABASE_URL postgres://localhost/db
+```
+
+**Features:**
+- ✅ Automatic upsert (updates existing, adds new)
+- ✅ Preserves comments and formatting
+- ✅ Handles quoted values
+- ✅ Validates key names
+- ✅ Shows summary of changes
+
 ## Secrets Commands
 
 | Command | Description |
@@ -191,7 +251,12 @@ lsh pull --env prod     # for production debugging
 | `lsh create` | Create new .env file |
 | `lsh delete` | Delete .env file (with confirmation) |
 | `lsh sync` | Smart sync (auto-setup and sync) |
-| `lsh status` | Get detailed secrets status |
+| `lsh status` | Get detailed secrets status (JSON) |
+| `lsh info` | Show current context and tracked environment |
+| `lsh get <key>` | Get a specific secret value |
+| `lsh set <key> <value>` | Set a single secret value |
+| `printenv \| lsh set` | Batch upsert from stdin (pipe) |
+| `lsh set --stdin < file` | Batch upsert from file |
 
 See the complete guide: [SECRETS_GUIDE.md](docs/features/secrets/SECRETS_GUIDE.md)
 

package/dist/services/secrets/secrets.js

@@ -6,6 +6,7 @@ import SecretsManager from '../../lib/secrets-manager.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as readline from 'readline';
+import { getGitRepoInfo } from '../../lib/git-utils.js';
 export async function init_secrets(program) {
     // Push secrets to cloud
     program
@@ -272,6 +273,105 @@ API_KEY=
             process.exit(1);
         }
     });
+    // Info command - show relevant context information
+    program
+        .command('info')
+        .description('Show current directory context and tracked environment')
+        .option('-f, --file <path>', 'Path to .env file', '.env')
+        .option('-e, --env <name>', 'Environment name', 'dev')
+        .action(async (options) => {
+        try {
+            const gitInfo = getGitRepoInfo();
+            const manager = new SecretsManager();
+            const envPath = path.resolve(options.file);
+            console.log('\n📍 Current Directory Context\n');
+            // Git Repository Info
+            if (gitInfo.isGitRepo) {
+                console.log('📁 Git Repository:');
+                console.log(`   Root: ${gitInfo.rootPath || 'unknown'}`);
+                console.log(`   Name: ${gitInfo.repoName || 'unknown'}`);
+                if (gitInfo.currentBranch) {
+                    console.log(`   Branch: ${gitInfo.currentBranch}`);
+                }
+                if (gitInfo.remoteUrl) {
+                    console.log(`   Remote: ${gitInfo.remoteUrl}`);
+                }
+            }
+            else {
+                console.log('📁 Not in a git repository');
+            }
+            console.log('');
+            // Environment Tracking
+            console.log('🔐 Environment Tracking:');
+            // Show the effective environment name used for cloud storage
+            const effectiveEnv = gitInfo.repoName
+                ? `${gitInfo.repoName}_${options.env}`
+                : options.env;
+            console.log(`   Base environment: ${options.env}`);
+            console.log(`   Cloud storage name: ${effectiveEnv}`);
+            if (gitInfo.repoName) {
+                console.log(`   Namespace: ${gitInfo.repoName}`);
+                console.log('   ℹ️  Repo-based isolation enabled');
+            }
+            else {
+                console.log('   Namespace: (none - not in git repo)');
+                console.log('   ⚠️  No isolation - shared environment name');
+            }
+            console.log('');
+            // Local File Status
+            console.log('📄 Local .env File:');
+            if (fs.existsSync(envPath)) {
+                const content = fs.readFileSync(envPath, 'utf8');
+                const lines = content.split('\n').filter(line => {
+                    const trimmed = line.trim();
+                    return trimmed && !trimmed.startsWith('#') && trimmed.includes('=');
+                });
+                console.log(`   Path: ${envPath}`);
+                console.log(`   Keys: ${lines.length}`);
+                console.log(`   Size: ${Math.round(content.length / 1024 * 10) / 10} KB`);
+                // Check for encryption key
+                const hasKey = content.includes('LSH_SECRETS_KEY=');
+                console.log(`   Has encryption key: ${hasKey ? '✅' : '❌'}`);
+            }
+            else {
+                console.log(`   Path: ${envPath}`);
+                console.log('   Status: ❌ Not found');
+            }
+            console.log('');
+            // Cloud Status
+            console.log('☁️  Cloud Storage:');
+            try {
+                const status = await manager.status(options.file, options.env);
+                if (status.cloudExists) {
+                    console.log(`   Environment: ${effectiveEnv}`);
+                    console.log(`   Keys stored: ${status.cloudKeys}`);
+                    console.log(`   Last updated: ${status.cloudModified ? new Date(status.cloudModified).toLocaleString() : 'unknown'}`);
+                    if (status.keyMatches !== undefined) {
+                        console.log(`   Key matches: ${status.keyMatches ? '✅' : '❌ MISMATCH'}`);
+                    }
+                }
+                else {
+                    console.log(`   Environment: ${effectiveEnv}`);
+                    console.log('   Status: ❌ Not synced yet');
+                }
+            }
+            catch (_error) {
+                console.log('   Status: ⚠️  Unable to check (Supabase not configured)');
+            }
+            console.log('');
+            // Quick Actions
+            console.log('💡 Quick Actions:');
+            console.log(`   Push:  lsh push --env ${options.env}`);
+            console.log(`   Pull:  lsh pull --env ${options.env}`);
+            console.log(`   Sync:  lsh sync --env ${options.env}`);
+            console.log('');
+        }
+        catch (error) {
+            const err = error;
+            console.error('❌ Failed to get info:', err.message);
+            process.exit(1);
+        }
+    });
     // Get a specific secret value
     program
         .command('get [key]')
@@ -351,52 +451,31 @@ API_KEY=
             process.exit(1);
         }
     });
-    // Set a specific secret value
+    // Set a specific secret value or batch upsert from stdin
     program
-        .command('set <key> <value>')
-        .description('Set a specific secret value in .env file')
+        .command('set [key] [value]')
+        .description('Set a specific secret value in .env file, or batch upsert from stdin (KEY=VALUE format)')
         .option('-f, --file <path>', 'Path to .env file', '.env')
+        .option('--stdin', 'Read KEY=VALUE pairs from stdin (one per line)')
         .action(async (key, value, options) => {
         try {
             const envPath = path.resolve(options.file);
-            // Validate key format
-            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-                console.error(`❌ Invalid key format: ${key}. Must be a valid environment variable name.`);
-                process.exit(1);
+            // Check if we should read from stdin
+            const isStdin = options.stdin || (!key && !value);
+            if (isStdin) {
+                // Batch mode: read from stdin
+                await batchSetSecrets(envPath);
             }
-            let content = '';
-            let found = false;
-            if (fs.existsSync(envPath)) {
-                content = fs.readFileSync(envPath, 'utf8');
-                const lines = content.split('\n');
-                const newLines = [];
-                for (const line of lines) {
-                    if (line.trim().startsWith('#') || !line.trim()) {
-                        newLines.push(line);
-                        continue;
-                    }
-                    const match = line.match(/^([^=]+)=(.*)$/);
-                    if (match && match[1].trim() === key) {
-                        // Quote values with spaces or special characters
-                        const needsQuotes = /[\s#]/.test(value);
-                        const quotedValue = needsQuotes ? `"${value}"` : value;
-                        newLines.push(`${key}=${quotedValue}`);
-                        found = true;
-                    }
-                    else {
-                        newLines.push(line);
-                    }
+            else {
+                // Single mode: set one key-value pair
+                if (!key || value === undefined) {
+                    console.error('❌ Usage: lsh set <key> <value>');
+                    console.error('   Or pipe input: printenv | lsh set');
+                    console.error('   Or use stdin: lsh set --stdin < file.env');
+                    process.exit(1);
                 }
-                content = newLines.join('\n');
-            }
-            // If key wasn't found, append it
-            if (!found) {
-                const needsQuotes = /[\s#]/.test(value);
-                const quotedValue = needsQuotes ? `"${value}"` : value;
-                content = content.trimRight() + `\n${key}=${quotedValue}\n`;
+                await setSingleSecret(envPath, key, value);
             }
-            fs.writeFileSync(envPath, content, 'utf8');
-            console.log(`✅ Set ${key} in ${options.file}`);
         }
         catch (error) {
             const err = error;
@@ -404,6 +483,199 @@ API_KEY=
             process.exit(1);
         }
     });
+    /**
+     * Set a single secret value
+     */
+    async function setSingleSecret(envPath, key, value) {
+        // Validate key format
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+            console.error(`❌ Invalid key format: ${key}. Must be a valid environment variable name.`);
+            process.exit(1);
+        }
+        let content = '';
+        let found = false;
+        if (fs.existsSync(envPath)) {
+            content = fs.readFileSync(envPath, 'utf8');
+            const lines = content.split('\n');
+            const newLines = [];
+            for (const line of lines) {
+                if (line.trim().startsWith('#') || !line.trim()) {
+                    newLines.push(line);
+                    continue;
+                }
+                const match = line.match(/^([^=]+)=(.*)$/);
+                if (match && match[1].trim() === key) {
+                    // Quote values with spaces or special characters
+                    const needsQuotes = /[\s#]/.test(value);
+                    const quotedValue = needsQuotes ? `"${value}"` : value;
+                    newLines.push(`${key}=${quotedValue}`);
+                    found = true;
+                }
+                else {
+                    newLines.push(line);
+                }
+            }
+            content = newLines.join('\n');
+        }
+        // If key wasn't found, append it
+        if (!found) {
+            const needsQuotes = /[\s#]/.test(value);
+            const quotedValue = needsQuotes ? `"${value}"` : value;
+            content = content.trimRight() + `\n${key}=${quotedValue}\n`;
+        }
+        fs.writeFileSync(envPath, content, 'utf8');
+        console.log(`✅ Set ${key}`);
+    }
+    /**
+     * Batch upsert secrets from stdin
+     */
+    async function batchSetSecrets(envPath) {
+        return new Promise((resolve, reject) => {
+            let inputData = '';
+            const stdin = process.stdin;
+            // Check if stdin is a TTY (interactive terminal)
+            if (stdin.isTTY) {
+                console.error('❌ No input provided. Please pipe data or use --stdin flag.');
+                console.error('');
+                console.error('Examples:');
+                console.error('  printenv | lsh set');
+                console.error('  lsh set --stdin < .env.backup');
+                console.error('  echo "API_KEY=secret123" | lsh set');
+                process.exit(1);
+            }
+            stdin.setEncoding('utf8');
+            stdin.on('data', (chunk) => {
+                inputData += chunk;
+            });
+            stdin.on('end', () => {
+                try {
+                    const lines = inputData.split('\n').filter(line => line.trim());
+                    if (lines.length === 0) {
+                        console.error('❌ No valid KEY=VALUE pairs found in input');
+                        process.exit(1);
+                    }
+                    // Read existing .env file
+                    let content = '';
+                    const existingKeys = new Map();
+                    if (fs.existsSync(envPath)) {
+                        content = fs.readFileSync(envPath, 'utf8');
+                        const existingLines = content.split('\n');
+                        for (const line of existingLines) {
+                            if (line.trim().startsWith('#') || !line.trim())
+                                continue;
+                            const match = line.match(/^([^=]+)=(.*)$/);
+                            if (match) {
+                                existingKeys.set(match[1].trim(), line);
+                            }
+                        }
+                    }
+                    const updates = [];
+                    const errors = [];
+                    const newKeys = new Map();
+                    // Parse input lines
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        // Skip comments and empty lines
+                        if (trimmed.startsWith('#') || !trimmed)
+                            continue;
+                        // Parse KEY=VALUE format
+                        const match = trimmed.match(/^([^=]+)=(.*)$/);
+                        if (!match) {
+                            errors.push(`Invalid format: ${trimmed}`);
+                            continue;
+                        }
+                        const key = match[1].trim();
+                        let value = match[2].trim();
+                        // Validate key format
+                        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+                            errors.push(`Invalid key format: ${key}`);
+                            continue;
+                        }
+                        // Remove surrounding quotes if present
+                        if ((value.startsWith('"') && value.endsWith('"')) ||
+                            (value.startsWith("'") && value.endsWith("'"))) {
+                            value = value.slice(1, -1);
+                        }
+                        // Track if this is an update or addition
+                        const action = existingKeys.has(key) ? 'updated' : 'added';
+                        updates.push({ key, value, action });
+                        newKeys.set(key, value);
+                    }
+                    // Build new content
+                    const newLines = [];
+                    let hasContent = false;
+                    if (fs.existsSync(envPath)) {
+                        const existingLines = content.split('\n');
+                        for (const line of existingLines) {
+                            if (line.trim().startsWith('#') || !line.trim()) {
+                                newLines.push(line);
+                                continue;
+                            }
+                            const match = line.match(/^([^=]+)=(.*)$/);
+                            if (match) {
+                                const key = match[1].trim();
+                                if (newKeys.has(key)) {
+                                    // Update existing key
+                                    const value = newKeys.get(key);
+                                    const needsQuotes = /[\s#]/.test(value);
+                                    const quotedValue = needsQuotes ? `"${value}"` : value;
+                                    newLines.push(`${key}=${quotedValue}`);
+                                    newKeys.delete(key); // Mark as processed
+                                    hasContent = true;
+                                }
+                                else {
+                                    // Keep existing line
+                                    newLines.push(line);
+                                    hasContent = true;
+                                }
+                            }
+                            else {
+                                newLines.push(line);
+                            }
+                        }
+                    }
+                    // Add new keys that weren't in the existing file
+                    for (const [key, value] of newKeys.entries()) {
+                        const needsQuotes = /[\s#]/.test(value);
+                        const quotedValue = needsQuotes ? `"${value}"` : value;
+                        if (hasContent) {
+                            newLines.push(`${key}=${quotedValue}`);
+                        }
+                        else {
+                            newLines.push(`${key}=${quotedValue}`);
+                            hasContent = true;
+                        }
+                    }
+                    // Write updated content
+                    let finalContent = newLines.join('\n');
+                    if (hasContent && !finalContent.endsWith('\n')) {
+                        finalContent += '\n';
+                    }
+                    fs.writeFileSync(envPath, finalContent, 'utf8');
+                    // Report results
+                    const added = updates.filter(u => u.action === 'added').length;
+                    const updated = updates.filter(u => u.action === 'updated').length;
+                    console.log(`✅ Batch upsert complete:`);
+                    if (added > 0)
+                        console.log(`   Added: ${added} key(s)`);
+                    if (updated > 0)
+                        console.log(`   Updated: ${updated} key(s)`);
+                    if (errors.length > 0) {
+                        console.log('');
+                        console.log('⚠️  Skipped invalid entries:');
+                        errors.forEach(err => console.log(`   ${err}`));
+                    }
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            stdin.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
     // Delete .env file with confirmation
     program
         .command('delete')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lsh-framework",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Encrypted secrets manager with automatic rotation, team sync, and multi-environment support. Built on a powerful shell with daemon scheduling and CI/CD integration.",
   "main": "dist/app.js",
   "bin": {