server.js

const net = require('net');
const { spawn } = require('child_process');
const express = require('express');
const bodyParser = require('body-parser');
const chalk = require('chalk');

const app = express();
app.use(bodyParser.json());

app.use((req, res, next) => {
    console.log("mid", req.method, req.path);
    res.header("Access-Control-Allow-Origin", "*"); // restrict it to the required domain
    res.header("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE,OPTIONS");
    // Set custom headers for CORS
    res.header("Access-Control-Allow-Headers", "Content-type,Accept,X-Custom-Header");

    if (req.method === "OPTIONS") {
        return res.status(200).end();
    }

    next()
})

// Debug logging utility with colors
const debug = {
    log: (...args) => console.log(chalk.blue('[DEBUG]'), ...args),
    error: (...args) => console.error(chalk.red('[ERROR]'), ...args),
    info: (...args) => console.info(chalk.green('[INFO]'), ...args),
    warn: (...args) => console.warn(chalk.yellow('[WARN]'), ...args),
    // Special loggers for DAP server communication
    dapRequest: (pid, data) => console.log(
        chalk.blue('[DEBUG]'),
        chalk.cyan(`[DAP Request PID ${pid}]`),
        chalk.white(JSON.stringify(data, null, 2))
    ),
    dapResponse: (pid, data) => console.log(
        chalk.blue('[DEBUG]'),
        chalk.magenta(`[DAP Response PID ${pid}]`),
        chalk.white(JSON.stringify(data, null, 2))
    ),
    dapServer: (pid, message) => console.log(
        chalk.blue('[DEBUG]'),
        chalk.green(`[DAP Server PID ${pid}]`),
        chalk.white(message)
    ),
    dapError: (pid, error) => console.error(
        chalk.red('[ERROR]'),
        chalk.red(`[DAP Server PID ${pid}]`),
        chalk.white(error)
    )
};

// Store multiple DAP server instances and their clients
const dapInstances = new Map();

// Function to start DAP server
async function startDAPServer(port = 8123) {
    return new Promise((resolve, reject) => {
        debug.log(chalk.cyan('Starting new DAP server instance'));

        const dapServer = spawn('node', ['../js-debug/src/dapDebugServer.js', port], {
            stdio: ['pipe', 'pipe', 'pipe']
        });

        let serverPort = null;
        const pid = dapServer.pid;
        debug.dapServer(pid, chalk.yellow(`Server spawned with PID: ${pid}`));

        dapServer.stdout.on('data', (data) => {
            const output = data.toString();
            debug.dapServer(pid, chalk.cyan(`stdout: ${output}`));
            // Look for port number in DAP server output - handle both formats
            const portMatch = output.match(/(?:port: (\d+)|\d+:(\d+))/);
            if (portMatch) {
                serverPort = parseInt(portMatch[1] || portMatch[2]);
                debug.dapServer(pid, chalk.green(`Listening on port: ${serverPort}`));
                dapInstances.set(pid, {
                    server: dapServer,
                    client: null,
                    port: serverPort,
                    pid: pid,
                    isInitialized: false,
                    responses: [],
                    childEvents: [],
                    child: null,
                });
                resolve({ port: serverPort, pid: pid });
            }
        });

        dapServer.stderr.on('data', (data) => {
            debug.dapError(pid, `stderr: ${data.toString()}`);
        });

        dapServer.on('error', (error) => {
            debug.dapError(pid, `error: ${error}`);
            reject(error);
        });

        dapServer.on('close', (code) => {
            debug.dapServer(pid, chalk.yellow(`Server exited with code ${code}`));
            dapInstances.delete(pid);
        });
    });
}

// Function to connect to DAP server
async function connectToDAPServer(pid, port, child = false) {
    return new Promise((resolve, reject) => {
        debug.dapServer(pid, chalk.cyan(`Connecting to port ${port}`));
        const dapClient = new net.Socket();
        const instance = dapInstances.get(pid);

        dapClient.connect(port, 'localhost', () => {
            debug.dapServer(pid, chalk.green('Connected successfully'));
            instance[child ? "child" : "client"] = dapClient;
            instance.isInitialized = true;
            resolve();
        });

        dapClient.on('error', (error) => {
            debug.dapError(pid, `Connection error: ${error}`);
            reject(error);
        });

        dapClient.on("data", (data) => {
            console.log(child ? "[child]" : "" + "net socket - data pid: " + pid + " ", data.toString())

            // if mutiple payload/json are present in one, returns Array.
            const jsonContent = processMessage(data)

            console.log("jsonContent", data.toString(), "\t\n ->> ", jsonContent)

            let responsesArr = !child ? instance.responses : instance.childEvents;
            if (!responsesArr) responsesArr = []
            try {
                if(Array.isArray((jsonContent))) {
                  for (json of jsonContent) {
                    responsesArr.push(json)
                  }

                  return;
                }

                responsesArr.push(jsonContent)
            } catch (e) { console.log(e) }
            //console.log("res", pid, responsesArr)
        })
    });
}

