serverless-ircd 0.5.0 → 0.7.0

package/apps/web/upstream/src/components/startups/KiwiBnc.vue

@@ -0,0 +1,361 @@
+<template>
+    <startup-layout ref="layout" class="kiwi-startbnc">
+        <template #connection>
+            <form class="kiwi-startbnc-form" @submit.prevent="startUp">
+                <h2 v-html="greetingText" />
+
+                <div class="kiwi-startbnc-status">{{ statusMessage }}</div>
+
+                <label>
+                    <span>{{ $t('username') }}</span>
+                    <input v-model="username" :disabled="loading" type="text">
+                </label>
+                <label>
+                    <span>{{ $t('password') }}</span>
+                    <input v-model="password" :disabled="loading" type="password">
+                </label>
+
+                <button
+                    :disabled="loading || !username || !password"
+                    type="submit"
+                    class="u-button u-button-primary u-submit"
+                >
+                    <span v-if="!loading" v-html="buttonText" />
+                    <i v-else class="fa fa-spinner fa-spin" aria-hidden="true" />
+                </button>
+            </form>
+        </template>
+    </startup-layout>
+</template>
+
+<script>
+'kiwi public';
+
+import _ from 'lodash';
+import Logger from '@/libs/Logger';
+import StartupLayout from './CommonLayout';
+
+let log = Logger.namespace('Startup/kiwiBnc');
+
+export default {
+    components: {
+        StartupLayout,
+    },
+    data: function data() {
+        return {
+            loading: false,
+            username: '',
+            password: '',
+            statusMessage: '',
+        };
+    },
+    computed: {
+        greetingText: function greetingText() {
+            let greeting = this.$state.settings.startupOptions.greetingText;
+            return typeof greeting === 'string' ?
+                greeting :
+                this.$t('start_greeting');
+        },
+        buttonText: function buttonText() {
+            if (this.loading) {
+                return '';
+            }
+
+            let greeting = this.$state.settings.startupOptions.buttonText;
+            return typeof greeting === 'string' ?
+                greeting :
+                this.$t('start_button');
+        },
+    },
+    methods: {
+        startUp: async function startUp() {
+            this.statusMessage = this.$t('logging_in');
+            this.loading = true;
+
+            let bncnet = this.getBncNetwork();
+
+            let cleanUpEvents = () => {
+                bncnet.ircClient.off('registered', onRegistered);
+                bncnet.ircClient.off('irc error', onError);
+                bncnet.ircClient.off('close', onClose);
+            };
+
+            let onRegistered = async() => {
+                cleanUpEvents();
+
+                let bncNetworks = await bncnet.ircClient.bnc.getNetworks();
+                for (let i = 0; i < bncNetworks.length; i++) {
+                    let network = bncNetworks[i];
+                    network.buffers = [];
+                    try {
+                        /* eslint-disable no-await-in-loop */
+                        let buffers = await bncnet.ircClient.bnc.getBuffers(network.name);
+                        network.buffers = buffers;
+                    } catch (err) {
+                        // Log the error here or something
+                        log.error(err);
+                    }
+
+                    this.addNetworkToState(network);
+                }
+
+                this.monitorNetworkChanges(bncnet, bncNetworks);
+                this.$refs.layout.close();
+            };
+
+            let onError = (event) => {
+                cleanUpEvents();
+                this.statusMessage = this.$t('invalid_login');
+                this.loading = false;
+            };
+
+            let onClose = (event) => {
+                cleanUpEvents();
+                this.statusMessage = this.$t('invalid_login');
+                this.loading = false;
+            };
+
+            bncnet.ircClient.once('registered', onRegistered);
+            bncnet.ircClient.once('irc error', onError);
+            bncnet.ircClient.once('close', onClose);
+            bncnet.ircClient.connect();
+        },
+
+        getBncNetwork: function getBncNetwork() {
+            let bnc = this.$state.setting('bnc');
+
+            if (bnc.network) {
+                bnc.username = this.username;
+                bnc.password = this.password;
+                return bnc.network;
+            }
+
+            let options = this.$state.settings.startupOptions;
+
+            // Indicate that all our connections will be going through a BNC
+            bnc.active = true;
+            bnc.server = options.server || '';
+            bnc.port = options.port || 6667;
+            bnc.tls = !!options.tls;
+            bnc.username = this.username;
+            bnc.password = this.password;
+
+            let bncnet = this.$state.addNetwork('bnccontrol', this.username, {
+                server: bnc.server,
+                port: bnc.port,
+                tls: bnc.tls,
+            });
+
+            bnc.network = bncnet;
+
+            return bncnet;
+        },
+
+        addNetworkToState: function addNetworkToState(network) {
+            // Expects network to be in the format of:
+            //  {
+            //  "buffers":[{"channel":"1","name":"#prawnsalad","joined":"1"}],
+            //  "name":"freenode",
+            //  "channel":"1",
+            //  "connected":"1",
+            //  "host":"irc.freenode.net",
+            //  "port":"6667",
+            //  "tls":"0",
+            //  "nick":"notprawn99829"
+            //  },
+            let net = this.$state.addNetwork(network.name, network.nick, {
+                server: network.host,
+                port: network.port,
+                tls: network.tls,
+                password: network.password,
+                bncname: network.name,
+                username: network.user,
+            });
+
+            network.buffers.forEach((buffer) => {
+                let newBuffer = this.$state.addBuffer(net.id, buffer.name);
+                if (buffer.joined) {
+                    newBuffer.enabled = true;
+                }
+                if (buffer.seen) {
+                    newBuffer.last_read = (new Date(buffer.seen)).getTime();
+                }
+            });
+        },
+
+        monitorNetworkChanges: function monitorNetworkChanges(bncNet, bncNetworks) {
+            let existingNets = Object.create(null);
+            function rememberNetworks() {
+                this.$state.networks.forEach((network) => {
+                    if (!network.connection.bncname) {
+                        return;
+                    }
+
+                    existingNets[network.connection.bncname] = {
+                        name: network.connection.bncname,
+                        host: network.connection.server,
+                        port: network.connection.port,
+                        tls: network.connection.tls,
+                        password: network.password,
+                        nick: network.nick,
+                        username: network.username,
+                    };
+                });
+            }
+
+            rememberNetworks();
+
+            let saveState = (newVal) => {
+                this.$state.networks.forEach((network) => {
+                    // Only deal with BNC networks
+                    if (network.name === 'bnccontrol') {
+                        return;
+                    }
+
+                    let bncName = network.connection.bncname;
+                    let current = existingNets[bncName] || {};
+                    let tags = {};
+
+                    if (network.connection.server !== current.host) {
+                        tags.host = network.connection.server;
+                    }
+                    if (network.connection.port !== current.port) {
+                        tags.port = network.connection.port;
+                    }
+                    if (network.connection.tls !== current.tls) {
+                        tags.tls = network.connection.tls;
+                    }
+                    if (network.password !== current.password) {
+                        tags.password = network.password;
+                    }
+                    if (network.nick !== current.nick) {
+                        tags.nick = network.nick;
+                    }
+                    if (network.username !== current.username) {
+                        tags.user = network.username;
+                    }
+
+                    // A newly added network would not have a current name property set yet.
+                    // Only save the network if we've entered a host.
+                    if (!current.name && tags.host) {
+                        network.connection.bncname = network.name;
+                        bncNet.ircClient.bnc.addNetwork(
+                            network.name,
+                            tags.host,
+                            tags.port,
+                            tags.tls,
+                            tags.nick,
+                            tags.user,
+                            tags.password,
+                        );
+                    } else if (current.name) {
+                        bncNet.ircClient.bnc.saveNetwork(bncName, tags);
+                    }
+                });
+
+                rememberNetworks();
+            };
+
+            let debouncedSaveState = _.debounce(saveState, 2000);
+
+            this.$state.$watch('networks', debouncedSaveState, { deep: true });
+
+            // Just before we connect to a network, make sure the BNC is sabed and connected to
+            // it or at least trying to connect.
+            this.$state.$on('network.connecting', (event) => {
+                saveState();
+
+                let netName = event.network.connection.bncname;
+                let networkFromBnc = _.find(bncNetworks, { name: netName });
+                if (networkFromBnc && !networkFromBnc.connected) {
+                    bncNet.ircClient.raw('BOUNCER connect ' + netName);
+                }
+            });
+
+            // Very hacky until we have network name renaming on the bnc. When a new network
+            // is added, change the name to the next available network name.
+            this.$state.$on('network.new', (event) => {
+                let currentNum = 1;
+                let existingNet = true;
+                while (existingNet) {
+                    existingNet = _.find(this.$state.networks, { name: 'Network' + currentNum });
+                    if (!existingNet) {
+                        event.network.name = 'Network' + currentNum;
+                    }
+
+                    currentNum++;
+                }
+            });
+
+            this.$state.$on('network.removed', (event) => {
+                bncNet.ircClient.bnc.removeNetwork(event.network.connection.bncname);
+            });
+
+            this.$state.$on('buffer.close', (event) => {
+                let buffer = event.buffer;
+                let network = event.buffer.getNetwork();
+                let bncName = network.connection.bncname;
+
+                if (bncName) {
+                    bncNet.ircClient.bnc.closeBuffer(bncName, buffer.name);
+                }
+            });
+        },
+    },
+};
+</script>
+
+<style>
+
+.kiwi-startbnc-form label {
+    text-align: left;
+    display: block;
+    margin-bottom: 1.5em;
+}
+
+.kiwi-startbnc-form input,
+.kiwi-startbnc-form input:active {
+    font-size: 1em;
+    width: 100%;
+    box-sizing: border-box;
+    line-height: 30px;
+    padding: 0 10px;
+    border: none;
+    border-bottom: 2px solid #42b992;
+    outline: none;
+}
+
+.kiwi-startbnc-status {
+    margin: 1em 0;
+    overflow: hidden;
+    max-height: 40px;
+    transition: max-height 0.2s;
+}
+
+.kiwi-startbnc-status:empty {
+    background: red;
+    max-height: 0;
+}
+
+.kiwi-startbnc-start {
+    font-size: 1.1em;
+    cursor: pointer;
+}
+
+.kiwi-startbnc-form {
+    width: 300px;
+    background-color: #fff;
+    border-radius: 0.5em;
+    padding: 1em;
+    border: 1px solid #ececec;
+}
+
+.kiwi-startbnc-form button {
+    width: 100%;
+    line-height: 36px;
+    padding: 0;
+    font-size: 1.2em;
+    font-weight: normal;
+}
+
+</style>

