844 lines
No EOL
28 KiB
JavaScript
844 lines
No EOL
28 KiB
JavaScript
const CHAR_CTRL_A = '\x01';
|
|
const CHAR_CTRL_B = '\x02';
|
|
const CHAR_CTRL_C = '\x03';
|
|
const CHAR_CTRL_D = '\x04';
|
|
const CHAR_CTRL_E = '\x05';
|
|
const CHAR_CRLF = '\x0a\x0d';
|
|
const CHAR_BKSP = '\x08';
|
|
const CHAR_TITLE_START = "\x1b]0;";
|
|
const CHAR_TITLE_END = "\x1b\\";
|
|
const CHAR_RAW_PASTE_UNSUPPORTED = "R\x00";
|
|
const CHAR_RAW_PASTE_SUPPORTED = "R\x01";
|
|
const REGEX_RAW_PASTE_RESPONSE = /R[\x00\x01]..\x01/;
|
|
|
|
const MODE_NORMAL = 1;
|
|
const MODE_RAW = 2;
|
|
const MODE_RAWPASTE = 3;
|
|
|
|
const TYPE_DIR = 16384;
|
|
const TYPE_FILE = 32768;
|
|
|
|
export const LINE_ENDING_CRLF = "\r\n";
|
|
export const LINE_ENDING_LF = "\n";
|
|
|
|
const CONTROL_SEQUENCES = [
|
|
REGEX_RAW_PASTE_RESPONSE
|
|
];
|
|
|
|
// TODO: The title occasionally has duplicate characters (such as 2 snakes). Likely the buffer pointers need adjusting.
|
|
// TODO: Get Raw Mode working
|
|
// TODO: Add parsing for non-english languages (alternatively, only look at symbols that are common across the languages)
|
|
|
|
// Mostly needed when the terminal echos back the input
|
|
const IGNORE_OUTPUT_LINE_PREFIXES = [/^\... /, /^>>> /];
|
|
|
|
// Default timeouts in milliseconds (can be overridden with properties)
|
|
const PROMPT_TIMEOUT = 10000;
|
|
const CODE_EXECUTION_TIMEOUT = 15000;
|
|
const PROMPT_CHECK_INTERVAL = 50;
|
|
|
|
const REGEX_PROMPT_RAW_MODE = /raw REPL; CTRL-B to exit/;
|
|
|
|
// Class to use python code to get file information
|
|
// We want to do stuff like writing files, reading files, and listing files
|
|
export class FileOps {
|
|
constructor(repl, checkReadOnly=true) {
|
|
this._repl = repl;
|
|
this._isReadOnly = null;
|
|
this._doCheckReadOnly = checkReadOnly;
|
|
}
|
|
|
|
async _checkReadOnly() {
|
|
if (!this._doCheckReadOnly) {
|
|
return;
|
|
}
|
|
|
|
if (this._isReadOnly == null) {
|
|
this._isReadOnly = await this.isReadOnly();
|
|
}
|
|
|
|
if (this._isReadOnly()) {
|
|
throw new Error("File System is Read Only. Try disabling or ejecting the drive.");
|
|
}
|
|
}
|
|
|
|
async _checkReplErrors() {
|
|
let error = this._repl.getErrorOutput();
|
|
if (error && error.type == "OSError" && error.errno == 30) {
|
|
this._isReadOnly = true;
|
|
// Throw an error if needed
|
|
await this._checkReadOnly();
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
// Write a file to the device path with contents beginning at offset. Modification time can be set and if raw is true, contents is written as binary
|
|
async _writeRawFile(path, contents, offset=0, modificationTime=null) {
|
|
let byteString = "";
|
|
// Contents needs to be converted from a ArrayBuffer to a byte string
|
|
let view = new Uint8Array(contents);
|
|
for (let byte of view) {
|
|
byteString += String.fromCharCode(byte);
|
|
}
|
|
contents = btoa(byteString); // Convert binary string to base64
|
|
|
|
let code = `
|
|
import binascii
|
|
with open("${path}", "wb") as f:
|
|
f.seek(${offset})
|
|
byte_string = binascii.a2b_base64("${contents}")
|
|
f.write(byte_string)
|
|
`;
|
|
|
|
if (modificationTime) {
|
|
code += `os.utime("${path}", (os.path.getatime("${path}"), ${modificationTime}))\n`;
|
|
}
|
|
await this._repl.execRawPasteMode(code);
|
|
}
|
|
|
|
async _writeTextFile(path, contents, offset=0, modificationTime=null) {
|
|
// The contents needs to be converted from a UInt8Array to a string
|
|
contents = String.fromCharCode.apply(null, contents);
|
|
contents = contents.replace(/"/g, '\\"');
|
|
|
|
let code = `
|
|
with open("${path}", "w") as f:
|
|
f.seek(${offset})
|
|
f.write("""${contents}""")
|
|
`;
|
|
|
|
if (modificationTime) {
|
|
code += `os.utime("${path}", (os.path.getatime("${path}"), ${modificationTime}))\n`;
|
|
}
|
|
await this._repl.execRawPasteMode(code);
|
|
}
|
|
|
|
// Write a file to the device path with contents beginning at offset. Modification time can be set and if raw is true, contents is written as binary
|
|
async writeFile(path, contents, offset=0, modificationTime=null, raw=false) {
|
|
this._repl.terminalOutput = false;
|
|
|
|
if (raw) {
|
|
await this._writeRawFile(path, contents, offset, modificationTime);
|
|
} else {
|
|
await this._writeTextFile(path, contents, offset, modificationTime);
|
|
}
|
|
|
|
this._repl.terminalOutput = true;
|
|
}
|
|
|
|
async _readRawFile(path) {
|
|
try {
|
|
let code = `
|
|
import binascii
|
|
with open("${path}", "rb") as f:
|
|
byte_string = f.read()
|
|
print(binascii.b2a_base64(byte_string, False))
|
|
`;
|
|
let result = await this._repl.execRawPasteMode(code);
|
|
if (this._checkReplErrors()) {
|
|
return null;
|
|
}
|
|
|
|
// strip the b, ending newline, and quotes from the beginning and end
|
|
result = result.slice(2, -3);
|
|
|
|
// convert the base64 string to an ArrayBuffer. Each byte of the Array buffer is a byte of the file with a value between 0-255
|
|
result = atob(result); // Convert base64 to binary string
|
|
let length = result.length;
|
|
let buffer = new ArrayBuffer(length);
|
|
let view = new Uint8Array(buffer);
|
|
for (let i = 0; i < length; i++) {
|
|
view[i] = result.charCodeAt(i);
|
|
}
|
|
|
|
result = new Blob([buffer]);
|
|
return result;
|
|
} catch(error) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async _readTextFile(path) {
|
|
try {
|
|
let code = `
|
|
with open("${path}", "r") as f:
|
|
print(f.read())
|
|
`;
|
|
let result = await this._repl.execRawPasteMode(code);
|
|
if (this._checkReplErrors()) {
|
|
return null;
|
|
}
|
|
|
|
// Remove last 2 bytes from the result because \r\n is added to the end
|
|
return result.slice(0, -2);
|
|
} catch(error) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Read a file from the device
|
|
async readFile(path, raw=false) {
|
|
let result;
|
|
this._repl.terminalOutput = false;
|
|
|
|
if (raw) {
|
|
result = await this._readRawFile(path);
|
|
} else {
|
|
result = await this._readTextFile(path);
|
|
}
|
|
|
|
this._repl.terminalOutput = true;
|
|
return result;
|
|
}
|
|
|
|
// List files using paste mode on the device returning the result as a javascript array
|
|
// We need the file name, whether or not it is a directory, file size and file date
|
|
async listDir(path) {
|
|
this._repl.terminalOutput = false;
|
|
// Mask sure path has a trailing slash
|
|
if (path[path.length - 1] != "/") {
|
|
path += "/";
|
|
}
|
|
|
|
let code = `
|
|
import os
|
|
import time
|
|
contents = os.listdir("${path}")
|
|
for item in contents:
|
|
result = os.stat("${path}" + item)
|
|
print(item, result[0], result[6], result[9])
|
|
`;
|
|
const result = await this._repl.execRawPasteMode(code);
|
|
let contents = [];
|
|
if (!result) {
|
|
return contents;
|
|
}
|
|
for (let line of result.split("\n")) {
|
|
let [name, isDir, fileSize, fileDate] = line.split(" ");
|
|
contents.push({
|
|
path: name,
|
|
isDir: isDir == TYPE_DIR,
|
|
fileSize: parseInt(fileSize),
|
|
fileDate: parseInt(fileDate) * 1000,
|
|
});
|
|
}
|
|
this._repl.terminalOutput = true;
|
|
return contents;
|
|
}
|
|
|
|
async isReadOnly() {
|
|
this._repl.terminalOutput = false;
|
|
|
|
let code = `
|
|
import storage
|
|
print(storage.getmount("/").readonly)
|
|
`;
|
|
let result = await this._repl.execRawPasteMode(code);
|
|
let isReadOnly = result.match("True") != null;
|
|
this._repl.terminalOutput = true;
|
|
|
|
return isReadOnly;
|
|
}
|
|
|
|
async makeDir(path, modificationTime=null) {
|
|
await this._checkReadOnly();
|
|
this._repl.terminalOutput = false;
|
|
let code = `os.mkdir("${path}")\n`;
|
|
if (modificationTime) {
|
|
code += `os.utime("${path}", (os.path.getatime("${path}"), ${modificationTime}))\n`;
|
|
}
|
|
await this._repl.execRawPasteMode(code);
|
|
this._checkReplErrors();
|
|
this._repl.terminalOutput = true;
|
|
}
|
|
|
|
async delete(path) {
|
|
await this._checkReadOnly();
|
|
this._repl.terminalOutput = false;
|
|
let code = `
|
|
import os
|
|
|
|
stat = os.stat("${path}")
|
|
if stat[0] == ${TYPE_FILE}:
|
|
os.remove("${path}")
|
|
else:
|
|
os.rmdir("${path}")
|
|
`;
|
|
await this._repl.execRawPasteMode(code);
|
|
this._checkReplErrors();
|
|
this._repl.terminalOutput = true;
|
|
}
|
|
|
|
async move(oldPath, newPath) {
|
|
await this._checkReadOnly();
|
|
// we need to check if the new path already exists
|
|
// Return true on success and false on failure
|
|
|
|
this._repl.terminalOutput = false;
|
|
let code = `
|
|
import os
|
|
os.rename("${oldPath}", "${newPath}")
|
|
`;
|
|
await this._repl.execRawPasteMode(code);
|
|
let error = this._checkReplErrors();
|
|
this._repl.terminalOutput = true;
|
|
return !error;
|
|
}
|
|
}
|
|
|
|
export class REPL {
|
|
constructor() {
|
|
this._pythonCodeRunning = false;
|
|
this._codeOutput = '';
|
|
this._errorOutput = '';
|
|
this._serialInputBuffer = '';
|
|
this._checkingPrompt = false;
|
|
this._titleMode = false;
|
|
this.promptTimeout = PROMPT_TIMEOUT;
|
|
this.promptCheckInterval = PROMPT_CHECK_INTERVAL;
|
|
this.title = '';
|
|
this.serialTransmit = null;
|
|
this._inputLineEnding = LINE_ENDING_CRLF; // The line ending the REPL returns
|
|
this._outputLineEnding = LINE_ENDING_LF; // The line ending for the code result
|
|
this._tokenQueue = [];
|
|
this._mode = MODE_NORMAL;
|
|
this._codeCheckPointer = 0; // Used for looking at code output
|
|
this._promptCheckPointer = 0; // Used for looking at prompt output/control characters
|
|
this._ctrlDCount = 0;
|
|
this.terminalOutput = true;
|
|
}
|
|
|
|
_sleep(ms) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
_timeout(callback, ms) {
|
|
return Promise.race([callback(), this._sleep(ms).then(() => {throw Error("Timed Out");})]);
|
|
}
|
|
|
|
_getControlCharBuffer() {
|
|
// Return the Serial Buffer from _controlCharPointer to the next line ending and update the position of the pointer
|
|
let bufferLines, controlChar = '';
|
|
let remainingBuffer = this._serialInputBuffer.slice(this._controlCharPointer);
|
|
if (remainingBuffer.includes(this._inputLineEnding)) {
|
|
[controlChar, ...bufferLines] = remainingBuffer.split(this._inputLineEnding);
|
|
this._controlCharPointer += controlChar.length + this._inputLineEnding.length;
|
|
}
|
|
return controlChar;
|
|
}
|
|
|
|
_getInputBufferLines() {
|
|
return this._serialInputBuffer.split(this._inputLineEnding);
|
|
}
|
|
|
|
_lineIsPrompt(prompt_regex) {
|
|
let lines = this._getInputBufferLines();
|
|
if (lines.length == 0) {
|
|
return false;
|
|
}
|
|
let lastLine = lines[lines.length - 1];
|
|
return lastLine.match(prompt_regex);
|
|
}
|
|
|
|
_checkForModeChange() {
|
|
let lines = this._getInputBufferLines();
|
|
for (let line of lines) {
|
|
if (line.match(REGEX_PROMPT_RAW_MODE)) {
|
|
this._mode = MODE_RAW;
|
|
}
|
|
}
|
|
}
|
|
|
|
_currentLineIsNormalPrompt() {
|
|
return this._lineIsPrompt(/>>> $/);
|
|
}
|
|
|
|
_currentLineIsPastePrompt() {
|
|
return this._lineIsPrompt(/=== $/);
|
|
}
|
|
|
|
_currentLineIsPrompt() {
|
|
if (this._mode == MODE_NORMAL) {
|
|
return this._currentLineIsNormalPrompt();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
_regexEscape(regexString) {
|
|
return regexString.replace(/\\/, "\\\\");
|
|
}
|
|
|
|
setLineEnding(lineEnding) {
|
|
if (lineEnding != LINE_ENDING_CRLF && lineEnding != LINE_ENDING_LF) {
|
|
throw new Error("Line ending expected to be either be LINE_ENDING_CRLF or LINE_ENDING_LF")
|
|
}
|
|
|
|
this._outputLineEnding = lineEnding;
|
|
}
|
|
|
|
// This should help detect lines like ">>> ", but not ">>> 1+1"
|
|
async checkPrompt() {
|
|
if (this._mode == MODE_RAWPASTE) {
|
|
let bytes = this._serialInputBuffer.slice(this._promptCheckPointer);
|
|
this._promptCheckPointer += bytes.length;
|
|
while (bytes.length > 0) {
|
|
if (bytes.slice(0, 1).match(CHAR_CTRL_D)) {
|
|
this._ctrlDCount++;
|
|
//console.log("CTRL-D Count: " + this._ctrlDCount);
|
|
} else {
|
|
if (this._ctrlDCount == 1) {
|
|
// Code Output
|
|
this._codeOutput += bytes.slice(0, 1);
|
|
} else if (this._ctrlDCount == 2) {
|
|
// Error Output
|
|
this._errorOutput += bytes.slice(0, 1);
|
|
} else if (this._ctrlDCount > 2) {
|
|
// Code is done running
|
|
this._pythonCodeRunning = false;
|
|
} else if (!this._pythonCodeRunning && bytes.slice(0, 1).match(">")) {
|
|
// We're at a prompt
|
|
this._mode = MODE_RAW;
|
|
return;
|
|
}
|
|
}
|
|
|
|
bytes = bytes.slice(1); // Remove the first byte
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Only allow one instance of this function to run at a time (unless this could cause it to miss a prompt)
|
|
if (!this._currentLineIsPrompt()) {
|
|
return;
|
|
}
|
|
|
|
// Check again after a short delay to see if it's still a prompt
|
|
await this._sleep(this.promptCheckInterval);
|
|
|
|
if (!this._currentLineIsPrompt()) {
|
|
return;
|
|
}
|
|
|
|
this._pythonCodeRunning = false;
|
|
}
|
|
|
|
async waitForPrompt() {
|
|
this._pythonCodeRunning = true;
|
|
|
|
// Wait for a prompt
|
|
try {
|
|
await this._timeout(
|
|
async () => {
|
|
while (this._pythonCodeRunning) {
|
|
await this.getToPrompt();
|
|
await this._sleep(100);
|
|
}
|
|
}, this.promptTimeout
|
|
);
|
|
} catch (error) {
|
|
console.error("Awaiting prompt timed out.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
async softRestart() {
|
|
await this.serialTransmit(CHAR_CTRL_D);
|
|
}
|
|
|
|
async interruptCode() {
|
|
await this.serialTransmit(CHAR_CTRL_C);
|
|
}
|
|
|
|
getErrorOutput(raw = false) {
|
|
if (raw) {
|
|
return this._errorOutput;
|
|
}
|
|
if (!this._errorOutput) {
|
|
return null;
|
|
}
|
|
let errorOutput = this._errorOutput;
|
|
let errorLines = errorOutput.split(this._inputLineEnding);
|
|
let error = {
|
|
file: null,
|
|
line: null,
|
|
type: null,
|
|
message: null,
|
|
errno: null,
|
|
};
|
|
if (errorLines.length > 0) {
|
|
error.file = errorLines[1].match(/File "(.*)"/)[1];
|
|
error.line = parseInt(errorLines[1].match(/line (\d+)/)[1]);
|
|
error.type = errorLines[2].match(/(.+?):/)[1];
|
|
error.message = errorLines[2].match(/: (.+)$/)[1];
|
|
if (error.type == "OSError") {
|
|
error.errno = parseInt(error.message.match(/\[Errno (\d+)\]/)[1]);
|
|
error.message = error.message.replace(/\[Errno \d+\] /, '');
|
|
}
|
|
}
|
|
error.raw = errorOutput;
|
|
return error;
|
|
}
|
|
|
|
getCodeOutput() {
|
|
return this._codeOutput;
|
|
}
|
|
|
|
async getToPrompt() {
|
|
// We use GetToPrompt to ensure we are at a known place before running code
|
|
// This will get from Paste Mode or Running App to Normal Prompt
|
|
await this.serialTransmit(CHAR_CTRL_C + CHAR_CTRL_C);
|
|
// This will get from Raw Paste or Raw Mode to Normal Prompt
|
|
await this.serialTransmit(CHAR_CTRL_B + CHAR_CTRL_D + CHAR_CTRL_B);
|
|
this.mode = MODE_NORMAL;
|
|
}
|
|
|
|
async execRawMode(code) {
|
|
await this.enterRawMode();
|
|
await this.serialTransmit(code);
|
|
return await this.finishRawMode();
|
|
}
|
|
|
|
async execRawPasteMode(code, codeTimeoutMs=CODE_EXECUTION_TIMEOUT) {
|
|
let success = await this.enterRawPasteMode();
|
|
//console.log("Success: " + success);
|
|
if (success) {
|
|
// We're in raw mode only
|
|
await this.serialTransmit(code);
|
|
// We need to use flow control
|
|
let flowControlWindowSize = this._readSerialBytes(2);
|
|
// Convert 2 bytes from unsigned little endian to an integer
|
|
flowControlWindowSize = flowControlWindowSize.charCodeAt(0) + (flowControlWindowSize.charCodeAt(1) << 8);
|
|
let remainingWindowSize = flowControlWindowSize;
|
|
this._readSerialBytes(1); // Skip the last byte
|
|
this._clearSerialBytes(); // Clear the serial buffer to remove the previous Raw Prompt
|
|
//console.log("Flow Control Window Size: " + remainingWindowSize);
|
|
// Send the code in chunks up to the window size
|
|
let codeLength = code.length;
|
|
let codePointer = 0;
|
|
while (codePointer < codeLength) {
|
|
let chunk = code.slice(codePointer, codePointer + remainingWindowSize);
|
|
await this.serialTransmit(chunk);
|
|
codePointer += remainingWindowSize;
|
|
// Reduce the remain window size
|
|
remainingWindowSize -= chunk.length;
|
|
if (remainingWindowSize <= 0) {
|
|
// Read the next byte at the flow control pointer
|
|
let instruction = this._readSerialBytes(1);
|
|
if (instruction.match(CHAR_CTRL_A)) {
|
|
remainingWindowSize = flowControlWindowSize;
|
|
} else if (instruction.match(CHAR_CTRL_D)) {
|
|
// We're done
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Inform the device we're done
|
|
await this.serialTransmit(CHAR_CTRL_D);
|
|
this._ctrlDCount = 0;
|
|
this._pythonCodeRunning = true;
|
|
this._codeOutput = '';
|
|
this._errorOutput = '';
|
|
await this._waitForCodeExecution(codeTimeoutMs);
|
|
this._clearSerialBytes();
|
|
await this.exitRawMode();
|
|
return this._codeOutput.slice(Math.ceil(this._codeOutput.length / 2));
|
|
} else {
|
|
await this.execRawMode(code);
|
|
}
|
|
}
|
|
|
|
async _waitForCodeExecution(codeTimeoutMs=CODE_EXECUTION_TIMEOUT) {
|
|
// Wait for the code to finish running, so we can capture the output
|
|
if (codeTimeoutMs) {
|
|
try {
|
|
await this._timeout(
|
|
async () => {
|
|
while (this._pythonCodeRunning) {
|
|
await this._sleep(100);
|
|
}
|
|
}, codeTimeoutMs
|
|
);
|
|
} catch (error) {
|
|
console.log("Code timed out.");
|
|
}
|
|
} else {
|
|
// Run without timeout
|
|
while (this._pythonCodeRunning) {
|
|
await this._sleep(100);
|
|
}
|
|
}
|
|
}
|
|
|
|
_readSerialBytes(byteCount, offset=null) {
|
|
if (offset == null) {
|
|
offset = this._promptCheckPointer;
|
|
}
|
|
let bytes = this._serialInputBuffer.slice(offset, offset + byteCount);
|
|
this._promptCheckPointer += byteCount;
|
|
return bytes;
|
|
}
|
|
|
|
_clearSerialBytes(offset=null) {
|
|
// Should this only clear up to the lower of the 2 pointers? (codeCheckPointer and promptCheckPointer)
|
|
if (offset == null) {
|
|
offset = this._promptCheckPointer;
|
|
}
|
|
if (offset > this._serialInputBuffer.length) {
|
|
offset = this._serialInputBuffer.length;
|
|
}
|
|
|
|
this._serialInputBuffer = this._serialInputBuffer.slice(offset);
|
|
this._promptCheckPointer -= offset;
|
|
this._codeCheckPointer -= offset;
|
|
}
|
|
|
|
async enterRawPasteMode() {
|
|
await this.enterRawMode();
|
|
let bufferLength = this._serialInputBuffer.length;
|
|
await this.serialTransmit(CHAR_CTRL_E + "A" + CHAR_CTRL_A);
|
|
await this._timeout(
|
|
async () => {
|
|
while (this._serialInputBuffer.length < bufferLength + 2) {
|
|
await this._sleep(100);
|
|
}
|
|
}, this.promptTimeout
|
|
);
|
|
if (this._serialInputBuffer.length < bufferLength + 2) {
|
|
console.error("Failed to enter raw paste mode.");
|
|
return;
|
|
}
|
|
// Grab the two characters after bufferLength
|
|
let response = this._readSerialBytes(2, bufferLength);
|
|
|
|
if (response.match(CHAR_RAW_PASTE_UNSUPPORTED)) {
|
|
console.error("Device does not support raw paste mode.");
|
|
} else if (response.match(CHAR_RAW_PASTE_SUPPORTED)) {
|
|
this._mode = MODE_RAWPASTE;
|
|
return true;
|
|
} else if (response == "ra") {
|
|
console.error("Device does not understand or support raw paste mode.");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Execute pasted code
|
|
async finishRawMode() {
|
|
this._pythonCodeRunning = true;
|
|
this._codeOutput = '';
|
|
this._errorOutput = '';
|
|
await this.serialTransmit(CHAR_CTRL_D);
|
|
|
|
// Wait for the code to finish running, so we can capture the output
|
|
await this._waitForCodeExecution();
|
|
|
|
this._mode = MODE_NORMAL;
|
|
return this._codeOutput;
|
|
}
|
|
|
|
async _waitForModeChange(mode) {
|
|
await this._timeout(
|
|
async () => {
|
|
while (this._mode != mode) {
|
|
this._checkForModeChange();
|
|
await this._sleep(100);
|
|
}
|
|
}, this.promptTimeout
|
|
);
|
|
}
|
|
|
|
// Raw mode allows code execution without echoing back to the terminal
|
|
async enterRawMode() {
|
|
if (this._mode == MODE_RAW) {
|
|
return;
|
|
}
|
|
await this.getToPrompt();
|
|
await this.serialTransmit(CHAR_CTRL_A);
|
|
await this._waitForModeChange(MODE_RAW);
|
|
}
|
|
|
|
async exitRawMode() {
|
|
await this.serialTransmit(CHAR_CTRL_B);
|
|
// Wait for >>> to be displayed
|
|
this._mode = MODE_NORMAL;
|
|
}
|
|
|
|
_getSerialCodeOutput() {
|
|
let bufferLines, codeline = '';
|
|
// Get the remaining buffer from _codeCheckPointer to the next line ending and update the position of the pointer
|
|
let remainingBuffer = this._serialInputBuffer.slice(this._codeCheckPointer);
|
|
if (remainingBuffer.includes(this._inputLineEnding)) {
|
|
[codeline, ...bufferLines] = remainingBuffer.split(this._inputLineEnding);
|
|
this._codeCheckPointer += codeline.length + this._inputLineEnding.length;
|
|
}
|
|
return this._formatCodeOutput(codeline);
|
|
}
|
|
|
|
_formatCodeOutput(codeline) {
|
|
// Remove lines that are prompts or control characters and strip control sequences
|
|
// Return the result
|
|
for (let prefix of IGNORE_OUTPUT_LINE_PREFIXES) {
|
|
if (codeline.match(prefix)) {
|
|
return '';
|
|
}
|
|
}
|
|
for (let sequence of CONTROL_SEQUENCES) {
|
|
codeline = codeline.replace(sequence, '');
|
|
}
|
|
return codeline;
|
|
}
|
|
|
|
async onSerialReceive(e) {
|
|
// We tokenize the serial data to handle special character sequences (currently titles only)
|
|
// We don't want to modify e.data, so we make a copy of it
|
|
let data = e.data;
|
|
|
|
// Prepend a partial token if it exists
|
|
if (this._partialToken) {
|
|
data = this._partialToken + data;
|
|
this._partialToken = null;
|
|
}
|
|
|
|
// Tokenize the larger string and send to the parent
|
|
let tokens = this._tokenize(data);
|
|
|
|
// Remove any partial tokens and store for the next serial data receive
|
|
if (tokens.length && this._hasPartialToken(tokens.slice(-1))) {
|
|
this._partialToken = tokens.pop();
|
|
}
|
|
|
|
// Send only full tokens to the token queue
|
|
for (let token of tokens) {
|
|
this._tokenQueue.push(token);
|
|
}
|
|
await this._processQueuedTokens();
|
|
if (this.terminalOutput) {
|
|
return data;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
async _processQueuedTokens() {
|
|
if (this._processing) {
|
|
return;
|
|
}
|
|
this._processing = true;
|
|
while (this._tokenQueue.length) {
|
|
await this._processToken(this._tokenQueue.shift());
|
|
}
|
|
this._processing = false;
|
|
}
|
|
|
|
async _processToken(token) {
|
|
if (token == CHAR_TITLE_START) {
|
|
this._titleMode = true;
|
|
//console.log("Title Start");
|
|
this._setTitle("");
|
|
} else if (token == CHAR_TITLE_END) {
|
|
//console.log("Title End");
|
|
this._titleMode = false;
|
|
} else if (this._titleMode) {
|
|
//console.log("New Title: " + token);
|
|
this._setTitle(token, true);
|
|
}
|
|
|
|
let codelines = [];
|
|
let codeline;
|
|
this._serialInputBuffer += token;
|
|
if (this._pythonCodeRunning) {
|
|
// Check if we are at a prompt
|
|
this.checkPrompt(); // Run asynchronously to avoid blocking the serial receive
|
|
|
|
if (this._mode != MODE_RAWPASTE) {
|
|
do {
|
|
codeline = this._getSerialCodeOutput();
|
|
if (codeline) {
|
|
codelines.push(codeline);
|
|
}
|
|
} while (codeline.length > 0);
|
|
}
|
|
}
|
|
|
|
// Is it still running? Then we add to code output if there is any
|
|
if (this._pythonCodeRunning && codelines.length > 0) {
|
|
for (codeline of codelines) {
|
|
//console.log(codeline);
|
|
if (!codeline.match(/^\... /) && !codeline.match(/^>>> /) && !codeline.match(/^=== /)) {
|
|
if (this._mode != MODE_RAWPASTE) {
|
|
if (codeline.match(REGEX_PROMPT_RAW_MODE)) {
|
|
this._mode = MODE_RAW;
|
|
continue;
|
|
}
|
|
}
|
|
this._codeOutput += codeline + this._outputLineEnding;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Placeholder Function
|
|
setTitle(title, append=false) {
|
|
return;
|
|
}
|
|
|
|
_setTitle(title, append=false) {
|
|
if (append) {
|
|
title = this.title + title;
|
|
}
|
|
|
|
this.title = title;
|
|
|
|
this.setTitle(title, append);
|
|
}
|
|
|
|
getVersion() {
|
|
return this._parseTitleInfo(/\| REPL \| (.*)$/);
|
|
}
|
|
|
|
getIpAddress() {
|
|
return this._parseTitleInfo(/((?:\d{1,3}\.){3}\d{1,3})/);
|
|
}
|
|
|
|
_parseTitleInfo(regex) {
|
|
if (this.title) {
|
|
let matches = this.title.match(regex);
|
|
if (matches && matches.length >= 2) {
|
|
return matches[1];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
async _serialTransmit(msg) {
|
|
if (!this.serialTransmit) {
|
|
console.log("Default serial transmit function called. Message: " + msg);
|
|
throw new Error("REPL serialTransmit must be connected to an external transmit function");
|
|
} else {
|
|
return await this.serialTransmit(msg);
|
|
}
|
|
}
|
|
|
|
// Allows for supplied python code to be run on the device via the REPL in normal mode
|
|
async runCode(code, codeTimeoutMs=CODE_EXECUTION_TIMEOUT) {
|
|
await this.getToPrompt();
|
|
return this.execRawPasteMode(code + LINE_ENDING_LF, codeTimeoutMs);
|
|
}
|
|
|
|
// Split a string up by full title start and end character sequences
|
|
_tokenize(string) {
|
|
const tokenRegex = new RegExp("(" + this._regexEscape(CHAR_TITLE_START) + "|" + this._regexEscape(CHAR_TITLE_END) + "|" + this._regexEscape(CHAR_CTRL_D) + ")", "gi");
|
|
return string.split(tokenRegex);
|
|
}
|
|
|
|
// Check if a chunk of data has a partial title start/end character sequence at the end
|
|
_hasPartialToken(chunk) {
|
|
const partialToken = /\\x1b(?:\](?:0"?)?)?$/gi;
|
|
return partialToken.test(chunk);
|
|
}
|
|
} |