Release 0.6.7

chat room monitor tool
do not send /LEAVE messages when leaving private chats
2019-11-26 09:55:10 +00:00 · 2019-11-26 09:43:53 +00:00 · 2019-11-26 05:31:22 +00:00 · 2019-11-26 05:28:24 +00:00 · 2019-11-26 05:00:55 +00:00 · 2019-11-23 20:28:29 +02:00
67 changed files with 3171 additions and 37 deletions
--- a/README.md
+++ b/README.md
@@ -4,11 +4,11 @@ MuWire is an easy to use file-sharing program which offers anonymity using [I2P

 It is inspired by the LimeWire Gnutella client and developped by a former LimeWire developer.

-The current stable release - 0.6.0 is avaiable for download at https://muwire.com.  You can find technical documentation in the "doc" folder.
+The current stable release - 0.6.6 is avaiable for download at https://muwire.com.  You can find technical documentation in the [doc] folder.  Also check out the [Wiki] for various documentation.

 ### Building

-You need JDK 8 or newer.  After installing that and setting up the appropriate paths, just type
+You need JDK 9 or newer.  After installing that and setting up the appropriate paths, just type

 ```
 ./gradlew clean assemble
@@ -19,11 +19,11 @@ If you want to run the unit tests, type
 ./gradlew clean build
 ```

-If you want to build binary bundles that do not depend on Java or I2P, see the https://github.com/zlatinb/muwire-pkg project
+If you want to build binary bundles that do not depend on Java or I2P, see the [muwire-pkg] project

 ### Running the GUI

-After you build the application, look inside `gui/build/distributions`.  Untar/unzip one of the `shadow` files and then run the jar contained inside by typing `java -jar gui-x.y.z.jar` in a terminal or command prompt.
+After you build the application, look inside `gui/build/distributions`.  Untar/unzip one of the `shadow` files and then run the jar contained inside by typing `java -jar gui-x.y.z-all.jar` in a terminal or command prompt.

 If you have an I2P router running on the same machine that is all you need to do.  If you use a custom I2CP host and port, create a file `i2p.properties` and put `i2cp.tcp.host=<host>` and `i2cp.tcp.port=<port>` in there.  On Windows that file should go into `%HOME%\AppData\Roaming\MuWire`, on Mac into `$HOME/Library/Application Support/MuWire` and on Linux `$HOME/.MuWire`

@@ -31,10 +31,14 @@ If you have an I2P router running on the same machine that is all you need to do

 ### Running the CLI

-Look inside `cli-lanterna/build/distributions`.  Untar/unzip one of the `shadow` files and then run the jar contained inside by typing `java -jar cli-lanterna-x.y.z.jar` in a terminal.  The CLI will ask you about the router host and port on startup, no need to edit any files.  However, the CLI does not have an options window yet, so if you need to change any options you will need to edit the configuration files.  The CLI options are documented here https://github.com/zlatinb/muwire/wiki/CLI-Configuration-Options
+Look inside `cli-lanterna/build/distributions`.  Untar/unzip one of the `shadow` files and then run the jar contained inside by typing `java -jar cli-lanterna-x.y.z-all.jar` in a terminal.  The CLI will ask you about the router host and port on startup, no need to edit any files.  However, the CLI does not have an options window yet, so if you need to change any options you will need to edit the configuration files.  The CLI options are documented here [cli options]

 The CLI is under active development and doesn't have all the features of the GUI.

+### Web UI
+
+If you are a Grails/Scala/JRuby/Kotlin developer and are interested in building a Web UI for MuWire, please get in touch.  The MuWire core is written in Groovy and should be easy to integrate with any JVM-based language.
+
 ### GPG Fingerprint

 ```
@@ -45,3 +49,7 @@ You can find the full key at https://keybase.io/zlatinb


 [Default I2CP port]: https://geti2p.net/en/docs/ports
+[Wiki]: https://github.com/zlatinb/muwire/wiki
+[doc]: https://github.com/zlatinb/muwire/tree/master/doc
+[muwire-pkg]: https://github.com/zlatinb/muwire-pkg 
+[cli options]: https://github.com/zlatinb/muwire/wiki/CLI-Configuration-Options
--- a/cli-lanterna/build.gradle
+++ b/cli-lanterna/build.gradle
@@ -6,7 +6,7 @@ buildscript {
    }

    dependencies {
-        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
+        classpath 'com.github.jengelman.gradle.plugins:shadow:5.2.0'
    }
 }

--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/BrowseModel.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/BrowseModel.groovy
@@ -72,4 +72,27 @@ class BrowseModel {
    void setPercentageLabel(Label percentage) {
        this.percentage = percentage
    }
+    
+    void sort(SortType type) {
+        Comparator<UIResultEvent> chosen
+        switch(type) {
+            case SortType.NAME_ASC : chosen = ResultComparators.NAME_ASC; break
+            case SortType.NAME_DESC : chosen = ResultComparators.NAME_DESC; break
+            case SortType.SIZE_ASC : chosen = ResultComparators.SIZE_ASC; break
+            case SortType.SIZE_DESC : chosen = ResultComparators.SIZE_DESC; break
+        }
+        
+        List<UIResultEvent> l = new ArrayList<>(rootToResult.values())
+        Collections.sort(l, chosen)
+        
+        int rowCount = model.getRowCount()
+        rowCount.times { model.removeRow(0) }
+        
+        l.each { e ->
+            String size = DataHelper.formatSize2Decimal(e.size, false) + "B"
+            String infoHash = Base64.encode(e.infohash.getRoot())
+            String comment = String.valueOf(e.comment != null)
+            model.addRow(e.name, size, infoHash, comment, e.certificates)
+        }
+    }
 }
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/BrowseView.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/BrowseView.groovy
@@ -58,11 +58,17 @@ class BrowseView extends BasicWindow {
        }
        contentPanel.addComponent(table, layoutData)
        
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(2))
+        Button sortButton = new Button("Sort...", {sort()})
        Button closeButton = new Button("Close",{
            model.unregister()
            close()
        })
-        contentPanel.addComponent(closeButton, layoutData)
+        buttonsPanel.addComponent(sortButton, layoutData)
+        buttonsPanel.addComponent(closeButton, layoutData)
+        
+        contentPanel.addComponent(buttonsPanel, layoutData)
        setComponent(contentPanel)
        
    }
@@ -120,4 +126,11 @@ class BrowseView extends BasicWindow {
        ViewCertificatesView view = new ViewCertificatesView(model, textGUI, core, terminalSize)
        textGUI.addWindowAndWait(view)
    }
+    
+    private void sort() {
+        SortPrompt prompt = new SortPrompt(textGUI)
+        SortType type = prompt.prompt()
+        if (type != null)
+            model.sort(type)
+    }
 }
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ChatConsoleModel.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ChatConsoleModel.groovy
@@ -0,0 +1,88 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.TextBox
+import com.googlecode.lanterna.gui2.TextGUIThread
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.chat.ChatConnectionEvent
+import com.muwire.core.chat.ChatLink
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.UIConnectChatEvent
+
+import net.i2p.data.DataHelper
+
+class ChatConsoleModel {
+    private final Core core
+    private final TextGUIThread guiThread
+    
+    volatile ChatLink link
+    volatile Thread poller
+    volatile boolean running
+    
+    volatile TextBox textBox
+    
+    
+    ChatConsoleModel(Core core, TextGUIThread guiThread) {
+        this.core = core
+        this.guiThread = guiThread
+    }
+    
+    void start() {
+        if (running)
+            return
+        running = true
+        core.chatServer.start()
+        core.eventBus.with { 
+            register(ChatConnectionEvent.class, this)
+            publish(new UIConnectChatEvent(host : core.me))
+        }
+    }
+    
+    void onChatConnectionEvent(ChatConnectionEvent e) {
+        if (e.persona != core.me)
+            return // can't really happen
+        
+        link = e.connection
+        poller = new Thread({eventLoop()} as Runnable)
+        poller.setDaemon(true)
+        poller.start()
+    }
+    
+    void stop() {
+        if (!running)
+            return
+        running = false
+        core.chatServer.stop()
+        poller?.interrupt()
+        link = null
+    }
+    
+    private void eventLoop() {
+        Thread.sleep(1000)
+        while(running) {
+            ChatLink link = this.link
+            if (link == null || !link.isUp()) {
+                Thread.sleep(100)
+                continue
+            }
+                
+            Object event = link.nextEvent()
+            if (event instanceof ChatMessageEvent)
+                handleChatMessage(event)
+            else if (event instanceof Persona)
+                handleLeave(event)
+            else
+                throw new IllegalArgumentException("unknown event type $event")
+        }
+    }
+    
+    private void handleChatMessage(ChatMessageEvent e) {
+        String text = DataHelper.formatTime(e.timestamp)+" <"+e.sender.getHumanReadableName()+ "> ["+
+            e.room+"] "+e.payload
+        guiThread.invokeLater({textBox.addLine(text)})
+    }
+    
+    private void handleLeave(Persona p) {
+        guiThread.invokeLater({textBox.addLine(p.getHumanReadableName()+ " disconnected")})
+    }
+}
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ChatConsoleView.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ChatConsoleView.groovy
@@ -0,0 +1,116 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.TerminalSize
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.Label
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextBox
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+import com.muwire.core.Core
+import com.muwire.core.chat.ChatCommand
+import com.muwire.core.chat.ChatConnection
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.ChatServer
+
+import net.i2p.data.DataHelper
+
+class ChatConsoleView extends BasicWindow {
+    private final TextGUI textGUI
+    private final ChatConsoleModel model
+    private final Core core
+    
+    private final LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false)
+    private final LayoutData layoutDataFill = GridLayout.createLayoutData(Alignment.FILL, Alignment.FILL, true, false)
+    
+    private final TextBox textBox
+    private final TextBox sayField
+    private final TextBox roomField
+    
+    ChatConsoleView(Core core, ChatConsoleModel model, TextGUI textGUI, TerminalSize terminalSize) {
+        super("Chat Server Console")
+        this.core = core
+        this.model = model
+        this.textGUI = textGUI
+        TextBox textBox = model.textBox == null ? new TextBox(terminalSize,"", TextBox.Style.MULTI_LINE) : model.textBox 
+        this.textBox = textBox
+        model.textBox = textBox
+        model.start()
+        TerminalSize textFieldSize = new TerminalSize((terminalSize.getColumns() / 2).toInteger(), 1)
+        this.sayField = new TextBox(textFieldSize,"", TextBox.Style.SINGLE_LINE)
+        this.roomField = new TextBox(textFieldSize,"__CONSOLE__", TextBox.Style.SINGLE_LINE)
+        
+        
+        setHints([Window.Hint.EXPANDED])
+        
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(1))
+        contentPanel.addComponent(textBox, layoutData)
+        
+        Panel inputPanel = new Panel()
+        inputPanel.with { 
+            setLayoutManager(new GridLayout(2))
+            addComponent(new Label("Say something here"), layoutData)
+            addComponent(sayField, layoutDataFill)
+            addComponent(new Label("In room:"), layoutData)
+            addComponent(roomField, layoutDataFill)
+        }
+        contentPanel.addComponent(inputPanel, layoutData)
+        
+        Panel bottomPanel = new Panel()
+        bottomPanel.setLayoutManager(new GridLayout(5))
+        
+        Button sayButton = new Button("Say",{say()})
+        Button startButton = new Button("Start Server",{model.start()})
+        Button stopButton = new Button("Stop Server", {model.stop()})
+        Button clearButton = new Button("Clear",{textBox.setText("")})
+        Button closeButton = new Button("Close",{close()})    
+        
+        bottomPanel.with { 
+            addComponent(sayButton, layoutData)
+            addComponent(startButton, layoutData)
+            addComponent(stopButton, layoutData)
+            addComponent(clearButton, layoutData)
+            addComponent(closeButton, layoutData)
+        }    
+        contentPanel.addComponent(bottomPanel, layoutData)
+        setComponent(contentPanel)
+    }
+    
+    private void say() {
+        String command = sayField.getText()
+        sayField.setText("")
+        
+        ChatCommand chatCommand
+        try {
+            chatCommand = new ChatCommand(command)
+        } catch (Exception e) {
+            chatCommand = new ChatCommand("/SAY $command")
+        }
+        command = chatCommand.source
+        
+        String room = roomField.getText()
+        
+        UUID uuid = UUID.randomUUID()
+        long now = System.currentTimeMillis()
+        
+        String toAppend = DataHelper.formatTime(now) + " <" + core.me.getHumanReadableName() + "> [$room] " + command
+        textBox.addLine(toAppend)
+        
+        byte[] sig = ChatConnection.sign(uuid, now, room, command, core.me, core.me, core.spk)
+        
+        def event = new ChatMessageEvent( uuid : uuid,
+            payload : command,
+            sender : core.me,
+            host : core.me,
+            room : room,
+            chatTime : now,
+            sig : sig
+            )
+        core.eventBus.publish(event)
+    }
+}
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/CliLanterna.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/CliLanterna.groovy
@@ -32,7 +32,7 @@ import com.muwire.core.UILoadedEvent
 import com.muwire.core.files.AllFilesLoadedEvent

 class CliLanterna {
-    private static final String MW_VERSION = "0.6.2"
+    private static final String MW_VERSION = "0.6.7"
    
    private static volatile Core core
    
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesModel.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesModel.groovy
@@ -78,4 +78,32 @@ class FilesModel {
            model.addRow(new SharedFileWrapper(it), DataHelper.formatSize2(size, false)+"B", comment, certified, hits, downloaders)
        }
    }
+    
+    private void sort(SortType type) {
+        Comparator<SharedFile> chosen
+        switch(type) {
+            case SortType.NAME_ASC : chosen = NAME_ASC; break
+            case SortType.NAME_DESC : chosen = NAME_DESC; break
+            case SortType.SIZE_ASC : chosen = SIZE_ASC; break
+            case SortType.SIZE_DESC : chosen = SIZE_DESC; break
+        }
+        
+        Collections.sort(sharedFiles, chosen)
+    }
+    
+    private static final Comparator<SharedFile> NAME_ASC = new Comparator<SharedFile>() {
+        public int compare(SharedFile a, SharedFile b) {
+            a.getFile().getName().compareTo(b.getFile().getName())
+        }
+    }
+    
+    private static final Comparator<SharedFile> NAME_DESC = NAME_ASC.reversed()
+    
+    private static final Comparator<SharedFile> SIZE_ASC = new Comparator<SharedFile>() {
+        public int compare(SharedFile a, SharedFile b) {
+            Long.compare(a.getCachedLength(), b.getCachedLength())
+        }
+    }
+    
+    private static final Comparator<SharedFile> SIZE_DESC = SIZE_ASC.reversed()
 }
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesView.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesView.groovy
@@ -51,17 +51,19 @@ class FilesView extends BasicWindow {
        contentPanel.addComponent(table, layoutData)
        
        Panel buttonsPanel = new Panel()
-        buttonsPanel.setLayoutManager(new GridLayout(4))
+        buttonsPanel.setLayoutManager(new GridLayout(5))
        
        Button shareFile = new Button("Share File", {shareFile()})
        Button shareDirectory = new Button("Share Directory", {shareDirectory()})
        Button unshareDirectory = new Button("Unshare Directory",{unshareDirectory()})
+        Button sort = new Button("Sort...",{sort()})
        Button close = new Button("Close", {close()})
        
        buttonsPanel.with { 
            addComponent(shareFile, layoutData)
            addComponent(shareDirectory, layoutData)
            addComponent(unshareDirectory, layoutData)
+            addComponent(sort, layoutData)
            addComponent(close, layoutData)
        }
        
@@ -134,4 +136,11 @@ class FilesView extends BasicWindow {
        core.eventBus.publish(new DirectoryUnsharedEvent(directory : directory))
        MessageDialog.showMessageDialog(textGUI, "Directory Unshared", directory.getName()+" has been unshared", MessageDialogButton.OK)
    }
+    
+    private void sort() {
+        SortPrompt prompt = new SortPrompt(textGUI)
+        SortType type = prompt.prompt()
+        if (type != null)
+            model.sort(type)
+    }
 }
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/MainWindowView.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/MainWindowView.groovy
@@ -44,6 +44,7 @@ class MainWindowView extends BasicWindow {
    private final UploadsModel uploadsModel
    private final FilesModel filesModel
    private final TrustModel trustModel
+    private final ChatConsoleModel chatModel
    
    private final Label connectionCount, incoming, outgoing
    private final Label known, failing, hopeless
@@ -63,6 +64,9 @@ class MainWindowView extends BasicWindow {
        uploadsModel = new UploadsModel(textGUI.getGUIThread(), core, props)
        filesModel = new FilesModel(textGUI.getGUIThread(),core)
        trustModel = new TrustModel(textGUI.getGUIThread(), core)
+        chatModel = new ChatConsoleModel(core, textGUI.getGUIThread())
+        if (core.muOptions.startChatServer)
+            core.chatServer.start()
        
        setHints([Window.Hint.EXPANDED])
        Panel contentPanel = new Panel()
@@ -74,7 +78,7 @@ class MainWindowView extends BasicWindow {
        Panel buttonsPanel = new Panel()
        contentPanel.addComponent(buttonsPanel, BorderLayout.Location.TOP)
        
-        GridLayout gridLayout = new GridLayout(7)
+        GridLayout gridLayout = new GridLayout(8)
        buttonsPanel.setLayoutManager(gridLayout)
        
        searchTextBox = new TextBox(new TerminalSize(40, 1))
@@ -83,6 +87,7 @@ class MainWindowView extends BasicWindow {
        Button uploadsButton = new Button("Uploads", {upload()})
        Button filesButton = new Button("Files", { files() })
        Button trustButton = new Button("Trust", {trust()})
+        Button chatButton = new Button("Chat", {chat()})
        Button quitButton = new Button("Quit", {close()})
        
        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
@@ -94,6 +99,7 @@ class MainWindowView extends BasicWindow {
            addComponent(uploadsButton, layoutData)
            addComponent(filesButton, layoutData)
            addComponent(trustButton, layoutData)
+            addComponent(chatButton, layoutData)
            addComponent(quitButton, layoutData)
        }
        
@@ -271,6 +277,10 @@ class MainWindowView extends BasicWindow {
        textGUI.addWindowAndWait(new TrustView(trustModel, textGUI, core, sizeForTables()))
    }
    
+    private void chat() {
+        textGUI.addWindowAndWait(new ChatConsoleView(core, chatModel, textGUI, sizeForTables()))
+    }
+    
    private void refreshStats() {
        int inCon = 0
        int outCon = 0
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultComparators.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultComparators.groovy
@@ -0,0 +1,21 @@
+package com.muwire.clilanterna
+
+import com.muwire.core.search.UIResultEvent
+
+class ResultComparators {
+    public static final Comparator<UIResultEvent> NAME_ASC = new Comparator<UIResultEvent>() {
+        public int compare(UIResultEvent a, UIResultEvent b) {
+            a.name.compareTo(b.name)
+        }
+    }
+    
+    public static final Comparator<UIResultEvent> NAME_DESC = NAME_ASC.reversed()
+    
+    public static final Comparator<UIResultEvent> SIZE_ASC = new Comparator<UIResultEvent>() {
+        public int compare(UIResultEvent a, UIResultEvent b) {
+            Long.compare(a.size, b.size)
+        }
+    }
+    
+    public static final Comparator<UIResultEvent> SIZE_DESC = SIZE_ASC.reversed()
+}
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultsModel.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultsModel.groovy
@@ -16,7 +16,27 @@ class ResultsModel {
    ResultsModel(UIResultBatchEvent results) {
        this.results = results
        model = new TableModel("Name","Size","Hash","Sources","Comment","Certificates")
-        results.results.each { 
+        updateModel()
+    }
+    
+    void sort(SortType type) {
+        Comparator<UIResultEvent> chosen
+        switch(type) {
+            case SortType.NAME_ASC : chosen = ResultComparators.NAME_ASC; break
+            case SortType.NAME_DESC : chosen = ResultComparators.NAME_DESC; break
+            case SortType.SIZE_ASC : chosen = ResultComparators.SIZE_ASC; break
+            case SortType.SIZE_DESC : chosen = ResultComparators.SIZE_DESC; break
+        }
+
+        Arrays.sort(results.results, chosen)
+        updateModel()
+    }
+    
+    private void updateModel() {
+        int rowCount = model.getRowCount()
+        rowCount.times { model.removeRow(0) }
+        
+        results.results.each {
            String size = DataHelper.formatSize2Decimal(it.size, false) + "B"
            String infoHash = Base64.encode(it.infohash.getRoot())
            String sources = String.valueOf(it.sources.size())
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultsView.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/ResultsView.groovy
@@ -43,9 +43,14 @@ class ResultsView extends BasicWindow {
        table.setTableModel(model.model)
        table.setVisibleRows(terminalSize.getRows())
        contentPanel.addComponent(table, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false))
-        
+
+        Panel buttonsPanel = new Panel()
+        buttonsPanel.setLayoutManager(new GridLayout(2))
+        Button sortButton = new Button("Sort...",{sort()})
+        buttonsPanel.addComponent(sortButton)        
        Button closeButton = new Button("Close", {close()})
-        contentPanel.addComponent(closeButton, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false))
+        buttonsPanel.addComponent(closeButton)
+        contentPanel.addComponent(buttonsPanel, GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER, true, false))
        
        setComponent(contentPanel)
        closeButton.takeFocus()    
@@ -109,4 +114,11 @@ class ResultsView extends BasicWindow {
        ViewCertificatesView view = new ViewCertificatesView(model, textGUI, core, terminalSize)
        textGUI.addWindowAndWait(view)
    }
+    
+    private void sort() {
+        SortPrompt prompt = new SortPrompt(textGUI)
+        SortType type = prompt.prompt()
+        if (type != null)
+            model.sort(type)
+    }
 }
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/SortPrompt.groovy
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/SortPrompt.groovy
@@ -0,0 +1,57 @@
+package com.muwire.clilanterna
+
+import com.googlecode.lanterna.gui2.BasicWindow
+import com.googlecode.lanterna.gui2.Button
+import com.googlecode.lanterna.gui2.GridLayout
+import com.googlecode.lanterna.gui2.GridLayout.Alignment
+import com.googlecode.lanterna.gui2.LayoutData
+import com.googlecode.lanterna.gui2.Panel
+import com.googlecode.lanterna.gui2.TextGUI
+import com.googlecode.lanterna.gui2.Window
+
+class SortPrompt extends BasicWindow {
+    private final TextGUI textGUI
+    private SortType type
+    SortPrompt(TextGUI textGUI) {
+        super("Select what to sort by")
+        this.textGUI = textGUI
+    }
+    
+    SortType prompt() {
+        setHints([Window.Hint.CENTERED])
+        Panel contentPanel = new Panel()
+        contentPanel.setLayoutManager(new GridLayout(5))
+        
+        LayoutData layoutData = GridLayout.createLayoutData(Alignment.CENTER, Alignment.CENTER)
+        
+        Button nameAsc = new Button("Name (ascending)",{
+            type = SortType.NAME_ASC
+            close()  
+        })
+        Button nameDesc = new Button("Name (descending)",{
+            type = SortType.NAME_DESC
+            close()
+        })
+        Button sizeAsc = new Button("Size (ascending)",{
+            type = SortType.SIZE_ASC
+            close()
+        })
+        Button sizeDesc = new Button("Size (descending)",{
+            type = SortType.SIZE_DESC
+            close()
+        })
+        Button close = new Button("Cancel",{close()})
+        
+        contentPanel.with { 
+            addComponent(nameAsc, layoutData)
+            addComponent(nameDesc, layoutData)
+            addComponent(sizeAsc, layoutData)
+            addComponent(sizeDesc, layoutData)
+            addComponent(close, layoutData)
+        }
+        
+        setComponent(contentPanel)
+        textGUI.addWindowAndWait(this)
+        type
+    }
+}
--- a/cli-lanterna/src/main/groovy/com/muwire/clilanterna/SortType.java
+++ b/cli-lanterna/src/main/groovy/com/muwire/clilanterna/SortType.java
@@ -0,0 +1,5 @@
+package com.muwire.clilanterna;
+
+public enum SortType {
+    NAME_ASC,NAME_DESC,SIZE_ASC,SIZE_DESC
+}
--- a/cli/build.gradle
+++ b/cli/build.gradle
@@ -6,7 +6,7 @@ buildscript {
    }

    dependencies {
-        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
+        classpath 'com.github.jengelman.gradle.plugins:shadow:5.2.0'
    }
 }

--- a/core/src/main/groovy/com/muwire/core/Core.groovy
+++ b/core/src/main/groovy/com/muwire/core/Core.groovy
@@ -3,6 +3,12 @@ package com.muwire.core
 import java.nio.charset.StandardCharsets
 import java.util.concurrent.atomic.AtomicBoolean

+import com.muwire.core.chat.ChatDisconnectionEvent
+import com.muwire.core.chat.ChatManager
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.ChatServer
+import com.muwire.core.chat.UIConnectChatEvent
+import com.muwire.core.chat.UIDisconnectChatEvent
 import com.muwire.core.connection.ConnectionAcceptor
 import com.muwire.core.connection.ConnectionEstablisher
 import com.muwire.core.connection.ConnectionEvent
@@ -105,6 +111,8 @@ public class Core {
    final UploadManager uploadManager
    final ContentManager contentManager
    final CertificateManager certificateManager
+    final ChatServer chatServer
+    final ChatManager chatManager

    private final Router router

@@ -278,8 +286,16 @@ public class Core {
        CertificateClient certificateClient = new CertificateClient(eventBus, i2pConnector)
        eventBus.register(UIFetchCertificatesEvent.class, certificateClient)
        
+        log.info("initializing chat server")
+        chatServer = new ChatServer(eventBus, props, trustService, me, spk)
+        eventBus.with {
+            register(ChatMessageEvent.class, chatServer)
+            register(ChatDisconnectionEvent.class, chatServer)
+            register(TrustEvent.class, chatServer)
+        }
+        
        log.info "initializing results sender"
-        ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me, props, certificateManager)
+        ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me, props, certificateManager, chatServer)

        log.info "initializing search manager"
        SearchManager searchManager = new SearchManager(eventBus, me, resultsSender)
@@ -302,11 +318,21 @@ public class Core {
        log.info("initializing connection establisher")
        connectionEstablisher = new ConnectionEstablisher(eventBus, i2pConnector, props, connectionManager, hostCache)

+        
+        log.info("initializing chat manager")
+        chatManager = new ChatManager(eventBus, me, i2pConnector, trustService, props)
+        eventBus.with { 
+            register(UIConnectChatEvent.class, chatManager)
+            register(UIDisconnectChatEvent.class, chatManager)
+            register(ChatMessageEvent.class, chatManager)
+            register(ChatDisconnectionEvent.class, chatManager)
+        }
+        
        log.info("initializing acceptor")
        I2PAcceptor i2pAcceptor = new I2PAcceptor(socketManager)
        connectionAcceptor = new ConnectionAcceptor(eventBus, connectionManager, props,
            i2pAcceptor, hostCache, trustService, searchManager, uploadManager, fileManager, connectionEstablisher,
-            certificateManager)
+            certificateManager, chatServer)

        log.info("initializing directory watcher")
        directoryWatcher = new DirectoryWatcher(eventBus, fileManager, home, props)
@@ -358,9 +384,9 @@ public class Core {
        saveMuSettings()
        log.info("shutting down trust subscriber")
        trustSubscriber.stop()
-        log.info("shutting down download manageer")
+        log.info("shutting down download manager")
        downloadManager.shutdown()
-        log.info("shutting down connection acceeptor")
+        log.info("shutting down connection acceptor")
        connectionAcceptor.stop()
        log.info("shutting down connection establisher")
        connectionEstablisher.stop()
@@ -368,6 +394,10 @@ public class Core {
        directoryWatcher.stop()
        log.info("shutting down cache client")
        cacheClient.stop()
+        log.info("shutting down chat server")
+        chatServer.stop()
+        log.info("shutting down chat manager")
+        chatManager.shutdown()
        log.info("shutting down connection manager")
        connectionManager.shutdown()
        if (router != null) {
@@ -406,7 +436,7 @@ public class Core {
            }
        }

-        Core core = new Core(props, home, "0.6.2")
+        Core core = new Core(props, home, "0.6.7")
        core.startServices()

        // ... at the end, sleep or execute script
--- a/core/src/main/groovy/com/muwire/core/MuWireSettings.groovy
+++ b/core/src/main/groovy/com/muwire/core/MuWireSettings.groovy
@@ -31,6 +31,10 @@ class MuWireSettings {
    boolean shareHiddenFiles
    boolean searchComments
    boolean browseFiles
+    boolean startChatServer
+    int maxChatConnections
+    boolean advertiseChat
+    File chatWelcomeFile
    Set<String> watchedDirectories
    float downloadSequentialRatio
    int hostClearInterval, hostHopelessInterval, hostRejectInterval
@@ -79,7 +83,13 @@ class MuWireSettings {
        speedSmoothSeconds = Integer.valueOf(props.getProperty("speedSmoothSeconds","60"))
        totalUploadSlots = Integer.valueOf(props.getProperty("totalUploadSlots","-1"))
        uploadSlotsPerUser = Integer.valueOf(props.getProperty("uploadSlotsPerUser","-1"))
-
+        startChatServer = Boolean.valueOf(props.getProperty("startChatServer","false"))
+        maxChatConnections = Integer.valueOf(props.get("maxChatConnections", "-1"))
+        advertiseChat = Boolean.valueOf(props.getProperty("advertiseChat","true"))
+        String chatWelcomeProp = props.getProperty("chatWelcomeFile")
+        if (chatWelcomeProp != null)
+            chatWelcomeFile = new File(chatWelcomeProp)
+        
        watchedDirectories = DataUtil.readEncodedSet(props, "watchedDirectories")
        watchedKeywords = DataUtil.readEncodedSet(props, "watchedKeywords")
        watchedRegexes = DataUtil.readEncodedSet(props, "watchedRegexes")
@@ -127,6 +137,11 @@ class MuWireSettings {
        props.setProperty("speedSmoothSeconds", String.valueOf(speedSmoothSeconds))
        props.setProperty("totalUploadSlots", String.valueOf(totalUploadSlots))
        props.setProperty("uploadSlotsPerUser", String.valueOf(uploadSlotsPerUser))
+        props.setProperty("startChatServer", String.valueOf(startChatServer))
+        props.setProperty("maxChatConnectios", String.valueOf(maxChatConnections))
+        props.setProperty("advertiseChat", String.valueOf(advertiseChat))
+        if (chatWelcomeFile != null)
+            props.setProperty("chatWelcomeFile", chatWelcomeFile.getAbsolutePath())

        DataUtil.writeEncodedSet(watchedDirectories, "watchedDirectories", props)
        DataUtil.writeEncodedSet(watchedKeywords, "watchedKeywords", props)
--- a/core/src/main/groovy/com/muwire/core/chat/ChatAction.java
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatAction.java
@@ -0,0 +1,24 @@
+package com.muwire.core.chat;
+
+enum ChatAction {
+    JOIN(true, false, true, false), 
+    LEAVE(false, false, true, false), 
+    SAY(false, false, true, false), 
+    LIST(true, true, true, false), 
+    HELP(true, true, true, false),
+    INFO(true, true, true, false),
+    JOINED(true, true, false, false),
+    TRUST(true, false, true, true),
+    DISTRUST(true, false, true, true);
+    
+    final boolean console;
+    final boolean stateless;
+    final boolean user;
+    final boolean local;
+    ChatAction(boolean console, boolean stateless, boolean user, boolean local) {
+        this.console = console;
+        this.stateless = stateless;
+        this.user = user;
+        this.local = local;
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatClient.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatClient.groovy
@@ -0,0 +1,141 @@
+package com.muwire.core.chat
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.trust.TrustService
+import com.muwire.core.util.DataUtil
+
+import groovy.util.logging.Log
+
+@Log
+class ChatClient implements Closeable {
+    
+    private static final long REJECTION_BACKOFF = 60 * 1000
+    
+    private static final Executor CONNECTOR = Executors.newCachedThreadPool()
+    
+    private final I2PConnector connector
+    private final EventBus eventBus
+    private final Persona host, me
+    private final TrustService trustService
+    private final MuWireSettings settings
+    
+    private ChatConnection connection
+    private boolean connectInProgress
+    private long lastRejectionTime
+    private Thread connectThread
+    
+    ChatClient(I2PConnector connector, EventBus eventBus, Persona host, Persona me, TrustService trustService,
+        MuWireSettings settings) {
+        this.connector = connector
+        this.eventBus = eventBus
+        this.host = host
+        this.me = me
+        this.trustService = trustService
+        this.settings = settings
+    }
+    
+    synchronized void connectIfNeeded() {
+        if (connection != null || connectInProgress || (System.currentTimeMillis() - lastRejectionTime < REJECTION_BACKOFF))
+            return
+        connectInProgress = true
+        CONNECTOR.execute({connect()})
+    }
+    
+    private void connect() {
+        synchronized(this) {
+            if (!connectInProgress)
+                return
+            connectThread = Thread.currentThread()
+        }
+        Endpoint endpoint = null
+        try {
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.CONNECTING, persona : host))
+            endpoint = connector.connect(host.destination)
+            DataOutputStream dos = new DataOutputStream(endpoint.getOutputStream())
+            DataInputStream dis = new DataInputStream(endpoint.getInputStream())
+            
+            dos.with {
+                write("IRC\r\n".getBytes(StandardCharsets.US_ASCII))
+                write("Version:${Constants.CHAT_VERSION}\r\n".getBytes(StandardCharsets.US_ASCII))
+                write("Persona:${me.toBase64()}\r\n".getBytes(StandardCharsets.US_ASCII))
+                write("\r\n".getBytes(StandardCharsets.US_ASCII))
+                flush()
+            }
+                
+            String codeString = DataUtil.readTillRN(dis)
+            int code = Integer.parseInt(codeString.split(" ")[0])
+            
+            if (code == 429) {
+                eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.REJECTED, persona : host))
+                try { dos.close() } catch (IOException ignore) {}
+                endpoint.close()
+                synchronized(this) {
+                    lastRejectionTime = System.currentTimeMillis()
+                }
+                return
+            }
+            
+            if (code != 200) 
+                throw new Exception("unknown code $code")
+
+            Map<String,String> headers = DataUtil.readAllHeaders(dis)
+            if (!headers.containsKey('Version'))
+                throw new Exception("Version header missing")
+            
+            int version = Integer.parseInt(headers['Version'])
+            if (version != Constants.CHAT_VERSION)
+                throw new Exception("Unknown chat version $version")
+            
+            synchronized(this) {
+                if (!connectInProgress)
+                    return
+                connection = new ChatConnection(eventBus, endpoint, host, false, trustService, settings)
+                connection.start()
+            }
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.SUCCESSFUL, persona : host, 
+                connection : connection))
+        } catch (Exception e) {
+            log.log(java.util.logging.Level.WARNING, "connect failed", e)
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.FAILED, persona : host))
+            if (endpoint != null) {
+                try {endpoint.getOutputStream().close() } catch (IOException ignore) {}
+                endpoint.close()
+            }
+        } finally {
+            synchronized(this) {
+                connectInProgress = false
+                connectThread = null
+            }
+        }
+    }
+    
+    synchronized void disconnected() {
+        connectInProgress = false
+        connection = null
+    }
+    
+    @Override
+    synchronized public void close() {
+        connectInProgress = false
+        connectThread?.interrupt()
+        connection?.close()
+        eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.DISCONNECTED, persona : host))
+    }
+    
+    synchronized void ping() {
+        connection?.sendPing()
+    }
+    
+    synchronized void sendChat(ChatMessageEvent e) {
+        connection?.sendChat(e)
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatCommand.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatCommand.groovy
@@ -0,0 +1,28 @@
+package com.muwire.core.chat
+
+class ChatCommand {
+    private final ChatAction action
+    private final String payload
+    final String source
+    ChatCommand(String source) {
+        if (source.charAt(0) != '/')
+            throw new Exception("command doesn't start with / $source")
+        
+        int position = 1
+        StringBuilder sb = new StringBuilder()
+        while(position < source.length()) {
+            char c = source.charAt(position)
+            if (c == ' ')
+                break
+            sb.append(c)
+            position++    
+        }
+        String command = sb.toString().toUpperCase()
+        action = ChatAction.valueOf(command)
+        if (position < source.length())
+            payload = source.substring(position + 1)
+        else
+            payload = ""
+        this.source = source
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatConnection.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatConnection.groovy
@@ -0,0 +1,280 @@
+package com.muwire.core.chat
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.BlockingQueue
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.logging.Level
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.trust.TrustLevel
+import com.muwire.core.trust.TrustService
+
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import groovy.util.logging.Log
+import net.i2p.crypto.DSAEngine
+import net.i2p.data.Base64
+import net.i2p.data.Signature
+import net.i2p.data.SigningPrivateKey
+
+@Log
+class ChatConnection implements ChatLink {
+    
+    private static final long PING_INTERVAL = 20000
+    private static final long MAX_CHAT_AGE = 5 * 60 * 1000
+    
+    private final EventBus eventBus
+    private final Endpoint endpoint
+    private final Persona persona
+    private final boolean incoming
+    private final TrustService trustService
+    private final MuWireSettings settings
+    
+    private final AtomicBoolean running = new AtomicBoolean()
+    private final BlockingQueue messages = new LinkedBlockingQueue()
+    private final Thread reader, writer
+    private final LinkedList<Long> timestamps = new LinkedList<>()
+    private final BlockingQueue incomingEvents = new LinkedBlockingQueue()
+    
+    private final DataInputStream dis
+    private final DataOutputStream dos
+    
+    private final JsonSlurper slurper = new JsonSlurper()
+    
+    private volatile long lastPingSentTime
+    
+    ChatConnection(EventBus eventBus, Endpoint endpoint, Persona persona, boolean incoming,
+        TrustService trustService, MuWireSettings settings) {
+        this.eventBus = eventBus
+        this.endpoint = endpoint
+        this.persona = persona
+        this.incoming = incoming
+        this.trustService = trustService
+        this.settings = settings
+        
+        this.dis = new DataInputStream(endpoint.getInputStream())
+        this.dos = new DataOutputStream(endpoint.getOutputStream())
+
+        this.reader = new Thread({readLoop()} as Runnable)
+        this.reader.setName("reader-${persona.getHumanReadableName()}")
+        this.reader.setDaemon(true)
+        
+        this.writer = new Thread({writeLoop()} as Runnable)
+        this.writer.setName("writer-${persona.getHumanReadableName()}")
+        this.writer.setDaemon(true)        
+    }
+    
+    void start() {
+        if (!running.compareAndSet(false, true)) {
+            log.log(Level.WARNING,"${persona.getHumanReadableName()} already running", new Exception())
+            return
+        }
+        reader.start()
+        writer.start()
+    }
+    
+    @Override
+    public boolean isUp() {
+        running.get()
+    }
+    
+    @Override
+    public Persona getPersona() {
+        persona
+    }
+    
+    @Override
+    public void close() {
+        if (!running.compareAndSet(true, false)) {
+            log.log(Level.WARNING,"${persona.getHumanReadableName()} already closed", new Exception())
+            return
+        }
+        log.info("Closing "+persona.getHumanReadableName())
+        reader.interrupt()
+        writer.interrupt()
+        endpoint.close()
+        eventBus.publish(new ChatDisconnectionEvent(persona : persona))
+    }
+    
+    private void readLoop() {
+        try {
+            while(running.get())
+                read()
+        } catch( InterruptedException | SocketTimeoutException ignored) {
+        } catch (Exception e) {
+          log.log(Level.WARNING,"unhandled exception in reader", e)  
+        } finally {
+            try {endpoint.getOutputStream().close()} catch (IOException ignore) {}
+            close()
+        }
+    }
+    
+    private void writeLoop() {
+        try {
+            while(running.get()) {
+                def message = messages.take()
+                write(message)
+            }
+        } catch (InterruptedException ignore) {
+        } catch (Exception e) {
+            log.log(Level.WARNING,"unhandled exception in writer",e)
+        } finally {
+            try {endpoint.getOutputStream().close()} catch (IOException ignore) {}
+            close()
+        }
+    }
+    
+    private void read() {
+        int length = dis.readUnsignedShort()
+        byte [] payload = new byte[length]
+        dis.readFully(payload)
+        def json = slurper.parse(payload)
+        if (json.type == null)
+            throw new Exception("missing json type")
+        switch(json.type) {
+            case "Ping" : break // just ignore
+            case "Chat" : handleChat(json); break
+            case "Leave": handleLeave(json); break
+            default :
+                throw new Exception("unknown json type ${json.type}")
+        }
+    }
+    
+    private void write(Object message) {
+        byte [] payload = JsonOutput.toJson(message).bytes
+        dos.with {
+            writeShort(payload.length)
+            write(payload)
+            flush()
+        }
+    }
+    
+    void sendPing() {
+        long now = System.currentTimeMillis()
+        if (now - lastPingSentTime < PING_INTERVAL)
+            return
+        def ping = [:]
+        ping.type = "Ping"
+        ping.version = 1
+        messages.put(ping)
+        lastPingSentTime = now
+    }
+    
+    private void handleChat(def json) {
+        UUID uuid = UUID.fromString(json.uuid)
+        Persona host = fromString(json.host)
+        Persona sender = fromString(json.sender)
+        long chatTime = json.chatTime
+        String room = json.room
+        String payload = json.payload
+        byte [] sig = Base64.decode(json.sig)
+        
+        if (!verify(uuid,host,sender,chatTime,room,payload,sig)) {
+            log.warning("chat didn't verify")
+            return
+        }
+        if (incoming) {
+            if (sender.destination != endpoint.destination) {
+                log.warning("Sender destination mismatch, dropping message")
+                return
+            }
+        } else {
+            if (host.destination != endpoint.destination) {
+                log.warning("Host destination mismatch, dropping message")
+                return
+            }
+        }
+        if (System.currentTimeMillis() - chatTime > MAX_CHAT_AGE) {
+            log.warning("Chat too old, dropping")
+            return
+        }
+        switch(trustService.getLevel(sender.destination)) {
+            case TrustLevel.TRUSTED : break
+            case TrustLevel.NEUTRAL :
+                if (!settings.allowUntrusted) 
+                    return
+                else
+                    break
+            case TrustLevel.DISTRUSTED :
+                return
+        }
+        def event = new ChatMessageEvent( uuid : uuid, payload : payload, sender : sender,
+            host : host, room : room, chatTime : chatTime, sig : sig)
+        eventBus.publish(event)
+        if (!incoming)
+            incomingEvents.put(event)
+    }
+    
+    private void handleLeave(def json) {
+        Persona leaver = fromString(json.persona)
+        eventBus.publish(new UserDisconnectedEvent(user : leaver, host : persona))
+        incomingEvents.put(leaver)
+    }
+    
+    private static Persona fromString(String base64) {
+        new Persona(new ByteArrayInputStream(Base64.decode(base64)))
+    }
+    
+    private static boolean verify(UUID uuid, Persona host, Persona sender, long chatTime, 
+        String room, String payload, byte []sig) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream()
+        DataOutputStream daos = new DataOutputStream(baos)
+        daos.write(uuid.toString().bytes)
+        host.write(daos)
+        sender.write(daos)
+        daos.writeLong(chatTime)
+        daos.write(room.getBytes(StandardCharsets.UTF_8))
+        daos.write(payload.getBytes(StandardCharsets.UTF_8))
+        daos.close()
+        byte [] signed = baos.toByteArray()
+        def spk = sender.destination.getSigningPublicKey()
+        def signature = new Signature(Constants.SIG_TYPE, sig)
+        DSAEngine.getInstance().verifySignature(signature, signed, spk)
+    }
+    
+    public static byte[] sign(UUID uuid, long chatTime, String room, String words, Persona sender, Persona host, SigningPrivateKey spk) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream()
+        DataOutputStream daos = new DataOutputStream(baos)
+        daos.with {
+            write(uuid.toString().bytes)
+            host.write(daos)
+            sender.write(daos)
+            writeLong(chatTime)
+            write(room.getBytes(StandardCharsets.UTF_8))
+            write(words.getBytes(StandardCharsets.UTF_8))
+            close()
+        }
+        byte [] payload = baos.toByteArray()
+        Signature sig = DSAEngine.getInstance().sign(payload, spk)
+        sig.getData()
+    }
+    
+    void sendChat(ChatMessageEvent e) {
+        def chat = [:]
+        chat.type = "Chat"
+        chat.uuid = e.uuid.toString()
+        chat.host = e.host.toBase64()
+        chat.sender = e.sender.toBase64()
+        chat.chatTime = e.chatTime
+        chat.room = e.room
+        chat.payload = e.payload
+        chat.sig = Base64.encode(e.sig)
+        messages.put(chat)
+    }
+    
+    void sendLeave(Persona p) {
+        def leave = [:]
+        leave.type = "Leave"
+        leave.persona = p.toBase64()
+        messages.put(leave)
+    }
+    
+    public Object nextEvent() {
+        incomingEvents.take()
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatConnectionAttemptStatus.java
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatConnectionAttemptStatus.java
@@ -0,0 +1,5 @@
+package com.muwire.core.chat;
+
+public enum ChatConnectionAttemptStatus {
+    CONNECTING, SUCCESSFUL, REJECTED, FAILED, DISCONNECTED
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatConnectionEvent.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatConnectionEvent.groovy
@@ -0,0 +1,14 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class ChatConnectionEvent extends Event {
+    ChatConnectionAttemptStatus status
+    Persona persona
+    ChatLink connection
+    
+    public String toString() {
+        super.toString() + " " + persona.getHumanReadableName() + " " + status.toString()
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatDisconnectionEvent.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatDisconnectionEvent.groovy
@@ -0,0 +1,8 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class ChatDisconnectionEvent extends Event {
+    Persona persona
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatLink.java
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatLink.java
@@ -0,0 +1,14 @@
+package com.muwire.core.chat;
+
+import java.io.Closeable;
+
+import com.muwire.core.Persona;
+
+public interface ChatLink extends Closeable {
+    public Persona getPersona();
+    public boolean isUp();
+    public void sendChat(ChatMessageEvent e);
+    public void sendLeave(Persona p);
+    public void sendPing();
+    public Object nextEvent() throws InterruptedException;
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatManager.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatManager.groovy
@@ -0,0 +1,73 @@
+package com.muwire.core.chat
+
+import java.util.concurrent.ConcurrentHashMap
+
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.trust.TrustService
+
+class ChatManager {
+    private final EventBus eventBus
+    private final Persona me
+    private final I2PConnector connector
+    private final TrustService trustService
+    private final MuWireSettings settings
+    
+    private final Map<Persona, ChatClient> clients = new ConcurrentHashMap<>()
+    
+    ChatManager(EventBus eventBus, Persona me, I2PConnector connector, TrustService trustService, 
+        MuWireSettings settings) {
+        this.eventBus = eventBus
+        this.me = me
+        this.connector = connector
+        this.trustService = trustService
+        this.settings = settings
+        
+        Timer timer = new Timer("chat-connector", true)
+        timer.schedule({connect()} as TimerTask, 1000, 1000)
+    }
+    
+    void onUIConnectChatEvent(UIConnectChatEvent e) {
+        if (e.host == me) { 
+            eventBus.publish(new ChatConnectionEvent(status : ChatConnectionAttemptStatus.SUCCESSFUL, 
+                persona : me, connection : LocalChatLink.INSTANCE))
+        } else {
+            ChatClient client = new ChatClient(connector, eventBus, e.host, me, trustService, settings)
+            clients.put(e.host, client)
+        }
+    }
+    
+    void onUIDisconnectChatEvent(UIDisconnectChatEvent e) {
+        if (e.host == me)
+            return
+        ChatClient client = clients.remove(e.host)
+        client?.close()
+    }
+    
+    void onChatMessageEvent(ChatMessageEvent e) {
+        if (e.host == me) 
+            return
+        if (e.sender != me)
+            return
+        clients[e.host]?.sendChat(e)
+    }
+    
+    void onChatDisconnectionEvent(ChatDisconnectionEvent e) {
+        clients[e.persona]?.disconnected()
+    }
+    
+    private void connect() {
+        clients.each { k, v -> 
+            v.connectIfNeeded()
+            v.ping() 
+        }
+    }
+    
+    void shutdown() {
+        clients.each { k, v ->
+            v.close() 
+        }
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatMessageEvent.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatMessageEvent.groovy
@@ -0,0 +1,13 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class ChatMessageEvent extends Event {
+    UUID uuid
+    String payload
+    Persona sender, host
+    String room
+    long chatTime
+    byte [] sig
+}
--- a/core/src/main/groovy/com/muwire/core/chat/ChatServer.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/ChatServer.groovy
@@ -0,0 +1,330 @@
+package com.muwire.core.chat
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.logging.Level
+import java.util.stream.Collectors
+
+import com.muwire.core.Constants
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
+import com.muwire.core.connection.Endpoint
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+import com.muwire.core.trust.TrustService
+import com.muwire.core.util.DataUtil
+
+import groovy.util.logging.Log
+import net.i2p.data.Base64
+import net.i2p.data.Destination
+import net.i2p.data.SigningPrivateKey
+import net.i2p.util.ConcurrentHashSet
+
+@Log
+class ChatServer {
+    public static final String CONSOLE = "__CONSOLE__"
+    private static final String DEFAULT_WELCOME = "Welcome to my chat server!  Type /HELP for list of available commands"
+    
+    private final EventBus eventBus
+    private final MuWireSettings settings
+    private final TrustService trustService
+    private final Persona me
+    private final SigningPrivateKey spk
+    
+    private final Map<Destination, ChatLink> connections = new ConcurrentHashMap()
+    private final Map<String, Set<Persona>> rooms = new ConcurrentHashMap<>()
+    private final Map<Persona, Set<String>> memberships = new ConcurrentHashMap<>()
+    private final Map<String, Persona> shortNames = new ConcurrentHashMap<>()
+    
+    private final AtomicBoolean running = new AtomicBoolean()
+    
+    ChatServer(EventBus eventBus, MuWireSettings settings, TrustService trustService, Persona me, SigningPrivateKey spk) {
+        this.eventBus = eventBus
+        this.settings = settings
+        this.trustService = trustService
+        this.me = me
+        this.spk = spk
+        
+        Timer timer = new Timer("chat-server-pinger", true)
+        timer.schedule({sendPings()} as TimerTask, 1000, 1000)
+    }
+    
+    public void start() {
+        if (!running.compareAndSet(false, true))
+            return
+        connections.put(me.destination, LocalChatLink.INSTANCE)
+        joinRoom(me, CONSOLE)
+        shortNames.put(me.getHumanReadableName(), me)
+        echo(getWelcome(),me.destination)
+    }
+    
+    private String getWelcome() {
+        String welcome = DEFAULT_WELCOME
+        if (settings.chatWelcomeFile != null)
+            welcome = settings.chatWelcomeFile.text
+        "/SAY $welcome"
+    }
+    
+    private void sendPings() {
+        connections.each { k,v -> 
+            v.sendPing()
+        }
+    }
+    
+    public void handle(Endpoint endpoint) {
+        InputStream is = endpoint.getInputStream()
+        OutputStream os = endpoint.getOutputStream()
+        
+        Map<String, String> headers = DataUtil.readAllHeaders(is)
+        
+        if (!headers.containsKey("Version"))
+            throw new Exception("Version header missing")
+        
+        int version = Integer.parseInt(headers['Version'])
+        if (version != Constants.CHAT_VERSION)
+            throw new Exception("Unknown chat version $version")
+        
+        if (!headers.containsKey('Persona'))
+            throw new Exception("Persona header missing")
+        
+        Persona client = new Persona(new ByteArrayInputStream(Base64.decode(headers['Persona'])))
+        if (client.destination != endpoint.destination)
+            throw new Exception("Client destination mismatch")
+        
+        if (!running.get()) {
+            os.write("400 Chat Not Enabled\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.close()
+            endpoint.close()
+            return
+        }
+        
+        if (connections.containsKey(client.destination) || connections.size() == settings.maxChatConnections) {
+            os.write("429 Rejected\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.close()
+            endpoint.close()
+            return
+        }
+        
+        os.with { 
+            write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
+            write("Version:${Constants.CHAT_VERSION}\r\n".getBytes(StandardCharsets.US_ASCII))
+            write("\r\n".getBytes(StandardCharsets.US_ASCII))
+            flush()
+        }
+        
+        ChatConnection connection = new ChatConnection(eventBus, endpoint, client, true, trustService, settings)
+        connections.put(endpoint.destination, connection)
+        joinRoom(client, CONSOLE)
+        shortNames.put(client.getHumanReadableName(), client)
+        connection.start()
+        echo(getWelcome(),connection.endpoint.destination)
+    }
+    
+    void onChatDisconnectionEvent(ChatDisconnectionEvent e) {
+        ChatConnection con = connections.remove(e.persona.destination)
+        if (con == null)
+            return
+            
+        Set<String> rooms = memberships.get(e.persona)
+        if (rooms != null) {
+            rooms.each { 
+                leaveRoom(e.persona, it)
+            }
+        }
+        shortNames.remove(e.persona.getHumanReadableName())
+        connections.each { k, v ->
+            v.sendLeave(e.persona)
+        }
+    }
+    
+    void onTrustEvent(TrustEvent e) {
+        if (e.level == TrustLevel.TRUSTED)
+            return
+        if (settings.allowUntrusted && e.level == TrustLevel.NEUTRAL)
+            return
+        
+        ChatConnection connection = connections.get(e.persona.destination)
+        connection?.close()
+    }
+    
+    private void joinRoom(Persona p, String room) {
+        Set<Persona> existing = rooms.get(room)
+        if (existing == null) {
+            existing = new ConcurrentHashSet<>()
+            rooms.put(room, existing)
+        }
+        existing.add(p)
+        
+        Set<String> membership = memberships.get(p)
+        if (membership == null) {
+            membership = new ConcurrentHashSet<>()
+            memberships.put(p, membership)
+        }
+        membership.add(room)
+    }
+    
+    private void leaveRoom(Persona p, String room) {
+        Set<Persona> existing = rooms.get(room)
+        if (existing == null) {
+            log.warning(p.getHumanReadableName() + " leaving room they hadn't joined")
+            return
+        }
+        existing.remove(p)
+        if (existing.isEmpty())
+            rooms.remove(room)
+            
+        Set<String> membership = memberships.get(p)
+        if (membership == null) {
+            log.warning(p.getHumanReadableName() + " didn't have any memberships")
+            return
+        }
+        membership.remove(room)
+        if (membership.isEmpty())
+            memberships.remove(p)
+    }
+    
+    void onChatMessageEvent(ChatMessageEvent e) {
+        if (e.host != me)
+            return
+        
+        ChatCommand command
+        try {
+            command = new ChatCommand(e.payload)
+        } catch (Exception badCommand) {
+            log.log(Level.WARNING, "bad chat command",badCommand)
+            return
+        }
+
+        if ((command.action.console && e.room != CONSOLE) ||
+            (!command.action.console && e.room == CONSOLE) ||
+            !command.action.user)
+            return
+        
+        if (command.action.local && e.sender != me)
+            return
+            
+        switch(command.action) {
+            case ChatAction.JOIN : processJoin(command.payload, e); break
+            case ChatAction.LEAVE : processLeave(e); break
+            case ChatAction.SAY : processSay(e); break
+            case ChatAction.LIST : processList(e.sender.destination); break
+            case ChatAction.INFO : processInfo(e.sender.destination); break
+            case ChatAction.HELP : processHelp(e.sender.destination); break
+            case ChatAction.TRUST : processTrust(command.payload, TrustLevel.TRUSTED); break
+            case ChatAction.DISTRUST : processTrust(command.payload, TrustLevel.DISTRUSTED); break
+        }
+    }
+    
+    private void processJoin(String room, ChatMessageEvent e) {
+        joinRoom(e.sender, room)
+        rooms[room].each { 
+            if (it == e.sender)
+                return
+            connections[it.destination].sendChat(e)
+        }
+        String payload = rooms[room].stream().filter({it != e.sender}).map({it.toBase64()})
+            .collect(Collectors.joining(","))
+        if (payload.length() == 0) {
+            return
+        }
+        payload = "/JOINED $payload"
+        long now = System.currentTimeMillis()
+        UUID uuid = UUID.randomUUID()
+        byte [] sig = ChatConnection.sign(uuid, now, room, payload, me, me, spk)
+        ChatMessageEvent echo = new ChatMessageEvent(
+            uuid : uuid,
+            payload : payload,
+            sender : me,
+            host : me,
+            room : room,
+            chatTime : now,
+            sig : sig
+            )
+        connections[e.sender.destination].sendChat(echo)
+    }
+    
+    private void processLeave(ChatMessageEvent e) {
+        leaveRoom(e.sender, e.room)
+        rooms.getOrDefault(e.room, []).each { 
+            if (it == e.sender)
+                return
+            connections[it.destination].sendChat(e)
+        }
+    }
+    
+    private void processSay(ChatMessageEvent e) {
+        if (rooms.containsKey(e.room)) {
+            // not a private message
+            rooms[e.room].each { 
+                if (it == e.sender)
+                    return
+                connections[it.destination].sendChat(e)
+            }
+        } else {
+            Persona target = new Persona(new ByteArrayInputStream(Base64.decode(e.room)))
+            connections[target.destination]?.sendChat(e)
+        }
+    }
+    
+    private void processList(Destination d) {
+        String roomList = rooms.keySet().stream().filter({it != CONSOLE}).collect(Collectors.joining("\n"))
+        roomList = "/SAY \nRoom List:\n"+roomList
+        echo(roomList, d)
+    }
+    
+    private void processInfo(Destination d) {
+        String info = "/SAY \nThe address of this server is\n========\n${me.toBase64()}\n========\nCopy/paste the above and share it\n"
+        String connectedUsers = memberships.keySet().stream().map({it.getHumanReadableName()}).collect(Collectors.joining("\n"))
+        info = "${info}\nConnected Users:\n$connectedUsers\n======="
+        echo(info, d)
+    }
+    
+    private void processHelp(Destination d) {
+        String help = """/SAY 
+            Available commands: /JOIN /LEAVE /SAY /LIST /INFO /TRUST /DISTRUST /HELP
+            /JOIN <room name>  - joins a room, or creates one if it does not exist.  You must type this in the console
+            /LEAVE             - leaves a room.  You must type this in the room you want to leave
+            /SAY               - optional, says something in the room you're in
+            /LIST              - lists the existing rooms on this server.  You must type this in the console
+            /INFO              - shows information about this server.  You must type this in the console
+            /TRUST <user>      - marks user as trusted.  This is only available to the server owner
+            /DISTRUST <user>   - marks user as distrusted.  This is only available to the server owner
+            /HELP              - prints this help message
+            """
+        echo(help, d)
+    }
+    
+    private void echo(String payload, Destination d) {
+        log.info "echoing $payload"
+        UUID uuid = UUID.randomUUID()
+        long now = System.currentTimeMillis()
+        byte [] sig = ChatConnection.sign(uuid, now, CONSOLE, payload, me, me, spk)
+        ChatMessageEvent echo = new ChatMessageEvent(
+            uuid : uuid,
+            payload : payload,
+            sender : me,
+            host : me,
+            room : CONSOLE,
+            chatTime : now,
+            sig : sig
+            )
+        connections[d]?.sendChat(echo)
+    }
+    
+    private void processTrust(String shortName, TrustLevel level) {
+        Persona p = shortNames.get(shortName)
+        if (p == null)
+            return
+        eventBus.publish(new TrustEvent(persona : p, level : level))
+    }
+    
+    void stop() {
+        if (running.compareAndSet(true, false)) {
+            connections.each { k, v ->
+                v.close()
+            }
+        }
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/LocalChatLink.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/LocalChatLink.groovy
@@ -0,0 +1,49 @@
+package com.muwire.core.chat
+
+import java.util.concurrent.BlockingQueue
+import java.util.concurrent.LinkedBlockingQueue
+
+import com.muwire.core.Persona
+
+import groovy.util.logging.Log
+
+@Log
+class LocalChatLink implements ChatLink {
+    
+    public static final LocalChatLink INSTANCE = new LocalChatLink()
+    
+    private final BlockingQueue messages = new LinkedBlockingQueue()
+
+    private LocalChatLink() {}
+    
+    @Override
+    public void close() throws IOException {
+    }
+
+    @Override
+    public void sendChat(ChatMessageEvent e) {
+        messages.put(e)
+    }
+
+    @Override
+    public void sendLeave(Persona p) {
+        messages.put(p)
+    }
+
+    @Override
+    public void sendPing() {}
+    
+    @Override
+    public Object nextEvent() {
+        messages.take()
+    }
+
+    @Override
+    public boolean isUp() {
+        true
+    }
+    
+    public Persona getPersona() {
+        null
+    }
+}
--- a/core/src/main/groovy/com/muwire/core/chat/UIConnectChatEvent.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/UIConnectChatEvent.groovy
@@ -0,0 +1,8 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class UIConnectChatEvent extends Event {
+    Persona host
+}
--- a/core/src/main/groovy/com/muwire/core/chat/UIDisconnectChatEvent.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/UIDisconnectChatEvent.groovy
@@ -0,0 +1,8 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class UIDisconnectChatEvent extends Event {
+    Persona host
+}
--- a/core/src/main/groovy/com/muwire/core/chat/UserDisconnectedEvent.groovy
+++ b/core/src/main/groovy/com/muwire/core/chat/UserDisconnectedEvent.groovy
@@ -0,0 +1,9 @@
+package com.muwire.core.chat
+
+import com.muwire.core.Event
+import com.muwire.core.Persona
+
+class UserDisconnectedEvent extends Event {
+    Persona user
+    Persona host
+}
--- a/core/src/main/groovy/com/muwire/core/connection/ConnectionAcceptor.groovy
+++ b/core/src/main/groovy/com/muwire/core/connection/ConnectionAcceptor.groovy
@@ -15,6 +15,7 @@ import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
 import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
+import com.muwire.core.chat.ChatServer
 import com.muwire.core.filecert.Certificate
 import com.muwire.core.filecert.CertificateManager
 import com.muwire.core.files.FileManager
@@ -50,6 +51,7 @@ class ConnectionAcceptor {
    final FileManager fileManager
    final ConnectionEstablisher establisher
    final CertificateManager certificateManager
+    final ChatServer chatServer

    final ExecutorService acceptorThread
    final ExecutorService handshakerThreads
@@ -61,7 +63,8 @@ class ConnectionAcceptor {
    ConnectionAcceptor(EventBus eventBus, UltrapeerConnectionManager manager,
        MuWireSettings settings, I2PAcceptor acceptor, HostCache hostCache,
        TrustService trustService, SearchManager searchManager, UploadManager uploadManager,
-        FileManager fileManager, ConnectionEstablisher establisher, CertificateManager certificateManager) {
+        FileManager fileManager, ConnectionEstablisher establisher, CertificateManager certificateManager,
+        ChatServer chatServer) {
        this.eventBus = eventBus
        this.manager = manager
        this.settings = settings
@@ -73,6 +76,7 @@ class ConnectionAcceptor {
        this.uploadManager = uploadManager
        this.establisher = establisher
        this.certificateManager = certificateManager
+        this.chatServer = chatServer

        acceptorThread = Executors.newSingleThreadExecutor { r ->
            def rv = new Thread(r)
@@ -154,6 +158,9 @@ class ConnectionAcceptor {
                case (byte)'C':
                    processCERTIFICATES(e)
                    break
+                case (byte)'I':
+                    processIRC(e)
+                    break
                default:
                    throw new Exception("Invalid read $read")
            }
@@ -299,6 +306,10 @@ class ConnectionAcceptor {
                throw new IOException("No Sender header")
            if (!headers.containsKey("Count"))
                throw new IOException("No Count header")
+            
+            boolean chat = false
+            if (headers.containsKey('Chat'))
+                chat = Boolean.parseBoolean(headers['Chat'])
                
            byte [] personaBytes = Base64.decode(headers['Sender'])
            Persona sender = new Persona(new ByteArrayInputStream(personaBytes))
@@ -317,6 +328,7 @@ class ConnectionAcceptor {
                dis.readFully(payload)
                def json = slurper.parse(payload)
                results[i] = ResultsParser.parse(sender, resultsUUID, json)
+                results[i].chat = chat
            }
            eventBus.publish(new UIResultBatchEvent(uuid: resultsUUID, results: results))
        } catch (IOException bad) {
@@ -498,5 +510,14 @@ class ConnectionAcceptor {
            e.close()
        }
    }
+    
+    private void processIRC(Endpoint e) {
+        byte[] IRC = new byte[4]
+        DataInputStream dis = new DataInputStream(e.getInputStream())
+        dis.readFully(IRC)
+        if (IRC != "RC\r\n".getBytes(StandardCharsets.US_ASCII))
+            throw new Exception("Invalid IRC connection")
+        chatServer.handle(e)
+    }

 }
--- a/core/src/main/groovy/com/muwire/core/files/FileTree.groovy
+++ b/core/src/main/groovy/com/muwire/core/files/FileTree.groovy
@@ -7,7 +7,7 @@ class FileTree {
    private final TreeNode root = new TreeNode()
    private final Map<File, TreeNode> fileToNode = new ConcurrentHashMap<>()
    
-    void add(File file) {
+    synchronized void add(File file) {
        List<File> path = new ArrayList<>()
        path.add(file)
        while (file.getParentFile() != null) {
@@ -31,7 +31,7 @@ class FileTree {
        }
    }

-    boolean remove(File file) {
+    synchronized boolean remove(File file) {
        TreeNode node = fileToNode.remove(file)
        if (node == null) {
            return false
--- a/core/src/main/groovy/com/muwire/core/search/ResultsSender.groovy
+++ b/core/src/main/groovy/com/muwire/core/search/ResultsSender.groovy
@@ -1,6 +1,7 @@
 package com.muwire.core.search

 import com.muwire.core.SharedFile
+import com.muwire.core.chat.ChatServer
 import com.muwire.core.connection.Endpoint
 import com.muwire.core.connection.I2PConnector
 import com.muwire.core.filecert.CertificateManager
@@ -48,13 +49,16 @@ class ResultsSender {
    private final EventBus eventBus
    private final MuWireSettings settings
    private final CertificateManager certificateManager
+    private final ChatServer chatServer

-    ResultsSender(EventBus eventBus, I2PConnector connector, Persona me, MuWireSettings settings, CertificateManager certificateManager) {
+    ResultsSender(EventBus eventBus, I2PConnector connector, Persona me, MuWireSettings settings, 
+        CertificateManager certificateManager, ChatServer chatServer) {
        this.connector = connector;
        this.eventBus = eventBus
        this.me = me
        this.settings = settings
        this.certificateManager = certificateManager
+        this.chatServer = chatServer
    }

    void sendResults(UUID uuid, SharedFile[] results, Destination target, boolean oobInfohash, boolean compressedResults) {
@@ -80,9 +84,11 @@ class ResultsSender {
                    infohash : it.getInfoHash(),
                    pieceSize : pieceSize,
                    uuid : uuid,
+                    browse : settings.browseFiles,
                    sources : suggested,
                    comment : comment,
-                    certificates : certificates
+                    certificates : certificates,
+                    chat : chatServer.running.get() && settings.advertiseChat
                    )
                uiResultEvents << uiResultEvent
            }
@@ -130,6 +136,8 @@ class ResultsSender {
                        os.write("RESULTS $uuid\r\n".getBytes(StandardCharsets.US_ASCII))
                        os.write("Sender: ${me.toBase64()}\r\n".getBytes(StandardCharsets.US_ASCII))
                        os.write("Count: $results.length\r\n".getBytes(StandardCharsets.US_ASCII))
+                        boolean chat = chatServer.running.get() && settings.advertiseChat
+                        os.write("Chat: $chat\r\n".getBytes(StandardCharsets.US_ASCII))
                        os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
                        DataOutputStream dos = new DataOutputStream(new GZIPOutputStream(os))
                        results.each { 
--- a/core/src/main/groovy/com/muwire/core/search/UIResultEvent.groovy
+++ b/core/src/main/groovy/com/muwire/core/search/UIResultEvent.groovy
@@ -17,6 +17,7 @@ class UIResultEvent extends Event {
    String comment
    boolean browse
    int certificates
+    boolean chat

    @Override
    public String toString() {
--- a/core/src/main/java/com/muwire/core/Constants.java
+++ b/core/src/main/java/com/muwire/core/Constants.java
@@ -5,10 +5,13 @@ import net.i2p.crypto.SigType;
 public class Constants {
    public static final byte PERSONA_VERSION = (byte)1;
    public static final byte FILE_CERT_VERSION = (byte)2;
+    public static final int CHAT_VERSION = 1;
+    
    public static final SigType SIG_TYPE = SigType.EdDSA_SHA512_Ed25519;

    public static final int MAX_HEADER_SIZE = 0x1 << 14;
    public static final int MAX_HEADERS = 16;
+    public static final long MAX_HEADER_TIME = 60 * 1000;
    
    public static final int MAX_RESULTS = 0x1 << 16;
    
--- a/core/src/main/java/com/muwire/core/util/DataUtil.java
+++ b/core/src/main/java/com/muwire/core/util/DataUtil.java
@@ -91,9 +91,12 @@ public class DataUtil {
    }

    public static String readTillRN(InputStream is) throws IOException {
+        final long start = System.currentTimeMillis();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while(baos.size() < (Constants.MAX_HEADER_SIZE)) {
            int read = is.read();
+            if (System.currentTimeMillis() - start > Constants.MAX_HEADER_TIME)
+                throw new IOException("header taking too long");
            if (read == -1)
                throw new IOException();
            if (read == '\r') {
--- a/doc/architecture.md
+++ b/doc/architecture.md
@@ -0,0 +1,59 @@
+# MuWire architecture
+
+### Core-UI separation
+
+The MuWire application is split conceptually into a `core` component and two `ui` components - one graphical component which is build using Swing and one text-only component built using the "lanterna" library.
+
+The core is written in mixture of Java and Groovy and is designed to be easy to embed into any application or language running on a JVM.  To achieve this, all communicatioon between the core and the outside world happens over an event bus using event objects.
+
+### Event bus and events
+
+At the heart of the core is the event bus.  It allows the different components that comprise the core to be decoupled, and allows the external components like UIs to communicate in asynchronous fashion with the core.
+
+The Core object has a single instance of the `com.muwire.core.EventBus` class.  It is responsible for dispatching events to any registered listeners.  Events themselves extend the `com.muwire.core.Event` class and carry arbitrary information relevant to the event.  See below or an example how to build a custom event:
+
+1.  Define the event in a class that extends `com.muwire.core.Event`:
+```
+package mypackage
+import com.muwire.core.Event
+
+class MyEvent extends Event {
+    // add relevant fields here
+}
+```
+
+2. Define one or more classes that will be notified of your events:
+```
+package mypackage
+
+class MyEventListener {
+    // ... add other logic here
+
+    void onMyEvent(MyEvent e) {
+        // logic to handle your type of event
+    }
+}
+```
+
+3. Register your event listener with the event bus:
+```
+MyEventListener myListener = new MyEventListener()
+eventBus.register(MyEvent.class,myListener)
+```
+You can register more than one listener for the same type of event; they will be notified in the order you register them.
+
+4. Publish events to the event bus
+```
+MyEvent myEvent = new MyEvent()
+// ... set relevant fields of the event ...
+eventBus.publish(myEvent)
+```
+
+Threading: the event bus creates a dedicated thread and all events are dispatched on that thread, regardless which thread publishes them.
+
+### Sharing files
+The UI publishes an event of type `com.muwire.core.files.FileSharedEvent` which contains a `java.io.File` reference to the file the user has chosen to share.  A component in the core called `HasherService` listens for these events, and when it receives notification that a FileSharedEvent has been posted it pereforms some sanity checks, then offloads the actual hashing to a dedicated thread.
+
+Before the hashing begins, another event of type `com.muwire.core.files.FileHashingEvent` is published that contains the name of the file.  At the moment that event serves only to update the UI with the current file being hashed.
+
+When the hashing completes, a `com.muwire.core.files.FileHashedEvent` is published by the HasherService.  The UI listens to this event and updates its list of shared files.  Another core component called `FileManager` also listens for such events and updates the interenal search index from the file name.
--- a/doc/chat.md
+++ b/doc/chat.md
@@ -0,0 +1,98 @@
+# MuWire Chat System
+
+Since version 0.6.3 MuWire comes with a built in chat system.  It is very similar to the way IRC operates, and the user experience mimics that of IRC as well.
+
+### Design
+
+The chat system uses a client-server model.  Each MuWire node can run a chat server which accepts incoming connections; clients wishing to connect to a chat server establish an outgoing streaming connection to the destination where the chat server is running.  The local client also connects to server through a special "loopback" connection.
+
+Once connected, the client automatically joins a special room called "__CONSOLE__" which is the server console.  In that room users can issue certain commands, but cannot actually chat.  In order to chat, the client needs to `/join` a chat room first.  The chat room is kept as state in the server and any messages sent to that chat room are forwarded to all other users who have joined the same room.  When the last member of a room leaves, the room state is destroyed server-side.
+
+Private messages work by replacing the room of the message with the base64-encoded persona of the recipient of the message. 
+
+
+### Chat Commands
+
+Clients issue commands to the chat server in order to perform operations.  Some commands can only be issued in the __CONSOLE__ room, others only in a regular chat room.  The server will ignore commands which are not issued in the appropriate place.
+
+There are several chat commands that MuWire supports, more can be added later.  Commands consist of a prefix and payload.  The prefix always beings with forward slash `/`.  Below is the list of commands a MuWire chat server supports as of version 0.6.6:
+
+##### /HELP - this command can be issued only in the __CONSOLE__ room.  It results in the server echoing back a help message of the commands it supports.
+##### /SAY - this command can be issued only in a regular chat room or private chat.  It's payload is the content of what the user wishes to say.
+##### /INFO - this command can be issued only in the __CONSOLE__ room.  It results in the server printing a status message.  As of 0.6.6, this consists of the base64-encoded address of the server as well as a list of user who are currently connected.
+##### /LIST - this command can be issued only in the __CONSOLE__ room.  It results in the server echoing the list of rooms which currently have at least one member.
+##### /JOIN - this command can be issued only in the __CONSOLE_ room.  The payload of the command is the name of the room that the user wishes to join.  This results in server-side state being updated to add the user to the membership list of the room.
+##### /LEAVE - this command can be issued only in a regular room.  It has no payload, and the result is that the server removes the user issuing the command from the room.
+##### /TRUST - this command can be issued only in the __CONSOLE__ room and only over the loopback connection, i.e. it is reserved for the owner of the server.  It's payload is the human-readable representation of a user the owner wishes to mark as trusted.  It results in adding the specified user to the owner's trust list.
+##### /DISTRUST - similar to /TRUST, this command results in the opposite; the user specified in the payload being added to the distrusted list.  This also results in the user getting disconnected from the server, i.e. kick/ban-ned.
+
+There is a command called "/JOINED" which is issued from the server to the client upon the client joining a room.  The payload of the command is a comma-separated list of base64-encoded representations of the personas of the users already in that room.
+
+### Protocol
+
+The client wishing to connect to a server establishes an I2P connection and sends the letters "IRC\r\n" in ASCII encoding.  These are followed by one more headers, each header consisting of a name, followed by colon, followed by value, terminated with "\r\n".  After all headers have been sent, an additional "\r\n" is written to the socket.  
+
+As of version 0.6.6 the following headers are required:
+
+* "Version" - this header indicates the version of the chat protocol that will be used over this connection.  Currently fixed at 1.
+* "Persona" - this header contains the base64-encoded representation of the persona of the client.
+
+The server responds with a status code encoded as an aSCII string, terminated with "\r\n", which can be one of the following:
+
+* 200 - connection accepted
+* 400 - connection not allowed.  This can be issued if the server is down for example.
+* 429 - connection rejected.  This can be issued when the server is overloaded or the client is already connected to the server.  Clients are encouraged to not re-attempt connecting for a short period of time.
+
+After the code, the server responds with a "Version" header followed by a "\r\n" on an empty line.
+
+### Messages
+
+After the headers have been exchanged, the connection starts transmitting messages back and forth.  Messages are encoded in UTF-8 JSON format, and preceeded by two bytes which are the unsigned representation of the number of bytes of JSON.
+
+As of protocol version 1, the following messages are supported:
+
+##### "Keepalive Ping".  
+This message serves only to prevent the blocking read from I2P sockets from timing out and is sent on regular intervals by both the server and the client.  Example payload of such message is:
+```
+{
+    "type" : "Ping",
+    "version" : 1
+}
+```
+
+##### "Chat Command"  
+This message is sent by both server and client whenever an event occurs, such as user issuing a command, or another user in a room the user has joined issues a command.  The payload is the following:
+```
+{
+    "type" : "Chat",
+    "uuid" : "1234-asdf-...",  // unique random UUID of this message
+    "host" : "asdf123..",      // base64-encoded persona of the server owner, i.e. the server this message is destined to
+    "sender" : "asdf123...",   // base64-encoded persona of the sender of the message.  The server verifies it matches the destination of the I2P socket it was received from.
+    "chatTime" : 1235...,      // time since epoch in milliseconds when the message was sent.
+    "room" : "asdf..."         // UTF-8 string indicating the room this message is destined to
+    "payload" : "/SAY asdf..." // UTF-8 string of the chat command being issued by the user.
+    "sig" : "asdf1234..."      // base64-encoded signature.
+}
+```
+In order to prevent spoofing and replay attacks, each Chat Command message contains a signature.  The signature covers the following fields in this order:
+
+1. uuid - toString() representation of the UUID
+2. host - binary representation of the persona in the host field
+3. sender - binary representation of the persona in the sender field
+4. chatTime - big endian representation of the timestamp of the message (8 bytes)
+5. room - UTF-8 representation of the room field
+6. payload - UTF-8 representation of the payload field.
+
+The signature is created with the signing private key (SPK) of the sender.
+
+##### "Leave"
+This message is only sent from a server to a client, whenever another client disconnects from the server.  It's format is the following:
+```
+{
+    "type" : "Leave,
+    "persona" : "asdf1234..." // base64-encoded persona of the user being disconnected from the server.
+}
+```
+
+### Future Work
+It is possible to extend this protocol to support inter-server relaying of messages.  Because every Chat Command message is signed, it will not be possible for malicious server operators to spoof its contents.
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,5 +1,5 @@
 group         = com.muwire
-version       = 0.6.2
+version       = 0.6.7
 i2pVersion    = 0.9.43
 groovyVersion = 2.4.15
 slf4jVersion  = 1.7.25
--- a/gui/build.gradle
+++ b/gui/build.gradle
@@ -9,7 +9,7 @@ buildscript {
        classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.8.2'
        classpath 'nl.javadude.gradle.plugins:license-gradle-plugin:0.11.0'
        classpath 'org.gradle.api.plugins:gradle-izpack-plugin:0.2.3'
-        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
+        classpath 'com.github.jengelman.gradle.plugins:shadow:5.2.0'
        classpath 'com.github.cr0:gradle-macappbundle-plugin:3.1.0'
        classpath 'org.kordamp.gradle:stats-gradle-plugin:0.2.2'
        classpath 'com.github.ben-manes:gradle-versions-plugin:0.17.0'
--- a/gui/griffon-app/conf/Config.groovy
+++ b/gui/griffon-app/conf/Config.groovy
@@ -111,4 +111,19 @@ mvcGroups {
        view = "com.muwire.gui.DownloadPreviewView"
        controller = "com.muwire.gui.DownloadPreviewController"
    }
+    'chat-server' {
+        model = 'com.muwire.gui.ChatServerModel'
+        view = 'com.muwire.gui.ChatServerView'
+        controller = 'com.muwire.gui.ChatServerController'
+    }
+    'chat-room' {
+        model = 'com.muwire.gui.ChatRoomModel'
+        view = 'com.muwire.gui.ChatRoomView'
+        controller = 'com.muwire.gui.ChatRoomController'
+    }
+    'chat-monitor' {
+        model = 'com.muwire.gui.ChatMonitorModel'
+        view = 'com.muwire.gui.ChatMonitorView'
+        controller = 'com.muwire.gui.ChatMonitorController'
+    }
 }
--- a/gui/griffon-app/controllers/com/muwire/gui/BrowseController.groovy
+++ b/gui/griffon-app/controllers/com/muwire/gui/BrowseController.groovy
@@ -64,8 +64,11 @@ class BrowseController {
        def selectedResults = view.selectedResults()
        if (selectedResults == null || selectedResults.isEmpty())
            return
+            
+        def group = application.mvcGroupManager.getGroups()['MainFrame']
+
        selectedResults.removeAll {
-            !mvcGroup.parentGroup.parentGroup.model.canDownload(it.infohash)
+            !group.model.canDownload(it.infohash)
        }
        
        selectedResults.each { result ->
@@ -74,11 +77,11 @@ class BrowseController {
                result : [result],
                sources : [model.host.destination],
                target : file,
-                sequential : mvcGroup.parentGroup.view.sequentialDownloadCheckbox.model.isSelected()
+                sequential : view.sequentialDownloadCheckbox.model.isSelected()
                ))
        }
        
-        mvcGroup.parentGroup.parentGroup.view.showDownloadsWindow.call()
+        group.view.showDownloadsWindow.call()
        dismiss()
    }
    
--- a/gui/griffon-app/controllers/com/muwire/gui/ChatMonitorController.groovy
+++ b/gui/griffon-app/controllers/com/muwire/gui/ChatMonitorController.groovy
@@ -0,0 +1,13 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonController)
+class ChatMonitorController {
+    @MVCMember @Nonnull
+    ChatMonitorModel model
+}
--- a/gui/griffon-app/controllers/com/muwire/gui/ChatRoomController.groovy
+++ b/gui/griffon-app/controllers/com/muwire/gui/ChatRoomController.groovy
@@ -0,0 +1,282 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import groovy.util.logging.Log
+import net.i2p.crypto.DSAEngine
+import net.i2p.data.Base64
+import net.i2p.data.DataHelper
+import net.i2p.data.Signature
+
+import java.nio.charset.StandardCharsets
+import java.util.logging.Level
+
+import javax.annotation.Nonnull
+import javax.swing.JOptionPane
+
+import com.muwire.core.Persona
+import com.muwire.core.chat.ChatCommand
+import com.muwire.core.chat.ChatAction
+import com.muwire.core.chat.ChatConnection
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.ChatServer
+import com.muwire.core.trust.TrustEvent
+import com.muwire.core.trust.TrustLevel
+
+@Log
+@ArtifactProviderFor(GriffonController)
+class ChatRoomController {
+    @MVCMember @Nonnull
+    ChatRoomModel model
+    @MVCMember @Nonnull
+    ChatRoomView view
+
+    boolean leftRoom
+    
+    @ControllerAction
+    void say() {
+        String words = view.sayField.text
+        view.sayField.setText(null)
+        
+        ChatCommand command
+        try {
+            command = new ChatCommand(words)
+        } catch (Exception nope) {
+            command = new ChatCommand("/SAY $words")
+        }
+        
+        if (!command.action.user) {
+            JOptionPane.showMessageDialog(null, "$words is not a user command","Invalid Command", JOptionPane.ERROR_MESSAGE)
+            return
+        }
+        long now = System.currentTimeMillis()
+        
+        if (command.action == ChatAction.SAY && command.payload.length() > 0) {
+            String toShow = DataHelper.formatTime(now) + " <" + model.core.me.getHumanReadableName() + "> "+command.payload
+
+            view.roomTextArea.append(toShow)
+            view.roomTextArea.append('\n')
+            trimLines()
+        }
+        
+        if (command.action == ChatAction.JOIN) {
+            String newRoom = command.payload
+            String groupId = model.host.getHumanReadableName()+"-"+newRoom
+            if (!mvcGroup.parentGroup.childrenGroups.containsKey(groupId)) {
+                def params = [:]
+                params['core'] = model.core
+                params['tabName'] = model.host.getHumanReadableName() + "-chat-rooms"
+                params['room'] = newRoom
+                params['console'] = false
+                params['host'] = model.host
+                params['roomTabName'] = newRoom
+                params['chatNotificator'] = view.chatNotificator
+
+                mvcGroup.parentGroup.createMVCGroup("chat-room", groupId, params)
+            }
+        }
+        if (command.action == ChatAction.LEAVE && !model.console) {
+            leftRoom = true
+            view.closeTab.call()
+        }
+        
+        String room = model.console ? ChatServer.CONSOLE : model.room
+        
+        UUID uuid = UUID.randomUUID()
+        byte [] sig = ChatConnection.sign(uuid, now, room, command.source, model.core.me, model.host, model.core.spk)
+
+        def event = new ChatMessageEvent(uuid : uuid,
+        payload : command.source,
+        sender : model.core.me,
+        host : model.host,
+        room : room,
+        chatTime : now,
+        sig : sig)
+
+        model.core.eventBus.publish(event)
+    }
+    
+    @ControllerAction
+    void privateMessage() { 
+        Persona p = view.getSelectedPersona()
+        if (p == null)
+            return
+        String groupId = model.host.getHumanReadableName() + "-" + p.getHumanReadableName() +"-private-chat"
+        if (p != model.core.me && !mvcGroup.parentGroup.childrenGroups.containsKey(groupId)) {
+            def params = [:]
+            params['core'] = model.core
+            params['tabName'] = model.tabName
+            params['room'] = p.toBase64()
+            params['privateChat'] = true
+            params['host'] = model.host
+            params['roomTabName'] = p.getHumanReadableName()
+            params['chatNotificator'] = view.chatNotificator
+            
+            mvcGroup.parentGroup.createMVCGroup("chat-room", groupId, params)
+        }
+    }
+    
+    void markTrusted() {
+        Persona p = view.getSelectedPersona()
+        if (p == null)
+            return
+        String reason = JOptionPane.showInputDialog("Enter reason (optional)")
+        model.core.eventBus.publish(new TrustEvent(persona : p, level : TrustLevel.TRUSTED, reason : reason))
+        view.refreshMembersTable()    
+    }
+    
+    void markDistrusted() {
+        Persona p = view.getSelectedPersona()
+        if (p == null)
+            return
+        String reason = JOptionPane.showInputDialog("Enter reason (optional)")
+        model.core.eventBus.publish(new TrustEvent(persona : p, level : TrustLevel.DISTRUSTED, reason : reason))
+        view.refreshMembersTable()
+    }
+    
+    void markNeutral() {
+        Persona p = view.getSelectedPersona()
+        if (p == null)
+            return
+        model.core.eventBus.publish(new TrustEvent(persona : p, level : TrustLevel.NEUTRAL))
+        view.refreshMembersTable()
+    }
+    
+    void browse() {
+        Persona p = view.getSelectedPersona()
+        if (p == null)
+            return
+        String groupId = p.getHumanReadableName() + "-browse"
+        def params = [:]
+        params['host'] = p
+        params['core'] = model.core
+        mvcGroup.createMVCGroup("browse",groupId,params)
+    }
+    
+    void leaveRoom() {
+        if (leftRoom || model.privateChat)
+            return
+        leftRoom = true
+        long now = System.currentTimeMillis()
+        UUID uuid = UUID.randomUUID()
+        byte [] sig = ChatConnection.sign(uuid, now, model.room, "/LEAVE", model.core.me, model.host, model.core.spk)
+        def event = new ChatMessageEvent(uuid : uuid,
+            payload : "/LEAVE",
+            sender : model.core.me,
+            host : model.host,
+            room : model.room,
+            chatTime : now,
+            sig : sig)
+        model.core.eventBus.publish(event)
+    }
+    
+    void handleChatMessage(ChatMessageEvent e) {
+        ChatCommand command
+        try {
+            command = new ChatCommand(e.payload)
+        } catch (Exception bad) {
+            log.log(Level.WARNING,"bad chat command",bad)
+            return
+        }
+        log.info("$model.room processing $command.action")
+        switch(command.action) {
+            case ChatAction.SAY : processSay(e, command.payload);break
+            case ChatAction.JOIN : processJoin(e.timestamp, e.sender); break
+            case ChatAction.JOINED : processJoined(command.payload); break
+            case ChatAction.LEAVE : processLeave(e.timestamp, e.sender); break
+        }
+    }
+    
+    private void processSay(ChatMessageEvent e, String text) {
+        String toDisplay = DataHelper.formatTime(e.timestamp) + " <"+e.sender.getHumanReadableName()+"> " + text + "\n"
+        runInsideUIAsync {
+            view.roomTextArea.append(toDisplay)
+            trimLines()
+            if (!model.console)
+                view.chatNotificator.onMessage(mvcGroup.mvcId)
+        }
+    }
+    
+    private void processJoin(long timestamp, Persona p) {
+        String toDisplay = DataHelper.formatTime(timestamp) + " " + p.getHumanReadableName() + " joined the room\n"
+        runInsideUIAsync {
+            model.members.add(p)
+            view.roomTextArea.append(toDisplay)
+            trimLines()
+            view.membersTable?.model?.fireTableDataChanged()
+        }
+    }
+    
+    private void processJoined(String list) {
+        runInsideUIAsync {
+            list.split(",").each { 
+                Persona p = new Persona(new ByteArrayInputStream(Base64.decode(it)))
+                model.members.add(p)
+            }
+            view.membersTable?.model?.fireTableDataChanged()
+        }
+    }
+    
+    private void processLeave(long timestamp, Persona p) {
+        String toDisplay = DataHelper.formatTime(timestamp) + " " + p.getHumanReadableName() + " left the room\n"
+        runInsideUIAsync {
+            model.members.remove(p)
+            view.roomTextArea.append(toDisplay)
+            trimLines()
+            view.membersTable?.model?.fireTableDataChanged()
+        }
+    }
+    
+    void handleLeave(Persona p) {
+        String toDisplay = DataHelper.formatTime(System.currentTimeMillis()) + " " + p.getHumanReadableName() + " disconnected\n"
+        runInsideUIAsync {
+            if (model.members.remove(p)) {
+                view.roomTextArea.append(toDisplay)
+                trimLines()
+                view.membersTable?.model?.fireTableDataChanged()
+            }
+        }
+    }
+    
+    private void trimLines() {
+        if (model.settings.maxChatLines < 0)
+            return
+        while(view.roomTextArea.getLineCount() > model.settings.maxChatLines) {
+            int line0Start = view.roomTextArea.getLineStartOffset(0)
+            int line0End = view.roomTextArea.getLineEndOffset(0)
+            view.roomTextArea.replaceRange(null, line0Start, line0End)
+        }
+    }
+    
+    void rejoinRoom() {
+        if (model.console || model.privateChat)
+            return
+        
+        model.members.clear()
+        model.members.add(model.core.me)
+        
+        UUID uuid = UUID.randomUUID()
+        long now = System.currentTimeMillis()
+        String join = "/JOIN $model.room"
+        byte [] sig = ChatConnection.sign(uuid, now, ChatServer.CONSOLE, join, model.core.me, model.host, model.core.spk)
+        def event = new ChatMessageEvent(
+            uuid : uuid,
+            payload : join,
+            sender : model.core.me,
+            host : model.host,
+            room : ChatServer.CONSOLE,
+            chatTime : now,
+            sig : sig
+        )
+        model.core.eventBus.publish(event)
+    }
+    
+    void serverDisconnected() {
+        runInsideUIAsync {
+            model.members.clear()
+            view.membersTable?.model?.fireTableDataChanged()
+        }
+    }
+}
--- a/gui/griffon-app/controllers/com/muwire/gui/ChatServerController.groovy
+++ b/gui/griffon-app/controllers/com/muwire/gui/ChatServerController.groovy
@@ -0,0 +1,31 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+import com.muwire.core.chat.UIDisconnectChatEvent
+
+@ArtifactProviderFor(GriffonController)
+class ChatServerController {
+    @MVCMember @Nonnull
+    ChatServerModel model
+
+    @ControllerAction
+    void disconnect() {
+        switch(model.buttonText) {
+            case "Disconnect" :
+                model.buttonText = "Connect"
+                mvcGroup.getChildrenGroups().each { k,v ->
+                    v.controller.serverDisconnected()
+                }
+                model.core.eventBus.publish(new UIDisconnectChatEvent(host : model.host))
+                break
+            case "Connect" :
+                 model.connect()
+                 break
+        }
+    }
+}
--- a/gui/griffon-app/controllers/com/muwire/gui/MainFrameController.groovy
+++ b/gui/griffon-app/controllers/com/muwire/gui/MainFrameController.groovy
@@ -234,8 +234,11 @@ class MainFrameController {
        int row = view.getSelectedTrustTablesRow(tableName)
        if (row < 0)
            return
+        String reason = null
+        if (level != TrustLevel.NEUTRAL)
+            reason = JOptionPane.showInputDialog("Enter reason (optional)")
        builder.getVariable(tableName).model.fireTableDataChanged()
-        core.eventBus.publish(new TrustEvent(persona : list[row].persona, level : level))
+        core.eventBus.publish(new TrustEvent(persona : list[row].persona, level : level, reason : reason))
    }

    @ControllerAction
@@ -322,6 +325,31 @@ class MainFrameController {
            return null
        model.subscriptions[row]
    }
+    
+    @ControllerAction
+    void browseFromTrusted() {
+        int row = view.getSelectedTrustTablesRow("trusted-table")
+        if (row < 0)
+            return
+        Persona p = model.trusted[row].persona
+        
+        String groupId = p.getHumanReadableName() + "-browse"
+        def params = [:]
+        params['host'] = p
+        params['core'] = model.core
+        mvcGroup.createMVCGroup("browse",groupId,params)
+    }
+    
+    @ControllerAction
+    void chatFromTrusted() {
+        int row = view.getSelectedTrustTablesRow("trusted-table")
+        if (row < 0)
+            return
+        Persona p = model.trusted[row].persona
+        
+        startChat(p)
+        view.showChatWindow.call()
+    }

    void unshareSelectedFile() {
        def sf = view.selectedSharedFiles()
@@ -420,6 +448,53 @@ class MainFrameController {
            Desktop.getDesktop().open(selected[0].file.getParentFile())
        } catch (Exception ignored) {}
    }
+    
+    @ControllerAction
+    void startChatServer() {
+        model.core.chatServer.start()
+        model.chatServerRunning = true
+        
+        if (!mvcGroup.getChildrenGroups().containsKey("local-chat-server")) {
+            def params = [:]
+            params['core'] = model.core
+            params['host'] = model.core.me
+            params['chatNotificator'] = view.chatNotificator
+            mvcGroup.createMVCGroup("chat-server","local-chat-server", params)
+        }
+    }
+    
+    @ControllerAction
+    void stopChatServer() {
+        model.core.chatServer.stop()
+        model.chatServerRunning = false
+    }
+
+    @ControllerAction
+    void connectChatServer() {
+        String address = JOptionPane.showInputDialog("Copy/paste the address of the server here")
+        if (address == null)
+            return
+        Persona p
+        try {
+            p = new Persona(new ByteArrayInputStream(Base64.decode(address)))
+        } catch (Exception bad) {
+            JOptionPane.showMessageDialog(null, "Invalid server address", "Invalid server address", JOptionPane.ERROR_MESSAGE)
+            return
+        }
+     
+        startChat(p)   
+    }
+    
+    void startChat(Persona p) {
+        if (!mvcGroup.getChildrenGroups().containsKey(p.getHumanReadableName())) {
+            def params = [:]
+            params['core'] = model.core
+            params['host'] = p
+            params['chatNotificator'] = view.chatNotificator
+            mvcGroup.createMVCGroup("chat-server", p.getHumanReadableName(), params)
+        } else 
+            mvcGroup.getChildrenGroups().get(p.getHumanReadableName()).model.connect()
+    }

    void saveMuWireSettings() {
        core.saveMuSettings()
--- a/gui/griffon-app/controllers/com/muwire/gui/OptionsController.groovy
+++ b/gui/griffon-app/controllers/com/muwire/gui/OptionsController.groovy
@@ -139,6 +139,25 @@ class OptionsController {
        String trustListInterval = view.trustListIntervalField.text
        model.trustListInterval = trustListInterval
        settings.trustListInterval = Integer.parseInt(trustListInterval)
+        
+        boolean startChatServer = view.startChatServerCheckbox.model.isSelected()
+        model.startChatServer = startChatServer
+        settings.startChatServer = startChatServer
+        
+        String maxChatConnections = view.maxChatConnectionsField.text
+        model.maxChatConnections = Integer.parseInt(maxChatConnections)
+        settings.maxChatConnections = Integer.parseInt(maxChatConnections)
+        
+        boolean advertiseChat = view.advertiseChatCheckbox.model.isSelected()
+        model.advertiseChat = advertiseChat
+        settings.advertiseChat = advertiseChat
+        
+        int maxChatLines = Integer.parseInt(view.maxChatLinesField.text)
+        model.maxChatLines = maxChatLines
+        uiSettings.maxChatLines = maxChatLines
+        
+        if (model.chatWelcomeFile != null)
+            settings.chatWelcomeFile = new File(model.chatWelcomeFile)

        core.saveMuSettings()

@@ -221,6 +240,19 @@ class OptionsController {
            model.incompleteLocation = chooser.getSelectedFile().getAbsolutePath()
    }
    
+    @ControllerAction
+    void chooseChatFile() {
+        def chooser = new JFileChooser()
+        chooser.with { 
+            setFileHidingEnabled(false)
+            setDialogTitle("Select location of chat server welcome file")
+            setFileSelectionMode(JFileChooser.FILES_ONLY)
+            int rv = chooser.showOpenDialog(null)
+            if (rv == JFileChooser.APPROVE_OPTION)
+                model.chatWelcomeFile = getSelectedFile().getAbsolutePath()
+        }
+    }
+    
    @ControllerAction
    void automaticFont() {
        model.automaticFontSize = true
--- a/gui/griffon-app/controllers/com/muwire/gui/SearchTabController.groovy
+++ b/gui/griffon-app/controllers/com/muwire/gui/SearchTabController.groovy
@@ -99,13 +99,24 @@ class SearchTabController {
        if (sender == null)
            return

-        String groupId = sender.getHumanReadableName()
+        String groupId = sender.getHumanReadableName() + "-browse"
        Map<String,Object> params = new HashMap<>()
        params['host'] = sender
        params['core'] = core

        mvcGroup.createMVCGroup("browse", groupId, params)
    }
+    
+    @ControllerAction
+    void chat() {
+        def sender = view.selectedSender()
+        if (sender == null)
+            return
+        
+        def parent = mvcGroup.parentGroup
+        parent.controller.startChat(sender)
+        parent.view.showChatWindow.call()
+    }

    @ControllerAction
    void showComment() {
--- a/gui/griffon-app/models/com/muwire/gui/ChatMonitorModel.groovy
+++ b/gui/griffon-app/models/com/muwire/gui/ChatMonitorModel.groovy
@@ -0,0 +1,46 @@
+package com.muwire.gui
+
+import javax.annotation.Nonnull
+
+import griffon.core.artifact.GriffonModel
+import griffon.inject.MVCMember
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class ChatMonitorModel implements ChatNotificator.Listener {
+    @MVCMember @Nonnull
+    ChatMonitorView view
+    
+    ChatNotificator chatNotificator
+    def rooms = []
+    
+    void mvcGroupInit(Map<String,String> args) {
+        chatNotificator.listener = this
+    }
+    
+    void mvcGroupDestroy() {
+        chatNotificator.listener = null
+    }
+    
+    public void update() {
+        rooms.clear()
+        chatNotificator.roomsWithMessages.each { room, count ->
+            int dash = room.indexOf('-')
+            String server = room.substring(0, dash)
+            String roomName = room.substring(dash + 1)
+            rooms.add(new ChatRoomEntry(server, roomName, count))
+        }
+        view.updateView()
+    }
+    
+    private static class ChatRoomEntry {
+        private final String server, room
+        private final int count
+        ChatRoomEntry(String server, String room, int count) {
+            this.server = server
+            this.room = room
+            this.count = count
+        }
+    }
+}
--- a/gui/griffon-app/models/com/muwire/gui/ChatRoomModel.groovy
+++ b/gui/griffon-app/models/com/muwire/gui/ChatRoomModel.groovy
@@ -0,0 +1,28 @@
+package com.muwire.gui
+
+import com.muwire.core.Core
+import com.muwire.core.Persona
+
+import griffon.core.artifact.GriffonModel
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class ChatRoomModel {
+    Core core
+    Persona host
+    String tabName
+    String room
+    boolean console
+    boolean privateChat
+    String roomTabName
+    
+    def members = []
+    
+    UISettings settings
+    
+    void mvcGroupInit(Map<String,String> args) {
+        members.add(core.me)
+        settings = application.context.get("ui-settings")
+    }
+}
--- a/gui/griffon-app/models/com/muwire/gui/ChatServerModel.groovy
+++ b/gui/griffon-app/models/com/muwire/gui/ChatServerModel.groovy
@@ -0,0 +1,157 @@
+package com.muwire.gui
+
+import java.util.logging.Level
+
+import javax.annotation.Nonnull
+
+import com.muwire.core.Core
+import com.muwire.core.Persona
+import com.muwire.core.chat.ChatCommand
+import com.muwire.core.chat.ChatAction
+import com.muwire.core.chat.ChatConnectionAttemptStatus
+import com.muwire.core.chat.ChatConnectionEvent
+import com.muwire.core.chat.ChatLink
+import com.muwire.core.chat.ChatMessageEvent
+import com.muwire.core.chat.UIConnectChatEvent
+
+import griffon.core.artifact.GriffonModel
+import griffon.inject.MVCMember
+import griffon.transform.Observable
+import groovy.util.logging.Log
+import griffon.metadata.ArtifactProviderFor
+
+@Log
+@ArtifactProviderFor(GriffonModel)
+class ChatServerModel {
+    @MVCMember @Nonnull
+    ChatServerView view
+    
+    Persona host
+    Core core
+    
+    @Observable boolean disconnectActionEnabled
+    @Observable String buttonText = "Disconnect"
+    @Observable ChatConnectionAttemptStatus status
+    @Observable boolean sayActionEnabled
+
+    volatile ChatLink link    
+    volatile Thread poller
+    volatile boolean running
+    
+    void mvcGroupInit(Map<String, String> params) {
+        disconnectActionEnabled = host != core.me // can't disconnect from myself
+        core.eventBus.register(ChatConnectionEvent.class, this)
+
+        connect()        
+    }
+    
+    void connect() {
+        runInsideUIAsync {
+            buttonText = "Disconnect"
+        }
+        core.eventBus.publish(new UIConnectChatEvent(host : host))
+    }
+    
+    void mvcGroupDestroy() {
+        stopPoller()
+        core.eventBus.unregister(ChatConnectionEvent.class, this)
+    }
+    
+    private void startPoller() {
+        if (running)
+            return
+        running = true
+        poller = new Thread({eventLoop()} as Runnable)
+        poller.setDaemon(true)
+        poller.start()
+    }
+    
+    private void stopPoller() {
+        running = false
+        poller?.interrupt()
+        link = null
+    }
+    
+    void onChatConnectionEvent(ChatConnectionEvent e) {
+        if (e.persona != host)
+            return
+            
+        runInsideUIAsync {
+            status = e.status
+            sayActionEnabled = status == ChatConnectionAttemptStatus.SUCCESSFUL
+        }
+
+        if (e.status == ChatConnectionAttemptStatus.SUCCESSFUL) {
+            ChatLink link = e.connection
+            if (link == null)
+                return
+            this.link = e.connection
+            
+            startPoller()
+
+            mvcGroup.childrenGroups.each {k,v ->
+                v.controller.rejoinRoom()
+            }
+        } else {
+            stopPoller()
+        }
+    }
+    
+    private void eventLoop() {
+        Thread.sleep(1000)
+        while(running) {
+            ChatLink link = this.link
+            if (link == null || !link.isUp()) {
+                Thread.sleep(100)
+                continue
+            }
+                
+            Object event = link.nextEvent()
+            if (event instanceof ChatMessageEvent)
+                handleChatMessage(event)
+            else if (event instanceof Persona)
+                handleLeave(event)
+            else
+                throw new IllegalArgumentException("event type $event")
+        }
+    }
+    
+    private void handleChatMessage(ChatMessageEvent e) {
+        ChatCommand chatCommand
+        try {
+            chatCommand = new ChatCommand(e.payload)
+        } catch (Exception badCommand) {
+            log.log(Level.WARNING,"bad chat command",badCommand)
+            return
+        }
+        String room = e.room
+        if (chatCommand.action == ChatAction.JOIN) {
+            room = chatCommand.payload
+        }
+        if (chatCommand.action == ChatAction.SAY &&
+            room == core.me.toBase64()) {
+            String groupId = host.getHumanReadableName()+"-"+e.sender.getHumanReadableName() + "-private-chat"
+            if (!mvcGroup.childrenGroups.containsKey(groupId)) {
+                def params = [:]
+                params['core'] = core
+                params['tabName'] = host.getHumanReadableName() + "-chat-rooms"
+                params['room'] = e.sender.toBase64()
+                params['privateChat'] = true
+                params['host'] = host
+                params['roomTabName'] = e.sender.getHumanReadableName() 
+                params['chatNotificator'] = view.chatNotificator
+
+                mvcGroup.createMVCGroup("chat-room",groupId, params)
+            }
+            room = groupId
+        } else
+            room = host.getHumanReadableName()+"-"+room
+        mvcGroup.childrenGroups[room]?.controller?.handleChatMessage(e)
+    }
+    
+    private void handleLeave(Persona p) {
+        mvcGroup.childrenGroups.each { k, v ->
+            v.controller.handleLeave(p)
+        }
+    }
+}
--- a/gui/griffon-app/models/com/muwire/gui/MainFrameModel.groovy
+++ b/gui/griffon-app/models/com/muwire/gui/MainFrameModel.groovy
@@ -106,6 +106,8 @@ class MainFrameModel {
    @Observable boolean subscribeButtonEnabled
    @Observable boolean markNeutralFromTrustedButtonEnabled
    @Observable boolean markDistrustedButtonEnabled
+    @Observable boolean browseFromTrustedButtonEnabled
+    @Observable boolean chatFromTrustedButtonEnabled
    @Observable boolean markNeutralFromDistrustedButtonEnabled
    @Observable boolean markTrustedButtonEnabled
    @Observable boolean reviewButtonEnabled
@@ -117,6 +119,9 @@ class MainFrameModel {
    @Observable boolean uploadsPaneButtonEnabled
    @Observable boolean monitorPaneButtonEnabled
    @Observable boolean trustPaneButtonEnabled
+    @Observable boolean chatPaneButtonEnabled
+    
+    @Observable boolean chatServerRunning
    
    @Observable Downloader downloader

@@ -218,6 +223,8 @@ class MainFrameModel {
                core.eventBus.publish(new ContentControlEvent(term : it, regex: true, add: true))
            }
            
+            chatServerRunning = core.chatServer.running.get()
+            
            timer.schedule({
                if (core.shutdown.get())
                    return
@@ -252,6 +259,10 @@ class MainFrameModel {
                uploadsPaneButtonEnabled = true
                monitorPaneButtonEnabled = true
                trustPaneButtonEnabled = true
+                chatPaneButtonEnabled = true
+                
+                if (core.muOptions.startChatServer)
+                    controller.startChatServer()
            }
        })

--- a/gui/griffon-app/models/com/muwire/gui/OptionsModel.groovy
+++ b/gui/griffon-app/models/com/muwire/gui/OptionsModel.groovy
@@ -56,6 +56,12 @@ class OptionsModel {
    @Observable boolean trustLists
    @Observable String trustListInterval

+    // chat options
+    @Observable boolean startChatServer
+    @Observable int maxChatConnections
+    @Observable boolean advertiseChat
+    @Observable int maxChatLines
+    @Observable String chatWelcomeFile

    void mvcGroupInit(Map<String, String> args) {
        MuWireSettings settings = application.context.get("muwire-settings")
@@ -104,5 +110,11 @@ class OptionsModel {
        searchExtraHop = settings.searchExtraHop
        trustLists = settings.allowTrustLists
        trustListInterval = String.valueOf(settings.trustListInterval)
+        
+        startChatServer = settings.startChatServer
+        maxChatConnections = settings.maxChatConnections
+        advertiseChat = settings.advertiseChat
+        maxChatLines = uiSettings.maxChatLines
+        chatWelcomeFile = settings.chatWelcomeFile?.getAbsolutePath()
    }
 }
--- a/gui/griffon-app/models/com/muwire/gui/SearchTabModel.groovy
+++ b/gui/griffon-app/models/com/muwire/gui/SearchTabModel.groovy
@@ -24,6 +24,7 @@ class SearchTabModel {
    @Observable boolean browseActionEnabled
    @Observable boolean viewCommentActionEnabled
    @Observable boolean viewCertificatesActionEnabled
+    @Observable boolean chatActionEnabled
    @Observable boolean groupedByFile

    Core core
--- a/gui/griffon-app/views/com/muwire/gui/BrowseView.groovy
+++ b/gui/griffon-app/views/com/muwire/gui/BrowseView.groovy
@@ -39,6 +39,8 @@ class BrowseView {
    def p
    def resultsTable
    def lastSortEvent
+    def sequentialDownloadCheckbox
+    
    void initUI() {
        int rowHeight = application.context.get("row-height")
        mainFrame = application.windowManager.findWindow("main-frame")
@@ -67,6 +69,8 @@ class BrowseView {
                button(text : "View Comment", enabled : bind{model.viewCommentActionEnabled}, viewCommentAction)
                button(text : "View Certificates", enabled : bind{model.viewCertificatesActionEnabled}, viewCertificatesAction)
                button(text : "Dismiss", dismissAction)
+                label(text : "Download sequentially")
+                sequentialDownloadCheckbox = checkBox()
            }
        }
        
@@ -106,8 +110,9 @@ class BrowseView {
            else
                model.viewCommentActionEnabled = false
             
+            def mainFrameGroup = application.mvcGroupManager.getGroups()['MainFrame']
            rows.each {
-                downloadActionEnabled &= mvcGroup.parentGroup.parentGroup.model.canDownload(model.results[it].infohash)
+                downloadActionEnabled &= mainFrameGroup.model.canDownload(model.results[it].infohash)
            }
            model.downloadActionEnabled = downloadActionEnabled
            
--- a/gui/griffon-app/views/com/muwire/gui/ChatMonitorView.groovy
+++ b/gui/griffon-app/views/com/muwire/gui/ChatMonitorView.groovy
@@ -0,0 +1,67 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonView
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+
+import javax.swing.JDialog
+import javax.swing.SwingConstants
+
+import java.awt.BorderLayout
+import java.awt.event.WindowAdapter
+import java.awt.event.WindowEvent
+
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonView)
+class ChatMonitorView {
+    @MVCMember @Nonnull
+    FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    ChatMonitorModel model
+
+    def mainFrame
+    def dialog
+    def panel
+    def roomsTable
+    
+    void initUI() {
+        mainFrame = application.windowManager.findWindow("main-frame")
+        int rowHeight = application.context.getAsInt("row-height")
+        dialog = new JDialog(mainFrame, "Chat Monitor", false)
+        dialog.setResizable(true)
+        
+        panel = builder.panel {
+            borderLayout()
+            panel(constraints : BorderLayout.NORTH) {
+                label("Chat rooms with unread messages")
+            }
+            scrollPane(constraints : BorderLayout.CENTER) {
+                roomsTable = table(autoCreateRowSorter : true, rowHeight : rowHeight) {
+                    tableModel(list : model.rooms) {
+                        closureColumn(header : "Server", type: String, read : {it.server})
+                        closureColumn(header : "Room", type : String, read : {it.room})
+                        closureColumn(header : "Messages", type : Integer, read : {it.count})
+                    }
+                }
+            }
+        }
+    }
+    
+    void updateView() {
+        roomsTable.model.fireTableDataChanged()
+    }
+    
+    void mvcGroupInit(Map<String,String> args) {
+        dialog.getContentPane().add(panel)
+        dialog.pack()
+        dialog.setLocationRelativeTo(mainFrame)
+        dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE)
+        dialog.addWindowListener(new WindowAdapter() {
+            public void windowClosed(WindowEvent e) {
+                mvcGroup.destroy()
+            }
+        })
+        dialog.show()
+    }
+}
--- a/gui/griffon-app/views/com/muwire/gui/ChatRoomView.groovy
+++ b/gui/griffon-app/views/com/muwire/gui/ChatRoomView.groovy
@@ -0,0 +1,182 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonView
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+
+import javax.swing.JMenuItem
+import javax.swing.JPopupMenu
+import javax.swing.JSplitPane
+import javax.swing.ListSelectionModel
+import javax.swing.SwingConstants
+import javax.swing.SpringLayout.Constraints
+
+import com.muwire.core.Persona
+import com.muwire.core.chat.ChatConnectionAttemptStatus
+
+import java.awt.BorderLayout
+import java.awt.event.MouseAdapter
+import java.awt.event.MouseEvent
+
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonView)
+class ChatRoomView {
+    @MVCMember @Nonnull
+    FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    ChatRoomModel model
+    @MVCMember @Nonnull
+    ChatRoomController controller
+
+    ChatNotificator chatNotificator
+    
+    def pane
+    def parent
+    def sayField
+    def roomTextArea
+    def textScrollPane
+    def membersTable
+    def lastMembersTableSortEvent
+    
+    void initUI() {
+        int rowHeight = application.context.get("row-height")
+        def parentModel = mvcGroup.parentGroup.model
+        if (model.console || model.privateChat) {
+            pane = builder.panel {
+                borderLayout()
+                panel(constraints : BorderLayout.CENTER) {
+                    gridLayout(rows : 1, cols : 1)
+                    textScrollPane = scrollPane {
+                        roomTextArea = textArea(editable : false, lineWrap : true, wrapStyleWord : true)
+                    }
+                }
+                panel(constraints : BorderLayout.SOUTH) {
+                    borderLayout()
+                    label(text : "Say something here: ", constraints : BorderLayout.WEST)
+                    sayField = textField(enabled : bind {parentModel.sayActionEnabled}, actionPerformed : {controller.say()}, constraints : BorderLayout.CENTER)
+                    button(enabled : bind {parentModel.sayActionEnabled},text : "Say", constraints : BorderLayout.EAST, sayAction)
+                }
+            }
+        } else {
+            pane = builder.panel {
+                borderLayout()
+                panel(constraints : BorderLayout.CENTER) {
+                    gridLayout(rows : 1, cols : 1)
+                    splitPane(orientation : JSplitPane.HORIZONTAL_SPLIT, continuousLayout : true, dividerLocation : 300) {
+                        panel {
+                            gridLayout(rows : 1, cols : 1)
+                            scrollPane {
+                                membersTable = table(autoCreateRowSorter : true, rowHeight : rowHeight) {
+                                    tableModel(list : model.members) {
+                                        closureColumn(header : "Name", preferredWidth: 100, type: String, read : {it.getHumanReadableName()})
+                                        closureColumn(header : "Trust Status", preferredWidth: 30, type : String, read : {String.valueOf(model.core.trustService.getLevel(it.destination))})
+                                    }
+                                }
+                            }
+                        }
+                        panel {
+                            gridLayout(rows : 1, cols : 1)
+                            textScrollPane = scrollPane {
+                                roomTextArea = textArea(editable : false, lineWrap : true, wrapStyleWord : true)
+                            }
+                        }
+                    }
+                }
+                panel(constraints : BorderLayout.SOUTH) {
+                    borderLayout()
+                    label(text : "Say something here: ", constraints : BorderLayout.WEST)
+                    sayField = textField(enabled : bind {parentModel.sayActionEnabled}, actionPerformed : {controller.say()}, constraints : BorderLayout.CENTER)
+                    button(enabled : bind {parentModel.sayActionEnabled}, text : "Say", constraints : BorderLayout.EAST, sayAction)
+                }
+
+            }
+        }
+        
+        SmartScroller smartScroller = new SmartScroller(textScrollPane)
+        pane.putClientProperty("mvcId", mvcGroup.mvcId)
+    }
+    
+    void mvcGroupInit(Map<String,String> args) {
+        parent = mvcGroup.parentGroup.view.builder.getVariable(model.tabName)
+        parent.addTab(model.roomTabName, pane)
+        
+        int index = parent.indexOfComponent(pane)
+        parent.setSelectedIndex(index)
+        
+        def tabPanel = builder.panel {
+            borderLayout()
+            panel (constraints : BorderLayout.CENTER) {
+                label(text : model.roomTabName)
+            }
+            button(icon : imageIcon("/close_tab.png"), preferredSize: [20, 20], constraints : BorderLayout.EAST,
+                actionPerformed : closeTab )
+        }
+        if (!model.console)
+            parent.setTabComponentAt(index, tabPanel)
+            
+        if (membersTable != null) {
+            
+            membersTable.rowSorter.addRowSorterListener({evt -> lastMembersTableSortEvent = evt})
+            membersTable.rowSorter.setSortsOnUpdates(true)
+            membersTable.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
+            
+            membersTable.addMouseListener(new MouseAdapter() {
+                        public void mouseClicked(MouseEvent e) {
+                            if (e.button == MouseEvent.BUTTON1 && e.clickCount > 1) {
+                                controller.privateMessage()
+                            } else if (e.isPopupTrigger() || e.button == MouseEvent.BUTTON3)
+                                showPopupMenu(e)
+                        }
+                        
+                        public void mouseReleased(MouseEvent e) {
+                            if (e.isPopupTrigger() || e.button == MouseEvent.BUTTON3)
+                                showPopupMenu(e)
+                        }
+                    })
+        }
+    }
+    
+    private void showPopupMenu(MouseEvent e) {
+        JPopupMenu menu = new JPopupMenu()
+        JMenuItem privateChat = new JMenuItem("Start Private Chat")
+        privateChat.addActionListener({controller.privateMessage()})
+        menu.add(privateChat)
+        JMenuItem browse = new JMenuItem("Browse")
+        browse.addActionListener({controller.browse()})
+        menu.add(browse)
+        JMenuItem markTrusted = new JMenuItem("Mark Trusted")
+        markTrusted.addActionListener({controller.markTrusted()})
+        menu.add(markTrusted)
+        JMenuItem markNeutral = new JMenuItem("Mark Neutral")
+        markNeutral.addActionListener({controller.markNeutral()})
+        menu.add(markNeutral)
+        JMenuItem markDistrusted = new JMenuItem("Mark Distrusted")
+        markDistrusted.addActionListener({controller.markDistrusted()})
+        menu.add(markDistrusted)
+        menu.show(e.getComponent(), e.getX(), e.getY())
+    }
+    
+    Persona getSelectedPersona() {
+        int selectedRow = membersTable.getSelectedRow()
+        if (selectedRow < 0)
+            return null
+        if (lastMembersTableSortEvent != null)
+            selectedRow = membersTable.rowSorter.convertRowIndexToModel(selectedRow)
+        model.members[selectedRow]
+    }
+    
+    void refreshMembersTable() {
+        int selectedRow = membersTable.getSelectedRow()
+        membersTable.model.fireTableDataChanged()
+        membersTable.selectionModel.setSelectionInterval(selectedRow, selectedRow)
+    }
+    
+    def closeTab = {
+        int index = parent.indexOfComponent(pane)
+        parent.removeTabAt(index)
+        controller.leaveRoom()
+        chatNotificator.roomClosed(mvcGroup.mvcId)
+        mvcGroup.destroy()
+    }
+}
--- a/gui/griffon-app/views/com/muwire/gui/ChatServerView.groovy
+++ b/gui/griffon-app/views/com/muwire/gui/ChatServerView.groovy
@@ -0,0 +1,92 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonView
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.swing.SwingConstants
+
+import com.muwire.core.chat.ChatServer
+
+import java.awt.BorderLayout
+
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonView)
+class ChatServerView {
+    @MVCMember @Nonnull
+    FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    ChatServerModel model
+    @MVCMember @Nonnull
+    ChatServerController controller
+    
+    ChatNotificator chatNotificator
+
+    def pane
+    def parent
+    def childPane
+
+    void initUI() {
+        pane = builder.panel {
+            borderLayout()
+            childPane = tabbedPane(id : model.host.getHumanReadableName()+"-chat-rooms", constraints : BorderLayout.CENTER)
+            panel(constraints : BorderLayout.SOUTH) {
+                gridLayout(rows : 1, cols : 3)
+                panel {}
+                panel {
+                    button(text : bind {model.buttonText}, enabled : bind {model.disconnectActionEnabled}, disconnectAction)
+                }
+                panel {
+                    label(text : "Connection Status ")
+                    label(text : bind {model.status.toString()})
+                }
+            }
+        }
+        pane.putClientProperty("mvcId",mvcGroup.mvcId)
+        pane.putClientProperty("childPane", childPane)
+        childPane.addChangeListener({e -> chatNotificator.roomTabChanged(e.getSource())})
+    }
+
+    void mvcGroupInit(Map<String,String> args) {
+        parent = mvcGroup.parentGroup.view.builder.getVariable("chat-tabs")
+        parent.addTab(model.host.getHumanReadableName(), pane)
+
+        int index = parent.indexOfComponent(pane)
+        parent.setSelectedIndex(index)
+
+        def tabPanel
+        builder.with {
+            tabPanel = panel {
+                borderLayout()
+                panel (constraints : BorderLayout.CENTER) {
+                    String text = model.host == model.core.me ? "Local Server" : model.host.getHumanReadableName()
+                    label(text : text)
+                }
+                button(icon : imageIcon("/close_tab.png"), preferredSize: [20, 20], constraints : BorderLayout.EAST,
+                actionPerformed : closeTab )
+            }
+        }
+        parent.setTabComponentAt(index, tabPanel)
+        
+        def params = [:]
+        params['core'] = model.core
+        params['tabName'] = model.host.getHumanReadableName() + "-chat-rooms"
+        params['room'] = 'Console'
+        params['roomTabName'] = 'Console'
+        params['console'] = true
+        params['host'] = model.host
+        params['chatNotificator'] = chatNotificator
+        mvcGroup.createMVCGroup("chat-room",model.host.getHumanReadableName()+"-"+ChatServer.CONSOLE, params) 
+    }
+
+    def closeTab = {
+        if (model.host == model.core.me) {
+            mvcGroup.parentGroup.controller.stopChatServer()
+        }
+        else if (model.buttonText == "Disconnect")
+            controller.disconnect()
+        int index = parent.indexOfComponent(pane)
+        parent.removeTabAt(index)
+        mvcGroup.destroy()
+    }
+}
--- a/gui/griffon-app/views/com/muwire/gui/MainFrameView.groovy
+++ b/gui/griffon-app/views/com/muwire/gui/MainFrameView.groovy
@@ -78,8 +78,10 @@ class MainFrameView {
    

    UISettings settings
+    ChatNotificator chatNotificator
    
    void initUI() {
+        chatNotificator = new ChatNotificator(application.getMvcGroupManager())
        settings = application.context.get("ui-settings")
        int rowHeight = application.context.get("row-height")
        builder.with {
@@ -129,6 +131,13 @@ class MainFrameView {
                            env['core'] = model.core
                            mvcGroup.createMVCGroup("certificate-control",env)
                        })
+                        menuItem("Chat Room Monitor", actionPerformed : {
+                            if (!mvcGroup.getChildrenGroups().containsKey("chat-monitor")) {
+                                def env = [:]
+                                env['chatNotificator'] = chatNotificator
+                                mvcGroup.createMVCGroup("chat-monitor","chat-monitor",env)
+                            }
+                        })
                    }
                }
                borderLayout()
@@ -142,6 +151,7 @@ class MainFrameView {
                        if (settings.showMonitor)
                            button(text: "Monitor", enabled: bind{model.monitorPaneButtonEnabled},actionPerformed : showMonitorWindow)
                        button(text: "Trust", enabled:bind{model.trustPaneButtonEnabled},actionPerformed : showTrustWindow)
+                        button(text: "Chat", enabled : bind{model.chatPaneButtonEnabled}, actionPerformed : showChatWindow)
                    }
                    panel(id: "top-panel", constraints: BorderLayout.CENTER) {
                        cardLayout()
@@ -305,7 +315,7 @@ class MainFrameView {
                                    radioButton(text : "Table", selected : false, buttonGroup : sharedViewType, actionPerformed : showSharedFilesTable)
                                }
                                panel {
-                                    button(text : "Share files", actionPerformed : shareFiles)
+                                    button(text : "Share", actionPerformed : shareFiles)
                                    button(text : "Add Comment", enabled : bind {model.addCommentButtonEnabled}, addCommentAction)
                                    button(text : "Certify", enabled : bind {model.addCommentButtonEnabled}, issueCertificateAction)
                                }
@@ -433,6 +443,8 @@ class MainFrameView {
                                    button(text : "Subscribe", enabled : bind {model.subscribeButtonEnabled}, constraints : gbc(gridx: 0, gridy : 0), subscribeAction)
                                    button(text : "Mark Neutral", enabled : bind {model.markNeutralFromTrustedButtonEnabled}, constraints : gbc(gridx: 1, gridy: 0), markNeutralFromTrustedAction)
                                    button(text : "Mark Distrusted", enabled : bind {model.markDistrustedButtonEnabled}, constraints : gbc(gridx: 2, gridy:0), markDistrustedAction)
+                                    button(text : "Browse", enabled : bind{model.browseFromTrustedButtonEnabled}, constraints:gbc(gridx:3, gridy:0), browseFromTrustedAction)
+                                    button(text : "Chat", enabled : bind{model.chatFromTrustedButtonEnabled} ,constraints : gbc(gridx:4, gridy:0), chatFromTrustedAction)
                                }
                            }
                            panel (border : etchedBorder()){
@@ -475,6 +487,15 @@ class MainFrameView {
                            }
                        }
                    }
+                    panel(constraints : "chat window") {
+                        borderLayout()
+                        tabbedPane(id : "chat-tabs", constraints : BorderLayout.CENTER)
+                        panel(constraints : BorderLayout.SOUTH) {
+                            button(text : "Start Chat Server", enabled : bind {!model.chatServerRunning}, startChatServerAction)
+                            button(text : "Stop Chat Server", enabled : bind {model.chatServerRunning}, stopChatServerAction)
+                            button(text : "Connect To Remote Server", connectChatServerAction)
+                        }
+                    }
                }
                panel (border: etchedBorder(), constraints : BorderLayout.SOUTH) {
                    borderLayout()
@@ -499,7 +520,9 @@ class MainFrameView {
                    public boolean importData(TransferHandler.TransferSupport support) {
                        def files = support.getTransferable().getTransferData(DataFlavor.javaFileListFlavor)
                        files.each {
-                            model.core.eventBus.publish(new FileSharedEvent(file : it))
+                            File canonical = it.getCanonicalFile()
+                            model.core.fileManager.negativeTree.remove(canonical)
+                            model.core.eventBus.publish(new FileSharedEvent(file : canonical))
                        }
                        showUploadsWindow.call()
                        true
@@ -508,6 +531,7 @@ class MainFrameView {
        
        mainFrame.addWindowListener(new WindowAdapter(){
                    public void windowClosing(WindowEvent e) {
+                        chatNotificator.mainWindowDeactivated()
                        if (application.getContext().get("tray-icon")) {
                            if (settings.closeWarning) {
                                runInsideUIAsync {
@@ -521,6 +545,13 @@ class MainFrameView {
                        } else {
                            closeApplication()
                        }
+                    }
+                    public void windowDeactivated(WindowEvent e) {
+                        chatNotificator.mainWindowDeactivated()
+                    }
+                    public void windowActivated(WindowEvent e) {
+                        if (!model.chatPaneButtonEnabled)
+                            chatNotificator.mainWindowActivated()
                    }})

        // search field
@@ -761,10 +792,42 @@ class MainFrameView {
                model.subscribeButtonEnabled = false
                model.markDistrustedButtonEnabled = false
                model.markNeutralFromTrustedButtonEnabled = false
+                model.chatFromTrustedButtonEnabled = false
+                model.browseFromTrustedButtonEnabled = false
            } else {
                model.subscribeButtonEnabled = true
                model.markDistrustedButtonEnabled = true
                model.markNeutralFromTrustedButtonEnabled = true
+                model.chatFromTrustedButtonEnabled = true
+                model.browseFromTrustedButtonEnabled = true
+            }
+        })
+        
+        JPopupMenu trustMenu = new JPopupMenu()
+        JMenuItem subscribeItem = new JMenuItem("Subscribe")
+        subscribeItem.addActionListener({mvcGroup.controller.subscribe()})
+        trustMenu.add(subscribeItem)
+        JMenuItem markNeutralItem = new JMenuItem("Mark Neutral")
+        markNeutralItem.addActionListener({mvcGroup.controller.markNeutralFromTrusted()})
+        trustMenu.add(markNeutralItem)
+        JMenuItem markDistrustedItem = new JMenuItem("Mark Distrusted")
+        markDistrustedItem.addActionListener({mvcGroup.controller.markDistrusted()})
+        trustMenu.add(markDistrustedItem)
+        JMenuItem browseItem = new JMenuItem("Browse")
+        browseItem.addActionListener({mvcGroup.controller.browseFromTrusted()})
+        trustMenu.add(browseItem)
+        JMenuItem chatItem = new JMenuItem("Chat")
+        chatItem.addActionListener({mvcGroup.controller.chatFromTrusted()})
+        trustMenu.add(chatItem)
+        
+        trustedTable.addMouseListener(new MouseAdapter() {
+            public void mousePressed(MouseEvent e) {
+                if (e.isPopupTrigger() || e.button == MouseEvent.BUTTON3)
+                    showPopupMenu(trustMenu, e)
+            }
+            public void mouseReleased(MouseEvent e) {
+                if (e.isPopupTrigger() || e.button == MouseEvent.BUTTON3)
+                    showPopupMenu(trustMenu, e)
            }
        })

@@ -785,6 +848,10 @@ class MainFrameView {
            }
        })
        
+        // chat tabs
+        def chatTabbedPane = builder.getVariable("chat-tabs")
+        chatTabbedPane.addChangeListener({e -> chatNotificator.serverTabChanged(e.getSource())})
+        
        // show tree by default
        showSharedFilesTree.call()
        
@@ -986,6 +1053,8 @@ class MainFrameView {
        model.uploadsPaneButtonEnabled = true
        model.monitorPaneButtonEnabled = true
        model.trustPaneButtonEnabled = true
+        model.chatPaneButtonEnabled = true
+        chatNotificator.mainWindowDeactivated()
    }

    def showDownloadsWindow = {
@@ -996,6 +1065,8 @@ class MainFrameView {
        model.uploadsPaneButtonEnabled = true
        model.monitorPaneButtonEnabled = true
        model.trustPaneButtonEnabled = true
+        model.chatPaneButtonEnabled = true
+        chatNotificator.mainWindowDeactivated()
    }

    def showUploadsWindow = {
@@ -1006,6 +1077,8 @@ class MainFrameView {
        model.uploadsPaneButtonEnabled = false
        model.monitorPaneButtonEnabled = true
        model.trustPaneButtonEnabled = true
+        model.chatPaneButtonEnabled = true
+        chatNotificator.mainWindowDeactivated()
    }

    def showMonitorWindow = {
@@ -1016,6 +1089,8 @@ class MainFrameView {
        model.uploadsPaneButtonEnabled = true
        model.monitorPaneButtonEnabled = false
        model.trustPaneButtonEnabled = true
+        model.chatPaneButtonEnabled = true
+        chatNotificator.mainWindowDeactivated()
    }

    def showTrustWindow = {
@@ -1026,6 +1101,20 @@ class MainFrameView {
        model.uploadsPaneButtonEnabled = true
        model.monitorPaneButtonEnabled = true
        model.trustPaneButtonEnabled = false
+        model.chatPaneButtonEnabled = true
+        chatNotificator.mainWindowDeactivated()
+    }
+    
+    def showChatWindow = {
+        def cardsPanel = builder.getVariable("cards-panel")
+        cardsPanel.getLayout().show(cardsPanel, "chat window")
+        model.searchesPaneButtonEnabled = true
+        model.downloadsPaneButtonEnabled = true
+        model.uploadsPaneButtonEnabled = true
+        model.monitorPaneButtonEnabled = true
+        model.trustPaneButtonEnabled = true
+        model.chatPaneButtonEnabled = false
+        chatNotificator.mainWindowActivated()
    }
    
    def showSharedFilesTable = {
@@ -1043,13 +1132,14 @@ class MainFrameView {
    def shareFiles = {
        def chooser = new JFileChooser()
        chooser.setFileHidingEnabled(!model.core.muOptions.shareHiddenFiles)
-        chooser.setDialogTitle("Select file to share")
-        chooser.setFileSelectionMode(JFileChooser.FILES_ONLY)
+        chooser.setDialogTitle("Select files or directories to share")
+        chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES)
        chooser.setMultiSelectionEnabled(true)
        int rv = chooser.showOpenDialog(null)
        if (rv == JFileChooser.APPROVE_OPTION) {
            chooser.getSelectedFiles().each {
                File canonical = it.getCanonicalFile()
+                model.core.fileManager.negativeTree.remove(canonical)
                model.core.eventBus.publish(new FileSharedEvent(file : canonical))
            }
        }
--- a/gui/griffon-app/views/com/muwire/gui/OptionsView.groovy
+++ b/gui/griffon-app/views/com/muwire/gui/OptionsView.groovy
@@ -33,6 +33,7 @@ class OptionsView {
    def u
    def bandwidth
    def trust
+    def chat

    def retryField
    def updateField
@@ -71,6 +72,11 @@ class OptionsView {
    def allowTrustListsCheckbox
    def trustListIntervalField

+    def startChatServerCheckbox
+    def maxChatConnectionsField
+    def advertiseChatCheckbox
+    def maxChatLinesField
+    
    def buttonsPanel

    def mainFrame
@@ -267,6 +273,26 @@ class OptionsView {
            }
            panel(constraints : gbc(gridx: 0, gridy : 1, weighty: 100))
        }
+        
+        chat = builder.panel {
+            gridBagLayout()
+            panel (border : titledBorder(title : "Chat Settings", border : etchedBorder(), titlePosition : TitledBorder.TOP),
+                constraints : gbc(gridx : 0, gridy : 0, fill : GridBagConstraints.HORIZONTAL, weightx: 100)) {
+                gridBagLayout()
+                label(text : "Start chat server on startup", constraints : gbc(gridx: 0, gridy: 0, anchor: GridBagConstraints.LINE_START, weightx: 100))
+                startChatServerCheckbox = checkBox(selected : bind{model.startChatServer}, constraints : gbc(gridx:2, gridy:0, anchor:GridBagConstraints.LINE_END))
+                label(text : "Maximum chat connections (-1 means unlimited)", constraints : gbc(gridx: 0, gridy:1, anchor:GridBagConstraints.LINE_START, weightx:100))
+                maxChatConnectionsField = textField(text : bind {model.maxChatConnections}, constraints : gbc(gridx: 2, gridy : 1, anchor:GridBagConstraints.LINE_END))
+                label(text : "Advertise chat ability in search results", constraints : gbc(gridx: 0, gridy:2, anchor:GridBagConstraints.LINE_START, weightx:100))
+                advertiseChatCheckbox = checkBox(selected : bind{model.advertiseChat}, constraints : gbc(gridx:2, gridy:2, anchor:GridBagConstraints.LINE_END))
+                label(text : "Maximum lines of scrollback (-1 means unlimited)", constraints : gbc(gridx:0, gridy:3, anchor : GridBagConstraints.LINE_START, weightx: 100))
+                maxChatLinesField = textField(text : bind{model.maxChatLines}, constraints : gbc(gridx:2, gridy: 3, anchor: GridBagConstraints.LINE_END))
+                label(text : "Welcome message file", constraints : gbc(gridx : 0, gridy : 4, anchor : GridBagConstraints.LINE_START, weightx: 100))
+                label(text : bind {model.chatWelcomeFile}, constraints : gbc(gridx : 1, gridy : 4))
+                button(text : "Choose", constraints : gbc(gridx : 2, gridy : 4, anchor : GridBagConstraints.LINE_END), chooseChatFileAction)
+            }
+            panel(constraints : gbc(gridx: 0, gridy : 1, weighty: 100))
+        }


        buttonsPanel = builder.panel {
@@ -286,6 +312,7 @@ class OptionsView {
            tabbedPane.addTab("Bandwidth", bandwidth)
        }
        tabbedPane.addTab("Trust", trust)
+        tabbedPane.addTab("Chat", chat)

        JPanel panel = new JPanel()
        panel.setLayout(new BorderLayout())
--- a/gui/griffon-app/views/com/muwire/gui/SearchTabView.groovy
+++ b/gui/griffon-app/views/com/muwire/gui/SearchTabView.groovy
@@ -74,6 +74,7 @@ class SearchTabView {
                                            closureColumn(header : "Sender", preferredWidth : 500, type: String, read : {row -> row.getHumanReadableName()})
                                            closureColumn(header : "Results", preferredWidth : 20, type: Integer, read : {row -> model.sendersBucket[row].size()})
                                            closureColumn(header : "Browse", preferredWidth : 20, type: Boolean, read : {row -> model.sendersBucket[row].first().browse})
+                                            closureColumn(header : "Chat", preferredWidth : 20, type : Boolean, read : {row -> model.sendersBucket[row].first().chat})
                                            closureColumn(header : "Trust", preferredWidth : 50, type: String, read : { row ->
                                                model.core.trustService.getLevel(row.destination).toString()
                                            })
@@ -84,6 +85,7 @@ class SearchTabView {
                                    gridLayout(rows: 1, cols : 2)
                                    panel (border : etchedBorder()){
                                        button(text : "Browse Host", enabled : bind {model.browseActionEnabled}, browseAction)
+                                        button(text : "Chat", enabled : bind{model.chatActionEnabled}, chatAction)
                                    }
                                    panel (border : etchedBorder()){
                                        button(text : "Trust", enabled: bind {model.trustButtonsEnabled }, trustAction)
@@ -154,6 +156,14 @@ class SearchTabView {
                                                }
                                                count
                                            })
+                                            closureColumn(header : "Chat Hosts", preferredWidth : 20, type : Integer, read : {
+                                                int count = 0
+                                                model.hashBucket[it].each { 
+                                                    if (it.chat)
+                                                        count++
+                                                }
+                                                count
+                                            })
                                        }
                                    }
                                }
@@ -177,6 +187,7 @@ class SearchTabView {
                                        tableModel(list : model.senders2) {
                                            closureColumn(header : "Sender", preferredWidth : 350, type : String, read : {it.sender.getHumanReadableName()})
                                            closureColumn(header : "Browse", preferredWidth : 20, type : Boolean, read : {it.browse})
+                                            closureColumn(header : "Chat", preferredWidth : 20, type : Boolean, read : {it.chat})
                                            closureColumn(header : "Comment", preferredWidth : 20, type : Boolean, read : {it.comment != null})
                                            closureColumn(header : "Certificates", preferredWidth : 20, type: Integer, read : {it.certificates})
                                            closureColumn(header : "Trust", preferredWidth : 50, type : String, read : {
@@ -189,6 +200,7 @@ class SearchTabView {
                                    gridLayout(rows : 1, cols : 2)
                                    panel (border : etchedBorder()) {
                                        button(text : "Browse Host", enabled : bind {model.browseActionEnabled}, browseAction)
+                                        button(text : "Chat", enabled : bind{model.chatActionEnabled}, chatAction)
                                        button(text : "View Comment", enabled : bind {model.viewCommentActionEnabled}, showCommentAction)
                                        button(text : "View Certificates", enabled : bind {model.viewCertificatesActionEnabled}, viewCertificatesAction)
                                    }
@@ -314,10 +326,12 @@ class SearchTabView {
            if (row < 0) {
                model.trustButtonsEnabled = false
                model.browseActionEnabled = false
+                model.chatActionEnabled = false
                return
            } else {
                Persona sender = model.senders[row]
                model.browseActionEnabled = model.sendersBucket[sender].first().browse
+                model.chatActionEnabled = model.sendersBucket[sender].first().chat
                model.trustButtonsEnabled = true
                model.results.clear()
                model.results.addAll(model.sendersBucket[sender])
@@ -337,6 +351,7 @@ class SearchTabView {
            if (e == null) {
                model.trustButtonsEnabled = false
                model.browseActionEnabled = false
+                model.chatActionEnabled = false
                model.viewCertificatesActionEnabled = false
                return
            }
@@ -370,12 +385,14 @@ class SearchTabView {
            int row = selectedSenderRow()
            if (row < 0 || model.senders2[row] == null) {
                model.browseActionEnabled = false
+                model.chatActionEnabled = false
                model.viewCertificatesActionEnabled = false
                model.trustButtonsEnabled = false
                model.viewCommentActionEnabled = false
                return
            }
            model.browseActionEnabled = model.senders2[row].browse
+            model.chatActionEnabled = model.senders2[row].chat
            model.trustButtonsEnabled = true
            model.viewCommentActionEnabled = model.senders2[row].comment != null
            model.viewCertificatesActionEnabled = model.senders2[row].certificates > 0
--- a/gui/src/main/groovy/com/muwire/gui/ChatNotificator.groovy
+++ b/gui/src/main/groovy/com/muwire/gui/ChatNotificator.groovy
@@ -0,0 +1,108 @@
+package com.muwire.gui
+
+import java.awt.Taskbar
+import java.awt.Taskbar.Feature
+
+import javax.swing.JPanel
+import javax.swing.JTabbedPane
+
+import griffon.core.mvc.MVCGroupManager
+
+class ChatNotificator {
+    
+    public static interface Listener {
+        void update()
+    }
+    
+    private final MVCGroupManager groupManager
+    
+    private boolean chatInFocus
+    private String currentServerTab
+    private String currentRoomTab
+    
+    private final Map<String, Integer> roomsWithMessages = new HashMap<>()
+    
+    private Listener listener
+    
+    ChatNotificator(MVCGroupManager groupManager) {
+        this.groupManager = groupManager
+    }
+    
+    void serverTabChanged(JTabbedPane source) {
+        JPanel panel = source.getSelectedComponent()
+        if (panel == null) {
+            currentServerTab = null
+            currentRoomTab = null
+            return
+        }
+            
+        String mvcId = panel.getClientProperty("mvcId")
+        def group = groupManager.getGroups().get(mvcId)
+        JTabbedPane childPane = panel.getClientProperty("childPane")
+        JPanel roomPanel = childPane.getSelectedComponent()
+        
+        currentServerTab = mvcId
+        currentRoomTab = childPane.getSelectedComponent()?.getClientProperty("mvcId")
+        
+        if (currentRoomTab != null) {
+            roomsWithMessages.remove(currentRoomTab)
+            updateBadge()
+        }
+    }
+    
+    void roomTabChanged(JTabbedPane source) {
+        JPanel panel = source.getSelectedComponent()
+        if (panel == null) {
+            currentRoomTab = null
+            return
+        }
+        currentRoomTab = panel.getClientProperty("mvcId")
+        roomsWithMessages.remove(currentRoomTab)
+        updateBadge()
+    }
+    
+    void roomClosed(String mvcId) {
+        roomsWithMessages.remove(mvcId)
+        updateBadge()
+    }
+    
+    void mainWindowDeactivated() {
+        chatInFocus = false
+    }
+    
+    void mainWindowActivated() {
+        chatInFocus = true
+        if (currentRoomTab != null)
+            roomsWithMessages.remove(currentRoomTab)
+        updateBadge()
+    }
+    
+    void onMessage(String roomId) {
+        if (roomId != currentRoomTab || !chatInFocus) {
+            Integer previous = roomsWithMessages[roomId]
+            if (previous == null)
+                roomsWithMessages[roomId] = 1
+             else
+                roomsWithMessages[roomId] = previous + 1
+        }
+        updateBadge()
+    }
+    
+    private void updateBadge() {
+        listener?.update()
+        if (!Taskbar.isTaskbarSupported())
+            return
+        def taskBar = Taskbar.getTaskbar()
+        if (!taskBar.isSupported(Feature.ICON_BADGE_NUMBER))
+            return
+        if (roomsWithMessages.isEmpty())
+            taskBar.setIconBadge("")
+        else {
+            int total = 0
+            roomsWithMessages.values().each { 
+                total += it
+            }
+            taskBar.setIconBadge(String.valueOf(total))
+        }
+    }
+}
--- a/gui/src/main/groovy/com/muwire/gui/UISettings.groovy
+++ b/gui/src/main/groovy/com/muwire/gui/UISettings.groovy
@@ -19,6 +19,7 @@ class UISettings {
    boolean clearUploads
    boolean storeSearchHistory
    boolean groupByFile
+    int maxChatLines
    Set<String> searchHistory
    Set<String> openTabs
    
@@ -38,6 +39,7 @@ class UISettings {
        clearUploads = Boolean.parseBoolean(props.getProperty("clearUploads","false"))
        storeSearchHistory = Boolean.parseBoolean(props.getProperty("storeSearchHistory","true"))
        groupByFile = Boolean.parseBoolean(props.getProperty("groupByFile","false"))
+        maxChatLines = Integer.parseInt(props.getProperty("maxChatLines","-1"))
        
        searchHistory = DataUtil.readEncodedSet(props, "searchHistory")
        openTabs = DataUtil.readEncodedSet(props, "openTabs")
@@ -59,6 +61,7 @@ class UISettings {
        props.setProperty("clearUploads", String.valueOf(clearUploads))
        props.setProperty("storeSearchHistory", String.valueOf(storeSearchHistory))
        props.setProperty("groupByFile", String.valueOf(groupByFile))
+        props.setProperty("maxChatLines", String.valueOf(maxChatLines))
        if (font != null)
            props.setProperty("font", font)

--- a/gui/src/main/java/com/muwire/gui/SmartScroller.java
+++ b/gui/src/main/java/com/muwire/gui/SmartScroller.java
@@ -0,0 +1,174 @@
+package com.muwire.gui;
+
+import java.awt.Component;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.text.*;
+
+/**
+ *  The SmartScroller will attempt to keep the viewport positioned based on
+ *  the users interaction with the scrollbar. The normal behaviour is to keep
+ *  the viewport positioned to see new data as it is dynamically added.
+ *
+ *  Assuming vertical scrolling and data is added to the bottom:
+ *
+ *  - when the viewport is at the bottom and new data is added,
+ *    then automatically scroll the viewport to the bottom
+ *  - when the viewport is not at the bottom and new data is added,
+ *    then do nothing with the viewport
+ *
+ *  Assuming vertical scrolling and data is added to the top:
+ *
+ *  - when the viewport is at the top and new data is added,
+ *    then do nothing with the viewport
+ *  - when the viewport is not at the top and new data is added, then adjust
+ *    the viewport to the relative position it was at before the data was added
+ *
+ *  Similiar logic would apply for horizontal scrolling.
+ */
+public class SmartScroller implements AdjustmentListener
+{
+    public final static int HORIZONTAL = 0;
+    public final static int VERTICAL = 1;
+
+    public final static int START = 0;
+    public final static int END = 1;
+
+    private int viewportPosition;
+
+    private JScrollBar scrollBar;
+    private boolean adjustScrollBar = true;
+
+    private int previousValue = -1;
+    private int previousMaximum = -1;
+
+    /**
+     *  Convenience constructor.
+     *  Scroll direction is VERTICAL and viewport position is at the END.
+     *
+     *  @param scrollPane the scroll pane to monitor
+     */
+    public SmartScroller(JScrollPane scrollPane)
+    {
+        this(scrollPane, VERTICAL, END);
+    }
+
+    /**
+     *  Convenience constructor.
+     *  Scroll direction is VERTICAL.
+     *
+     *  @param scrollPane the scroll pane to monitor
+     *  @param viewportPosition valid values are START and END
+     */
+    public SmartScroller(JScrollPane scrollPane, int viewportPosition)
+    {
+        this(scrollPane, VERTICAL, viewportPosition);
+    }
+
+    /**
+     *  Specify how the SmartScroller will function.
+     *
+     *  @param scrollPane the scroll pane to monitor
+     *  @param scrollDirection indicates which JScrollBar to monitor.
+     *                         Valid values are HORIZONTAL and VERTICAL.
+     *  @param viewportPosition indicates where the viewport will normally be
+     *                          positioned as data is added.
+     *                          Valid values are START and END
+     */
+    public SmartScroller(JScrollPane scrollPane, int scrollDirection, int viewportPosition)
+    {
+        if (scrollDirection != HORIZONTAL
+        &&  scrollDirection != VERTICAL)
+            throw new IllegalArgumentException("invalid scroll direction specified");
+
+        if (viewportPosition != START
+        &&  viewportPosition != END)
+            throw new IllegalArgumentException("invalid viewport position specified");
+
+        this.viewportPosition = viewportPosition;
+
+        if (scrollDirection == HORIZONTAL)
+            scrollBar = scrollPane.getHorizontalScrollBar();
+        else
+            scrollBar = scrollPane.getVerticalScrollBar();
+
+        scrollBar.addAdjustmentListener( this );
+
+        //  Turn off automatic scrolling for text components
+
+        Component view = scrollPane.getViewport().getView();
+
+        if (view instanceof JTextComponent)
+        {
+            JTextComponent textComponent = (JTextComponent)view;
+            DefaultCaret caret = (DefaultCaret)textComponent.getCaret();
+            caret.setUpdatePolicy(DefaultCaret.NEVER_UPDATE);
+        }
+    }
+
+    @Override
+    public void adjustmentValueChanged(final AdjustmentEvent e)
+    {
+        SwingUtilities.invokeLater(new Runnable()
+        {
+            public void run()
+            {
+                checkScrollBar(e);
+            }
+        });
+    }
+
+    /*
+     *  Analyze every adjustment event to determine when the viewport
+     *  needs to be repositioned.
+     */
+    private void checkScrollBar(AdjustmentEvent e)
+    {
+        //  The scroll bar listModel contains information needed to determine
+        //  whether the viewport should be repositioned or not.
+
+        JScrollBar scrollBar = (JScrollBar)e.getSource();
+        BoundedRangeModel listModel = scrollBar.getModel();
+        int value = listModel.getValue();
+        int extent = listModel.getExtent();
+        int maximum = listModel.getMaximum();
+
+        boolean valueChanged = previousValue != value;
+        boolean maximumChanged = previousMaximum != maximum;
+
+        //  Check if the user has manually repositioned the scrollbar
+
+        if (valueChanged && !maximumChanged)
+        {
+            if (viewportPosition == START)
+                adjustScrollBar = value != 0;
+            else
+                adjustScrollBar = value + extent >= maximum;
+        }
+
+        //  Reset the "value" so we can reposition the viewport and
+        //  distinguish between a user scroll and a program scroll.
+        //  (ie. valueChanged will be false on a program scroll)
+
+        if (adjustScrollBar && viewportPosition == END)
+        {
+            //  Scroll the viewport to the end.
+            scrollBar.removeAdjustmentListener( this );
+            value = maximum - extent;
+            scrollBar.setValue( value );
+            scrollBar.addAdjustmentListener( this );
+        }
+
+        if (adjustScrollBar && viewportPosition == START)
+        {
+            //  Keep the viewport at the same relative viewportPosition
+            scrollBar.removeAdjustmentListener( this );
+            value = value + maximum - previousMaximum;
+            scrollBar.setValue( value );
+            scrollBar.addAdjustmentListener( this );
+        }
+
+        previousValue = value;
+        previousMaximum = maximum;
+    }
+}
Author	SHA1	Message	Date
Zlatin Balevsky	8fedc0c605	Release 0.6.7	2019-11-26 09:55:10 +00:00
Zlatin Balevsky	5831b06842	chat room monitor tool	2019-11-26 09:43:53 +00:00
Zlatin Balevsky	57d5b5f386	do not send /LEAVE messages when leaving private chats	2019-11-26 05:31:22 +00:00
Zlatin Balevsky	c0f6b1ed73	do not rejoin console or private chats, fix NPE when disconnecting with private window open	2019-11-26 05:28:24 +00:00
Zlatin Balevsky	f4cd1c30cd	Do not remove connection on distrust so that disconnect can be processed correctly	2019-11-26 05:00:55 +00:00
Zlatin Balevsky	6b717f560e	file hashing	2019-11-23 20:28:29 +02:00
Zlatin Balevsky	e8a3db76bb	wip on architecture doc	2019-11-23 20:15:45 +02:00
Zlatin Balevsky	5acf7f2953	add clear button	2019-11-20 18:47:14 +00:00
Zlatin Balevsky	e760e9f600	add option to select chat server welcome message	2019-11-19 09:02:42 +00:00
Zlatin Balevsky	8a47972b10	proper group name for manual rejoin	2019-11-19 03:37:35 +00:00
Zlatin Balevsky	f8e0c9524e	make text input fields longer	2019-11-18 10:03:01 +00:00
Zlatin Balevsky	919aeaaed5	preserve chat box contents across openings of the chat window	2019-11-18 09:55:11 +00:00
Zlatin Balevsky	9474512cbd	default to /SAY command	2019-11-18 09:44:05 +00:00
Zlatin Balevsky	8c50f6c6d6	proper model update	2019-11-18 09:33:25 +00:00
Zlatin Balevsky	01ee7209c8	clear members list on server disconnect	2019-11-18 09:31:25 +00:00
Zlatin Balevsky	ff7c4eae28	stop local server if tab is closed	2019-11-18 09:06:29 +00:00
Zlatin Balevsky	9373d58b53	limit the time a header read can take	2019-11-18 09:00:11 +00:00
Zlatin Balevsky	df71ade69f	formatting	2019-11-18 08:46:28 +00:00
Zlatin Balevsky	2ed29be072	selected component can be null when closing a tab	2019-11-17 22:41:31 +00:00
Zlatin Balevsky	a398ab7d4b	indentation	2019-11-17 18:38:53 +00:00
Zlatin Balevsky	a0125e7195	document chat protocol	2019-11-17 18:37:30 +00:00
Zlatin Balevsky	cb9a1cfff6	remove stray import	2019-11-17 15:05:29 +00:00
Zlatin Balevsky	445e73521a	more links	2019-11-17 13:35:40 +00:00
Zlatin Balevsky	7bdc922d2c	add links	2019-11-17 13:32:11 +00:00
Zlatin Balevsky	0c40c8f269	Release 0.6.6	2019-11-16 17:12:21 +00:00
Zlatin Balevsky	681ddb99a2	add ability to say something in a room	2019-11-16 17:10:21 +00:00
Zlatin Balevsky	5dff319746	prevent starting chat server more than once. Implement chat console in the cli	2019-11-16 16:40:07 +00:00
Zlatin Balevsky	57c4a00ac6	do not call disconnect() unless connecting/ed. This prevents trying to connect after closing the tab	2019-11-16 15:25:23 +00:00
Zlatin Balevsky	286a0a8678	redo locking around chat client state	2019-11-16 14:41:47 +00:00
Zlatin Balevsky	17eff7d77f	toString	2019-11-16 00:25:50 +00:00
Zlatin Balevsky	2e22369ce0	set flag before submitting to threadpool	2019-11-15 23:12:17 +00:00
Zlatin Balevsky	15c59b440f	flush outputstream on chat connect failures or rejections	2019-11-15 21:52:35 +00:00
Zlatin Balevsky	8fb015acbf	sort browse host as well	2019-11-15 14:59:52 +00:00
Zlatin Balevsky	f7b11c90fd	sort results from search	2019-11-15 14:49:15 +00:00
Zlatin Balevsky	df93a35062	wip on sorting	2019-11-15 14:23:00 +00:00
Zlatin Balevsky	ecb19a8412	do not update badge if the room is a console	2019-11-15 13:50:13 +00:00
Zlatin Balevsky	b1e5b40800	update minimum JDK to 9, version bump	2019-11-15 13:18:34 +00:00
Zlatin Balevsky	daa3a293f2	new messages update taskbar badge	2019-11-15 13:15:27 +00:00
Zlatin Balevsky	907264fc67	enable/disable chat and browse from trusted pane buttons	2019-11-15 02:15:56 +00:00
Zlatin Balevsky	c6becb93dc	enable/disable say field when not connected	2019-11-15 01:57:48 +00:00
Zlatin Balevsky	2954bd2f1a	smart scrolling the chat text area	2019-11-15 01:44:54 +00:00
Zlatin Balevsky	35322d2c15	fetch group by name,add sequential download checkbox to browse view	2019-11-14 12:40:40 +00:00
Zlatin Balevsky	9f6a7eb368	make sure browse window works from every parent group	2019-11-14 11:04:38 +00:00
Zlatin Balevsky	fec81808e5	Release 0.6.5	2019-11-14 05:15:26 +00:00
Zlatin Balevsky	4db890484d	do not rejoin console	2019-11-14 04:49:13 +00:00
Zlatin Balevsky	dfd5e06889	add browse ability from chat room view	2019-11-14 04:40:15 +00:00
Zlatin Balevsky	71da8e14da	name button earlier	2019-11-14 04:25:45 +00:00
Zlatin Balevsky	7dc37e3e0d	change button to connect/disconnect	2019-11-14 04:20:57 +00:00
Zlatin Balevsky	3de058a078	send rejoins to the console pt2	2019-11-14 03:59:01 +00:00
Zlatin Balevsky	4d70c7adce	send rejoins to the console	2019-11-14 03:58:36 +00:00
Zlatin Balevsky	5b41106476	start and stop poller thread on events	2019-11-14 03:45:21 +00:00
Zlatin Balevsky	6240b22e66	fix reconnecting to server, start with fresh member list upon rejoin	2019-11-14 03:13:01 +00:00
Zlatin Balevsky	0e26f5afd7	rejoin rooms on reconnect	2019-11-14 02:40:22 +00:00
Zlatin Balevsky	114bc06dbb	If the user explicitly shares a file, remove it form the negative tree. #26	2019-11-13 22:00:10 +00:00
Zlatin Balevsky	5fa2f2753c	Release 0.6.4	2019-11-13 20:06:53 +00:00
Zlatin Balevsky	cacdd2a7a9	add browse and chat buttons to trusted panel	2019-11-13 19:40:28 +00:00
Zlatin Balevsky	d56f7c6184	add right-click menu to trusted table	2019-11-13 19:33:34 +00:00
Zlatin Balevsky	f7f4513109	better help and welcome message	2019-11-13 17:50:50 +00:00
Zlatin Balevsky	dd15d893ba	Call for help for Web UI	2019-11-13 17:26:14 +00:00
Zlatin Balevsky	bf5ab9c82e	)	2019-11-13 14:10:26 +00:00
Zlatin Balevsky	edd5a29b10	make private chat room ids unique across servers	2019-11-13 14:09:09 +00:00
Zlatin Balevsky	38eb89f2f7	prepend server name to room id in order to make ids unique across server connections	2019-11-13 13:44:22 +00:00
Zlatin Balevsky	73f1d64428	indentation of text field	2019-11-13 12:24:21 +00:00
Zlatin Balevsky	bc1cae2d75	enable sharing of directories from button	2019-11-13 12:03:23 +00:00
Zlatin Balevsky	a0ab07a7c0	show browse status for local results correctly	2019-11-13 11:58:55 +00:00
Zlatin Balevsky	f875c379ce	Release 0.6.3	2019-11-12 17:22:38 +00:00
Zlatin Balevsky	0ce9784ccf	add right-click menu on the members table	2019-11-12 17:08:38 +00:00
Zlatin Balevsky	be82136e32	limit scrollback	2019-11-12 16:30:55 +00:00
Zlatin Balevsky	7d25bb9364	tidy up views	2019-11-12 16:06:31 +00:00
Zlatin Balevsky	c6e98db9d4	initialize result sender properly	2019-11-12 15:50:58 +00:00
Zlatin Balevsky	35a26e2a47	advertise chat ability in search results	2019-11-12 15:47:38 +00:00
Zlatin Balevsky	beef4af329	ui for chat options	2019-11-12 15:31:20 +00:00
Zlatin Balevsky	cec3c1bc0f	disconnect on close tab	2019-11-12 14:21:47 +00:00
Zlatin Balevsky	289b958784	disconnect functionality	2019-11-12 14:19:57 +00:00
Zlatin Balevsky	e9c554d717	proper group name pt3	2019-11-12 13:53:33 +00:00
Zlatin Balevsky	1875fcddb2	proper room name pt2	2019-11-12 13:33:53 +00:00
Zlatin Balevsky	bee6154fa9	set more room tab names correctly	2019-11-12 13:26:07 +00:00
Zlatin Balevsky	1f9b171021	wip on private messages	2019-11-12 13:16:36 +00:00
Zlatin Balevsky	59c03be35e	suffix for group ids	2019-11-12 12:33:18 +00:00
Zlatin Balevsky	621af96bdf	wip on private chat	2019-11-12 12:20:49 +00:00
Zlatin Balevsky	bcb7016202	add myself to the room member list when joining, fix /SAY	2019-11-12 11:40:28 +00:00
Zlatin Balevsky	b1b2bcaef8	show disconnects	2019-11-12 11:34:23 +00:00
Zlatin Balevsky	eec007e83b	update status only if it matches host	2019-11-12 11:11:42 +00:00
Zlatin Balevsky	3d36351a6b	fetch the list of current room members when joining	2019-11-12 10:55:21 +00:00
Zlatin Balevsky	d57d2ccb71	print help message on joining	2019-11-12 04:18:35 +00:00
Zlatin Balevsky	d91f15ee54	dispatch joins to the target room	2019-11-12 03:53:38 +00:00
Zlatin Balevsky	6bc61c920d	start outgoing connection	2019-11-12 00:11:26 +00:00
Zlatin Balevsky	146ed53e12	connection code	2019-11-11 23:52:34 +00:00
Zlatin Balevsky	8ebae1600b	fix up chat room view	2019-11-11 23:46:43 +00:00
Zlatin Balevsky	18d19ca75e	wip on joining and leaving rooms	2019-11-11 23:32:23 +00:00
Zlatin Balevsky	29e499fe9d	hook up core and backend	2019-11-11 22:42:55 +00:00
Zlatin Balevsky	3db167bade	send periodic pings	2019-11-11 17:54:33 +00:00
Zlatin Balevsky	bfe0ab7867	wip on hooking UI with core	2019-11-11 17:48:42 +00:00
Zlatin Balevsky	1fbb1e7932	add chat pane and associated components	2019-11-11 16:35:15 +00:00
Zlatin Balevsky	0632336cd1	add ability to start and stop chat server from UI	2019-11-11 15:16:23 +00:00
Zlatin Balevsky	aa221cd6dc	server-side handling of disconnects and trust events	2019-11-11 14:54:10 +00:00
Zlatin Balevsky	29b5c55328	client-side disconnect handling	2019-11-11 13:31:00 +00:00
Zlatin Balevsky	5e7f3587df	shutdown chat components	2019-11-11 13:26:25 +00:00
Zlatin Balevsky	8afd387ca6	hook up chat components with core	2019-11-11 13:21:16 +00:00
Zlatin Balevsky	5d16963d1c	process join/leave/say server-side	2019-11-11 12:19:32 +00:00
Zlatin Balevsky	6080c8b308	chat client and server	2019-11-11 10:43:52 +00:00
Zlatin Balevsky	915deb1dee	update readme for new shadow jar name	2019-11-11 09:13:56 +00:00
Zlatin Balevsky	8afca3dc7f	Merge pull request #24 from theosotr/fix Bugfix: Update plugin version to fix bug about shadow jar	2019-11-11 09:04:42 +00:00
Thodoris Sotiropoulos	f072d0343c	Update plugin version to fix bug about shadow jar	2019-11-11 10:52:37 +02:00
Zlatin Balevsky	a549ad3d8d	wip on chat	2019-11-11 04:36:43 +00:00
Zlatin Balevsky	b6f5ec7d22	wip on chat	2019-11-10 20:34:24 +00:00