package/apps/web/upstream/src/components/startups/Personal.vue

@@ -0,0 +1,317 @@
+<template>
+    <div class="kiwi-personal">
+        <h1>{{ $t('personal_client') }}</h1>
+
+        <div v-if="server && server.server && !readyToShowOptions" />
+        <div v-else-if="server && server.server">
+            <div v-if="addedNetworkToExisting">
+                <p>
+                    {{ $t('personal_added_to_existing') }}
+                </p>
+            </div>
+            <div v-else>
+                <p v-html="$t('personal_connect_to', { network: `<b>${server.server}</b>` })" />
+                <button
+                    v-if="hasOtherTab"
+                    type="button"
+                    class="u-button u-button-primary"
+                    @click="addNetworkToExistingTab"
+                >
+                    {{ $t('personal_add_existing_tab') }}
+                </button>
+                <button
+                    v-else
+                    type="button"
+                    class="u-button u-button-primary"
+                    @click="addNetwork()"
+                >
+                    Add network to Kiwi
+                </button>
+
+                <br>
+                <button
+                    type="button"
+                    class="u-button u-button-primary"
+                    @click="addNetwork(true)"
+                >
+                    {{ $t('personal_connect_temporary') }}
+                </button> <br>
+            </div>
+        </div>
+        <div v-else>
+            <p>{{ $t('personal_addjoin') }}</p>
+            <p>{{ $t('personal_return') }}</p>
+
+            <button type="button" class="u-button u-button-primary" @click="addEmptyNetwork">
+                {{ $t('personal_add') }}
+            </button> <br>
+
+            <a
+                v-if="networks.length>0"
+                class="u-link kiwi-personal-existing-networks"
+                @click.stop="toggleStateBrowser"
+            >
+                {{ $t('personal_saved') }}
+            </a>
+        </div>
+    </div>
+</template>
+
+<script>
+'kiwi public';
+
+import * as TextFormatting from '@/helpers/TextFormatting';
+import * as Misc from '@/helpers/Misc';
+import BouncerProvider from '@/libs/BouncerProvider';
+import IPC from '@/libs/IPC';
+
+let firstRun = true;
+
+export default {
+    data: function data() {
+        return {
+            hasOtherTab: false,
+            addedNetworkToExisting: false,
+            server: null,
+            readyToShowOptions: false,
+        };
+    },
+    computed: {
+        networks() {
+            return this.$state.networks;
+        },
+        hasFragment() {
+            return window.location.hash && window.location.hash.length > 1;
+        },
+    },
+    created: function created() {
+        this.$state.setting('allowRegisterProtocolHandler', true);
+
+        // Enable IPC listeners
+        // This is used to allow opening new servers in existing tab
+        IPC.init();
+
+        let server = null;
+        if (this.hasFragment) {
+            server = this.parseFragment();
+            this.server = server;
+        }
+
+        if (server) {
+            this.findOtherTabs().then((hasOtherTab) => {
+                if (hasOtherTab) {
+                    this.hasOtherTab = true;
+                    // Don't start the main kiwi app here as it's already open elsewhere
+                } else {
+                    this.listenForOtherTabs();
+                    this.init();
+                }
+
+                this.readyToShowOptions = true;
+            });
+        } else {
+            this.listenForOtherTabs();
+            this.init();
+        }
+    },
+    methods: {
+        listenForOtherTabs() {
+            IPC.on('message', (e) => { // respond to other tabs that are looking
+                let msg = e.data;
+                if (msg.type === 'ping' && this.networks.length > 0) {
+                    IPC.send({ type: 'pong' });
+                } else if (msg.type === 'addNetwork') {
+                    let network = this.networks.find((n) => n.name === msg.server);
+                    if (!network) {
+                        network = this.$state.addNetwork(msg.server, msg.nick || ('Guest' + Math.floor(Math.random() * 100)), msg);
+                    }
+                    network.showServerBuffer('settings');
+                }
+            });
+        },
+        addEmptyNetwork() {
+            let nick = 'Guest' + Math.floor(Math.random() * 100);
+            let network = this.$state.addNetwork(TextFormatting.t('new_network'), nick, {});
+            network.showServerBuffer('settings');
+        },
+        async findOtherTabs() { // ping other tabs to try find one with added networks
+            return new Promise((resolve, reject) => {
+                const handleIPCMessage = (e) => {
+                    let msg = e.data;
+                    if (msg.type === 'pong') {
+                        clearTimeout(timer);
+                        resolve(true);
+                    }
+                };
+
+                let timer = setTimeout((e) => {
+                    IPC.removeListener('message', handleIPCMessage);
+                    resolve(false);
+                }, 200);
+
+                IPC.on('message', handleIPCMessage);
+                IPC.send({ type: 'ping' });
+            });
+        },
+        addNetworkToExistingTab() {
+            let nick = 'Guest' + Math.floor(Math.random() * 100);
+            let con = this.server;
+
+            this.$state.addNetwork(TextFormatting.t('new_network'), nick, {});
+
+            IPC.send({
+                nick: nick,
+                server: con.server,
+                port: con.port,
+                tls: con.tls,
+                direct: con.direct,
+                password: con.password || '',
+                type: 'addNetwork',
+            });
+
+            window.location.hash = '';
+
+            this.addedNetworkToExisting = true;
+        },
+        addNetwork(temporary = false) {
+            if (!this.server) {
+                return;
+            }
+
+            let con = this.server;
+
+            if (temporary) {
+                this.$state.persistence.storageKey = null;
+                this.$state.persistence.forgetState();
+
+                this.init();
+            }
+
+            let network = this.$state.getNetworkFromAddress(con.server);
+            if (!network) {
+                network = this.$state.addNetwork(con.server, con.nick || ('Guest' + Math.floor(Math.random() * 100)), {
+                    server: con.server,
+                    port: con.port,
+                    tls: con.tls,
+                    direct: con.direct,
+                    password: con.password || '',
+                });
+            }
+
+            window.location.hash = '';
+            network.showServerBuffer('settings');
+
+            this.$emit('start', {
+                fallbackComponent: this.constructor,
+            });
+        },
+        parseFragment() {
+            if (window.location.hash.substr(1)) {
+                let fragment = window.location.hash.substr(1);
+
+                // Check to see if we're dealing with an encoded irc: uri (browsers do this
+                // when clicking an IRC link)
+                let uriCheck = fragment.substr(0, 7).toLowerCase();
+                if (uriCheck === 'ircs%3a' || uriCheck.substr(0, 6) === 'irc%3a') {
+                    fragment = decodeURIComponent(fragment);
+                }
+
+                let connections = Misc.parseIrcUri(fragment);
+                let con = connections[0];
+                return con;
+            }
+            return null;
+        },
+        toggleStateBrowser() {
+            this.$state.$emit('statebrowser.show');
+        },
+        async init() {
+            if (!firstRun) {
+                return;
+            }
+
+            firstRun = false;
+
+            // persist the buffers in the state by default
+            let persistSetting = this.$state.settings.startupOptions.remember_buffers;
+            if (typeof persistSetting === 'undefined') {
+                this.$state.persistence.includeBuffers = true;
+            } else {
+                this.$state.persistence.includeBuffers = !!persistSetting;
+            }
+
+            this.$state.persistence.watchStateForChanges();
+
+            if (this.$state.settings.startupOptions.bouncer) {
+                let controllerNet = this.$state.networks.find((n) => n.is_bnc);
+                if (controllerNet) {
+                    let bouncer = new BouncerProvider(this.$state);
+                    bouncer.enable(
+                        controllerNet.connection.server,
+                        controllerNet.connection.port,
+                        controllerNet.connection.tls,
+                        controllerNet.connection.direct,
+                        controllerNet.connection.path,
+                    );
+                }
+            }
+            // force restricted: false as users need access
+            // to network settings to add a network
+            this.$state.setSetting('settings.restricted', false);
+
+            if (this.$state.networks.length) {
+                // small screen devices cannot open the statebrowser unless a network is selected
+                // if any network exists in saved config make that active on startup
+                this.$state.setActiveBuffer(this.$state.networks[0].id, '*');
+            }
+
+            this.$emit('start', {
+                fallbackComponent: this.constructor,
+            });
+        },
+    },
+};
+</script>
+
+<style>
+
+.kiwi-personal {
+    box-sizing: border-box;
+    height: 100%;
+    overflow-y: auto;
+    text-align: center;
+    padding-top: 1em;
+    font-size: 1.2em;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+}
+
+.kiwi-personal h1 {
+    margin: 0 0 20px 0;
+}
+
+.kiwi-personal p {
+    margin: 0 0 10px 0;
+}
+
+.kiwi-personal button {
+    margin: 10px auto 0 auto;
+    padding: 0 40px;
+    font-size: 1em;
+    line-height: 40px;
+}
+
+/* Only show the toggle state browser link if on a small screen */
+.kiwi-personal-existing-networks {
+    display: none;
+}
+
+@media screen and (max-width: 500px) {
+    .kiwi-personal-existing-networks {
+        display: inherit;
+    }
+}
+
+</style>