analyze_qauth.js

// @ts-check

const traverse = require('@babel/traverse').default;
const parser = require('@babel/parser');

/**
 * exposeRootFunctions: Add window assignments immediately after each root function declaration
 *
 * @param {string} sourceCode - Original source code
 * @param {Object} stats - Analysis statistics containing root functions
 * @returns {string} - Modified source code with window assignments inserted after function declarations
 */
function exposeRootFunctions(sourceCode, stats) {
    if (!stats || !stats.rootFunctions) {
        console.log('No root functions found to expose');
        return sourceCode;
    }

    const ast = parser.parse(sourceCode, {
        sourceType: 'module',
        plugins: ['jsx', 'typescript'],
        locations: true,
        allowImportExportEverywhere: true,
        allowReturnOutsideFunction: true,
    });

    const rootFunctionNames = Object.keys(stats.rootFunctions);
    console.log(`\n🌍 Exposing ${rootFunctionNames.length} root functions to window...`);

    // Collect all insertion points with their positions
    const insertions = [];

    traverse(ast, {
        FunctionDeclaration(path) {
            const funcName = path.node.id ? path.node.id.name : null;
            if (funcName && rootFunctionNames.includes(funcName)) {
                const funcEnd = path.node.end;
                const windowAssignment = `\nwindow.__${funcName} = ${funcName};`;

                insertions.push({
                    position: funcEnd,
                    code: windowAssignment,
                    funcName: funcName,
                });

                console.log(
                    `✓ Found function declaration: ${funcName} at line ${path.node.loc?.start.line || 'unknown'}`
                );
                console.log(`📌 Will insert: window.__${funcName} = ${funcName}; after position ${funcEnd}`);
            }
        },
    });

    if (insertions.length === 0) {
        console.log('No function declarations found to expose');
        return sourceCode;
    }

    // Sort insertions by position in reverse order (so we insert from end to beginning)
    // This prevents position shifts from affecting subsequent insertions
    insertions.sort((a, b) => b.position - a.position);

    let modifiedSource = sourceCode;

    // Insert window assignments after each function declaration
    insertions.forEach((insertion) => {
        const beforeInsertion = modifiedSource.substring(0, insertion.position);
        const afterInsertion = modifiedSource.substring(insertion.position);
        modifiedSource = beforeInsertion + insertion.code + afterInsertion;

        console.log(`✅ Inserted window assignment for ${insertion.funcName}`);
    });

    console.log(
        `\n🎉 Successfully added ${insertions.length} window assignments immediately after function declarations`
    );
    return modifiedSource;
}

/**
 * analyzeAndExpose: Complete workflow - analyze code and generate exposed version
 *
 * @param {string} sourceCode - Original source code
 * @returns {Object} - { originalResults, exposedSourceCode, stats }
 */
function analyzeAndExpose(sourceCode) {
    console.log('🔍 Starting analysis and exposure process...\n');

    // Step 1: Analyze the original code
    const analysisResult = analyzeSourceCode(sourceCode);
    if (!analysisResult.results || analysisResult.results.length === 0) {
        console.log('❌ No function calls found to analyze');
        return {
            originalResults: [],
            exposedSourceCode: sourceCode,
            stats: null,
        };
    }

    // Step 2: Generate exposed version
    const exposedSourceCode = exposeRootFunctions(sourceCode, analysisResult.stats);

    // Step 3: Return comprehensive results
    return {
        originalResults: analysisResult.results,
        exposedSourceCode: exposedSourceCode,
        stats: analysisResult.stats,
    };
}

/**
 * findAssignmentInScope: Look for assignment expressions in the scope that assign to the given variable
 *
 * @param {string} varName - Variable name to search for
 * @param {Scope} scope - The scope to search in
 * @param {Set<string>} visited - Visited bindings to prevent infinite loops
 * @param {boolean} debug - Enable detailed debugging output
 * @returns {Object} - { found: boolean, rightName: string|null, assignmentPath: NodePath|null }
 */
