+ If message is an object it sets the full content of the message.
+
Room ID to send image to. Optional if configured on the node. If configured on the node this input will be overridden.
msg.payload
- string
+ string|object
-
the message text. If configured on the node this is ignored otherwise it required.
+
the message text or an object to customize the full content. If configured on the node this is ignored otherwise it required.
msg.replace
bool
diff --git a/src/matrix-send-message.js b/src/matrix-send-message.js
index 632ace5..c975348 100644
--- a/src/matrix-send-message.js
+++ b/src/matrix-send-message.js
@@ -70,22 +70,6 @@ module.exports = function(RED) {
let msgType = node.messageType,
msgFormat = node.messageFormat;
- if(msgType === 'msg.type') {
- if(!msg.type) {
- node.error("msg.type type is set to be passed in via msg.type but was not defined", msg);
- return;
- }
- msgType = msg.type;
- }
-
- if(msgFormat === 'msg.format') {
- if(!msg.format) {
- node.error("Message format is set to be passed in via msg.format but was not defined", msg);
- return;
- }
- msgFormat = msg.format;
- }
-
if (!node.server || !node.server.matrixClient) {
node.warn("No matrix server selected");
return;
@@ -109,36 +93,57 @@ module.exports = function(RED) {
return;
}
- let content = {
- msgtype: msgType,
- body: payload.toString()
- };
-
- if(msgFormat === 'html') {
- content.format = "org.matrix.custom.html";
- content.formatted_body =
- (typeof msg.formatted_payload !== 'undefined' && msg.formatted_payload)
- ? msg.formatted_payload.toString()
- : payload.toString();
- }
-
- if((node.replaceMessage || msg.replace) && msg.eventId) {
- content['m.new_content'] = {
- msgtype: content.msgtype,
- body: content.body
- };
- if('format' in content) {
- content['m.new_content']['format'] = content['format'];
- }
- if('formatted_body' in content) {
- content['m.new_content']['formatted_body'] = content['formatted_body'];
+ let content = null;
+ if(typeof payload === 'object') {
+ content = payload;
+ } else {
+ if(msgType === 'msg.type') {
+ if(!msg.type) {
+ node.error("msg.type type is set to be passed in via msg.type but was not defined", msg);
+ return;
+ }
+ msgType = msg.type;
}
- content['m.relates_to'] = {
- rel_type: RelationType.Replace,
- event_id: msg.eventId
+ if(msgFormat === 'msg.format') {
+ if(!msg.format) {
+ node.error("Message format is set to be passed in via msg.format but was not defined", msg);
+ return;
+ }
+ msgFormat = msg.format;
+ }
+
+ content = {
+ msgtype: msgType,
+ body: payload.toString()
};
- content['body'] = ' * ' + content['body'];
+
+ if(msgFormat === 'html') {
+ content.format = "org.matrix.custom.html";
+ content.formatted_body =
+ (typeof msg.formatted_payload !== 'undefined' && msg.formatted_payload)
+ ? msg.formatted_payload.toString()
+ : payload.toString();
+ }
+
+ if((node.replaceMessage || msg.replace) && msg.eventId) {
+ content['m.new_content'] = {
+ msgtype: content.msgtype,
+ body: content.body
+ };
+ if('format' in content) {
+ content['m.new_content']['format'] = content['format'];
+ }
+ if('formatted_body' in content) {
+ content['m.new_content']['formatted_body'] = content['formatted_body'];
+ }
+
+ content['m.relates_to'] = {
+ rel_type: RelationType.Replace,
+ event_id: msg.eventId
+ };
+ content['body'] = ' * ' + content['body'];
+ }
}
node.server.matrixClient.sendMessage(msg.topic, content)
diff --git a/src/matrix-typing.html b/src/matrix-typing.html
index b426357..cd6cf74 100644
--- a/src/matrix-typing.html
+++ b/src/matrix-typing.html
@@ -76,7 +76,7 @@
- Timeout MS is how many milliseconds the server should show the user typing for.
+ Timeout Milliseconds is how many milliseconds the server should show the user typing for. Ignored if setting typing to false.
diff --git a/src/matrix-upload-file.html b/src/matrix-upload-file.html
new file mode 100644
index 0000000..e0aa396
--- /dev/null
+++ b/src/matrix-upload-file.html
@@ -0,0 +1,163 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/matrix-upload-file.js b/src/matrix-upload-file.js
new file mode 100644
index 0000000..a203615
--- /dev/null
+++ b/src/matrix-upload-file.js
@@ -0,0 +1,471 @@
+const crypto = require("isomorphic-webcrypto");
+const ffmpeg = require('fluent-ffmpeg');
+const getImageSize = require('image-size');
+const tmp = require('tmp');
+const fs = require('fs');
+const path = require('path');
+module.exports = function(RED) {
+ function MatrixUploadFile(n) {
+ RED.nodes.createNode(this, n);
+
+ let node = this;
+
+ this.name = n.name;
+ this.server = RED.nodes.getNode(n.server);
+ this.inputType = n.inputType;
+ this.inputValue = n.inputValue;
+ this.fileNameType = n.fileNameType;
+ this.fileNameValue = n.fileNameValue;
+ this.contentType = n.contentType;
+ this.generateThumbnails = n.generateThumbnails;
+
+ if (!node.server) {
+ node.warn("No configuration node");
+ return;
+ }
+ node.server.register(node);
+
+ node.status({ fill: "red", shape: "ring", text: "disconnected" });
+
+ node.server.on("disconnected", function(){
+ node.status({ fill: "red", shape: "ring", text: "disconnected" });
+ });
+
+ node.server.on("connected", function() {
+ node.status({ fill: "green", shape: "ring", text: "connected" });
+ });
+
+ async function detectFileType(filename, bufferOrPath)
+ {
+ const Mime = require('mime');
+ let file = Buffer.isBuffer(bufferOrPath) ? filename : bufferOrPath;
+
+ if(file)
+ {
+ let type = Mime.getType(file);
+ let ext = Mime.getExtension(file);
+ if(type) {
+ return {ext: ext, mime: type}
+ }
+ }
+ }
+
+ function getFileBuffer(data)
+ {
+ if(Buffer.isBuffer(data)) {
+ return data;
+ }
+
+ if (data && RED.settings.fileWorkingDirectory && !path.isAbsolute(data)) {
+ return fs.readFileSync(path.resolve(path.join(RED.settings.fileWorkingDirectory,data)));
+ }
+ return fs.readFileSync(data);
+ }
+
+ function getToValue(msg, type, property) {
+ let value = property;
+ if (type === "msg") {
+ value = RED.util.getMessageProperty(msg, property);
+ } else if ((type === 'flow') || (type === 'global')) {
+ try {
+ value = RED.util.evaluateNodeProperty(property, type, node, msg);
+ } catch(e2) {
+ throw new Error("Invalid value evaluation");
+ }
+ } else if(type === "bool") {
+ value = (property === 'true');
+ } else if(type === "num") {
+ value = Number(property);
+ }
+ return value;
+ }
+
+ node.on("input", onInput);
+ async function onInput(msg)
+ {
+ if (! node.server || ! node.server.matrixClient) {
+ node.warn("No matrix server selected");
+ return;
+ }
+
+ if(!node.server.isConnected()) {
+ node.error("Matrix server connection is currently closed", msg);
+ msg.error = "Matrix server connection is currently closed";
+ node.send([null, msg]);
+ return;
+ }
+
+ let bufferOrPath = getToValue(msg, node.inputType, node.inputValue);
+ if(!bufferOrPath) {
+ node.error('Missing file path/buffer input', msg);
+ msg.error = 'Missing file path/buffer input';
+ node.send([null, msg]);
+ return;
+ }
+
+ let filename = getToValue(msg, node.fileNameType, node.fileNameValue);
+ if(!filename || typeof filename !== 'string') {
+ if(!Buffer.isBuffer(bufferOrPath)) {
+ filename = path.basename(bufferOrPath);
+ } else {
+ node.error('Missing filename, this is required if input is a file buffer', msg);
+ msg.error = 'Missing filename, this is required if input is a file buffer';
+ node.send([null, msg]);
+ return;
+ }
+ }
+
+ msg.contentType = node.contentType || msg.contentType || null;
+ let detectedFileType = await detectFileType(filename, bufferOrPath);
+ node.log("Detected file type " + JSON.stringify(detectedFileType) + " for " + (Buffer.isBuffer(bufferOrPath) ? 'buffer' : `file ${bufferOrPath}`), msg);
+
+ let contentType = msg.contentType || detectedFileType?.mime || null,
+ msgtype = msg.msgtype || null;
+ if(!contentType) {
+ node.warn("Content-type failed to detect, falling back to text/plain", msg);
+ contentType = 'text/plain';
+ }
+ if(!msgtype) {
+ msgtype = autoDetectMatrixMessageType(detectedFileType);
+ }
+
+ let encryptedFile = null;
+ if(msg.encrypted) {
+ encryptedFile = await encryptAttachment(getFileBuffer(bufferOrPath));
+ }
+
+ node.log("Uploading file ", msg);
+ let file;
+ try {
+ file = await node.server.matrixClient.uploadContent(
+ encryptedFile?.data || getFileBuffer(bufferOrPath),
+ {
+ name: filename, // Name to give the file on the server.
+ rawResponse: false, // Return the raw body, rather than parsing the JSON.
+ type: contentType, // Content-type for the upload. Defaults to file.type, or applicaton/octet-stream.
+ onlyContentUri: false // Just return the content URI, rather than the whole body. Defaults to false. Ignored if opts.rawResponse is true.
+ });
+ } catch(e) {
+ node.error("Upload content error " + e);
+ msg.error = e;
+ node.send([null, msg]);
+ return;
+ }
+
+ // we call this method when we need a file and cannot use the buffer
+ // so if we get passed a buffer we write it to a tmp file and return that
+ // otherwise we just return the string because it's already a file
+ let tempFile = null;
+ function getFile(bufferOrFile) {
+ if(!Buffer.isBuffer(bufferOrFile)) {
+ return bufferOrFile; // already a file
+ }
+
+ if(tempFile) {
+ return tempFile;
+ }
+
+ // write buffer to tmp file and return path
+ let tmpObj = tmp.fileSync({ postfix: `.${detectedFileType.ext}` });
+ fs.writeFileSync(tmpObj.name, bufferOrFile);
+ tempFile = tmpObj.name;
+ return tmpObj.name;
+ }
+
+ function deleteTempFile() {
+ if(!tempFile) return null;
+ fs.rmSync(tempFile);
+ }
+
+ // get size of a buffer or file in bytes
+ function getFileSize(bufferOrPath) {
+ if(Buffer.isBuffer(bufferOrPath)) {
+ return Buffer.byteLength(bufferOrPath);
+ }
+
+ return fs.statSync(bufferOrPath).size;
+ }
+
+ async function addThumbnail(buffer) {
+ let imageSize = getImageSize(Buffer.isBuffer(buffer) ? buffer : buffer.data);
+ msg.payload.info.thumbnail_info = {
+ w: imageSize.width,
+ h: imageSize.height,
+ size: getFileSize(Buffer.isBuffer(buffer) ? buffer : buffer.data)
+ }
+ let uploadedThumbnail = await node.server.matrixClient.uploadContent(
+ Buffer.isBuffer(buffer) ? buffer : buffer.data,
+ {
+ name: "thumbnail.png", // Name to give the file on the server.
+ rawResponse: false, // Return the raw body, rather than parsing the JSON.
+ type: "image/png", // Content-type for the upload. Defaults to file.type, or applicaton/octet-stream.
+ onlyContentUri: false // Just return the content URI, rather than the whole body. Defaults to false. Ignored if opts.rawResponse is true.
+ });
+ // delete local file
+ if(msg.encrypted) {
+ msg.payload.info.thumbnail_file.url = uploadedThumbnail.content_uri;
+ } else {
+ msg.payload.info.thumbnail_url = uploadedThumbnail.content_uri;
+ }
+ }
+
+ function _ffmpegVideoThumbnail(filepath){
+ return new Promise((resolve,reject) => {
+ let filename = `${msg._msgid}-screenshot.png`;
+ ffmpeg(filepath)
+ .on('end', async function() {
+ let path = `/tmp/${filename}`;
+ let buffer = getFileBuffer(path);
+ let encryptedThumbnail = null;
+ if(msg.encrypted) {
+ encryptedThumbnail = await encryptAttachment(buffer);
+ msg.payload.info.thumbnail_file = encryptedFile.info;
+ }
+ try {
+ await addThumbnail(encryptedThumbnail || buffer);
+ fs.rmSync(path); // delete temporary thumbnail file
+ resolve();
+ } catch(e) {
+ return reject(new Error("Thumbnail upload failure: " + e));
+ }
+ })
+ .on('error', function(err) {
+ return reject(err);
+ })
+ .screenshots({
+ timestamps: [0],
+ filename: filename,
+ folder: '/tmp',
+ size: '320x?'
+ });
+ });
+ }
+
+ msg.payload = {};
+ if(msg.encrypted) {
+ msg.payload.file = encryptedFile?.info || {};
+ msg.payload.file.url = file.content_uri;
+ } else {
+ msg.payload.url = file.content_uri;
+ }
+ msg.payload.msgtype = msgtype;
+ msg.payload.body = msg.body || msg.filename || "";
+ msg.payload.info = {
+ "mimetype": contentType,
+ "size": getFileSize(bufferOrPath),
+ };
+ if(msgtype === 'm.image') {
+ // detect size of image
+ try {
+ let imageSize = getImageSize(buffer);
+ msg.payload.info.h = imageSize.height;
+ msg.payload.info.w = imageSize.width;
+ } catch(e) {
+ node.error("Failed to get image size: " + e, msg);
+ }
+ } else if(msgtype === 'm.audio' && detectedFileType) {
+ try {
+ // detect duration of audio clip
+ let filepath = getFile(bufferOrPath);
+ let metadata = await _ffprobe(filepath);
+ let audioStream = metadata?.streams.filter(function(stream){return stream.codec_type === "audio" || false;})[0];
+ if(audioStream?.duration) {
+ msg.payload.info.duration = audioStream?.duration * 1000;
+ }
+ } catch(e) {
+ node.error(e, msg);
+ }
+ deleteTempFile();
+ } else if(msgtype === 'm.video' && detectedFileType) {
+ let filepath = getFile(bufferOrPath);
+
+ try {
+ // detect duration & width/height of video clip
+ let metadata = await _ffprobe(filepath);
+ let videoStream = metadata?.streams.filter(function(stream){return stream.codec_type === "video" || false;})[0];
+ if(videoStream) {
+ msg.payload.info.duration = videoStream.duration * 1000;
+ msg.payload.info.w = videoStream.width;
+ msg.payload.info.h = videoStream.height;
+ }
+ } catch(e) {
+ node.error("ffprobe error: " + e);
+ }
+
+ if(node.generateThumbnails) {
+ try {
+ await _ffmpegVideoThumbnail(filepath);
+ } catch(e) {
+ node.error("Screenshot generation error: " + e);
+ }
+ }
+ deleteTempFile();
+ }
+
+ node.send(msg, null);
+ }
+
+ node.on("close", function() {
+ node.server.deregister(node);
+ });
+ }
+ RED.nodes.registerType("matrix-upload-file", MatrixUploadFile);
+
+ // the following was taken & modified from https://github.com/matrix-org/browser-encrypt-attachment/blob/master/index.js
+ /**
+ * Encrypt an attachment.
+ * @param {ArrayBuffer} plaintextBuffer The attachment data buffer.
+ * @return {Promise} A promise that resolves with an object when the attachment is encrypted.
+ * The object has a "data" key with an ArrayBuffer of encrypted data and an "info" key
+ * with an object containing the info needed to decrypt the data.
+ */
+ function encryptAttachment(plaintextBuffer) {
+ let cryptoKey; // The AES key object.
+ let exportedKey; // The AES key exported as JWK.
+ let ciphertextBuffer; // ArrayBuffer of encrypted data.
+ let sha256Buffer; // ArrayBuffer of digest.
+ let ivArray; // Uint8Array of AES IV
+ // Generate an IV where the first 8 bytes are random and the high 8 bytes
+ // are zero. We set the counter low bits to 0 since it makes it unlikely
+ // that the 64 bit counter will overflow.
+ ivArray = new Uint8Array(16);
+ crypto.getRandomValues(ivArray.subarray(0,8));
+ // Load the encryption key.
+ return crypto.subtle.generateKey(
+ {"name": "AES-CTR", length: 256}, true, ["encrypt", "decrypt"]
+ ).then(function(generateKeyResult) {
+ cryptoKey = generateKeyResult;
+ // Export the Key as JWK.
+ return crypto.subtle.exportKey("jwk", cryptoKey);
+ }).then(function(exportKeyResult) {
+ exportedKey = exportKeyResult;
+ // Encrypt the input ArrayBuffer.
+ // Use half of the iv as the counter by setting the "length" to 64.
+ return crypto.subtle.encrypt(
+ {name: "AES-CTR", counter: ivArray, length: 64}, cryptoKey, plaintextBuffer
+ );
+ }).then(function(encryptResult) {
+ ciphertextBuffer = encryptResult;
+ // SHA-256 the encrypted data.
+ return crypto.subtle.digest("SHA-256", ciphertextBuffer);
+ }).then(function (digestResult) {
+ sha256Buffer = digestResult;
+
+ return {
+ data: ciphertextBuffer,
+ info: {
+ v: "v2",
+ key: exportedKey,
+ iv: encodeBase64(ivArray),
+ hashes: {
+ sha256: encodeBase64(new Uint8Array(sha256Buffer)),
+ },
+ },
+ };
+ });
+ }
+
+ /**
+ * Decrypt an attachment.
+ * @param {ArrayBuffer} ciphertextBuffer The encrypted attachment data buffer.
+ * @param {Object} info The information needed to decrypt the attachment.
+ * @param {Object} info.key AES-CTR JWK key object.
+ * @param {string} info.iv Base64 encoded 16 byte AES-CTR IV.
+ * @param {string} info.hashes.sha256 Base64 encoded SHA-256 hash of the ciphertext.
+ * @return {Promise} A promise that resolves with an ArrayBuffer when the attachment is decrypted.
+ */
+ function decryptAttachment(ciphertextBuffer, info) {
+
+ if (info === undefined || info.key === undefined || info.iv === undefined
+ || info.hashes === undefined || info.hashes.sha256 === undefined) {
+ throw new Error("Invalid info. Missing info.key, info.iv or info.hashes.sha256 key");
+ }
+
+ let cryptoKey; // The AES key object.
+ let ivArray = decodeBase64(info.iv);
+ let expectedSha256base64 = info.hashes.sha256;
+ // Load the AES from the "key" key of the info object.
+ return crypto.subtle.importKey(
+ "jwk", info.key, {"name": "AES-CTR"}, false, ["encrypt", "decrypt"]
+ ).then(function (importKeyResult) {
+ cryptoKey = importKeyResult;
+ // Check the sha256 hash
+ return crypto.subtle.digest("SHA-256", ciphertextBuffer);
+ }).then(function (digestResult) {
+ if (encodeBase64(new Uint8Array(digestResult)) !== expectedSha256base64) {
+ throw new Error("Mismatched SHA-256 digest (expected: " + encodeBase64(new Uint8Array(digestResult)) + ") got (" + expectedSha256base64 + ")");
+ }
+ let counterLength;
+ if (info.v.toLowerCase() === "v1" || info.v.toLowerCase() === "v2") {
+ // Version 1 and 2 use a 64 bit counter.
+ counterLength = 64;
+ } else {
+ // Version 0 uses a 128 bit counter.
+ counterLength = 128;
+ }
+ return crypto.subtle.decrypt(
+ {name: "AES-CTR", counter: ivArray, length: counterLength}, cryptoKey, ciphertextBuffer
+ );
+ });
+ }
+
+ /**
+ * Encode a typed array of uint8 as base64.
+ * @param {Uint8Array} uint8Array The data to encode.
+ * @return {string} The base64 without padding.
+ */
+ function encodeBase64(uint8Array) {
+ // Misinterpt the Uint8Array as Latin-1.
+ // window.btoa expects a unicode string with codepoints in the range 0-255.
+ // var latin1String = String.fromCharCode.apply(null, uint8Array);
+ // Use the builtin base64 encoder.
+ var paddedBase64 = btoa(uint8Array);
+ // Calculate the unpadded length.
+ var inputLength = uint8Array.length;
+ var outputLength = 4 * Math.floor((inputLength + 2) / 3) + (inputLength + 2) % 3 - 2;
+ // Return the unpadded base64.
+ return paddedBase64.slice(0, outputLength);
+ }
+
+ /**
+ * Decode a base64 string to a typed array of uint8.
+ * This will decode unpadded base64, but will also accept base64 with padding.
+ * @param {string} base64 The unpadded base64 to decode.
+ * @return {Uint8Array} The decoded data.
+ */
+ function decodeBase64(base64) {
+ // Pad the base64 up to the next multiple of 4.
+ var paddedBase64 = base64 + "===".slice(0, (4 - base64.length % 4) % 4);
+ // Decode the base64 as a misinterpreted Latin-1 string.
+ // window.atob returns a unicode string with codepoints in the range 0-255.
+ var latin1String = atob(paddedBase64);
+ // Encode the string as a Uint8Array as Latin-1.
+ var uint8Array = new Uint8Array(latin1String.length);
+ for (var i = 0; i < latin1String.length; i++) {
+ uint8Array[i] = latin1String.charCodeAt(i);
+ }
+ return uint8Array;
+ }
+
+ function autoDetectMatrixMessageType(fileType) {
+ switch(fileType ? fileType.mime.split('/')[0].toLowerCase() : undefined) {
+ case 'video': return 'm.video';
+ case 'image': return 'm.image';
+ case 'audio': return 'm.audio';
+ default: return 'm.file';
+ }
+ }
+
+ // ffprobe method for getting metadata from a file wrapped in a promise
+ function _ffprobe(filepath){
+ return new Promise((resolve,reject) => {
+ ffmpeg.ffprobe(filepath, function(err, metadata) {
+ if(err) {
+ return reject(new Error(err));
+ }
+
+ resolve(metadata);
+ });
+ });
+ }
+}
\ No newline at end of file