// Function to get or create DAP server instance
async function getOrCreateDAPInstance(pid) {
    debug.log(chalk.cyan(`Getting or creating DAP instance for PID: ${pid}`));
    let instance = dapInstances.get(pid);

    if (!instance) {
        debug.log(chalk.yellow(`No existing instance found for PID ${pid}, creating new one`));
        // Create new instance if none exists
        const { port, pid: newPid } = await startDAPServer();
        await connectToDAPServer(newPid, port);
        instance = dapInstances.get(newPid);
    } else if (!instance.isInitialized) {
        debug.log(chalk.yellow(`Instance found for PID ${pid} but not initialized, reconnecting`));
        // Reconnect if instance exists but not initialized
        await connectToDAPServer(pid, instance.port);
    }

    return instance;
}

// Handle incoming requests from client
app.post('/debug', async (req, res) => {
    try {
        debug.log(chalk.cyan('Received new debug session request'));
        const portInc = dapInstances.size;
        // Create new instance for initial request
        const { port, pid: newPid } = await startDAPServer(8123 + portInc);
        await connectToDAPServer(newPid, port);
        const instance = dapInstances.get(newPid);

        debug.dapRequest(newPid, req.body);
        // Forward request to DAP server
        const request = JSON.stringify({
            type: "request",
            ...(req.body)
        });
        instance.client.write(`Content-Length: ${Buffer.byteLength(request, "utf8")}\r\n\r\n${request}`);

        // Handle response from DAP server
        const response = await new Promise((resolve, reject) => {
            let responseData = '';

            const responseHandler = (data) => {
                responseData += data.toString();
                if (responseData.includes('\n')) {
                    instance.client.removeListener('data', responseHandler);
                    // Extract the JSON content after header with processMessage function.
                    const processedJsonContent = processMessage(responseData);
                    console.log("j", processedJsonContent)
                    const jsonContent = (Array.isArray(processedJsonContent) && processedJsonContent.find(e => e.type === "response")) || processedJsonContent

                    debug.dapResponse(newPid, responseData);
                    resolve(jsonContent);
                }
            };

            instance.client.on('data', responseHandler);
        });

        res.json({ ...response, pid: newPid });
    } catch (error) {
        debug.error(chalk.red('Error handling debug request:'), error);
        res.status(500).json({ error: error.message });
    }
});

// Handle subsequent requests to existing DAP server
app.post('/debug/:pid', async (req, res) => {
    try {
        const pid = parseInt(req.params.pid);
        debug.dapRequest(pid, req.body);
        console.log("req - query", req.query)
        const child = req.query.child === 'true';

        const instance = await getOrCreateDAPInstance(pid);

        if (!instance || !instance.client) {
            throw new Error('DAP server connection not available');
        }

        let client = instance.client;

        console.log(`found instance for pid: ${pid}, IsChild: ${child} (${req.query.child})`)

        if (child) {
            if (!instance.child) {
                console.log("connecting again for child instance")
                await connectToDAPServer(pid, instance.port, child)
            }

            client = instance.child;
        }

        // Forward request to DAP server
        //const request = JSON.stringify(req.body);
        //instance.client.write(request + '\n');
        const request = JSON.stringify({
            type: "request",
            ...(req.body)
        });

        client.write(`Content-Length: ${Buffer.byteLength(request, "utf8")}\r\n\r\n${request}`);



        // Handle response from DAP server
        const response = await new Promise((resolve, reject) => {
            let responseData = Buffer.from([]);

            const responseHandler = (data) => {
                console.log("responseHandler", data.toString(), responseData)
                responseData = Buffer.concat([responseData, data]);
                if (responseData.includes('\n')) {
                    debug.dapResponse(pid, responseData.toString());
                    const processedJsonContent = processMessage(responseData);

                    const jsonContent = (Array.isArray(processedJsonContent) && processedJsonContent.find(e => e.type === "response" && e.request_seq === request.seq)) || processedJsonContent


                    console.log("res - json", jsonContent, request)

                    if (jsonContent.request_seq === req.body.seq) {
                        client.removeListener('data', responseHandler);
                        resolve(jsonContent);
                    }
                }
            };

            client.on('data', responseHandler);
        });

        res.json(response);
    } catch (error) {
        debug.error(chalk.red('Error handling debug request:'), error);
        res.status(500).json({ error: error.message });
    }
});

// Get DAP server status by PID
app.get('/status/:pid', (req, res) => {
    const pid = parseInt(req.params.pid);
    debug.log(chalk.cyan(`Checking status for DAP server (PID ${pid})`));
    const instance = dapInstances.get(pid);

    if (instance) {
        res.json({
            status: 'running',
            pid: instance.pid,
            port: instance.port,
            hasClient: !!instance.client,
            isInitialized: instance.isInitialized
        });
    } else {
        debug.warn(chalk.yellow(`No DAP server found with PID ${pid}`));
        res.json({
            status: 'not_found',
            message: 'No DAP server running with this PID'
        });
    }
});

