build(electron): added much more robust dependency checking to electron app

electron/debug-packaged-app.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+/**
+ * Debug script to test the packaged app backend in isolation
+ * This helps identify issues with the backend executable in different user environments
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+function testBackendExecutable(backendPath, testBundlePath) {
+    console.log(`\n=== Testing Backend Executable ===`);
+    console.log(`Backend path: ${backendPath}`);
+    console.log(`Test bundle: ${testBundlePath}`);
+    console.log(`Backend exists: ${fs.existsSync(backendPath)}`);
+    
+    if (!fs.existsSync(backendPath)) {
+        console.error(`❌ Backend executable not found at: ${backendPath}`);
+        return Promise.resolve(false);
+    }
+    
+    // Test with inspect_bundle command (same as open-bundle)
+    const args = ['inspect_bundle', JSON.stringify({ bundle_path: testBundlePath })];
+    console.log(`Command: ${backendPath} ${args.join(' ')}`);
+    
+    return new Promise((resolve) => {
+        const process = spawn(backendPath, args);
+        let stdoutBuffer = '';
+        let stderrBuffer = '';
+        
+        process.stdout.on('data', (data) => {
+            stdoutBuffer += data.toString();
+        });
+        
+        process.stderr.on('data', (data) => {
+            stderrBuffer += data.toString();
+        });
+        
+        process.on('close', (code) => {
+            console.log(`\n--- Backend Test Results ---`);
+            console.log(`Exit code: ${code}`);
+            console.log(`Stdout length: ${stdoutBuffer.length}`);
+            console.log(`Stderr length: ${stderrBuffer.length}`);
+            
+            if (stdoutBuffer.length > 0) {
+                console.log(`\nStdout first 500 chars:`);
+                console.log(`"${stdoutBuffer.substring(0, 500)}"`);
+                
+                try {
+                    const parsed = JSON.parse(stdoutBuffer.trim());
+                    console.log(`✅ JSON parsing successful`);
+                    console.log(`Success: ${parsed.success}`);
+                } catch (e) {
+                    console.log(`❌ JSON parsing failed: ${e.message}`);
+                    console.log(`First problematic character: "${stdoutBuffer.charAt(0)}" (${stdoutBuffer.charCodeAt(0)})`);
+                }
+            }
+            
+            if (stderrBuffer.length > 0) {
+                console.log(`\nStderr output:`);
+                console.log(stderrBuffer);
+            }
+            
+            resolve(code === 0);
+        });
+        
+        process.on('error', (err) => {
+            console.error(`❌ Failed to start backend process: ${err.message}`);
+            resolve(false);
+        });
+    });
+}
+
+async function main() {
+    console.log('=== 4DSTAR Packaged App Debug Tool ===');
+    console.log(`Platform: ${process.platform}`);
+    console.log(`Architecture: ${process.arch}`);
+    console.log(`Node version: ${process.version}`);
+    console.log(`Working directory: ${process.cwd()}`);
+    
+    // Get test bundle path from command line or use default
+    const testBundlePath = process.argv[2] || '/path/to/test.fbundle';
+    
+    if (!fs.existsSync(testBundlePath)) {
+        console.error(`❌ Test bundle not found: ${testBundlePath}`);
+        console.log(`Usage: node debug-packaged-app.js <path-to-test-bundle>`);
+        process.exit(1);
+    }
+    
+    // Test different backend paths
+    const backendPaths = [
+        // Development path
+        path.resolve(__dirname, '..', 'build', 'electron', 'dist', 'fourdst-backend', 'fourdst-backend'),
+        // Packaged app path (if running from within app)
+        path.join(process.resourcesPath || '', 'backend', 'fourdst-backend'),
+        // Alternative packaged paths
+        path.join(__dirname, '..', 'resources', 'backend', 'fourdst-backend'),
+        path.join(__dirname, 'backend', 'fourdst-backend'),
+    ];
+    
+    console.log(`\n=== Testing Backend Paths ===`);
+    for (const backendPath of backendPaths) {
+        console.log(`\nTesting: ${backendPath}`);
+        const success = await testBackendExecutable(backendPath, testBundlePath);
+        if (success) {
+            console.log(`✅ Backend test successful!`);
+            break;
+        } else {
+            console.log(`❌ Backend test failed`);
+        }
+    }
+    
+    // Environment diagnostics
+    console.log(`\n=== Environment Diagnostics ===`);
+    console.log(`USER: ${process.env.USER || 'unknown'}`);
+    console.log(`HOME: ${process.env.HOME || 'unknown'}`);
+    console.log(`PATH: ${process.env.PATH || 'unknown'}`);
+    console.log(`PYTHONPATH: ${process.env.PYTHONPATH || 'not set'}`);
+    
+    // Check permissions
+    console.log(`\n=== Permission Check ===`);
+    for (const backendPath of backendPaths) {
+        if (fs.existsSync(backendPath)) {
+            try {
+                const stats = fs.statSync(backendPath);
+                console.log(`${backendPath}:`);
+                console.log(`  Executable: ${!!(stats.mode & parseInt('111', 8))}`);
+                console.log(`  Mode: ${stats.mode.toString(8)}`);
+                console.log(`  Size: ${stats.size} bytes`);
+            } catch (e) {
+                console.log(`${backendPath}: Permission error - ${e.message}`);
+            }
+        }
+    }
+}
+
+if (require.main === module) {
+    main().catch(console.error);
+}
+
+module.exports = { testBackendExecutable };