@eldrforge/kodrdriv 0.1.0 → 1.2.1

package/dist/util/interactive.js

@@ -5,6 +5,19 @@ import * as path from 'path';
 import * as os from 'os';
 import * as fs from 'fs/promises';
 
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 /**
  * Get user choice interactively from terminal input
  * @param prompt The prompt message to display
@@ -32,54 +45,179 @@ import * as fs from 'fs/promises';
         }
         return 's'; // Default to skip
     }
-    return new Promise((resolve)=>{
-        // Ensure stdin is referenced so the process doesn't exit while waiting for input
-        if (typeof process.stdin.ref === 'function') {
-            process.stdin.ref();
-        }
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.on('data', (key)=>{
-            const keyStr = key.toString().toLowerCase();
-            const choice = choices.find((c)=>c.key === keyStr);
-            if (choice) {
-                process.stdin.setRawMode(false);
+    return new Promise((resolve, reject)=>{
+        let isResolved = false;
+        let dataHandler = null;
+        let errorHandler = null;
+        const cleanup = ()=>{
+            if (dataHandler) {
+                process.stdin.removeListener('data', dataHandler);
+            }
+            if (errorHandler) {
+                process.stdin.removeListener('error', errorHandler);
+            }
+            try {
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                }
                 process.stdin.pause();
                 // Detach stdin again now that we're done
                 if (typeof process.stdin.unref === 'function') {
                     process.stdin.unref();
                 }
-                logger.info(`Selected: ${choice.label}\n`);
-                resolve(choice.key);
+            } catch  {
+            // Ignore cleanup errors
             }
-        });
+        };
+        const safeResolve = (value)=>{
+            if (!isResolved) {
+                isResolved = true;
+                cleanup();
+                resolve(value);
+            }
+        };
+        const safeReject = (error)=>{
+            if (!isResolved) {
+                isResolved = true;
+                cleanup();
+                reject(error);
+            }
+        };
+        try {
+            // Ensure stdin is referenced so the process doesn't exit while waiting for input
+            if (typeof process.stdin.ref === 'function') {
+                process.stdin.ref();
+            }
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            dataHandler = (key)=>{
+                try {
+                    const keyStr = key.toString().toLowerCase();
+                    const choice = choices.find((c)=>c.key === keyStr);
+                    if (choice) {
+                        logger.info(`Selected: ${choice.label}\n`);
+                        safeResolve(choice.key);
+                    }
+                } catch (error) {
+                    safeReject(error instanceof Error ? error : new Error('Unknown error processing input'));
+                }
+            };
+            errorHandler = (error)=>{
+                safeReject(error);
+            };
+            process.stdin.on('data', dataHandler);
+            process.stdin.on('error', errorHandler);
+        } catch (error) {
+            safeReject(error instanceof Error ? error : new Error('Failed to setup input handlers'));
+        }
     });
 }
 /**
- * Create a secure temporary file for editing with proper permissions
- * @param prefix Prefix for the temporary filename
- * @param extension File extension (e.g., '.txt', '.md')
- * @returns Promise resolving to the temporary file path
- */ async function createSecureTempFile(prefix = 'kodrdriv', extension = '.txt') {
-    const tmpDir = os.tmpdir();
-    const tmpFilePath = path.join(tmpDir, `${prefix}_${Date.now()}_${Math.random().toString(36).substring(7)}${extension}`);
-    // Create file with restrictive permissions (owner read/write only)
-    const fd = await fs.open(tmpFilePath, 'w', 0o600);
-    await fd.close();
-    return tmpFilePath;
-}
-/**
- * Clean up a temporary file
- * @param filePath Path to the temporary file to clean up
- */ async function cleanupTempFile(filePath) {
-    try {
-        await fs.unlink(filePath);
-    } catch (error) {
-        // Only ignore ENOENT (file not found) errors
-        if (error.code !== 'ENOENT') {
-            const logger = getDryRunLogger(false);
-            logger.warn(`Failed to cleanup temp file ${filePath}: ${error.message}`);
+ * Secure temporary file handle that prevents TOCTOU vulnerabilities
+ */ class SecureTempFile {
+    /**
+     * Create a secure temporary file with proper permissions and atomic operations
+     * @param prefix Prefix for the temporary filename
+     * @param extension File extension (e.g., '.txt', '.md')
+     * @returns Promise resolving to SecureTempFile instance
+     */ static async create(prefix = 'kodrdriv', extension = '.txt') {
+        const tmpDir = os.tmpdir();
+        // Ensure temp directory exists and is writable (skip check in test environments)
+        if (!process.env.VITEST) {
+            try {
+                await fs.access(tmpDir, fs.constants.W_OK);
+            } catch (error) {
+                // Try to create the directory if it doesn't exist
+                try {
+                    await fs.mkdir(tmpDir, {
+                        recursive: true,
+                        mode: 0o700
+                    });
+                } catch (mkdirError) {
+                    throw new Error(`Temp directory not writable: ${tmpDir} - ${error.message}. Failed to create: ${mkdirError.message}`);
+                }
+            }
+        }
+        const tmpFilePath = path.join(tmpDir, `${prefix}_${Date.now()}_${Math.random().toString(36).substring(7)}${extension}`);
+        // Create file with exclusive access and restrictive permissions (owner read/write only)
+        // Using 'wx' flag ensures exclusive creation (fails if file exists)
+        let fd;
+        try {
+            fd = await fs.open(tmpFilePath, 'wx', 0o600);
+        } catch (error) {
+            if (error.code === 'EEXIST') {
+                // Highly unlikely with timestamp + random suffix, but handle it
+                throw new Error(`Temporary file already exists: ${tmpFilePath}`);
+            }
+            throw new Error(`Failed to create temporary file: ${error.message}`);
+        }
+        return new SecureTempFile(tmpFilePath, fd);
+    }
+    /**
+     * Get the file path (use with caution in external commands)
+     */ get path() {
+        if (this.isCleanedUp) {
+            throw new Error('Temp file has been cleaned up');
         }
+        return this.filePath;
+    }
+    /**
+     * Write content to the temporary file
+     */ async writeContent(content) {
+        if (!this.fd || this.isCleanedUp) {
+            throw new Error('Temp file is not available for writing');
+        }
+        await this.fd.writeFile(content, 'utf8');
+    }
+    /**
+     * Read content from the temporary file
+     */ async readContent() {
+        if (!this.fd || this.isCleanedUp) {
+            throw new Error('Temp file is not available for reading');
+        }
+        const content = await this.fd.readFile('utf8');
+        return content;
+    }
+    /**
+     * Close the file handle
+     */ async close() {
+        if (this.fd && !this.isCleanedUp) {
+            await this.fd.close();
+            this.fd = null;
+        }
+    }
+    /**
+     * Securely cleanup the temporary file - prevents TOCTOU by using file descriptor
+     */ async cleanup() {
+        if (this.isCleanedUp) {
+            return; // Already cleaned up
+        }
+        try {
+            // Close file descriptor first if still open
+            if (this.fd) {
+                await this.fd.close();
+                this.fd = null;
+            }
+            // Now safely remove the file
+            // Use fs.unlink which is safer than checking existence first
+            await fs.unlink(this.filePath);
+        } catch (error) {
+            // Only ignore ENOENT (file not found) errors
+            if (error.code !== 'ENOENT') {
+                const logger = getDryRunLogger(false);
+                logger.warn(`Failed to cleanup temp file ${this.filePath}: ${error.message}`);
+            // Don't throw here to avoid masking main operations
+            }
+        } finally{
+            this.isCleanedUp = true;
+        }
+    }
+    constructor(filePath, fd){
+        _define_property(this, "fd", null);
+        _define_property(this, "filePath", void 0);
+        _define_property(this, "isCleanedUp", false);
+        this.filePath = filePath;
+        this.fd = fd;
     }
 }
 /**
@@ -91,10 +229,8 @@ import * as fs from 'fs/promises';
  */ async function editContentInEditor(content, templateLines = [], fileExtension = '.txt') {
     const logger = getDryRunLogger(false);
     const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
-    let tmpFilePath = null;
+    const secureTempFile = await SecureTempFile.create('kodrdriv_edit', fileExtension);
     try {
-        // Create secure temporary file
-        tmpFilePath = await createSecureTempFile('kodrdriv_edit', fileExtension);
         // Build template content
         const templateContent = [
             ...templateLines,
@@ -104,11 +240,12 @@ import * as fs from 'fs/promises';
             content,
             ''
         ].join('\n');
-        await fs.writeFile(tmpFilePath, templateContent, 'utf8');
+        await secureTempFile.writeContent(templateContent);
+        await secureTempFile.close(); // Close before external editor access
         logger.info(`📝 Opening ${editor} to edit content...`);
         // Open the editor synchronously
         const result = spawnSync(editor, [
-            tmpFilePath
+            secureTempFile.path
         ], {
             stdio: 'inherit'
         });
@@ -116,7 +253,7 @@ import * as fs from 'fs/promises';
             throw new Error(`Failed to launch editor '${editor}': ${result.error.message}`);
         }
         // Read the file back in, stripping comment lines
-        const fileContent = (await fs.readFile(tmpFilePath, 'utf8')).split('\n').filter((line)=>!line.trim().startsWith('#')).join('\n').trim();
+        const fileContent = (await fs.readFile(secureTempFile.path, 'utf8')).split('\n').filter((line)=>!line.trim().startsWith('#')).join('\n').trim();
         if (!fileContent) {
             throw new Error('Content is empty after editing');
         }
@@ -126,10 +263,8 @@ import * as fs from 'fs/promises';
             wasEdited: fileContent !== content.trim()
         };
     } finally{
-        // Always clean up the temp file
-        if (tmpFilePath) {
-            await cleanupTempFile(tmpFilePath);
-        }
+        // Always clean up the temp file securely
+        await secureTempFile.cleanup();
     }
 }
 /**
@@ -178,42 +313,73 @@ import * as fs from 'fs/promises';
     logger.info('');
     return new Promise((resolve, reject)=>{
         let inputBuffer = '';
-        // Ensure stdin is referenced so the process doesn't exit while waiting for input
-        if (typeof process.stdin.ref === 'function') {
-            process.stdin.ref();
-        }
-        process.stdin.setEncoding('utf8');
-        process.stdin.resume();
-        const onData = (chunk)=>{
-            inputBuffer += chunk;
-            // Check if user pressed Enter (newline character)
-            if (inputBuffer.includes('\n')) {
-                cleanup();
-                const userInput = inputBuffer.replace(/\n$/, '').trim();
-                if (userInput === '') {
-                    logger.warn('Empty input received. Please provide feedback text.');
-                    reject(new Error('Empty input received'));
-                } else {
-                    logger.info(`✅ Received feedback: "${userInput}"\n`);
-                    resolve(userInput);
+        let isResolved = false;
+        let dataHandler = null;
+        let errorHandler = null;
+        const cleanup = ()=>{
+            if (dataHandler) {
+                process.stdin.removeListener('data', dataHandler);
+            }
+            if (errorHandler) {
+                process.stdin.removeListener('error', errorHandler);
+            }
+            try {
+                process.stdin.pause();
+                // Detach stdin again now that we're done
+                if (typeof process.stdin.unref === 'function') {
+                    process.stdin.unref();
                 }
+            } catch  {
+            // Ignore cleanup errors
             }
         };
-        const onError = (error)=>{
-            cleanup();
-            reject(error);
+        const safeResolve = (value)=>{
+            if (!isResolved) {
+                isResolved = true;
+                cleanup();
+                resolve(value);
+            }
         };
-        const cleanup = ()=>{
-            process.stdin.pause();
-            process.stdin.removeListener('data', onData);
-            process.stdin.removeListener('error', onError);
-            // Detach stdin again now that we're done
-            if (typeof process.stdin.unref === 'function') {
-                process.stdin.unref();
+        const safeReject = (error)=>{
+            if (!isResolved) {
+                isResolved = true;
+                cleanup();
+                reject(error);
             }
         };
-        process.stdin.on('data', onData);
-        process.stdin.on('error', onError);
+        try {
+            // Ensure stdin is referenced so the process doesn't exit while waiting for input
+            if (typeof process.stdin.ref === 'function') {
+                process.stdin.ref();
+            }
+            process.stdin.setEncoding('utf8');
+            process.stdin.resume();
+            dataHandler = (chunk)=>{
+                try {
+                    inputBuffer += chunk;
+                    // Check if user pressed Enter (newline character)
+                    if (inputBuffer.includes('\n')) {
+                        const userInput = inputBuffer.replace(/\n$/, '').trim();
+                        if (userInput === '') {
+                            logger.warn('Empty input received. Please provide feedback text.');
+                            safeReject(new Error('Empty input received'));
+                        } else {
+                            logger.info(`✅ Received feedback: "${userInput}"\n`);
+                            safeResolve(userInput);
+                        }
+                    }
+                } catch (error) {
+                    safeReject(error instanceof Error ? error : new Error('Unknown error processing input'));
+                }
+            };
+            errorHandler = (error)=>{
+                safeReject(error);
+            };
+            process.stdin.on('data', dataHandler);
+            process.stdin.on('error', errorHandler);
+        } catch (error) {
+            safeReject(error instanceof Error ? error : new Error('Failed to setup input handlers'));
+        }
     });
 }
 /**
@@ -293,5 +459,5 @@ import * as fs from 'fs/promises';
     return finalResult;
 }
 
-export { STANDARD_CHOICES, cleanupTempFile, createSecureTempFile, editContentInEditor, getLLMFeedbackInEditor, getUserChoice, getUserTextInput, improveContentWithLLM, requireTTY };
+export { STANDARD_CHOICES, SecureTempFile, editContentInEditor, getLLMFeedbackInEditor, getUserChoice, getUserTextInput, improveContentWithLLM, requireTTY };
 //# sourceMappingURL=interactive.js.map