serverless-ircd 0.6.0 → 0.7.0

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

@@ -0,0 +1,157 @@
+'kiwi public';
+
+/** @module */
+
+/**
+ * Command input Alias + re-writing
+ *
+ * Variables used in aliases:
+ * - $0 = the command being run
+ * - $1 = first param of input
+ * - $N = Nth param of input
+ * - $1+2 = first param of input and the next 2 words
+ * - $2+4 = second param of input and the next 4 words
+ * - $2+ = second param of input and all words after
+ * - $variable = variable as set in the vars object
+ */
+export default class AliasRewriter {
+    constructor() {
+        // Max alias recursion depth
+        this.recursiveDepth = 3;
+        // Current alias recursion depth
+        this.depth = 0;
+
+        this.aliases = {};
+    }
+
+    /** Reset the current aliases object from a newline delimited string of aliases */
+    importFromString(str) {
+        // Clear out the current aliases before adding new ones in
+        this.aliases = {};
+
+        str.split('\n').forEach((line) => {
+            if (line[0] !== '/') {
+                return;
+            }
+
+            let spaceSep = line.indexOf(' ');
+            if (spaceSep === -1) {
+                return;
+            }
+
+            let command = line.substring(0, spaceSep);
+            let actions = line.substring(spaceSep + 1).trim();
+            if (!actions) {
+                return;
+            }
+
+            this.aliases[command.toLowerCase()] = actions;
+        });
+    }
+
+    // Takes an array of words to process!
+    processInput(input, vars) {
+        let words = input || [];
+        let alias = this.aliases[words[0].toLowerCase()];
+        let aliasLen;
+        let currentAliasWord = '';
+        let currentAliasWordLen = 0;
+        let processedConditionals = false;
+        let compiled = [];
+
+        // If an alias wasn't found, return the original input
+        if (!alias) return input;
+
+        // Split the alias up into useable words
+        alias = alias.split(' ');
+        aliasLen = alias.length;
+
+        // Iterate over each word and pop them into the final compiled array.
+        // Any $ words are processed with the result ending into the compiled array.
+        for (let i = 0; i < aliasLen; i++) {
+            currentAliasWord = alias[i];
+            currentAliasWordLen = currentAliasWord.length;
+
+            // $var? word makes this command only run if the var exists
+            if (
+                !processedConditionals &&
+                currentAliasWord[0] === '$' && currentAliasWord[currentAliasWordLen - 1] === '?'
+            ) {
+                let checkVar = currentAliasWord.substr(1, currentAliasWordLen - 2);
+                if (!vars[checkVar]) {
+                    compiled = [];
+                    break;
+                } else {
+                    continue;
+                }
+            } else {
+                processedConditionals = true;
+            }
+
+            // Non $ word
+            if (currentAliasWord[0] !== '$') {
+                compiled.push(currentAliasWord);
+                continue;
+            }
+
+            // Refering to an input word ($N)
+            if ((currentAliasWord[1] || '').match(/\d/)) {
+                let num = currentAliasWord.match(/\$(\d+)(\+)?(\d+)?/);
+
+                // Did we find anything or does the word it refers to non-existant?
+                if (!num || !words[num[1]]) continue;
+
+                if (num[2] === '+' && num[3]) {
+                    // Add X number of words
+                    compiled = compiled.concat(words.slice(
+                        parseInt(num[1], 10),
+                        parseInt(num[1], 10) + parseInt(num[3], 10)
+                    ));
+                } else if (num[2] === '+') {
+                    // Add the remaining of the words
+                    compiled = compiled.concat(words.slice(parseInt(num[1], 10)));
+                } else {
+                    // Add a single word
+                    compiled.push(words[parseInt(num[1], 10)]);
+                }
+
+                continue;
+            }
+
+            // Refering to a variable
+            if (typeof vars[currentAliasWord.substr(1)] !== 'undefined') {
+                // Get the variable
+                compiled.push(vars[currentAliasWord.substr(1)]);
+
+                continue;
+            }
+        }
+
+        return compiled;
+    }
+
+    /** Take a string input, process any aliases and output the finalised string */
+    process(input, vars) {
+        let line = input || '';
+        let words = line.split(' ');
+        let firstWord = (words[0] || '').toLowerCase();
+
+        this.depth++;
+        if (this.depth >= this.recursiveDepth) {
+            this.depth--;
+            return line;
+        }
+
+        if (this.aliases[firstWord]) {
+            words = this.processInput(words, vars);
+            firstWord = (words[0] || '').toLowerCase();
+
+            if (this.aliases[firstWord]) {
+                words = this.process(words.join(' '), vars).split(' ');
+            }
+        }
+
+        this.depth--;
+        return words.join(' ');
+    }
+}

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

