Shellia/lib/command.js

/**
 * Attaches to a chat, spawns a pty, attaches it to the terminal emulator
 * and the renderer and manages them. Handles incoming commands & input,
 * and posts complimentary messages such as command itself and output code.
 **/

var util = require("util");
var escapeHtml = require("escape-html");
var pty = require("node-pty");
var termios = require("node-termios");
var utils = require("./utils");
var terminal = require("./terminal");
var renderer = require("./renderer");
var tsyms = termios.native.ALL_SYMBOLS;

function Command(reply, context, command) {
  var toUser = reply.destination > 0;

  this.startTime = Date.now();
  this.reply = reply;
  this.command = command;
  this.pty = pty.spawn(context.shell, [context.interactive ? "-ic" : "-c", command], {
    cols: context.size.columns,
    rows: context.size.rows,
    cwd: context.cwd,
    env: context.env,
  });
  this.termios = new termios.Termios(this.pty._fd);
  this.termios.c_lflag &= ~(tsyms.ISIG | tsyms.IEXTEN);
  this.termios.c_lflag &= ~tsyms.ECHO; // disable ECHO
  this.termios.c_lflag |= tsyms.ICANON | tsyms.ECHONL; // we need it for /end, it needs to be active beforehand
  this.termios.c_iflag = (this.termios.c_iflag & ~(tsyms.INLCR | tsyms.IGNCR)) | tsyms.ICRNL; // CR to NL
  this.termios.writeTo(this.pty._fd);

  this.terminal = terminal.createTerminal({
    columns: context.size.columns,
    rows: context.size.rows,
  });
  this.state = this.terminal.state;
  this.renderer = new renderer.Renderer(reply, this.state, {
    cursorString: "\uD83D\uDD38",
    cursorBlinkString: "\uD83D\uDD38",
    hidePreview: !context.linkPreviews,
    unfinishedHidePreview: true,
    silent: context.silent,
    unfinishedSilent: true,
    maxLinesWait: toUser ? 20 : 30,
    maxLinesEmitted: 30,
    lineTime: toUser ? 400 : 1200,
    chunkTime: toUser ? 3000 : 6000,
    editTime: toUser ? 300 : 2500,
    unfinishedTime: toUser ? 1000 : 2000,
    startFill: "·  ",
  });
  this._initKeypad();
  //FIXME: take additional steps to reduce messages sent to group. do typing actions count?

  // Post initial message
  this.initialMessage = new utils.EditedMessage(reply, this._renderInitial(), "HTML");

  // Process command output
  this.pty.on("data", this._ptyData.bind(this));

  // Handle command exit
  this.pty.on("exit", this._exit.bind(this));
}
util.inherits(Command, require("events").EventEmitter);

Command.prototype._renderInitial = function _renderInitial() {
  var content = "", title = this.state.metas.title, badges = this.badges || "";
  if (title) {
    content += "<strong>" + escapeHtml(title) + "</strong>\n";
    content += badges + "<strong>$</strong> " + escapeHtml(this.command);
  } else {
    content += badges + "<strong>$ " + escapeHtml(this.command) + "</strong>";
  }
  return content;
}

Command.prototype._ptyData = function _ptyData(chunk) {
  //FIXME: implement some backpressure, for example, read smaller chunks, stop reading if there are >= 20 lines waiting to be pushed, set the HWM
  if ((typeof chunk !== "string") && !(chunk instanceof String))
    throw new Error("Expected a String, you liar.");
  this.interacted = true;
  this.terminal.write(chunk, "utf-8", this._update.bind(this));
};

Command.prototype._update = function _update() {
  this.initialMessage.edit(this._renderInitial());
  this.renderer.update();
};

Command.prototype.resize = function resize(size) {
  this.interacted = true;
  this.metaActive = false;
  this.state.resize(size);
  this._update();
  this.pty.resize(size.columns, size.rows);
};

Command.prototype.redraw = function redraw() {
  this.interacted = true;
  this.metaActive = false;
  this.pty.redraw();
};

Command.prototype.sendSignal = function sendSignal(signal, group) {
  this.interacted = true;
  this.metaActive = false;
  var pid = this.pty.pid;
  if (group) pid = -pid;
  process.kill(pid, signal);
};

Command.prototype.sendEof = function sendEof() {
  this.interacted = true;
  this.metaActive = false;

  // I don't know how to cause a 'buffer flush to the app' (the effect of Control+D)
  // without actually pressing it into the console. So let's do just that.
  // TTY needs to be in ICANON mode from the start, enabling it now doesn't work

  // write EOF control character
  this.termios.loadFrom(this.pty._fd);
  this.pty.write(Buffer.from([ this.termios.c_cc[tsyms.VEOF] ]));
};

