serverless-ircd 0.5.0 → 0.7.0

package/apps/web/upstream/src/libs/MessageParser.js

@@ -0,0 +1,249 @@
+'kiwi public';
+
+import { trim } from 'lodash';
+
+import * as EmojiProvider from '@/libs/EmojiProvider';
+import formatIrcMessage, { createNewBlock } from '@/libs/MessageFormatter';
+import { urlRegex, channelRegex } from '@/helpers/TextFormatting';
+
+/**
+ * Receives a message, parses its irc blocks, and then finds urls, users, channels and emoji. Each
+ * content is extracted to a separate block.
+ * E.g. the message:
+ *   "this is a message www.google.com and #kiwiirc"
+ * will be split into the blocks:
+ *   ["this is a message "]["www.google.com"][" and "]["#kiwiirc"]
+ * The special content blocks will also contain additional info about their content according to
+ * their type, such as the url, nick colour, emoji code...
+ * @param {Array} blocks Array of style blocks from MessageFormatter
+ * @param {Array} userList List of users to find within the message
+ * @returns An array of blocks, where each special content will be extracted into a separate block.
+ */
+export default function parseMessage(message, formatOpts = {}, userList = null) {
+    const blocks = formatIrcMessage(message, formatOpts);
+    let formatedBlocks = blocks.reduce(
+        (acc, block, i) => acc.concat(processBlock(block, userList)),
+        []
+    );
+
+    return formatedBlocks;
+}
+
+/**
+ * Receives a block, splits it into words and tries finding channels, urls, nicks, and emoji.
+ * @param {Object} block A block that came from MessageFormatter.formatIrcMessage()
+ * @param {Object} userList List of users to find within the message
+ * @returns An array of blocks, where each special content will be extracted into a separate block.
+ */
+function processBlock(block, userList) {
+    const wordsRegex = /\S+/g;
+
+    let wordMatch;
+    let word;
+    const specialMatches = [];
+    // Array containing the special matches. Each `specialMatch` is an object with:
+    // {
+    //    index: <index of the match>
+    //    match: <match, i.e. the text that will be extracted into a new block>
+    //    block: <the block that will replace the match>
+    // }
+
+    // eslint-disable-next-line no-cond-assign
+    while ((wordMatch = wordsRegex.exec(block.content)) !== null) {
+        // `wordMatch` is an array with the match and the index of the match. We need that so
+        // we can re-construct the original message.
+        const matchInfo = wordMatch;
+        word = wordMatch[0];
+
+        const matches =
+            matchChannel(word) ||
+            matchUrl(word) ||
+            matchUser(word, userList) ||
+            EmojiProvider.matchEmoji(word);
+
+        if (!matches || !matches.length) {
+            continue;
+        }
+
+        matches.forEach((match) => {
+            specialMatches.push({
+                index: matchInfo.index + match.index,
+                match: match.match,
+                block: createNewBlock(
+                    match.match,
+                    block.styles,
+                    match.type,
+                    match.meta
+                ),
+            });
+        });
+    }
+
+    // if there are no special matches, return the original block as is.
+    if (specialMatches.length === 0) {
+        return [block];
+    }
+
+    // split block with special matches.
+    return mergeMatches(block, specialMatches);
+}
+
+/**
+ * Finds a channel in the word match.
+ * @param {String} word Word to be searched for channels.
+ * @returns {object} Object with the matched channel, index within the word, and block.
+ */
+function matchChannel(word) {
+    const channelMatch = channelRegex.exec(word);
+    // matches the groups (spaces before)(prefix)(channel)(suffix punctuation)
+
+    if (channelMatch === null) {
+        return false;
+    }
+
+    return [{
+        index: channelMatch[1].length + channelMatch[2].length,
+        match: channelMatch[3],
+        type: 'channel',
+        meta: {
+            channel: channelMatch[3],
+        },
+    }];
+}
+
+/**
+ * Finds an url in the word match.
+ * @param {String} word Word to be searched for urls.
+ * @returns {Object} Object with the index of the url match in the block content, the
+ * url match itself, and the new url text to be placed where the first url was.
+ */
+function matchUrl(word) {
+    // this check avoids running the urlRegex, which would return the same result
+    // but take much more time to process
+    if (!(word.includes('://') || word.startsWith('www'))) {
+        return false;
+    }
+
+    const urlMatch = urlRegex.exec(word);
+
+    if (urlMatch === null) {
+        return false;
+    }
+
+    let url = urlMatch[0];
+
+    // Don't allow javascript execution
+    if (url.match(/^javascript:/i)) {
+        return false;
+    }
+
+    // Trim common punctuation from the end of a link. End of scentences etc.
+    let punctuation = '.,;:';
+    while (punctuation.indexOf(url[url.length - 1]) > -1) {
+        url = url.substr(0, url.length - 1);
+    }
+
+    // Links almost always contain an opening bracket if the last character is a closing
+    // bracket and should be part of the URL.
+    // If there isn't an opening bracket but the URL ends in a closing bracket, consider the
+    // closing bracket as punctuation outside of the URL.
+    if (url.indexOf('(') === -1 && url[url.length - 1] === ')') {
+        url = url.substr(0, url.length - 1);
+    }
+
+    // Add the http if no protocol was found
+    let urlText = url;
+    if (urlText.match(/^www\./i)) {
+        urlText = 'http://' + url;
+    }
+
+    return [{
+        index: urlMatch.index,
+        match: url,
+        matchText: urlText,
+        type: 'url',
+        meta: {
+            url: urlText,
+        },
+    }];
+}
+
+/**
+ * Finds an user in the word match.
+ * @param {String} word Word to be searched for users.
+ * @returns {Object} Object with the index of the user match in the block content, the
+ * user match itself, and the user colour.
+ */
+function matchUser(word, userList) {
+    if (!userList) {
+        return false;
+    }
+
+    let user = null;
+    let punc = ',.!:;+)]?¿\\/<>@';
+    let hasProp = Object.prototype.hasOwnProperty;
+    let nickIdx = 0;
+
+    const trimWord = trim(word, punc);
+    let normWord = trimWord.toUpperCase();
+
+    if (hasProp.call(userList, normWord)) {
+        user = userList[normWord];
+        nickIdx = word.indexOf(trimWord);
+    } else {
+        return false;
+    }
+
+    return [{
+        index: nickIdx,
+        match: trimWord,
+        type: 'user',
+        meta: {
+            user: trimWord,
+            colour: user.colour,
+        },
+    }];
+}
+
+/**
+ * Merges the special matches into the block.
+ * @param {Object} block A block that came from MessageFormatter.formatIrcMessage()
+ * @param {Array} specialMatches Array of special matches. See definition above
+ * @returns An array of blocks, where each special content will be extracted into a separate block.
+ */
+function mergeMatches(block, specialMatches) {
+    const resultBlocks = [];
+    let lastProcessedIndex = 0;
+
+    // for each special content, creat a block with the text up to the match, and a block with the
+    // special content itself.
+    specialMatches.forEach((specialMatch, index) => {
+        const beforeMatchContent = block.content.substr(
+            lastProcessedIndex,
+            specialMatch.index - lastProcessedIndex
+        );
+
+        if (beforeMatchContent) {
+            resultBlocks.push({
+                content: beforeMatchContent,
+                styles: { ...block.styles },
+                containsContent: !!beforeMatchContent,
+            });
+        }
+
+        resultBlocks.push(specialMatch.block);
+
+        lastProcessedIndex = specialMatch.index + specialMatch.match.length;
+    });
+
+    // remaining content after the last special content.
+    if (lastProcessedIndex < block.content.length) {
+        resultBlocks.push({
+            content: block.content.substr(lastProcessedIndex),
+            styles: { ...block.styles },
+            containsContent: !!block.content.substr(lastProcessedIndex),
+        });
+    }
+
+    return resultBlocks;
+}