app.get('/debug/:pid/polling', (req, res) => {

    const pid = parseInt(req.params.pid);
    const instance = dapInstances.get(pid);

    if (instance) {
        console.log("polling", instance.responses, instance.childEvents)
        res.json(instance.child ? ({
            events: instance.responses || [],
            childEvents: instance.childEvents || []
        }) : ({
            events: instance.responses || []
        })
        );

        if (instance.responses?.length) instance.responses.length = 0
        if (instance?.childEvents?.length) instance.childEvents.length = 0
    } else {
        res.json({
            status: 'not_found',
            message: 'No DAP server running with this PID'
        });
    }
})

// Terminate DAP server instance
app.delete('/debug/:pid', (req, res) => {
    const pid = parseInt(req.params.pid);
    debug.log(chalk.cyan(`Received termination request for DAP server (PID ${pid})`));

    const instance = dapInstances.get(pid);
    if (instance) {
        cleanupInstance(pid);
        debug.log(chalk.green(`Successfully terminated DAP server (PID ${pid})`));
        res.json({ status: 'terminated', pid });
    } else {
        debug.warn(chalk.yellow(`Attempted to terminate non-existent DAP server (PID ${pid})`));
        res.status(404).json({
            status: 'not_found',
            message: 'No DAP server running with this PID'
        });
    }
});

// Cleanup function for a specific PID
async function cleanupInstance(pid) {
    debug.log(chalk.cyan(`Cleaning up DAP server instance (PID ${pid})`));
    const instance = dapInstances.get(pid);
    if (instance) {
        try {
            if (instance.client) {
                instance.client.end();
                instance.client = null;
                debug.log(chalk.yellow(`Closed client connection for DAP server (PID ${pid})`));
            }
            if (instance.child) {
                instance.child.end();
                instance.child = null;
                debug.log(chalk.yellow(`Closed child client connection for DAP server (PID ${pid})`));

            }

            if (instance.server) {
                instance.server.kill();
                instance.server = null;
                debug.log(chalk.yellow(`Terminated DAP server process (PID ${pid})`));
            }
            dapInstances.delete(pid);
            debug.log(chalk.green(`Removed DAP server instance from tracking (PID ${pid})`));
        } catch (error) {
            debug.error(chalk.red(`Error cleaning up instance ${pid}:`), error);
        }
    }
}

function processMessage(message) {
    let processedMsg;
    let startTime = performance.now()
    while (message.length > 0) {
        const headerEnd = message.indexOf("\r\n\r\n")
        console.log("processMessage - loop headerEnd:", headerEnd)
        if (headerEnd === -1) break;

        const header = message.slice(0, headerEnd).toString()
        let contentLength = header.match(/Content-Length: (\d+)/)[1]

        console.log("processMessage - loop contentLength:", contentLength)
        if (!contentLength) break;

        contentLength = parseInt(contentLength, 10);
        const headerLength = headerEnd + 4;


        console.log("processMessage - loop totalMessageLength & message.length:", { totalMessageLength: contentLength + headerLength, "message.length": message.length, contentLength })

        const bodyBuffer = message.slice(headerLength)

        if (bodyBuffer.length < contentLength) break;

        const payloadBuffer = message.slice(headerLength, headerLength + contentLength + 1);

        const JSONString = payloadBuffer.toString()

        try {
            const JSONContent = JSON.parse(JSONString);
            processedMsg = bodyBuffer.length > contentLength ? [JSONContent, ...(processedMsg || [])] : JSONContent;
        } catch (e) {
            console.log('[ERROR] Invalid JSON:', e.message);
        }

        console.log(processedMsg)

        message = message.slice(headerEnd + contentLength + 1)
        console.log(message)

    }
    console.log(`[processed - batch mark (time spent)]: ⏱️ ${performance.now() - startTime} ms!`)
    return processedMsg;
}

// Cleanup all instances
async function cleanupAll() {
    debug.log(chalk.cyan('Cleaning up all DAP server instances'));
    const cleanupPromises = [];

    for (const pid of dapInstances.keys()) {
        cleanupPromises.push(cleanupInstance(pid));
    }

    try {
        // Wait for all cleanup operations to complete
        await Promise.all(cleanupPromises);
        debug.log(chalk.green('All cleanup operations completed'));

        // Exit the process
        process.exit(0);
    } catch (error) {
        debug.error(chalk.red('Error during cleanup:'), error);
        process.exit(1);
    }
}

// Handle process termination
process.on('SIGINT', cleanupAll);
process.on('SIGTERM', cleanupAll);

const PORT = process.env.PORT || 8777;
app.listen(PORT, () => {
    debug.info(chalk.green(`Bridge server listening on port ${PORT}`));
});