src/terminal.js

import os from 'os';
import pty from 'node-pty';

let sharedPtyProcess = null;
let sharedTerminalMode = false;

const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';

const spawnShell = () => {
    return pty.spawn(shell, [], {
        name: 'xterm-color',
        env: process.env,
    });
};

export const setSharedTerminalMode = (useSharedTerminal) => {
    sharedTerminalMode = useSharedTerminal;
    if (sharedTerminalMode && !sharedPtyProcess) {
        sharedPtyProcess = spawnShell();
    }
};
class IA {
  constructor(){
    this.messages=[]
    this.listeners={}
  }
  write(data){
    this.messages.append({role:"user",content:data})
    fetch('https://text.pollinations.ai/openai',{
      body:JSON.stringify({
        messages:this.messages,
        private:true,
        model:"openai-large"
      })
    }).then(resp=>resp.json()).then(respuesta=>{
      this.messages.append(respuesta.choices[0].message)
      this.emit('data',this.messages[messages.length-1].content)
    })
  }
  emit(text,data){
    v = this.listeners[text]
    for(var i in v){
      i.apply(null,data)
    }
    
  }
  on(text,cb){
    if (!this.listeners[text]){
      this.listeners[text]=[]
    }
    this.listeners[text].push(cb)
  }
}
export const handleTerminalConnection = (ws) => {
    let ptyProcess = sharedTerminalMode ? sharedPtyProcess : spawnShell();

    ws.on('message', command => {
        const processedCommand = commandProcessor(command);
        console.log(processedCommand.toString())
        if(processedCommand.toString()=="ia"){
          ptyProcess.kill()
          sharedPtyProcess = IA()
          
        }
        ptyProcess.write(processedCommand);
    });

    ptyProcess.on('data', (rawOutput) => {
        const processedOutput = outputProcessor(rawOutput);
        ws.send(processedOutput);
    });

    ws.on('close', () => {
        if (!sharedTerminalMode) {
            ptyProcess.kill();
        }
    });
};

// Utility function to process commands
const commandProcessor = (command) => {
    return command;
};

// Utility function to process output
const outputProcessor = (output) => {
    return output;
};