package/apps/web/upstream/src/libs/Notifications.js

@@ -0,0 +1,78 @@
+'kiwi public';
+
+import _ from 'lodash';
+
+let isEnabled = false;
+
+export function requestPermission(state) {
+    // Do we support notifications?
+    if (!('Notification' in window)) {
+        isEnabled = false;
+        return;
+    }
+
+    // Permissions already been granted?
+    if (Notification.permission === 'granted') {
+        state.$emit('notification.enabled');
+        isEnabled = true;
+        return;
+    }
+
+    if (Notification.permission !== 'denied') {
+        Notification.requestPermission((permission) => {
+            if (permission === 'granted') {
+                state.$emit('notification.enabled');
+                isEnabled = true;
+            } else {
+                isEnabled = false;
+            }
+        });
+    }
+}
+
+export function show(title, body, opts) {
+    if (!isEnabled) {
+        return false;
+    }
+
+    let notify = new Notification(title, {
+        body: body,
+        icon: opts.icon,
+    });
+
+    if (opts.ttl) {
+        setTimeout(notify.close.bind(notify), opts.ttl);
+    }
+
+    return notify;
+}
+
+const throttledShow = _.throttle(show, 2000);
+
+export function listenForNewMessages(state) {
+    state.$on('notification.show', (message, _opts) => {
+        if (!isEnabled) {
+            return;
+        }
+
+        let opts = Object.assign({
+            title: 'Kiwi IRC',
+            message: message,
+            icon: '',
+            onclick: null,
+            ttl: 10000,
+        }, _opts);
+
+        if (!opts.message) {
+            return;
+        }
+
+        let notification = throttledShow(opts.title, opts.message, {
+            ttl: opts.ttl,
+        });
+
+        if (notification && typeof opts.onclick === 'function') {
+            notification.onclick = opts.onclick;
+        }
+    });
+}