function findAssignmentInScope(varName, scope, visited, debug = false) {
    if (debug) console.log(`     🔍 Searching for assignments to "${varName}" in scope...`);

    let foundAssignment = null;

    // Search through ALL paths in the scope, not just references
    scope.path.traverse({
        AssignmentExpression(path) {
            const left = path.node.left;
            const right = path.node.right;

            if (debug) {
                console.log(
                    `     📍 Found assignment: ${left.type} = ${right.type} at ${
                        path.node.loc ? `${path.node.loc.start.line}:${path.node.loc.start.column}` : 'unknown'
                    }`
                );
            }

            // Check if left side matches our variable name
            if (left.type === 'Identifier' && left.name === varName && right.type === 'Identifier') {
                if (debug) console.log(`     ✓ Found matching assignment: ${varName} = ${right.name}`);
                foundAssignment = {
                    found: true,
                    rightName: right.name,
                    assignmentPath: path,
                };
                // Stop traversal once found
                path.stop();
            }
        },
    });

    if (debug && !foundAssignment) {
        console.log(`     ❌ No assignments found for "${varName}" using traverse method`);
    }

    return foundAssignment || { found: false, rightName: null, assignmentPath: null };
}

/**
 * resolveIdentifier: Enhanced version - Track identifier through scope chain to find root function definition
 *
 * @param {string} name - The identifier name to resolve
 * @param {NodePath} startPath - The starting path for scope lookup
 * @param {Set<string>} visited - Prevent circular references using unique binding identifiers
 * @param {boolean} debug - Enable detailed debugging output
 * @returns {Object} - { rootName: String|null, chain: Array<String>, finalDeclaration: NodePath|null }
 */
function resolveIdentifier(name, startPath, visited = new Set(), debug = false) {
    const chain = [];
    let currentName = name;
    let currentPath = startPath;

    if (debug) console.log(`\n🔍 DEBUG: Starting resolution for "${name}"`);

    while (true) {
        // Find binding in current scope
        const binding = currentPath.scope.getBinding(currentName);
        if (!binding) {
            if (debug) console.log(`   ❌ No binding found for "${currentName}"`);
            chain.push(`${currentName} (no binding found)`);
            return { rootName: null, chain, finalDeclaration: null };
        }

        if (debug) {
            console.log(`   ✓ Found binding for "${currentName}"`);
            console.log(`     Binding kind: ${binding.kind}`);
            console.log(`     Declaration type: ${binding.path.node.type}`);
            console.log(
                `     Declaration location: ${
                    binding.path.node.loc
                        ? `${binding.path.node.loc.start.line}:${binding.path.node.loc.start.column}`
                        : 'unknown'
                }`
            );
        }

        // Create unique identifier for this binding using path position + name + scope level
        const bindingId = `${binding.path.node.start}-${binding.path.node.end}-${currentName}-${binding.scope.uid}`;

        // Check for circular reference using unique binding identifier
        if (visited.has(bindingId)) {
            if (debug) console.log(`   🔄 Circular reference detected for "${currentName}"`);
            chain.push(`${currentName} (circular reference detected)`);
            return { rootName: null, chain, finalDeclaration: null };
        }

        visited.add(bindingId);
        chain.push(currentName);

        const declPath = binding.path;

        // Case 1: Direct function declaration - function name() {}
        if (declPath.isFunctionDeclaration()) {
            const funcName = declPath.node.id ? declPath.node.id.name : '(anonymous function)';
            if (debug) console.log(`   🎯 Found function declaration: "${funcName}"`);
            return { rootName: funcName, chain, finalDeclaration: declPath };
        }

        // Case 2: Variable declaration - var/let/const name = ...
        if (declPath.isVariableDeclarator()) {
            const init = declPath.node.init;

            if (debug) {
                console.log(`   📝 Variable declarator for "${declPath.node.id.name}"`);
                console.log(`     Has initializer: ${!!init}`);
                if (init) console.log(`     Initializer type: ${init.type}`);
            }

            if (!init) {
                if (debug) console.log(`   🔍 No initializer, searching for assignments...`);
                // No initializer in declaration, look for assignments in the scope
                const assignmentResult = findAssignmentInScope(currentName, binding.scope, visited, debug);
                if (assignmentResult.found) {
                    if (debug) console.log(`   ✓ Found assignment: ${currentName} = ${assignmentResult.rightName}`);
                    chain.push(`(found assignment: ${currentName} = ${assignmentResult.rightName})`);
                    currentName = assignmentResult.rightName;
                    currentPath = assignmentResult.assignmentPath;
                    continue;
                } else {
                    if (debug) console.log(`   ❌ No assignment found for "${currentName}"`);
                    chain.push('(no initializer and no assignment found)');
                    return { rootName: null, chain, finalDeclaration: null };
                }
            }

            // 2a: var name = identifier (alias)
            if (init.type === 'Identifier') {
                if (debug) console.log(`   ➡️ Following alias: ${currentName} -> ${init.name}`);
                currentName = init.name;
                // Important: Update scope lookup starting point
                currentPath = declPath.parentPath;
                continue;
            }

            // 2b: var name = function() {} (function expression)
            if (init.type === 'FunctionExpression' || init.type === 'ArrowFunctionExpression') {
                const varName = declPath.node.id ? declPath.node.id.name : currentName;
                if (debug) console.log(`   🎯 Found function expression assigned to: "${varName}"`);
                return { rootName: varName, chain, finalDeclaration: declPath };
            }

            // 2c: var name = someComplexExpression
            if (debug) console.log(`   ⚠️ Complex expression assignment: ${init.type}`);
            chain.push('(complex expression assignment)');
            return { rootName: null, chain, finalDeclaration: declPath };
        }

        // Case 3: Assignment expression - name = ...
        if (declPath.isAssignmentExpression()) {
            const right = declPath.node.right;

            if (debug) {
                console.log(`   📝 Assignment expression`);
                console.log(`     Right side type: ${right.type}`);
            }

            if (right.type === 'Identifier') {
                if (debug) console.log(`   ➡️ Following assignment: ${currentName} -> ${right.name}`);
                currentName = right.name;
                currentPath = declPath.parentPath;
                continue;
            }

            if (right.type === 'FunctionExpression' || right.type === 'ArrowFunctionExpression') {
                // For assignments, use left-hand side name as function name
                const leftName = declPath.node.left.type === 'Identifier' ? declPath.node.left.name : currentName;
                if (debug) console.log(`   🎯 Found function expression in assignment: "${leftName}"`);
                return { rootName: leftName, chain, finalDeclaration: declPath };
            }
        }

        // Case 4: Function parameter
        if (declPath.isParameter()) {
            if (debug) console.log(`   📋 Function parameter: ${currentName}`);
            chain.push('(function parameter)');
            return { rootName: null, chain, finalDeclaration: declPath };
        }

        // Case 5: Import declaration
        if (declPath.isImportSpecifier() || declPath.isImportDefaultSpecifier()) {
            if (debug) console.log(`   📦 Import declaration: ${currentName}`);
            chain.push('(import declaration)');
            return { rootName: null, chain, finalDeclaration: declPath };
        }

        // Other cases
        if (debug) console.log(`   ❓ Unhandled declaration type: ${declPath.node.type}`);
        chain.push(`(unhandled declaration type: ${declPath.node.type})`);
        return { rootName: null, chain, finalDeclaration: declPath };
    }
}

