lsh-framework 0.8.2 → 0.9.0

package/dist/lib/secrets-manager.js

@@ -6,7 +6,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'crypto';
 import DatabasePersistence from './database-persistence.js';
-import { createLogger } from './logger.js';
+import { createLogger, LogLevel } from './logger.js';
 import { getGitRepoInfo, hasEnvExample, ensureEnvInGitignore } from './git-utils.js';
 const logger = createLogger('SecretsManager');
 export class SecretsManager {
@@ -66,15 +66,16 @@ export class SecretsManager {
             return decrypted;
         }
         catch (error) {
-            if (error.message.includes('bad decrypt') || error.message.includes('wrong final block length')) {
+            const err = error;
+            if (err.message.includes('bad decrypt') || err.message.includes('wrong final block length')) {
                 throw new Error('Decryption failed. This usually means:\n' +
                     '  1. You need to set LSH_SECRETS_KEY environment variable\n' +
                     '  2. The key must match the one used during encryption\n' +
                     '  3. Generate a shared key with: lsh secrets key\n' +
                     '  4. Add it to your .env: LSH_SECRETS_KEY=<key>\n' +
-                    '\nOriginal error: ' + error.message);
+                    '\nOriginal error: ' + err.message);
             }
-            throw error;
+            throw err;
         }
     }
     /**
@@ -116,10 +117,48 @@ export class SecretsManager {
         })
             .join('\n') + '\n';
     }
+    /**
+     * Detect destructive changes (filled secrets becoming empty)
+     */
+    detectDestructiveChanges(cloudSecrets, localSecrets) {
+        const destructive = [];
+        for (const [key, cloudValue] of Object.entries(cloudSecrets)) {
+            // Only check if key exists in local AND cloud has a non-empty value
+            if (key in localSecrets && cloudValue.trim() !== '') {
+                const localValue = localSecrets[key];
+                // If cloud had value but local is now empty/whitespace - this is destructive
+                if (localValue.trim() === '') {
+                    destructive.push({ key, cloudValue, localValue });
+                }
+            }
+        }
+        return destructive;
+    }
+    /**
+     * Format error message for destructive changes
+     */
+    formatDestructiveChangesError(destructive) {
+        const count = destructive.length;
+        const plural = count === 1 ? 'secret' : 'secrets';
+        let message = `⚠️  Destructive change detected!\n\n`;
+        message += `${count} ${plural} would go from filled → empty:\n\n`;
+        for (const { key, cloudValue } of destructive) {
+            // Mask the value for security (show first 4-5 chars)
+            const preview = cloudValue.length > 5
+                ? cloudValue.substring(0, 5) + '****'
+                : '****';
+            message += `  • ${key}: "${preview}" → "" (empty)\n`;
+        }
+        message += `\nThis is likely unintentional and could break your application.\n\n`;
+        message += `To proceed anyway, use the --force flag:\n`;
+        message += `  lsh lib secrets push --force\n`;
+        message += `  lsh lib secrets sync --force\n`;
+        return message;
+    }
     /**
      * Push local .env to Supabase
      */