Command.prototype._exit = function _exit(code, signal) {
  this._update();
  this.renderer.flushUnfinished();


  //FIXME: could wait until all edits are made before posting exited message
  if ((Date.now() - this.startTime) < 2000 && !signal && code === 0 && !this.interacted) {
    // For short lived commands that completed without output, we simply add a tick to the original message
    this.badges = "\u2705 ";
    this.initialMessage.edit(this._renderInitial());
  } else {
    if (signal)
      this.reply.html("\uD83D\uDC80 <strong>Killed</strong> by %s.", utils.formatSignal(signal));
    else if (code === 0)
      this.reply.html("\u2705 <strong>Exited</strong> correctly.");
    else
      this.reply.html("\u26D4 <strong>Exited</strong> with %s.", code);
  }

  this._removeKeypad();
  this.emit("exit");
};

Command.prototype.handleReply = function handleReply(msg) {
  //FIXME: feature: if photo, file, video, voice or music, put the terminal in raw mode, hold off further input, pipe binary asset to terminal, restore
  //Flags we would need to touch: -INLCR -IGNCR -ICRNL -IUCLC -ISIG -ICANON -IEXTEN, and also for convenience -ECHO -ECHONL

  if (msg.type !== "text") return false;
  this.sendInput(msg.text);
};

Command.prototype.sendInput = function sendInput(text, noTerminate) {
  this.interacted = true;
  text = text.replace(/\n/g, "\r");
  if (!noTerminate) text += "\r";
  if (this.metaActive) text = "\x1b" + text;
  this.pty.write(text);
  this.metaActive = false;
};

Command.prototype.toggleMeta = function toggleMeta(metaActive) {
  if (metaActive === undefined) metaActive = !this.metaActive;
  this.metaActive = metaActive;
};

Command.prototype.setSilent = function setSilent(silent) {
  this.renderer.options.silent = silent;
};

Command.prototype.setLinkPreviews = function setLinkPreviews(linkPreviews) {
  this.renderer.options.hidePreview = !linkPreviews;
};

Command.prototype._initKeypad = function _initKeypad() {
  this.keypadToken = utils.generateToken();

  var keys = {
    esc:       { label: "ESC", content: "\x1b" },
    tab:       { label: "⇥", content: "\t" },
    enter:     { label: "⏎", content: "\r" },
    backspace: { label: "↤", content: "\x7F" },
    space:     { label: " ", content: " " },

    up:        { label: "↑", content: "\x1b[A", appKeypadContent: "\x1bOA" },
    down:      { label: "↓", content: "\x1b[B", appKeypadContent: "\x1bOB" },
    right:     { label: "→", content: "\x1b[C", appKeypadContent: "\x1bOC" },
    left:      { label: "←", content: "\x1b[D", appKeypadContent: "\x1bOD" },

    insert:    { label: "INS", content: "\x1b[2~" },
    del:       { label: "DEL", content: "\x1b[3~" },
    home:      { label: "⇱", content: "\x1bOH" },
    end:       { label: "⇲", content: "\x1bOF" },

    prevPage:  { label: "⇈", content: "\x1b[5~" },
    nextPage:  { label: "⇊", content: "\x1b[6~" },
  };

  var keypad = [
    [ "esc",  "up",    "backspace", "del"  ],
    [ "left", "space", "right",     "home" ],
    [ "tab",  "down",  "enter",     "end"  ],
  ];

  this.buttons = [];
  this.inlineKeyboard = keypad.map(function (row) {
    return row.map(function (name) {
      var button = keys[name];
      var data = JSON.stringify({ token: this.keypadToken, button: this.buttons.length });
      var keyboardButton = { text: button.label, callback_data: data };
      this.buttons.push(button);
      return keyboardButton;
    }.bind(this));
  }.bind(this));

  this.reply.bot.callback(function (query, next) {
    try {
      var data = JSON.parse(query.data);
    } catch (e) { return next(); }
    if (data.token !== this.keypadToken) return next();
    this._keypadPressed(data.button, query);
  }.bind(this));
};

Command.prototype.toggleKeypad = function toggleKeypad() {
  if (this.keypadMessage) {
    this.keypadMessage.markup = null;
    this.keypadMessage.refresh();
    this.keypadMessage = null;
    return;
  }

  // FIXME: this is pretty badly implemented, we should wait until last message (or message with cursor) has known id
  var messages = this.renderer.messages;
  var msg = messages[messages.length - 1].ref;
  msg.markup = {inline_keyboard: this.inlineKeyboard};
  msg.refresh();
  this.keypadMessage = msg;
};

Command.prototype._keypadPressed = function _keypadPressed(id, query) {
  this.interacted = true;
  if (typeof id !== "number" || !(id in this.buttons)) return;
  var button = this.buttons[id];
  var content = button.content;
  if (button.appKeypadContent !== undefined && this.state.getMode("appKeypad"))
    content = button.appKeypadContent;
  this.pty.write(content);
  query.answer();
};

Command.prototype._removeKeypad = function _removeKeypad() {
  if (this.keypadMessage) this.toggleKeypad();
};



exports.Command = Command;