@@ -0,0 +1,60 @@
+'kiwi public';
+
+/** @module */
+
+/**
+ * Plays alert sounds
+ */
+export class AudioManager {
+    constructor(audio) {
+        this.lastPlayed = 0;
+        this.audio = audio;
+    }
+
+    /** Play the alert sound */
+    play() {
+        // Only play the bleep once every 2 seconds
+        if (!this.lastPlayed || Date.now() - this.lastPlayed > 2000) {
+            this.audio.play();
+            this.lastPlayed = Date.now();
+        }
+    }
+
+    listen(state) {
+        state.$on('audio.bleep', () => {
+            this.play();
+        });
+    }
+
+    /** Watch the Kiwi state for any message highlights and play an alert */
+    watchForMessages(state) {
+        state.$on('message.new', (event) => {
+            let { message, buffer } = event;
+            if (buffer.setting('mute_sound')) {
+                return;
+            }
+
+            let ignoreTypes = [
+                'connection',
+                'traffic',
+                'mode',
+                'nick',
+            ];
+            if (ignoreTypes.indexOf(message.type) > -1) {
+                return;
+            }
+
+            if (message.ignore || buffer.isSpecial()) {
+                return;
+            }
+
+            let shouldBleep = buffer.getNetwork().nick !== message.nick && ((message.isHighlight && buffer.setting('alert_on') === 'highlight') || buffer.setting('alert_on') === 'message');
+            let isActiveBuffer = state.getActiveBuffer() === buffer;
+            let inFocus = isActiveBuffer && state.ui.app_has_focus;
+
+            if (shouldBleep || (buffer.isQuery() && !inFocus)) {
+                this.play();
+            }
+        });
+    }
+}

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