-    async push(envFilePath = '.env', environment = 'dev') {
+    async push(envFilePath = '.env', environment = 'dev', force = false) {
         if (!fs.existsSync(envFilePath)) {
             throw new Error(`File not found: ${envFilePath}`);
         }
@@ -138,6 +177,51 @@ export class SecretsManager {
         logger.info(`Pushing ${envFilePath} to Supabase (${environment})...`);
         const content = fs.readFileSync(envFilePath, 'utf8');
         const env = this.parseEnvFile(content);
+        // Check for destructive changes unless force is true
+        if (!force) {
+            try {
+                const jobs = await this.persistence.getActiveJobs();
+                const safeFilename = filename.replace(/[^a-zA-Z0-9._-]/g, '_');
+                const secretsJobs = jobs
+                    .filter(j => {
+                    return j.command === 'secrets_sync' &&
+                        j.job_id.includes(environment) &&
+                        j.job_id.includes(safeFilename);
+                })
+                    .sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime());
+                if (secretsJobs.length > 0) {
+                    const latestSecret = secretsJobs[0];
+                    if (latestSecret.output) {
+                        try {
+                            const decrypted = this.decrypt(latestSecret.output);
+                            const cloudEnv = this.parseEnvFile(decrypted);
+                            const destructive = this.detectDestructiveChanges(cloudEnv, env);
+                            if (destructive.length > 0) {
+                                throw new Error(this.formatDestructiveChangesError(destructive));
+                            }
+                        }
+                        catch (error) {
+                            const err = error;
+                            // If decryption fails, it's a key mismatch - let it proceed
+                            // (will fail later with proper error)
+                            if (!err.message.includes('Destructive change')) {
+                                // Only ignore decryption errors, re-throw destructive change errors
+                                throw err;
+                            }
+                            throw err;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const err = error;
+                // Re-throw any errors (including destructive change errors)
+                if (err.message.includes('Destructive change') || err.message.includes('Decryption failed')) {
+                    throw err;
+                }
+                // Ignore other errors (like connection issues) and proceed
+            }
+        }
         // Encrypt entire .env content
         const encrypted = this.encrypt(content);
         // Include filename in job_id for tracking multiple .env files
@@ -227,7 +311,7 @@ export class SecretsManager {
                 let filename = '.env';
                 if (parts.length >= 4) {
                     // New format with filename
-                    const timestamp = parts[parts.length - 1];
+                    const _timestamp = parts[parts.length - 1];
                     // Reconstruct filename from middle parts
                     const filenameParts = parts.slice(2, -1);
                     if (filenameParts.length > 0) {
@@ -322,13 +406,13 @@ export class SecretsManager {
                         status.cloudKeys = Object.keys(env).length;
                         status.keyMatches = true;
                     }
-                    catch (error) {
+                    catch (_error) {
                         status.keyMatches = false;
                     }
                 }
             }
         }
-        catch (error) {
+        catch (_error) {
             // Cloud check failed, likely no connection
         }
         return status;
@@ -378,6 +462,7 @@ export class SecretsManager {
             return true;
         }
         catch (error) {
+            const err = error;
             logger.error(`Failed to save encryption key: ${error.message}`);
             logger.info('Please set it manually:');
             logger.info(`export LSH_SECRETS_KEY=${key}`);
@@ -414,6 +499,7 @@ LSH_SECRETS_KEY=${this.encryptionKey}
                 return true;
             }
             catch (error) {
+                const err = error;
                 logger.error(`Failed to create ${envFilePath}: ${error.message}`);
                 return false;
             }
@@ -431,6 +517,7 @@ LSH_SECRETS_KEY=${this.encryptionKey}
             return true;
         }
         catch (error) {
+            const err = error;
             logger.error(`Failed to create ${envFilePath}: ${error.message}`);
             return false;
         }
@@ -475,118 +562,162 @@ LSH_SECRETS_KEY=${this.encryptionKey}
      * Smart sync command - automatically set up and synchronize secrets
      * This is the new enhanced sync that does everything automatically
      */
-    async smartSync(envFilePath = '.env', environment = 'dev', autoExecute = true, loadMode = false) {
-        // Use repo-aware environment if in git repo
-        const effectiveEnv = this.getRepoAwareEnvironment(environment);
-        const displayEnv = this.gitInfo?.repoName ? `${this.gitInfo.repoName}/${environment}` : environment;
-        // In load mode, redirect output to stderr so stdout only has export commands
-        const out = loadMode ? console.error : console.log;
-        out(`\n🔍 Smart sync for: ${displayEnv}\n`);
-        // Show git repo context if detected
-        if (this.gitInfo?.isGitRepo) {
-            out('📁 Git Repository:');
-            out(`   Repo: ${this.gitInfo.repoName || 'unknown'}`);
-            if (this.gitInfo.currentBranch) {
-                out(`   Branch: ${this.gitInfo.currentBranch}`);
-            }
-            out();
-        }
-        // Step 1: Ensure encryption key exists
-        if (!process.env.LSH_SECRETS_KEY) {
-            logger.info('🔑 No encryption key found...');
-            await this.ensureEncryptionKey();
-            out();
-        }
-        // Step 2: Ensure .gitignore includes .env
-        if (this.gitInfo?.isGitRepo) {
-            ensureEnvInGitignore(process.cwd());
+    async smartSync(envFilePath = '.env', environment = 'dev', autoExecute = true, loadMode = false, force = false) {
+        // In load mode, suppress all logger output to prevent zsh glob interpretation
+        // Save original level and restore at the end
+        const originalLogLevel = loadMode ? logger['config'].level : undefined;
+        if (loadMode) {
+            logger.setLevel(LogLevel.NONE);
         }
-        // Step 3: Check current status
-        const status = await this.status(envFilePath, effectiveEnv);
-        out('📊 Current Status:');
-        out(`   Encryption key: ${status.keySet ? '✅' : '❌'}`);
-        out(`   Local ${envFilePath}: ${status.localExists ? `✅ (${status.localKeys} keys)` : '❌'}`);
-        out(`   Cloud storage: ${status.cloudExists ? `✅ (${status.cloudKeys} keys)` : '❌'}`);
-        if (status.cloudExists && status.keyMatches !== undefined) {
-            out(`   Key matches: ${status.keyMatches ? '✅' : '❌'}`);
-        }
-        out();
-        // Step 4: Determine action and execute if auto mode
-        let action = 'in-sync';
-        if (status.cloudExists && status.keyMatches === false) {
-            action = 'key-mismatch';
-            out('⚠️  Encryption key mismatch!');
-            out('   The local key does not match the cloud storage.');
-            out('   Please use the original key or push new secrets with:');
-            out(`   lsh lib secrets push -f ${envFilePath} -e ${environment}`);
-            out();
-            return;
-        }
-        if (!status.localExists && !status.cloudExists) {
-            action = 'create-and-push';
-            out('🆕 No secrets found locally or in cloud');
-            out('   Creating new .env file...');
-            if (autoExecute) {
-                await this.createEnvFromExample(envFilePath);
-                out('   Pushing to cloud...');
-                await this.push(envFilePath, effectiveEnv);
+        try {
+            // Use repo-aware environment if in git repo
+            const effectiveEnv = this.getRepoAwareEnvironment(environment);
+            const displayEnv = this.gitInfo?.repoName ? `${this.gitInfo.repoName}/${environment}` : environment;
+            // In load mode, suppress all output except the final export commands
+            const out = loadMode ? () => { } : console.log;
+            out(`\n🔍 Smart sync for: ${displayEnv}\n`);
+            // Show git repo context if detected
+            if (this.gitInfo?.isGitRepo) {
+                out('📁 Git Repository:');
+                out(`   Repo: ${this.gitInfo.repoName || 'unknown'}`);
+                if (this.gitInfo.currentBranch) {
+                    out(`   Branch: ${this.gitInfo.currentBranch}`);
+                }
                 out();
-                out('✅ Setup complete! Edit your .env and run sync again to update.');
-            }
-            else {
-                out('💡 Run: lsh lib secrets create && lsh lib secrets push');
             }
-            out();
-            // Output export commands in load mode
-            if (loadMode && fs.existsSync(envFilePath)) {
-                console.log(this.generateExportCommands(envFilePath));
+            // Step 1: Ensure encryption key exists
+            if (!process.env.LSH_SECRETS_KEY) {
+                logger.info('🔑 No encryption key found...');
+                await this.ensureEncryptionKey();
+                out();
             }
-            return;
-        }
-        if (status.localExists && !status.cloudExists) {
-            action = 'push';
-            out('⬆️  Local .env exists but not in cloud');
-            if (autoExecute) {
-                out('   Pushing to cloud...');
-                await this.push(envFilePath, effectiveEnv);
-                out('✅ Secrets pushed to cloud!');
+            // Step 2: Ensure .gitignore includes .env
+            if (this.gitInfo?.isGitRepo) {
+                ensureEnvInGitignore(process.cwd());
             }
-            else {
-                out(`💡 Run: lsh lib secrets push -f ${envFilePath} -e ${environment}`);
+            // Step 3: Check current status
+            const status = await this.status(envFilePath, effectiveEnv);
+            out('📊 Current Status:');
+            out(`   Encryption key: ${status.keySet ? '✅' : '❌'}`);
+            out(`   Local ${envFilePath}: ${status.localExists ? `✅ (${status.localKeys} keys)` : '❌'}`);
+            out(`   Cloud storage: ${status.cloudExists ? `✅ (${status.cloudKeys} keys)` : '❌'}`);
+            if (status.cloudExists && status.keyMatches !== undefined) {
+                out(`   Key matches: ${status.keyMatches ? '✅' : '❌'}`);
             }
             out();
-            // Output export commands in load mode
-            if (loadMode && fs.existsSync(envFilePath)) {
-                console.log(this.generateExportCommands(envFilePath));
+            // Step 4: Determine action and execute if auto mode
+            let _action = 'in-sync';
+            if (status.cloudExists && status.keyMatches === false) {
+                _action = 'key-mismatch';
+                out('⚠️  Encryption key mismatch!');
+                out('   The local key does not match the cloud storage.');
+                out('   Please use the original key or push new secrets with:');
+                out(`   lsh lib secrets push -f ${envFilePath} -e ${environment}`);
+                out();
+                return;
             }
-            return;
-        }
-        if (!status.localExists && status.cloudExists && status.keyMatches) {
-            action = 'pull';
-            out('⬇️  Cloud secrets available but no local file');
-            if (autoExecute) {
-                out('   Pulling from cloud...');
-                await this.pull(envFilePath, effectiveEnv, false);
-                out('✅ Secrets pulled from cloud!');
+            if (!status.localExists && !status.cloudExists) {
+                _action = 'create-and-push';
+                out('🆕 No secrets found locally or in cloud');
+                out('   Creating new .env file...');
+                if (autoExecute) {
+                    await this.createEnvFromExample(envFilePath);
+                    out('   Pushing to cloud...');
+                    await this.push(envFilePath, effectiveEnv, force);
+                    out();
+                    out('✅ Setup complete! Edit your .env and run sync again to update.');
+                }
+                else {
+                    out('💡 Run: lsh lib secrets create && lsh lib secrets push');
+                }
+                out();
+                // Output export commands in load mode
+                if (loadMode && fs.existsSync(envFilePath)) {
+                    console.log(this.generateExportCommands(envFilePath));
+                }
+                return;
             }
-            else {
-                out(`💡 Run: lsh lib secrets pull -f ${envFilePath} -e ${environment}`);
+            if (status.localExists && !status.cloudExists) {
+                _action = 'push';
+                out('⬆️  Local .env exists but not in cloud');
+                if (autoExecute) {
+                    out('   Pushing to cloud...');
+                    await this.push(envFilePath, effectiveEnv, force);
+                    out('✅ Secrets pushed to cloud!');
+                }
+                else {
+                    out(`💡 Run: lsh lib secrets push -f ${envFilePath} -e ${environment}`);
+                }
+                out();
+                // Output export commands in load mode
+                if (loadMode && fs.existsSync(envFilePath)) {
+                    console.log(this.generateExportCommands(envFilePath));
+                }
+                return;
             }
-            out();
-            // Output export commands in load mode
-            if (loadMode && fs.existsSync(envFilePath)) {
-                console.log(this.generateExportCommands(envFilePath));
+            if (!status.localExists && status.cloudExists && status.keyMatches) {
+                _action = 'pull';
+                out('⬇️  Cloud secrets available but no local file');
+                if (autoExecute) {
+                    out('   Pulling from cloud...');
+                    await this.pull(envFilePath, effectiveEnv, false);
+                    out('✅ Secrets pulled from cloud!');
+                }
+                else {
+                    out(`💡 Run: lsh lib secrets pull -f ${envFilePath} -e ${environment}`);
+                }
+                out();
+                // Output export commands in load mode
+                if (loadMode && fs.existsSync(envFilePath)) {
+                    console.log(this.generateExportCommands(envFilePath));
+                }
+                return;
             }
-            return;
-        }
-        if (status.localExists && status.cloudExists && status.keyMatches) {
-            if (status.localModified && status.cloudModified) {
-                const localNewer = status.localModified > status.cloudModified;
-                const timeDiff = Math.abs(status.localModified.getTime() - status.cloudModified.getTime());
-                const minutesDiff = Math.floor(timeDiff / (1000 * 60));
-                // If difference is less than 1 minute, consider in sync
-                if (minutesDiff < 1) {
-                    out('✅ Local and cloud are in sync!');
+            if (status.localExists && status.cloudExists && status.keyMatches) {
+                if (status.localModified && status.cloudModified) {
+                    const localNewer = status.localModified > status.cloudModified;
+                    const timeDiff = Math.abs(status.localModified.getTime() - status.cloudModified.getTime());
+                    const minutesDiff = Math.floor(timeDiff / (1000 * 60));
+                    // If difference is less than 1 minute, consider in sync
+                    if (minutesDiff < 1) {
+                        out('✅ Local and cloud are in sync!');
+                        out();
+                        if (!loadMode) {
+                            this.showLoadInstructions(envFilePath);
+                        }
+                        else if (fs.existsSync(envFilePath)) {
+                            console.log(this.generateExportCommands(envFilePath));
+                        }
+                        return;
+                    }
+                    if (localNewer) {
+                        _action = 'push';
+                        out('⬆️  Local file is newer than cloud');
+                        out(`   Local: ${status.localModified.toLocaleString()}`);
+                        out(`   Cloud: ${status.cloudModified.toLocaleString()}`);
+                        if (autoExecute) {
+                            out('   Pushing to cloud...');
+                            await this.push(envFilePath, effectiveEnv, force);
+                            out('✅ Secrets synced to cloud!');
+                        }
+                        else {
+                            out(`💡 Run: lsh lib secrets push -f ${envFilePath} -e ${environment}`);
+                        }
+                    }
+                    else {
+                        _action = 'pull';
+                        out('⬇️  Cloud is newer than local file');
+                        out(`   Local: ${status.localModified.toLocaleString()}`);
+                        out(`   Cloud: ${status.cloudModified.toLocaleString()}`);
+                        if (autoExecute) {
+                            out('   Pulling from cloud (backup created)...');
+                            await this.pull(envFilePath, effectiveEnv, false);
+                            out('✅ Secrets synced from cloud!');
+                        }
+                        else {
+                            out(`💡 Run: lsh lib secrets pull -f ${envFilePath} -e ${environment}`);
+                        }
+                    }
                     out();
                     if (!loadMode) {
                         this.showLoadInstructions(envFilePath);
@@ -596,52 +727,22 @@ LSH_SECRETS_KEY=${this.encryptionKey}
                     }
                     return;
                 }
-                if (localNewer) {
-                    action = 'push';
-                    out('⬆️  Local file is newer than cloud');
-                    out(`   Local: ${status.localModified.toLocaleString()}`);
-                    out(`   Cloud: ${status.cloudModified.toLocaleString()}`);
-                    if (autoExecute) {
-                        out('   Pushing to cloud...');
-                        await this.push(envFilePath, effectiveEnv);
-                        out('✅ Secrets synced to cloud!');
-                    }
-                    else {
-                        out(`💡 Run: lsh lib secrets push -f ${envFilePath} -e ${environment}`);
-                    }
-                }
-                else {
-                    action = 'pull';
-                    out('⬇️  Cloud is newer than local file');
-                    out(`   Local: ${status.localModified.toLocaleString()}`);
-                    out(`   Cloud: ${status.cloudModified.toLocaleString()}`);
-                    if (autoExecute) {
-                        out('   Pulling from cloud (backup created)...');
-                        await this.pull(envFilePath, effectiveEnv, false);
-                        out('✅ Secrets synced from cloud!');
-                    }
-                    else {
-                        out(`💡 Run: lsh lib secrets pull -f ${envFilePath} -e ${environment}`);
-                    }
-                }
-                out();
-                if (!loadMode) {
-                    this.showLoadInstructions(envFilePath);
-                }
-                else if (fs.existsSync(envFilePath)) {
-                    console.log(this.generateExportCommands(envFilePath));
-                }
-                return;
+            }
+            // Default: everything is in sync
+            out('✅ Secrets are synchronized!');
+            out();
+            if (!loadMode) {
+                this.showLoadInstructions(envFilePath);
+            }
+            else if (fs.existsSync(envFilePath)) {
+                console.log(this.generateExportCommands(envFilePath));
             }
         }
-        // Default: everything is in sync
-        out('✅ Secrets are synchronized!');
-        out();
-        if (!loadMode) {
-            this.showLoadInstructions(envFilePath);
-        }
-        else if (fs.existsSync(envFilePath)) {
-            console.log(this.generateExportCommands(envFilePath));
+        finally {
+            // Restore original logger level if it was changed
+            if (loadMode && originalLogLevel !== undefined) {
+                logger.setLevel(originalLogLevel);
+            }
         }
     }
     /**

package/dist/lib/zsh-import-manager.js

@@ -124,15 +124,16 @@ export class ZshImportManager {
             return result;
         }
         catch (error) {
+            const err = error;
             this.log({
                 type: 'error',
                 name: 'IMPORT_ERROR',
                 status: 'failed',
-                reason: error.message
+                reason: err.message
             });
             const result = {
                 success: false,
-                message: `Import failed: ${error.message}`,
+                message: `Import failed: ${err.message}`,
                 diagnostics: this.diagnostics,
                 stats: { total: 0, succeeded: 0, failed: 1, skipped: 0, conflicts: 0 },
             };
@@ -280,7 +281,7 @@ export class ZshImportManager {
      */
     async loadExistingItems() {
         // Get existing aliases from context
-        const context = this.executor.context;
+        const context = this.executor.getContext();
         if (context && context.variables) {
             for (const key in context.variables) {
                 if (key.startsWith('alias_')) {
@@ -353,11 +354,12 @@ export class ZshImportManager {
                 stats.succeeded++;
             }
             catch (error) {
+                const err = error;
                 this.log({
                     type: 'alias',
                     name: alias.name,
                     status: 'failed',
-                    reason: error.message,
+                    reason: err.message,
                     source: `line ${alias.line}`,
                 });
                 stats.failed++;
@@ -415,11 +417,12 @@ export class ZshImportManager {
                 stats.succeeded++;
             }
             catch (error) {
+                const err = error;
                 this.log({
                     type: 'export',
                     name: export_.name,
                     status: 'failed',
-                    reason: error.message,
+                    reason: err.message,
                     source: `line ${export_.line}`,
                 });
                 stats.failed++;
@@ -490,11 +493,12 @@ export class ZshImportManager {
                 stats.succeeded++;
             }
             catch (error) {
+                const err = error;
                 this.log({
                     type: 'function',
                     name: func.name,
                     status: 'disabled',
-                    reason: `Parse error: ${error.message}`,
+                    reason: `Parse error: ${err.message}`,
                     source: `line ${func.line}`,
                 });
                 stats.failed++;
@@ -521,11 +525,12 @@ export class ZshImportManager {
                 stats.succeeded++;
             }
             catch (error) {
+                const err = error;
                 this.log({
                     type: 'setopt',
                     name: setopt.option,
                     status: 'disabled',
-                    reason: error.message,
+                    reason: err.message,
                     source: `line ${setopt.line}`,
                 });
                 stats.failed++;
@@ -635,7 +640,8 @@ export class ZshImportManager {
             fs.appendFileSync(this.options.diagnosticLog, logContent + '\n\n', 'utf8');
         }
         catch (error) {
-            console.error(`Failed to write diagnostic log: ${error.message}`);
+            const err = error;
+            console.error(`Failed to write diagnostic log: ${err.message}`);
         }
     }
     /**
@@ -684,7 +690,7 @@ export class ZshImportManager {
             if (diagnostic.status === 'conflict')
                 stats.conflicts++;
             if (!stats.byType[diagnostic.type]) {
-                stats.byType[diagnostic.type] = { total: 0, succeeded: 0, failed: 0, skipped: 0 };
+                stats.byType[diagnostic.type] = { total: 0, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 };
             }
             stats.byType[diagnostic.type].total++;
             if (diagnostic.status === 'success')
@@ -693,6 +699,8 @@ export class ZshImportManager {
                 stats.byType[diagnostic.type].failed++;
             if (diagnostic.status === 'skipped')
                 stats.byType[diagnostic.type].skipped++;
+            if (diagnostic.status === 'conflict')
+                stats.byType[diagnostic.type].conflicts++;
         }
         return stats;
     }

package/dist/pipeline/job-tracker.js

@@ -443,7 +443,7 @@ export class JobTracker extends EventEmitter {
             targetSystem: row.target_system,
             status: row.status,
             priority: row.priority,
-            config: row.config,
+            config: row.config || {},
             parameters: row.parameters,
             cpuRequest: row.cpu_request ? parseFloat(row.cpu_request) : undefined,
             memoryRequest: row.memory_request,