@tng-sh/js 0.0.9 → 0.1.1

package/lib/goUiSession.js

@@ -7,6 +7,7 @@ class GoUISession {
     constructor() {
         this._binaryPath = this._findGoUiBinary();
         this._running = false;
+        this._tempFiles = new Set();
     }
 
     start() {
@@ -15,20 +16,30 @@ class GoUISession {
 
     stop() {
         this._running = false;
+        this.cleanup();
     }
 
     running() {
         return this._running;
     }
 
+    cleanup() {
+        for (const file of this._tempFiles) {
+            this._cleanupTempFile(file);
+        }
+        this._tempFiles.clear();
+    }
+
     showMenu() {
-        const outputFile = this._createTempFile('menu-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('menu-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['menu', '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['menu', '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
                 return 'exit';
             }
@@ -36,7 +47,7 @@ class GoUISession {
             const choice = fs.readFileSync(outputFile, 'utf8').trim();
             return choice || 'exit';
         } catch (error) {
-            console.error('Menu error:', error);
+            console.error('Menu error:', error.message);
             return 'exit';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -44,13 +55,15 @@ class GoUISession {
     }
 
     showJsTestMenu() {
-        const outputFile = this._createTempFile('js-menu-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('js-menu-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['js-test-menu', '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['js-test-menu', '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
                 return 'back';
             }
@@ -58,7 +71,7 @@ class GoUISession {
             const choice = fs.readFileSync(outputFile, 'utf8').trim();
             return choice || 'back';
         } catch (error) {
-            console.error('JS API Menu error:', error);
+            console.error('JS API Menu error:', error.message);
             return 'back';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -67,13 +80,15 @@ class GoUISession {
 
     showListView(title, items) {
         const dataJson = JSON.stringify({ title, items });
-        const outputFile = this._createTempFile('list-view-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('list-view-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['list-view', '--data', dataJson, '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['list-view', '--data', dataJson, '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
                 return 'back';
             }
@@ -81,7 +96,7 @@ class GoUISession {
             const selected = fs.readFileSync(outputFile, 'utf8').trim();
             return selected || 'back';
         } catch (error) {
-            console.error('List view error:', error);
+            console.error('List view error:', error.message);
             return 'back';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -89,10 +104,9 @@ class GoUISession {
     }
 
     showSpinner(message, func) {
-        const controlFile = this._createTempFile('spinner-control', '.json');
+        const controlFile = this._trackTempFile(this._createTempFile('spinner-control', '.json'));
 
-        // Start spinner in background
-        const process = spawn(this._binaryPath, ['spinner', '--message', message, '--control', controlFile], {
+        const child = spawn(this._binaryPath, ['spinner', '--message', message, '--control', controlFile], {
             stdio: ['ignore', 'inherit', 'inherit']
         });
 
@@ -106,19 +120,20 @@ class GoUISession {
 
             fs.writeFileSync(controlFile, JSON.stringify(status));
 
-            // Wait for process to exit
-            // Wait for process to exit
-            // In Node, we can't easily wait sync for background spawned process without busy loop or async
-            // But for this simple implementation, we'll wait for the process to exit
+            // Wait for spinner to exit (it should exit after reading success/error from control file)
+            spawnSync('sleep', ['0.2']);
+
             return result;
         } catch (error) {
             const status = { status: 'error', message: error.message };
-            fs.writeFileSync(controlFile, JSON.stringify(status));
+            try { fs.writeFileSync(controlFile, JSON.stringify(status)); } catch (e) { }
             throw error;
         } finally {
-            // We don't delete controlFile immediately here if process is still running
-            // but spawnSync/wait logic would be better.
-            // For now, let's keep it simple.
+            // Give the child process a moment to exit before we delete the control file
+            setTimeout(() => {
+                this._cleanupTempFile(controlFile);
+                if (!child.killed) child.kill();
+            }, 500);
         }
     }
 
@@ -129,7 +144,7 @@ class GoUISession {
                 stdio: 'inherit'
             });
         } catch (error) {
-            console.error('Stats error:', error);
+            console.error('Stats error:', error.message);
         }
     }
 
@@ -139,26 +154,28 @@ class GoUISession {
                 stdio: 'inherit'
             });
         } catch (error) {
-            console.error('About error:', error);
+            console.error('About error:', error.message);
         }
     }
 
     showPostGenerationMenu(filePath, runCommand) {
         const dataJson = JSON.stringify({ file_path: filePath, run_command: runCommand });
-        const outputFile = this._createTempFile('post-gen-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('post-gen-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['post-generation-menu', '--data', dataJson, '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['post-generation-menu', '--data', dataJson, '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
                 return 'back';
             }
 
             return fs.readFileSync(outputFile, 'utf8').trim() || 'back';
         } catch (error) {
-            console.error('Post-gen menu error:', error);
+            console.error('Post-gen menu error:', error.message);
             return 'back';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -166,9 +183,8 @@ class GoUISession {
     }
 
     async showProgress(title, handler) {
-        const controlFile = this._createTempFile('progress-control', '.json');
+        const controlFile = this._trackTempFile(this._createTempFile('progress-control', '.json'));
 
-        // Spawn progress in background
         const child = spawn(this._binaryPath, ['progress', '--title', title, '--control', controlFile], {
             stdio: ['ignore', 'inherit', 'inherit'],
             env: process.env
@@ -196,20 +212,19 @@ class GoUISession {
                     data.percent = options.percent;
                 }
 
-                fs.writeFileSync(controlFile, JSON.stringify(data));
+                try {
+                    fs.writeFileSync(controlFile, JSON.stringify(data));
+                } catch (e) {
+                    // Silently fail if control file is locked or missing
+                }
 
                 if (options.explicit_step === undefined && options.step_increment !== false) {
                     stepCounter++;
                 }
-
-                // Small delay to ensure Go UI (polling at 100ms) doesn't miss rapid updates
-                if (options.explicit_step !== undefined) {
-                    spawnSync('sleep', ['0.05']);
-                }
             },
             error: (message) => {
                 const data = { type: 'error', message };
-                fs.writeFileSync(controlFile, JSON.stringify(data));
+                try { fs.writeFileSync(controlFile, JSON.stringify(data)); } catch (e) { }
             },
             complete: (message, options = {}) => {
                 const data = {
@@ -217,68 +232,68 @@ class GoUISession {
                     message: message || 'Done!',
                     auto_exit: options.auto_exit === true
                 };
-                fs.writeFileSync(controlFile, JSON.stringify(data));
+                try { fs.writeFileSync(controlFile, JSON.stringify(data)); } catch (e) { }
             }
         };
 
         try {
             const result = await handler(progress);
-            // Signal success if not already completed/errored
             progress.complete();
-
-            // Wait for progress bar to exit CLEANLY
             await processPromise;
-
             return result;
         } catch (error) {
             progress.error(error.message);
-            await processPromise; // Wait even on error
+            await processPromise;
             throw error;
-            // If the process was killed or died, exitCode will be set.
+        } finally {
+            setTimeout(() => this._cleanupTempFile(controlFile), 500);
         }
     }
 
-
     showClipboardSuccess(command) {
-        spawnSync(this._binaryPath, ['clipboard-success', '--command', command], {
-            stdio: 'inherit'
-        });
+        try {
+            spawnSync(this._binaryPath, ['clipboard-success', '--command', command], {
+                stdio: 'inherit'
+            });
+        } catch (e) { }
     }
 
     showTestResults(title, passed, failed, errors, total, results = []) {
         const dataJson = JSON.stringify({ title, passed, failed, errors, total, results });
-        spawnSync(this._binaryPath, ['test-results', '--data', dataJson], {
-            stdio: 'inherit'
-        });
+        try {
+            spawnSync(this._binaryPath, ['test-results', '--data', dataJson], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('Test results display error:', error.message);
+        }
     }
-
-    async showAuditResults(auditResult) {
+    async showAuditResults(auditResult, index = 0) {
         const dataJson = JSON.stringify(auditResult);
-        const inputFile = this._createTempFile('audit-data', '.json');
-        const outputFile = this._createTempFile('audit-choice', '.txt');
+        const inputFile = this._trackTempFile(this._createTempFile('audit-data', '.json'));
+        const outputFile = this._trackTempFile(this._createTempFile('audit-choice', '.txt'));
 
         try {
             fs.writeFileSync(inputFile, dataJson);
 
-            // Pause stdin to allow child process to take control of TTY
             if (process.stdin.setRawMode) {
                 process.stdin.setRawMode(false);
             }
             process.stdin.pause();
 
             await new Promise((resolve, reject) => {
-                const child = spawn(this._binaryPath, ['audit-results', '--file', inputFile, '--output', outputFile], {
+                const args = ['audit-results', '--file', inputFile, '--output', outputFile];
+                if (index > 0) {
+                    args.push('--index', index.toString());
+                }
+
+                const child = spawn(this._binaryPath, args, {
                     stdio: ['inherit', 'inherit', 'inherit'],
                     env: process.env
                 });
 
-                child.on('error', (err) => {
-                    reject(err);
-                });
-
-                child.on('exit', (code) => {
-                    resolve();
-                });
+                child.on('error', (err) => reject(err));
+                child.on('exit', () => resolve());
             });
 
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
@@ -287,24 +302,75 @@ class GoUISession {
 
             return fs.readFileSync(outputFile, 'utf8').trim() || 'back';
         } catch (error) {
-            console.error('Audit results error:', error);
+            console.error('Audit results error:', error.message);
             return 'back';
         } finally {
-            // Resume stdin
             process.stdin.resume();
-
             this._cleanupTempFile(inputFile);
             this._cleanupTempFile(outputFile);
         }
     }
 
+    async showStreamingAuditResults(methodName, className, sourceCode) {
+        const outputFile = this._trackTempFile(this._createTempFile('audit-choice', '.txt'));
+
+        try {
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.pause();
+
+            const child = spawn(this._binaryPath, [
+                'streaming-audit-results',
+                '--method', methodName || '',
+                '--class', className || '',
+                '--source', sourceCode || '',
+                '--output', outputFile
+            ], {
+                stdio: ['pipe', 'inherit', 'inherit'],
+                env: process.env
+            });
+
+            // Handle potential broken pipes defensively
+            child.stdin.on('error', (err) => {
+                if (err.code !== 'EPIPE' && err.code !== 'EOF') {
+                    console.error('Streaming stdin error:', err.message);
+                }
+            });
+
+            const processPromise = new Promise((resolve, reject) => {
+                child.on('error', (err) => reject(err));
+                child.on('exit', (code) => resolve(code));
+            });
+
+            return {
+                process: child,
+                wait: processPromise,
+                outputFile: outputFile,
+                write: (msg) => {
+                    if (child.stdin.writable) {
+                        try {
+                            child.stdin.write(msg + '\n');
+                        } catch (e) {
+                            // Suppress EPIPE errors during write
+                        }
+                    }
+                }
+            };
+        } catch (error) {
+            console.error('Streaming audit results error:', error.message);
+            process.stdin.resume();
+            return null;
+        }
+    }
+
     showNoItems(itemType) {
         try {
             spawnSync(this._binaryPath, ['no-items', '--type', itemType], {
                 stdio: 'inherit'
             });
         } catch (error) {
-            console.error('No items error:', error);
+            console.error('UI No Items error:', error.message);
         }
     }
 
@@ -321,29 +387,32 @@ class GoUISession {
             throw new Error(`Unsupported platform: ${platform}`);
         }
 
-        // Look in binaries folder relative to this file
         const localBinary = path.join(__dirname, '..', 'binaries', binaryName);
         if (fs.existsSync(localBinary)) {
             return localBinary;
         }
 
-        throw new Error(`go-ui binary not found: ${localBinary}`);
+        throw new Error(`Critical: TNG UI binary not found at ${localBinary}. Please reinstall the extension.`);
     }
 
     _createTempFile(prefix, suffix) {
         const tmpDir = os.tmpdir();
-        const filePath = path.join(tmpDir, `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1000)}${suffix}`);
+        const filePath = path.join(tmpDir, `tng-${prefix}-${Date.now()}-${Math.floor(Math.random() * 1000)}${suffix}`);
         fs.writeFileSync(filePath, '');
         return filePath;
     }
 
+    _trackTempFile(filePath) {
+        this._tempFiles.add(filePath);
+        return filePath;
+    }
+
     _cleanupTempFile(filePath) {
         if (fs.existsSync(filePath)) {
             try {
                 fs.unlinkSync(filePath);
-            } catch (e) {
-                // Ignore cleanup errors
-            }
+                this._tempFiles.delete(filePath);
+            } catch (e) { }
         }
     }
 }

package/lib/jsonSession.js

@@ -14,21 +14,21 @@ class JsonSession {
     }
 
     displayError(message) {
-        this.emitEvent('error', { message: this.stripColors(message) });
+        this.emitEvent('error', { message: this.stripColors(message || 'Unknown error') });
     }
 
     displayWarning(message) {
-        this.emitEvent('warning', { message: this.stripColors(message) });
+        this.emitEvent('warning', { message: this.stripColors(message || 'Warning') });
     }
 
     displayInfo(message) {
-        this.emitEvent('info', { message: this.stripColors(message) });
+        this.emitEvent('info', { message: this.stripColors(message || '') });
     }
 
     displayList(title, items) {
         this.emitEvent('list', {
-            title: this.stripColors(title),
-            items: items
+            title: this.stripColors(title || 'Items'),
+            items: items || []
         });
     }
 
@@ -37,7 +37,7 @@ class JsonSession {
     }
 
     showProgress(title, callback) {
-        this.emitEvent('progress_start', { title });
+        this.emitEvent('progress_start', { title: title || 'Processing' });
 
         const reporter = new JsonProgressReporter();
 
@@ -45,33 +45,35 @@ class JsonSession {
             const result = callback(reporter);
 
             if (result && result.error) {
-                // Error handled by reporter or caller
+                // Keep progress state but report error
+                this.emitEvent('error', { message: result.error });
             } else {
                 this.emitEvent('progress_complete', {
                     message: result?.message || 'Done',
-                    result: result
+                    result: result || {}
                 });
             }
 
             return result;
         } catch (error) {
-            this.emitEvent('error', { message: error.message });
+            const errMsg = error?.message || 'Progress interrupted by unknown error';
+            this.emitEvent('error', { message: errMsg });
             throw error;
         }
     }
 
     showAuditResults(auditResult) {
-        this.emitEvent('result', auditResult);
+        this.emitEvent('result', auditResult || {});
     }
 
     showTestResults(title, passed, failed, errors, total, results = []) {
         this.emitEvent('test_results', {
-            title,
-            passed,
-            failed,
-            errors,
-            total,
-            results
+            title: title || 'Test Results',
+            passed: Math.max(0, passed || 0),
+            failed: Math.max(0, failed || 0),
+            errors: Math.max(0, errors || 0),
+            total: Math.max(0, total || 0),
+            results: results || []
         });
     }
 
@@ -80,29 +82,35 @@ class JsonSession {
     }
 
     showConfigError(missing) {
-        this.emitEvent('config_error', { missing });
+        this.emitEvent('config_error', { missing: missing || [] });
     }
 
     showConfigMissing(missingItems) {
-        this.emitEvent('config_missing', { missing: missingItems });
+        this.emitEvent('config_missing', { missing: missingItems || [] });
     }
 
     showSystemStatus(status) {
-        this.emitEvent('system_status', status);
+        this.emitEvent('system_status', status || {});
     }
 
     showNoItems(type) {
-        this.emitEvent('no_items', { type });
+        this.emitEvent('no_items', { type: type || 'items' });
     }
 
     stripColors(str) {
+        if (typeof str !== 'string') return '';
         // Remove ANSI color codes
         return str.replace(/\x1b\[\d+(;\d+)*m/g, '');
     }
 
     emitEvent(type, data = {}) {
-        const event = { type, ...data };
-        console.log(JSON.stringify(event));
+        try {
+            const event = { type, ...data, timestamp: Date.now() };
+            console.log(JSON.stringify(event));
+        } catch (e) {
+            // If serialization fails (e.g. circular ref), emit minimal error
+            console.log(JSON.stringify({ type: 'error', message: 'Internal session serialization error' }));
+        }
     }
 }
 
@@ -115,17 +123,29 @@ class JsonProgressReporter {
         const { stepIncrement = true, explicitStep = null } = options;
         const stepIdx = explicitStep !== null ? explicitStep : this.step;
 
-        const payload = {
+        let payload = {
             type: 'progress_update',
-            message,
             step: stepIdx
         };
 
+        if (typeof message === 'string' && message.trim().startsWith('{')) {
+            try {
+                const parsed = JSON.parse(message);
+                payload = { ...payload, ...parsed };
+            } catch (e) {
+                payload.message = message;
+            }
+        } else {
+            payload.message = message || '';
+        }
+
         if (percent !== null) {
-            payload.percent = percent;
+            payload.percent = Math.min(100, Math.max(0, percent));
         }
 
-        console.log(JSON.stringify(payload));
+        try {
+            console.log(JSON.stringify(payload));
+        } catch (e) { }
 
         if (stepIncrement && explicitStep === null) {
             this.step += 1;
@@ -133,7 +153,9 @@ class JsonProgressReporter {
     }
 
     error(message) {
-        console.log(JSON.stringify({ type: 'error', message }));
+        try {
+            console.log(JSON.stringify({ type: 'error', message: message || 'Unknown error' }));
+        } catch (e) { }
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tng-sh/js",
-    "version": "0.0.9",
+    "version": "0.1.1",
     "description": "TNG JavaScript CLI",
     "repository": {
         "type": "git",