/**
 * findAndResolveCalls: Find all matching call expressions and resolve them
 */
function findAndResolveCalls(ast) {
    const results = [];

    traverse(ast, {
        CallExpression(path) {
            const node = path.node;

            // Must have exactly two arguments
            if (node.arguments.length !== 2) return;

            const [arg0, arg1] = node.arguments;

            // First argument must be number, second must be string
            if (arg0.type !== 'NumericLiteral' || arg1.type !== 'StringLiteral') {
                return;
            }

            // Callee must be identifier
            if (node.callee.type !== 'Identifier') return;

            const calleeName = node.callee.name;
            const numValue = arg0.value;
            const strValue = arg1.value;

            // Get location info
            const loc = node.loc ? `${node.loc.start.line}:${node.loc.start.column}` : 'unknown location';

            // Resolve identifier to root function (enable debug for unresolved calls)
            const shouldDebug = !results.some((r) => r.calleeName === calleeName && r.resolved);
            const resolution = resolveIdentifier(calleeName, path, new Set(), shouldDebug);

            const result = {
                location: loc,
                calleeName,
                rootName: resolution.rootName,
                chain: resolution.chain,
                arguments: { number: numValue, string: strValue },
                resolved: !!resolution.rootName,
            };

            results.push(result);

            // Print result
            console.log(`\n=== Call Analysis ===`);
            console.log(`Location: [${loc}]`);
            console.log(`Call: ${calleeName}(${numValue}, "${strValue}")`);
            console.log(`Alias chain: ${resolution.chain.join(' → ')}`);

            if (resolution.rootName) {
                console.log(`✓ Resolution SUCCESS: Root function is "${resolution.rootName}"`);
            } else {
                console.log(`✗ Resolution FAILED: Cannot find root function`);
            }
        },
    });

    return results;
}