@@ -0,0 +1,247 @@
+'kiwi public';
+
+/** @module */
+
+import { MessageTags } from 'irc-framework';
+import * as Misc from '@/helpers/Misc';
+
+/**
+ * Adds the BOUNCER IRCv3 spec to irc-framework
+ */
+export default function bouncerMiddleware() {
+    let networks = [];
+    let buffers = {};
+
+    return function middleware(client, rawEvents, parsedEvents) {
+        client.requestCap('bouncer');
+        addFunctionsToClient(client);
+        rawEvents.use(theMiddleware);
+    };
+
+    function theMiddleware(command, message, rawLine, client, next) {
+        if (command !== 'BOUNCER') {
+            next();
+            return;
+        }
+
+        let params = message.params;
+
+        if (params[0] === 'listnetworks' && ['end', 'RPL_OK'].indexOf(params[1]) > -1) {
+            client.command_handler.emit('bouncer networks', networks);
+            networks = [];
+        } else if (params[0] === 'listnetworks') {
+            let tags = MessageTags.decode(params[2]);
+            networks.push({
+                networkId: params[1],
+                name: tags.network,
+                host: tags.host,
+                port: parseInt(tags.port, 10),
+                tls: tags.tls === '1',
+                connected: tags.state === 'connected',
+                nick: tags.nick,
+                currentNick: tags.currentNick,
+                password: tags.password || '',
+                account: tags.account || '',
+                account_password: tags.account_password || '',
+            });
+        } else if (params[0] === 'listbuffers' && ['end', 'RPL_OK'].indexOf(params[2]) > -1) {
+            let netId = (params[1] || '');
+            let detectedBuffers = buffers[netId] || [];
+            delete buffers[netId];
+
+            client.command_handler.emit('bouncer buffers', detectedBuffers);
+            client.command_handler.emit('bouncer buffers ' + netId, detectedBuffers);
+        } else if (params[0] === 'listbuffers') {
+            let netId = (params[1] || '');
+            let tags = MessageTags.decode(params[2]);
+            buffers[netId] = buffers[netId] || [];
+            buffers[netId].push({
+                networkId: netId,
+                network: tags.network,
+                name: tags.buffer,
+                topic: tags.topic,
+                joined: tags.joined === '1',
+                seen: tags.seen,
+                notify: tags.notify || 'highlight',
+            });
+        } else if (params[0] === 'state') {
+            client.command_handler.emit('bouncer state', {
+                networkId: params[1],
+                network: params[2],
+                state: params[3],
+            });
+        }
+
+        // BOUNCER addnetwork NetID Network1 ERR_NAMEINUSE
+        if (params[0] === 'addnetwork' && params[3].substr(0, 4) === 'ERR_') {
+            let netName = (params[2] || '').toLowerCase();
+            let eventObj = {
+                error: params[3],
+                reason: params[4] || '',
+            };
+            client.command_handler.emit('bouncer addnetwork error', eventObj);
+            client.command_handler.emit('bouncer addnetwork error ' + netName, eventObj);
+        } else if (params[0] === 'addnetwork' && ['end', 'RPL_OK'].indexOf(params[3]) > -1) {
+            // BOUNCER addnetwork 5 Network1 RPL_OK
+            let netId = (params[1] || '');
+            let netName = (params[2] || '').toLowerCase();
+            let eventObj = {
+                networkId: netId,
+                network: netName,
+            };
+            client.command_handler.emit('bouncer addnetwork ok', eventObj);
+            client.command_handler.emit('bouncer addnetwork ok ' + netName, eventObj);
+        }
+    }
+}
+
+function addFunctionsToClient(client) {
+    let bnc = client.bnc = {};
+
+    bnc.tags = function tags() {
+        let token = client.network.supports('bouncer');
+        return !token || typeof token !== 'string' ?
+            {} :
+            MessageTags.decode(token) || {};
+    };
+
+    bnc.hasNetwork = function hasNetwork() {
+        let token = client.network.supports('bouncer');
+        if (!token || token === true) {
+            return false;
+        }
+
+        let tags = MessageTags.decode(token);
+        return tags && !!tags.network;
+    };
+
+    bnc.getNetworks = function getNetworks() {
+        return new Promise((resolve, reject) => {
+            client.raw('BOUNCER listnetworks');
+            client.once('bouncer networks', (networks) => {
+                resolve(networks);
+            });
+        });
+    };
+
+    bnc.getBuffers = function getBuffers(netId) {
+        return new Promise((resolve, reject) => {
+            client.raw('BOUNCER listbuffers ' + netId);
+            client.once('bouncer buffers ' + netId, (buffers) => {
+                resolve(buffers);
+            });
+        });
+    };
+
+    bnc.closeBuffer = function closeBuffer(netId, bufferName) {
+        return new Promise((resolve, reject) => {
+            client.raw(`BOUNCER delbuffer ${netId} ${bufferName}`);
+        });
+    };
+
+    bnc.bufferSeen = function bufferSeen(netId, bufferName, seenTime) {
+        return new Promise((resolve, reject) => {
+            // 1 tells the bouncer to use the current time
+            let timeStr = seenTime ? Misc.dateIso(seenTime) : '1';
+            client.raw(`BOUNCER changebuffer ${netId} ${bufferName} seen=${timeStr}`);
+        });
+    };
+
+    bnc.addNetwork = function addNetwork(netName, host, port, tls, nick, user, password) {
+        let tags = {};
+        tags.network = netName;
+        tags.host = host;
+        tags.port = port;
+        tags.tls = tls ? 1 : 0;
+        tags.nick = nick;
+        tags.password = password;
+
+        if (user) {
+            tags.user = user;
+        }
+
+        let tagString = createTagString(tags);
+        return new Promise((resolve, reject) => {
+            client.raw('BOUNCER addnetwork ' + tagString);
+            client.once('bouncer addnetwork ok ' + netName.toLowerCase(), onOk);
+            client.once('bouncer addnetwork error', onError);
+
+            function onOk(event) {
+                client.off('bouncer addnetwork error', onError);
+                resolve(event);
+            }
+            function onError(event) {
+                client.off('bouncer addnetwork ok ' + netName.toLowerCase(), onOk);
+                reject({
+                    error: event.error,
+                    reason: event.reason,
+                });
+            }
+        });
+    };
+
+    bnc.removeNetwork = function removeNetwork(netId, bufferName) {
+        return new Promise((resolve, reject) => {
+            client.raw(`BOUNCER delnetwork ${netId}`);
+        });
+    };
+
+    bnc.saveNetwork = function saveNetwork(netId, opts) {
+        let tags = {};
+
+        if (typeof opts.network !== 'undefined') {
+            tags.network = opts.network;
+        }
+        if (typeof opts.host !== 'undefined') {
+            tags.host = opts.host;
+        }
+        if (typeof opts.port !== 'undefined') {
+            tags.port = opts.port;
+        }
+        if (typeof opts.tls !== 'undefined') {
+            tags.tls = opts.tls ? 1 : 0;
+        }
+        if (typeof opts.nick !== 'undefined') {
+            tags.nick = opts.nick;
+        }
+        if (typeof opts.user !== 'undefined') {
+            tags.user = opts.user;
+        }
+        if (typeof opts.password !== 'undefined') {
+            tags.password = opts.password;
+        }
+        if (typeof opts.account_password !== 'undefined') {
+            tags.account_password = opts.account_password;
+        }
+        if (typeof opts.account !== 'undefined') {
+            tags.account = opts.account;
+        }
+
+        let tagString = createTagString(tags);
+        return new Promise((resolve, reject) => {
+            if (tagString.length === 0) {
+                resolve();
+            } else {
+                client.raw(`BOUNCER changenetwork ${netId} ${tagString}`);
+            }
+        });
+    };
+}
+
+function createTagString(tags) {
+    let tagParts = [];
+
+    Object.keys(tags).forEach((tag) => {
+        let val = tags[tag];
+        if (typeof val !== 'undefined') {
+            val = val.toString()
+                .replace(' ', '\\s')
+                .replace(';', '\\:');
+            tagParts.push(tag + '=' + val);
+        } else {
+            tagParts.push(tag);
+        }
+    });
+
+    return tagParts.join(';');
+}