265 lines
8.9 KiB
JavaScript
265 lines
8.9 KiB
JavaScript
/**
|
|
* 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;
|