lsh-framework 2.3.0 → 2.3.2

package/dist/lib/ipfs-secrets-storage.js

@@ -108,8 +108,43 @@ export class IPFSSecretsStorage {
         try {
             const metadataKey = this.getMetadataKey(gitRepo, environment);
             let metadata = this.metadata[metadataKey];
+            // Construct display name for error messages
+            const displayEnv = gitRepo
+                ? (environment ? `${gitRepo}_${environment}` : gitRepo)
+                : (environment || 'default');
+            // If no local metadata, try to fetch from Storacha registry first (for git repos)
+            if (!metadata && gitRepo) {
+                try {
+                    const storacha = getStorachaClient();
+                    if (storacha.isEnabled() && await storacha.isAuthenticated()) {
+                        logger.info(`   🔍 No local metadata found, checking Storacha registry...`);
+                        const latestCid = await storacha.getLatestCID(gitRepo);
+                        if (latestCid) {
+                            logger.info(`   ✅ Found secrets in registry (CID: ${latestCid})`);
+                            // Create metadata from registry
+                            metadata = {
+                                environment,
+                                git_repo: gitRepo,
+                                cid: latestCid,
+                                timestamp: new Date().toISOString(),
+                                keys_count: 0, // Unknown until decrypted
+                                encrypted: true,
+                            };
+                            this.metadata[metadataKey] = metadata;
+                            this.saveMetadata();
+                        }
+                    }
+                }
+                catch (error) {
+                    // Registry check failed, continue to error
+                    const err = error;
+                    logger.debug(`   Registry check failed: ${err.message}`);
+                }
+            }
             if (!metadata) {
-                throw new Error(`No secrets found for environment: ${environment}`);
+                throw new Error(`No secrets found for environment: ${displayEnv}\n\n` +
+                    `💡 Tip: Check available environments with: lsh env\n` +
+                    `   Or push secrets first with: lsh push`);
             }
             // Check if there's a newer version in the registry (for git repos)
             if (gitRepo) {
@@ -253,7 +288,7 @@ export class IPFSSecretsStorage {
     /**
      * Store encrypted data locally
      */
-    async storeLocally(cid, encryptedData, environment) {
+    async storeLocally(cid, encryptedData, _environment) {
         const cachePath = path.join(this.cacheDir, `${cid}.encrypted`);
         fs.writeFileSync(cachePath, encryptedData, 'utf8');
         logger.debug(`Cached secrets locally: ${cachePath}`);

package/dist/lib/secrets-manager.js

@@ -282,7 +282,7 @@ export class SecretsManager {
                 `   Or push secrets first with: lsh push --env ${environment}`);
         }
         // Preserve local LSH-internal keys before overwriting
-        let localLshKeys = {};
+        const localLshKeys = {};
         if (fs.existsSync(envFilePath)) {
             const existingContent = fs.readFileSync(envFilePath, 'utf8');
             const existingEnv = this.parseEnvFile(existingContent);

package/dist/lib/storacha-client.js

@@ -244,12 +244,24 @@ export class StorachaClient {
         if (!await this.isAuthenticated()) {
             throw new Error('Not authenticated');
         }
+        // Get the latest registry version and increment it
+        let registryVersion = 1;
+        try {
+            const latestRegistry = await this.getLatestRegistry(repoName);
+            if (latestRegistry && latestRegistry.registryVersion) {
+                registryVersion = latestRegistry.registryVersion + 1;
+            }
+        }
+        catch (err) {
+            logger.debug(`Could not fetch latest registry version, using version 1: ${err.message}`);
+        }
         const registry = {
             repoName,
             environment,
             cid: secretsCid, // Include the secrets CID
             timestamp: new Date().toISOString(),
-            version: '2.2.2',
+            version: '2.3.0', // LSH version
+            registryVersion, // Incremental version counter
         };
         const content = JSON.stringify(registry, null, 2);
         const buffer = Buffer.from(content, 'utf-8');
@@ -259,7 +271,7 @@ export class StorachaClient {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const file = new File([uint8Array], filename, { type: 'application/json' });
         const cid = await client.uploadFile(file);
-        logger.debug(`📝 Uploaded registry for ${repoName} (secrets CID: ${secretsCid}): ${cid}`);
+        logger.debug(`📝 Uploaded registry v${registryVersion} for ${repoName} (secrets CID: ${secretsCid}): ${cid}`);
         return cid.toString();
     }
     /**
@@ -303,6 +315,7 @@ export class StorachaClient {
                             cid: cid,
                             timestamp: json.timestamp,
                             secretsCid: json.cid,
+                            registryVersion: json.registryVersion || 0, // Default to 0 for old registries without version
                         });
                     }
                 }
@@ -311,11 +324,18 @@ export class StorachaClient {
                     continue;
                 }
             }
-            // Sort by timestamp (newest first) and return the most recent secrets CID
+            // Sort by registryVersion (highest first), then timestamp as tie-breaker
             if (registries.length > 0) {
-                registries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+                registries.sort((a, b) => {
+                    // First compare by registryVersion (higher is newer)
+                    if (b.registryVersion !== a.registryVersion) {
+                        return b.registryVersion - a.registryVersion;
+                    }
+                    // If versions match, use timestamp as tie-breaker
+                    return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+                });
                 const latest = registries[0];
-                logger.debug(`✅ Found latest CID for ${repoName}: ${latest.secretsCid} (timestamp: ${latest.timestamp})`);
+                logger.debug(`✅ Found latest CID for ${repoName}: ${latest.secretsCid} (v${latest.registryVersion}, timestamp: ${latest.timestamp})`);
                 return latest.secretsCid;
             }
             // No registry found
@@ -327,6 +347,76 @@ export class StorachaClient {
             return null;
         }
     }
+    /**
+     * Get the latest registry object for a repo
+     * Returns the full registry object including registryVersion
+     */
+    async getLatestRegistry(repoName) {
+        if (!this.isEnabled()) {
+            return null;
+        }
+        if (!await this.isAuthenticated()) {
+            return null;
+        }
+        try {
+            const client = await this.getClient();
+            // Only check recent uploads (limit to 20 for performance)
+            const pageSize = 20;
+            // Get first page of uploads
+            const results = await client.capability.upload.list({
+                cursor: '',
+                size: pageSize,
+            });
+            // Collect all registry files for this repo
+            const registries = [];
+            for (const upload of results.results) {
+                try {
+                    const cid = upload.root.toString();
+                    // Download with timeout
+                    const downloadPromise = this.download(cid);
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000));
+                    const content = await Promise.race([downloadPromise, timeoutPromise]);
+                    // Skip large files (registry should be < 1KB)
+                    if (content.length > 1024) {
+                        continue;
+                    }
+                    // Try to parse as JSON
+                    const json = JSON.parse(content.toString('utf-8'));
+                    // Check if it's an LSH registry file for our repo
+                    if (json.repoName === repoName && json.version && json.cid && json.timestamp) {
+                        registries.push({
+                            repoName: json.repoName,
+                            environment: json.environment,
+                            cid: json.cid,
+                            timestamp: json.timestamp,
+                            version: json.version,
+                            registryVersion: json.registryVersion || 0,
+                        });
+                    }
+                }
+                catch {
+                    // Not an LSH registry file or failed to download
+                    continue;
+                }
+            }
+            // Sort by registryVersion (highest first), then timestamp as tie-breaker
+            if (registries.length > 0) {
+                registries.sort((a, b) => {
+                    if (b.registryVersion !== a.registryVersion) {
+                        return b.registryVersion - a.registryVersion;
+                    }
+                    return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+                });
+                return registries[0];
+            }
+            return null;
+        }
+        catch (error) {
+            const err = error;
+            logger.debug(`Failed to get latest registry: ${err.message}`);
+            return null;
+        }
+    }
     /**
      * Check if registry exists for a repo by listing uploads
      * Returns true if a registry file for this repo exists in Storacha

package/dist/services/lib/lib.js

@@ -18,53 +18,6 @@ export async function loadCommands() {
     const cmdMap = await parseCommands(files);
     return cmdMap;
 }
-async function _makeCommand(commander) {
-    const _commands = await loadCommands();
-    commander.command("jug").action(() => {
-        console.log("heat jug");
-    });
-    commander.command("pot").action(() => {
-        console.log("heat pot");
-    });
-    return commander;
-}
-// export async function init_lib_cmd(program: Command) {
-//   const brew = program.command("lib");
-//   // const commands = await loadCommands();
-//   // await set(lsh.commands, commands);
-//   brew.command("tea").action(() => {
-//     console.log("brew tea");
-//   });
-//   brew.command("coffee").action(() => {
-//     console.log("brew coffee");
-//   });
-//   await makeCommand(brew);
-//   // for (let c in commands) {
-//   //   brew.command(c).action(() => console.log(c));
-//   // }
-//   // .command("lib").description("lsh lib commands");
-//   // lib
-//   // .showHelpAfterError(true)
-//   // .showSuggestionAfterError(true);
-//   // const commands = await loadCommands();
-//   // set(lsh.commands, commands);
-//   // for (const [key, value] of Object.entries(get(lsh.commands))) {
-//   //   // console.log(`${key} : ${value}`);
-//   //   lib.command(key).action(() => {console.log(value)});
-//   // };
-//   // .action(async (type: String, action: String, spec: Spec) => {
-//   //   const commands = await loadCommands();
-//   //   set(lsh.commands, commands);
-//   //   switch (type) {
-//   //     case "ls":
-//   //       // console.log("lsh called");
-//   //       // console.log(get(lsh.commands)['rand']());
-//   //       break;
-//   //     default:
-//   //       console.log("default");
-//   //   }
-//   // });
-// }
 export async function init_lib(program) {
     const lib = program
         .command("lib")

package/dist/services/secrets/secrets.js

@@ -842,5 +842,208 @@ API_KEY=
             process.exit(1);
         }
     });
+    // Clear stuck registries and local metadata
+    program
+        .command('clear')
+        .description('Clear local metadata and cache to resolve stuck registries')
+        .option('--repo <name>', 'Clear metadata for specific repo only')
+        .option('--cache', 'Also clear local encrypted secrets cache')
+        .option('--storacha', 'Also delete old Storacha uploads (registries and secrets)')
+        .option('--all', 'Clear all metadata and cache (requires confirmation)')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (options) => {
+        try {
+            const lshDir = path.join(process.env.HOME || process.env.USERPROFILE || '', '.lsh');
+            const metadataPath = path.join(lshDir, 'secrets-metadata.json');
+            const cacheDir = path.join(lshDir, 'secrets-cache');
+            // Determine what we're clearing
+            if (!options.repo && !options.all) {
+                console.error('❌ Please specify either --repo <name> or --all');
+                console.log('');
+                console.log('Examples:');
+                console.log('  lsh clear --repo lsh_test_repo    # Clear metadata for specific repo');
+                console.log('  lsh clear --all                    # Clear all metadata');
+                console.log('  lsh clear --all --cache            # Clear metadata and cache');
+                process.exit(1);
+            }
+            // Load metadata
+            if (!fs.existsSync(metadataPath)) {
+                console.log('ℹ️  No metadata file found - nothing to clear');
+                return;
+            }
+            const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+            const keys = Object.keys(metadata);
+            if (keys.length === 0) {
+                console.log('ℹ️  Metadata is already empty');
+                return;
+            }
+            // Show what will be cleared
+            console.log('📋 Current metadata entries:');
+            console.log('');
+            if (options.repo) {
+                const repoKeys = keys.filter(k => metadata[k].git_repo === options.repo);
+                if (repoKeys.length === 0) {
+                    console.log(`ℹ️  No metadata found for repo: ${options.repo}`);
+                    return;
+                }
+                console.log(`Repo: ${options.repo}`);
+                repoKeys.forEach(key => {
+                    console.log(`  - ${key} (CID: ${metadata[key].cid.substring(0, 12)}...)`);
+                });
+                console.log('');
+                console.log(`Will clear ${repoKeys.length} ${repoKeys.length === 1 ? 'entry' : 'entries'}`);
+            }
+            else {
+                const repoCount = new Set(keys.map(k => metadata[k].git_repo)).size;
+                console.log(`Total entries: ${keys.length} across ${repoCount} ${repoCount === 1 ? 'repo' : 'repos'}`);
+            }
+            if (options.cache) {
+                if (fs.existsSync(cacheDir)) {
+                    const cacheFiles = fs.readdirSync(cacheDir);
+                    console.log(`Cache files: ${cacheFiles.length}`);
+                }
+            }
+            console.log('');
+            // Confirmation
+            if (!options.yes) {
+                console.log('⚠️  WARNING: This will clear local metadata!');
+                console.log('');
+                console.log('This is useful when:');
+                console.log('  • Registry is returning stale/old CIDs');
+                console.log('  • Pull fails with "bad decrypt" errors');
+                console.log('  • You need to force a fresh sync');
+                console.log('');
+                console.log('After clearing, you will need to push secrets again.');
+                console.log('');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question('Continue? (yes/no): ', (ans) => {
+                        rl.close();
+                        resolve(ans.trim().toLowerCase());
+                    });
+                });
+                if (answer !== 'yes' && answer !== 'y') {
+                    console.log('');
+                    console.log('❌ Cancelled');
+                    return;
+                }
+            }
+            console.log('');
+            // Clear metadata
+            if (options.repo) {
+                const repoKeys = keys.filter(k => metadata[k].git_repo === options.repo);
+                repoKeys.forEach(key => delete metadata[key]);
+                fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+                console.log(`✅ Cleared ${repoKeys.length} metadata ${repoKeys.length === 1 ? 'entry' : 'entries'} for ${options.repo}`);
+            }
+            else {
+                fs.writeFileSync(metadataPath, '{}');
+                console.log(`✅ Cleared all ${keys.length} metadata ${keys.length === 1 ? 'entry' : 'entries'}`);
+            }
+            // Clear cache if requested
+            if (options.cache && fs.existsSync(cacheDir)) {
+                const cacheFiles = fs.readdirSync(cacheDir);
+                let cleared = 0;
+                for (const file of cacheFiles) {
+                    const filePath = path.join(cacheDir, file);
+                    if (fs.statSync(filePath).isFile()) {
+                        fs.unlinkSync(filePath);
+                        cleared++;
+                    }
+                }
+                console.log(`✅ Cleared ${cleared} cache ${cleared === 1 ? 'file' : 'files'}`);
+            }
+            // Clear Storacha uploads if requested
+            if (options.storacha && options.repo) {
+                console.log('');
+                console.log('🌐 Clearing Storacha uploads...');
+                try {
+                    const { StorachaClient } = await import('../../lib/storacha-client.js');
+                    const storacha = new StorachaClient();
+                    if (!storacha.isEnabled()) {
+                        console.log('ℹ️  Storacha is not enabled - skipping cloud cleanup');
+                    }
+                    else if (!(await storacha.isAuthenticated())) {
+                        console.log('ℹ️  Not authenticated with Storacha - skipping cloud cleanup');
+                    }
+                    else {
+                        // Get all uploads
+                        const client = await storacha.getClient();
+                        const pageSize = 50;
+                        const results = await client.capability.upload.list({
+                            cursor: '',
+                            size: pageSize,
+                        });
+                        // Find LSH-related uploads for this repo
+                        const toDelete = [];
+                        for (const upload of results.results) {
+                            try {
+                                const cid = upload.root.toString();
+                                // Download with timeout
+                                const downloadPromise = storacha.download(cid);
+                                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000));
+                                const content = await Promise.race([downloadPromise, timeoutPromise]);
+                                // Check if it's a registry file for this repo
+                                if (content.length < 2048) {
+                                    try {
+                                        const json = JSON.parse(content.toString('utf-8'));
+                                        if (json.repoName === options.repo) {
+                                            toDelete.push({ cid, type: 'registry', size: content.length });
+                                        }
+                                    }
+                                    catch {
+                                        // Not JSON, might be encrypted secrets
+                                        // Check filename pattern
+                                        const _filename = `lsh-secrets-${options.repo}`;
+                                        if (cid.includes(options.repo) || content.toString().includes(options.repo)) {
+                                            toDelete.push({ cid, type: 'secrets', size: content.length });
+                                        }
+                                    }
+                                }
+                            }
+                            catch {
+                                // Failed to download or parse, skip
+                                continue;
+                            }
+                        }
+                        if (toDelete.length > 0) {
+                            console.log(`Found ${toDelete.length} Storacha ${toDelete.length === 1 ? 'upload' : 'uploads'} for ${options.repo}:`);
+                            toDelete.forEach((item) => {
+                                console.log(`  - ${item.type}: ${item.cid.substring(0, 16)}... (${item.size} bytes)`);
+                            });
+                            // Note: Storacha doesn't currently support deletion via SDK
+                            // The uploads will remain but won't be used after metadata is cleared
+                            console.log('');
+                            console.log('⚠️  Note: Storacha uploads cannot be deleted programmatically.');
+                            console.log('   These files will remain in Storacha but won\'t be used after metadata is cleared.');
+                            console.log('   To fully remove them, use the Storacha web console:');
+                            console.log('   https://console.storacha.network/');
+                        }
+                        else {
+                            console.log(`ℹ️  No Storacha uploads found for ${options.repo}`);
+                        }
+                    }
+                }
+                catch (storageError) {
+                    const storErr = storageError;
+                    console.error(`⚠️  Failed to check Storacha uploads: ${storErr.message}`);
+                    console.log('   Local metadata has been cleared, but cloud uploads may remain.');
+                }
+            }
+            console.log('');
+            console.log('💡 Next steps:');
+            console.log('   1. lsh push .env     # Push secrets with current key');
+            console.log('   2. lsh pull .env     # Verify pull works');
+            console.log('');
+        }
+        catch (error) {
+            const err = error;
+            console.error('❌ Failed to clear metadata:', err.message);
+            process.exit(1);
+        }
+    });
 }
 export default init_secrets;

package/package.json

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