package/apps/web/upstream/src/libs/ServerConnection.js

@@ -0,0 +1,270 @@
+'kiwi public';
+
+/** @module */
+
+/*
+ * Multiplexed channels over a websocket connection
+ *     * Only allow 1 websocket per server
+ *     * Multiple channels through a single websocket
+ *     * A channel per IRC network connection
+ * Messages are prefixed with : and the channel name then a space. eg:
+ *     :1 Here is the data
+ *
+ * Example protocol chatter:
+ *     Client > START             Client tells the server it's starting a session
+ *     Server > SESSION 1234      Server sends the client the current session ID
+ *     Client > :1                Client is creating a new channel, ID 1
+ *     Server > :1                Server acknowledges the new channel, ID 1
+ *     Client > :1 some data      Client sends data over channel 1 to the server
+ *     Server > :1 some data      Server sends data over channel 1 to the client
+ *     Client > :2                Client is creating a new channel, ID 2
+ *     Server > :2                Server acknowledges the new channel, ID 2
+ */
+
+import SockJS from 'sockjs-client';
+import EventEmitter from 'eventemitter3';
+
+const serverConnections = Object.create(null);
+const createdChannels = Object.create(null);
+const controlChannel = '0';
+
+/**
+ *
+ * @param {String} _addr Sockjs endpoint
+ * @param {String} sessionId Optional session ID to continue
+ * @param {String} _socketChannel The optional multiplexed channel ID. Autogenerated if not provided
+ */
+export function createChannelConstructor(_addr, sessionId, _socketChannel) {
+    let addr = _addr.toLowerCase();
+
+    if (!serverConnections[addr]) {
+        serverConnections[addr] = createNewConnection(addr, sessionId);
+    }
+
+    // If a channel ID hasn't been specified, create a new one
+    let socketChannel = _socketChannel;
+    if (!socketChannel) {
+        socketChannel = serverConnections[addr].nextChannelId++;
+    }
+
+    return createChannelOnConnection(
+        serverConnections[addr],
+        socketChannel
+    );
+}
+
+/*
+ * Creates a new socket connection to a kiwi server.
+ * Channels will be created on this connection to send data back and forth.
+ */
+function createNewConnection(wsAddr, sessionId) {
+    let connection = new EventEmitter();
+    connection.sessionId = '';
+
+    serverConnections[wsAddr] = connection;
+
+    connection.nextChannelId = 1;
+    connection.connected = false;
+
+    connection.reconnect =
+    connection.connect = function connect() {
+        if (connection.ws) {
+            try {
+                connection.ws.close();
+            } catch (err) {
+                // Ignore any closing errors. Most likely due to not
+                // being connected yet.
+            }
+
+            connection.ws = null;
+        }
+        connection.ws = new SockJS(wsAddr);
+        connection.ws.onopen = () => {
+            let connectStr = sessionId ?
+                'CONTROL SESSION ' + sessionId :
+                'CONTROL START';
+            connection.ws.send(`:${controlChannel} ${connectStr}`);
+            connection.connected = true;
+            connection.emit('open');
+        };
+        connection.ws.onclose = (err) => {
+            connection.connected = false;
+            connection.ws = null;
+            connection.emit('close', err);
+        };
+        connection.ws.onmessage = (event) => {
+            connection.emit('message', event);
+
+            // If the message starts with ":channel " then extract that channel and emit
+            // an event for it.
+            if (event.data[0] === ':') {
+                let message = event.data;
+                let spacePos = message.indexOf(' ');
+
+                // If no space, ie. ":1", this is the server acknowledging this channel
+                // is now open and ready to be used.
+                if (spacePos === -1) {
+                    connection.emit('open.' + message.substr(1));
+                    return;
+                }
+
+                let channelId = message.substr(1, spacePos - 1);
+                event.data = message.substr(spacePos + 1);
+                connection.emit('message.' + channelId, event);
+            } else {
+                // Core messages. Used for session handling and session syncing
+                let parts = event.data.split(' ');
+
+                if (parts[0] === 'SESSION') {
+                    connection.sessionId = parts[1];
+                }
+            }
+        };
+    };
+
+    connection.connect();
+    return connection;
+}
+
+/*
+ * Create a channel on a server connection.
+ * The ConnectionChannel implements an IrcFramework transport
+ */
+function createChannelOnConnection(connection, channelId) {
+    // Only allow 1 ConnectionChannel instance per channel
+    return function ConnectionChannelWrapper(options) {
+        if (!createdChannels[channelId]) {
+            createdChannels[channelId] = new ConnectionChannel(options);
+        } else if (connection.connected) {
+            createdChannels[channelId].initChannel();
+        }
+
+        return createdChannels[channelId];
+    };
+
+    function ConnectionChannel(options) {
+        let sendControlBuffer = [];
+        let encoding = 'utf8';
+        let channel = new EventEmitter();
+        channel.id = channelId;
+        channel.isOpen = false;
+        channel.state = 0; // TODO: Is this used anywhere?
+        // 0 = disconnected, 1 = connected
+        channel.remoteState = 0;
+
+        // When the websocket opens, open this channel on it
+        connection.on('open', () => {
+            connection.ws.send(':' + channelId);
+        });
+        // When we get confirmation of this channel being opened, send any control
+        // messages that were buffered
+        connection.on('open.' + channelId, () => {
+            channel.isOpen = true;
+            // channel.emit('open');
+            if (sendControlBuffer.length) {
+                sendControlBuffer.forEach((line) => {
+                    channel.sendControl(line);
+                });
+                sendControlBuffer = [];
+            }
+
+            channel.setEncoding(encoding);
+
+            // This channel is now open and can start sending data to the server
+            channel.remoteState = 1;
+            channel.emit('open');
+        });
+        connection.on('close', (err) => {
+            channel.state = 3;
+            channel.remoteState = 0;
+            channel.isOpen = false;
+            channel.emit('close', err);
+        });
+        connection.on('message.' + channelId, (event) => {
+            if (event.data.indexOf('control ') === 0) {
+                // When we get the signal that the connection to the IRC server
+                // has connected, start proxying all data
+                if (event.data.indexOf('control connected') === 0) {
+                    channel.remoteState = 1;
+                }
+
+                if (event.data.indexOf('control closed') === 0) {
+                    let err = event.data.split(' ')[2];
+                    channel.remoteState = 0;
+                    channel.emit('close', err);
+                }
+            }
+
+            if (channel.remoteState === 1) {
+                channel.emit('line', event.data);
+            }
+        });
+
+        // Send a control message to the server (not relayed to an IRC network)
+        channel.sendControl = function writeTarget(data) {
+            if (channel.isOpen) {
+                connection.ws.send(':' + channelId + ' ' + data);
+            } else {
+                sendControlBuffer.push(data);
+            }
+        };
+
+        channel.writeLine = function writeTarget(data, cb) {
+            // Buffer the data if the socket has not yet been sent
+            if (channel.remoteState >= 1) {
+                connection.ws.send(':' + channelId + ' ' + data);
+            }
+
+            // Websocket.send() does not support callbacks
+            // call the callback in the next tick instead
+            if (cb) {
+                setTimeout(cb, 0);
+            }
+        };
+
+        // Tell the server to connect to an IRC network
+        channel.connect = function connect() {
+            // Clear any buffered control messages so we have a clean slate
+            sendControlBuffer = [];
+
+            // If the websocket is not connected, try to reconnect it
+            if (!connection.ws) {
+                connection.reconnect();
+            }
+
+            let host = options.host;
+            let port = options.port;
+            let tls = options.tls || options.ssl;
+            channel.sendControl('HOST ' + host + ':' + (tls ? '+' : '') + port);
+        };
+
+        channel.close = function close() {
+            if (channel.remoteState >= 1) {
+                connection.ws.send(':' + channelId);
+            }
+        };
+
+        // This is not supported but irc-framework transports need it, so just noop it
+        channel.setEncoding = function setEncoding(newEncoding) {
+            encoding = newEncoding;
+            if (connection.connected) {
+                connection.ws.send(':' + channelId + ' ENCODING ' + newEncoding);
+            }
+            return true;
+        };
+
+        channel.disposeSocket = function disposeSocket() {
+            // noop
+        };
+
+        channel.initChannel = function initChannel() {
+            connection.ws.send(':' + channelId);
+        };
+        // Let the server know of this new channel if we're already connected
+        if (connection.connected) {
+            channel.initChannel();
+        }
+
+        return channel;
+    }
+}

