VS Code JavaScript Error Diagnostic Tools & Scripts

When dealing with a JavaScript error when opening Visual Studio Code, having quick diagnostic tools can save valuable troubleshooting time. These ready-to-use scripts help identify and resolve common VS Code startup issues efficiently.

VS Code Health Check Script #

This comprehensive script checks your VS Code installation and identifies potential causes of JavaScript errors when opening Visual Studio Code.

// vscode-health-check.js
const fs = require('fs');
const path = require('path');
const os = require('os');

class VSCodeDiagnostic {
    constructor() {
        this.platform = os.platform();
        this.homeDir = os.homedir();
        this.results = [];
    }

    // Check VS Code installation
    checkInstallation() {
        const installPaths = {
            win32: [
                path.join(process.env.LOCALAPPDATA, 'Programs', 'Microsoft VS Code'),
                path.join(process.env.PROGRAMFILES, 'Microsoft VS Code')
            ],
            darwin: ['/Applications/Visual Studio Code.app'],
            linux: ['/usr/share/code', '/opt/visual-studio-code']
        };

        const paths = installPaths[this.platform] || [];
        const installed = paths.some(p => fs.existsSync(p));
        
        this.results.push({
            check: 'VS Code Installation',
            status: installed ? 'PASS' : 'FAIL',
            message: installed ? 'VS Code found' : 'VS Code installation not detected'
        });
        
        return installed;
    }

    // Check for corrupted settings
    checkSettings() {
        const settingsPaths = {
            win32: path.join(process.env.APPDATA, 'Code', 'User', 'settings.json'),
            darwin: path.join(this.homeDir, 'Library', 'Application Support', 'Code', 'User', 'settings.json'),
            linux: path.join(this.homeDir, '.config', 'Code', 'User', 'settings.json')
        };

        const settingsPath = settingsPaths[this.platform];
        
        if (!fs.existsSync(settingsPath)) {
            this.results.push({
                check: 'Settings File',
                status: 'WARN',
                message: 'Settings file not found (using defaults)'
            });
            return true;
        }

        try {
            const settings = fs.readFileSync(settingsPath, 'utf8');
            JSON.parse(settings);
            this.results.push({
                check: 'Settings File',
                status: 'PASS',
                message: 'Settings file is valid JSON'
            });
            return true;
        } catch (error) {
            this.results.push({
                check: 'Settings File',
                status: 'FAIL',
                message: `Settings file corrupted: ${error.message}`
            });
            return false;
        }
    }

    // Check extension directory
    checkExtensions() {
        const extensionPaths = {
            win32: path.join(this.homeDir, '.vscode', 'extensions'),
            darwin: path.join(this.homeDir, '.vscode', 'extensions'),
            linux: path.join(this.homeDir, '.vscode', 'extensions')
        };

        const extensionPath = extensionPaths[this.platform];
        
        if (!fs.existsSync(extensionPath)) {
            this.results.push({
                check: 'Extensions Directory',
                status: 'WARN',
                message: 'No extensions directory found'
            });
            return true;
        }

        try {
            const extensions = fs.readdirSync(extensionPath);
            this.results.push({
                check: 'Extensions Directory',
                status: 'PASS',
                message: `Found ${extensions.length} extensions`
            });
            return true;
        } catch (error) {
            this.results.push({
                check: 'Extensions Directory',
                status: 'FAIL',
                message: `Cannot read extensions: ${error.message}`
            });
            return false;
        }
    }

    // Run all diagnostics
    runDiagnostics() {
        console.log('🔍 Running VS Code Diagnostic Checks...\n');
        
        this.checkInstallation();
        this.checkSettings();
        this.checkExtensions();
        
        console.log('📊 Diagnostic Results:');
        console.log('='.repeat(50));
        
        this.results.forEach(result => {
            const icon = result.status === 'PASS' ? '✅' : 
                        result.status === 'WARN' ? '⚠️' : '❌';
            console.log(`${icon} ${result.check}: ${result.message}`);
        });
        
        const failed = this.results.filter(r => r.status === 'FAIL').length;
        if (failed > 0) {
            console.log(`\n🚨 Found ${failed} issue(s) that may cause JavaScript errors when opening VS Code`);
        } else {
            console.log('\n✨ All checks passed! VS Code should start normally.');
        }
    }
}

// Usage
const diagnostic = new VSCodeDiagnostic();
diagnostic.runDiagnostics();

Extension Conflict Detector #

This script identifies potentially problematic extensions that might cause JavaScript errors when opening Visual Studio Code.

Settings Backup & Recovery Utility #

Quickly backup and restore VS Code settings when dealing with JavaScript errors during startup.

// settings-backup-utility.js
const fs = require('fs');
const path = require('path');
const os = require('os');

class SettingsManager {
    constructor() {
        this.platform = os.platform();
        this.settingsPath = this.getSettingsPath();
        this.backupDir = path.join(os.homedir(), 'vscode-backups');
    }

    getSettingsPath() {
        const paths = {
            win32: path.join(process.env.APPDATA, 'Code', 'User'),
            darwin: path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User'),
            linux: path.join(os.homedir(), '.config', 'Code', 'User')
        };
        return paths[this.platform];
    }

    // Create backup of current settings
    backupSettings() {
        if (!fs.existsSync(this.backupDir)) {
            fs.mkdirSync(this.backupDir, { recursive: true });
        }

        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
        const backupPath = path.join(this.backupDir, `settings-${timestamp}.json`);
        const settingsFile = path.join(this.settingsPath, 'settings.json');

        if (fs.existsSync(settingsFile)) {
            fs.copyFileSync(settingsFile, backupPath);
            console.log(`✅ Settings backed up to: ${backupPath}`);
            return backupPath;
        } else {
            console.log('⚠️ No settings file found to backup');
            return null;
        }
    }

    // Reset to default settings
    resetToDefault() {
        const settingsFile = path.join(this.settingsPath, 'settings.json');
        const defaultSettings = {
            "editor.fontSize": 14,
            "editor.tabSize": 4,
            "files.autoSave": "afterDelay",
            "editor.wordWrap": "on"
        };

        fs.writeFileSync(settingsFile, JSON.stringify(defaultSettings, null, 4));
        console.log('✅ Settings reset to default configuration');
    }

    // Restore from backup
    restoreSettings(backupPath) {
        const settingsFile = path.join(this.settingsPath, 'settings.json');
        
        if (fs.existsSync(backupPath)) {
            fs.copyFileSync(backupPath, settingsFile);
            console.log('✅ Settings restored from backup');
        } else {
            console.log('❌ Backup file not found');
        }
    }
}

// Usage examples
const settingsManager = new SettingsManager();

// Backup current settings before troubleshooting
settingsManager.backupSettings();

// Reset to defaults if experiencing JavaScript errors
// settingsManager.resetToDefault();

Quick Extension Manager #

Manage extensions efficiently when troubleshooting JavaScript errors when opening Visual Studio Code.

Usage Instructions #

Running the Health Check #

1. Save the health check script as vscode-health-check.js
2. Run with Node.js: node vscode-health-check.js
3. Review the diagnostic results for potential issues

Extension Management #

• Use the extension conflict detector to identify problematic extensions
• Run extension disable commands individually to isolate issues
• Re-enable extensions one by one after resolving JavaScript errors

Settings Management #

• Always backup settings before making changes
• Use the reset function if settings corruption is suspected
• Restore from backup once the issue is resolved

These diagnostic tools provide a systematic approach to resolving JavaScript errors when opening Visual Studio Code, helping you quickly identify and fix common startup issues.