/**
 * Main function to analyze source code
 */
function analyzeSourceCode(sourceCode) {
    try {
        const ast = parser.parse(sourceCode, {
            sourceType: 'module',
            plugins: ['jsx', 'typescript'],
            locations: true,
            allowImportExportEverywhere: true,
            allowReturnOutsideFunction: true,
        });

        console.log('Starting source code analysis...\n');
        const results = findAndResolveCalls(ast);

        // Generate final statistics
        const stats = generateStatistics(results);
        printFinalStatistics(stats);

        return { results, stats };
    } catch (error) {
        console.error('Error parsing code:', error.message);
        return { results: [], stats: null };
    }
}

/**
 * Generate detailed statistics from analysis results
 */
function generateStatistics(results) {
    const totalCalls = results.length;
    const resolvedCalls = results.filter((r) => r.resolved);
    const unresolvedCalls = results.filter((r) => !r.resolved);

    // Group by root functions
    const rootFunctions = {};
    resolvedCalls.forEach((result) => {
        const rootName = result.rootName;
        if (!rootFunctions[rootName]) {
            rootFunctions[rootName] = [];
        }
        rootFunctions[rootName].push(result);
    });

    // Group unresolved calls by their immediate caller name
    const unresolvedCallers = {};
    unresolvedCalls.forEach((result) => {
        const callerName = result.calleeName;
        if (!unresolvedCallers[callerName]) {
            unresolvedCallers[callerName] = [];
        }
        unresolvedCallers[callerName].push(result);
    });

    return {
        totalCalls,
        resolvedCount: resolvedCalls.length,
        unresolvedCount: unresolvedCalls.length,
        rootFunctions,
        unresolvedCallers,
        uniqueRootFunctions: Object.keys(rootFunctions).length,
    };
}

/**
 * Print comprehensive final statistics
 */
function printFinalStatistics(stats) {
    if (!stats) return;

    console.log('\n'.repeat(2));
    console.log('='.repeat(60));
    console.log('                   FINAL STATISTICS');
    console.log('='.repeat(60));

    // Overall summary
    console.log(`\nOVERALL SUMMARY:`);
    console.log(`• Total function calls found: ${stats.totalCalls}`);
    console.log(`• Successfully resolved: ${stats.resolvedCount}`);
    console.log(`• Failed to resolve: ${stats.unresolvedCount}`);
    console.log(`• Success rate: ${((stats.resolvedCount / stats.totalCalls) * 100).toFixed(1)}%`);

    // Root functions found
    console.log(`\nROOT FUNCTIONS DISCOVERED: ${stats.uniqueRootFunctions} unique functions`);
    console.log('-'.repeat(40));

    Object.entries(stats.rootFunctions).forEach(([rootFunc, calls]) => {
        console.log(`\n📍 Root Function: "${rootFunc}"`);
        console.log(`   └─ Called ${calls.length} times through these aliases:`);

        calls.forEach((call) => {
            const chainStr = call.chain.length > 1 ? ` (chain: ${call.chain.join(' → ')})` : '';
            console.log(
                `      • ${call.calleeName}(${call.arguments.number}, "${call.arguments.string}") at ${call.location}${chainStr}`
            );
        });
    });

    // Unresolved calls
    if (stats.unresolvedCount > 0) {
        console.log(`\n❌ UNRESOLVED CALLS: ${stats.unresolvedCount} calls`);
        console.log('-'.repeat(40));

        Object.entries(stats.unresolvedCallers).forEach(([callerName, calls]) => {
            console.log(`\n🔍 Caller: "${callerName}" (${calls.length} unresolved calls)`);
            calls.forEach((call) => {
                console.log(
                    `   └─ ${call.calleeName}(${call.arguments.number}, "${call.arguments.string}") at ${call.location}`
                );
                console.log(`      Chain: ${call.chain.join(' → ')}`);
            });
        });
    }

    console.log('\n' + '='.repeat(60));
}

/**
 * Helper function: Batch analysis with grouping
 */
function batchAnalyze(sourceCode) {
    return analyzeSourceCode(sourceCode);
}

module.exports = {
    resolveIdentifier,
    findAndResolveCalls,
    analyzeSourceCode,
    batchAnalyze,
    generateStatistics,
    printFinalStatistics,
    exposeRootFunctions,
    analyzeAndExpose,
};