package/apps/web/upstream/src/libs/ServerSession.js

@@ -0,0 +1,102 @@
+'kiwi public';
+
+import EventEmitter from 'eventemitter3';
+import getState from './state';
+import * as ServerConnection from './ServerConnection';
+
+export default class ServerSession {
+    constructor(sessionId) {
+        let channelConstruct = ServerConnection.createChannelConstructor(
+            getState().settings.kiwiServer,
+            sessionId || '',
+            '0'
+        );
+
+        this.bus = new EventEmitter();
+        this.channel = channelConstruct();
+        this.channel.on('line', (line) => {
+            if (line.indexOf('CONTROL ') === 0) {
+                let parts = line.split(' ');
+
+                // Remove the 'CONTROL' first part
+                parts.shift();
+
+                let command = parts.shift();
+                this.bus.emit(command, parts);
+            }
+        });
+    }
+
+    auth(userId, password) {
+        return new Promise((resolve, reject) => {
+            this.bus.once('AUTH', (params) => {
+                let result = params[0];
+
+                if (result === 'OK') {
+                    resolve(true);
+                } else {
+                    reject(result);
+                }
+            });
+
+            this.channel.sendControl(`CONTROL AUTH ${userId} ${password}`);
+        });
+    }
+
+    getNetworks() {
+        return new Promise((resolve) => {
+            let networks = Object.create(null);
+
+            let onListing = (params) => {
+                if (params[1] === 'END') {
+                    this.bus.off('LISTING', onListing);
+
+                    // Convert our networks object to an array first
+                    let networkArr = [];
+                    Object.keys(networks).forEach((channeId) => {
+                        networkArr.push(networks[channeId]);
+                    });
+
+                    resolve(networkArr);
+                    return;
+                }
+
+                if (params[0] === 'NETWORK') {
+                    let props = params.slice(1);
+                    let network = { buffers: [] };
+
+                    props.forEach((prop) => {
+                        let parts = prop.split('=');
+                        if (parts[0] && parts[1]) {
+                            network[parts[0].toLowerCase()] = parts[1];
+                        }
+                    });
+
+                    if (network.channel) {
+                        networks[network.channel] = network;
+                    }
+                }
+
+                if (params[0] === 'BUFFER') {
+                    let props = params.slice(1);
+                    let buffer = {};
+
+                    props.forEach((prop) => {
+                        let parts = prop.split('=');
+                        if (parts[0] && parts[1]) {
+                            buffer[parts[0].toLowerCase()] = parts[1];
+                        }
+                    });
+
+                    let network = networks[buffer.channel];
+                    if (network) {
+                        network.buffers.push(buffer);
+                    }
+                }
+            };
+
+            this.bus.on('LISTING', onListing);
+            this.channel.sendControl('CONTROL LIST NETWORKS');
+        });
+    }
+}