gritty/server/gritty.js

Web terminal emulator

import process from 'node:process';
import path, {dirname} from 'node:path';
import {fileURLToPath} from 'node:url';
import debug from 'debug';
import Router from 'router';
import currify from 'currify';
import wraptile from 'wraptile';
import _pty from 'node-pty';
import stringArgv from 'string-to-argv';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const log = debug('gritty');
const isFn = (a) => typeof a === 'function';
const isBool = (a) => typeof a === 'boolean';

const DIR_ROOT = `${__dirname}/..`;

const terminalFn = currify(_terminalFn);
const connectionWraped = wraptile(connection);

const getCMD = (overrides = {}) => {
    const {platform = process.platform} = overrides;
    
    return platform === 'win32' ? 'cmd.exe' : 'bash';
};

const isDev = () => process.env.NODE_ENV === 'development';

const getDist = () => {
    if (isDev())
        return '/dist-dev';
    
    return '/dist';
};

const choose = (a, b, options) => {
    if (isBool(a))
        return a;
    
    if (isBool(b))
        return b;
    
    return options.default;
};

export default gritty;

export function gritty(options = {}) {
    const router = Router();
    const {prefix = '/gritty'} = options;
    
    router
        .route(`${prefix}/*name`)
        .get(terminalFn(options))
        .get(staticFn);
    
    return router;
};
function _terminalFn(options, req, res, next) {
    const {prefix = '/gritty'} = options;
    
    req.url = req.url.replace(prefix, '');
    
    if (/^\/gritty\.js(\.map)?$/.test(req.url))
        req.url = getDist() + req.url;
    
    next();
}

function staticFn(req, res) {
    const file = path.normalize(DIR_ROOT + req.url);
    
    res.sendFile(file, {
        dotfiles: 'allow',
    });
}

function createTerminal(overrides = {}) {
    const {
        command,
        env,
        cwd,
        cols = 80,
        rows = 24,
        pty = _pty,
    } = overrides;
    
    const [cmd, ...args] = stringArgv(command);
    
    const term = pty.spawn(cmd, args, {
        name: 'xterm-color',
        cols,
        rows,
        cwd,
        env: {
            ...process.env,
            ...env,
        },
    });
    
    log(`Created terminal with PID: ${term.pid}`);
    
    return term;
}

gritty.listen = (socket, options = {}) => {
    check(socket, options);
    
    const {prefix, auth} = options;
    
    socket
        .of(prefix || '/gritty')
        .on('connection', (socket) => {
            const connect = connectionWraped(options, socket);
            
            if (!auth)
                return connection(options, socket);
            
            const reject = () => socket.emit('reject');
            socket.on('auth', auth(connect, reject));
        });
};

function check(socket, options) {
    if (!socket)
        throw Error('socket could not be empty!');
    
    const {auth} = options;
    
    if (auth && !isFn(auth))
        throw Error('options.auth should be a function!');
}

function connection(options, socket) {
    socket.emit('accept');
    
    let term;
    
    socket.on('terminal', onTerminal);
    
    const onResize = (size) => {
        size = size || {};
        
        const {
            cols = 80,
            rows = 25,
        } = size;
        
        term.resize(cols, rows);
        log(`Resized terminal ${term.pid} to ${cols} cols and ${rows} rows.`);
    };
    
    const onData = (msg) => {
        term.write(msg);
    };
    
    function onTerminal(overrides = {}) {
        const {
            env,
            rows,
            cols,
            cwd,
            platform,
        } = overrides;
        
        const command = overrides.command || options.command || getCMD({
            platform,
        });
        
        const autoRestart = choose(overrides.autoRestart, options.autoRestart, {
            default: true,
        });
        
        term = createTerminal({
            command,
            cwd,
            env,
            rows,
            cols,
        });
        
        const onExit = (code) => {
            socket.emit('exit', code);
            onDisconnect();
            
            if (!autoRestart)
                return;
            
            onTerminal();
        };
        
        const onDisconnect = () => {
            term.removeListener('exit', onExit);
            term.kill();
            log(`Closed terminal ${term.pid}`);
            
            socket.removeListener('resize', onResize);
            socket.removeListener('data', onData);
            socket.removeListener('terminal', onTerminal);
            socket.removeListener('disconnect', onDisconnect);
        };
        
        term.on('data', (data) => {
            socket.emit('data', data);
        });
        
        term.on('exit', onExit);
        
        log('Connected to terminal ' + term.pid);
        
        socket.on('data', onData);
        socket.on('resize', onResize);
        socket.on('disconnect', onDisconnect);
    }
}