Furious-GUI 0.2.4__tar.gz → 0.2.5.dev0__tar.gz

{Furious-GUI-0.2.4 → Furious-GUI-0.2.5.dev0}/Furious/Action/Connect.py

@@ -1,5 +1,23 @@
+# Copyright (C) 2023  Loren Eteval <loren.eteval@proton.me>
+#
+# This file is part of Furious.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 from Furious.Core.Core import XrayCore, Hysteria
 from Furious.Core.TorRelay import TorRelay
+from Furious.Core.Tun2socks import Tun2socks
 from Furious.Core.Intellisense import Intellisense
 from Furious.Core.Configuration import Configuration
 from Furious.Action.Routing import BUILTIN_ROUTING_TABLE, BUILTIN_ROUTING
@@ -8,18 +26,29 @@ from Furious.Widget.ConnectingProgressBar import ConnectingProgressBar
 from Furious.Widget.Widget import MessageBox
 from Furious.Utility.Constants import (
     APP,
+    PLATFORM,
     APPLICATION_NAME,
     PROXY_SERVER_BYPASS,
+    APPLICATION_TUN_DEVICE_NAME,
+    APPLICATION_TUN_NETWORK_INTERFACE_NAME,
+    APPLICATION_TUN_IP_ADDRESS,
+    APPLICATION_TUN_GATEWAY_ADDRESS,
     DEFAULT_TOR_HTTPS_PORT,
+    DEFAULT_TOR_SOCKS_PORT,
+    DEFAULT_TOR_RELAY_ESTABLISH_TIMEOUT,
 )
 from Furious.Utility.Utility import (
     Switch,
     SupportConnectedCallback,
     bootstrapIcon,
     getAbsolutePath,
+    isValidIPAddress,
+    isAdministrator,
+    isVPNMode,
 )
 from Furious.Utility.Translator import gettext as _
 from Furious.Utility.Proxy import Proxy
+from Furious.Utility.RoutingTable import RoutingTable
 
 from PySide6 import QtCore
 from PySide6.QtTest import QTest
@@ -37,7 +66,11 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-class HttpProxyServerError(Exception):
+class HttpsProxyServerError(Exception):
+    pass
+
+
+class SocksProxyServerError(Exception):
     pass
 
 
@@ -55,9 +88,10 @@ class ConnectAction(Action):
         self.configurationIcingBox = MessageBox()
         self.configurationErrorBox = MessageBox()
         self.configurationTampered = MessageBox()
-        self.httpProxyConfErrorBox = MessageBox()
+        self.configurationProxyErr = MessageBox()
 
-        self.proxyServer = ''
+        self.httpsProxyServer = ''
+        self.socksProxyServer = ''
 
         self.networkAccessManager = QNetworkAccessManager(parent=self)
         self.networkReply = None
@@ -89,6 +123,7 @@ class ConnectAction(Action):
 
         self.XrayCore = XrayCore()
         self.Hysteria = Hysteria()
+        self.Tun2socks = Tun2socks()
         self.TorRelay = TorRelay()
 
     def XrayCoreExitCallback(self, exitcode):
@@ -97,6 +132,10 @@ class ConnectAction(Action):
             assert self.coreRunning
             assert self.coreName == XrayCore.name()
 
+        if exitcode == XrayCore.ExitCode.SystemShuttingDown:
+            # System shutting down. Do nothing
+            return
+
         if exitcode == XrayCore.ExitCode.ConfigurationError:
             if not self.isConnecting():
                 # Protect connecting action. Mandatory
@@ -142,6 +181,10 @@ class ConnectAction(Action):
             assert self.coreRunning
             assert self.coreName == Hysteria.name()
 
+        if exitcode == Hysteria.ExitCode.SystemShuttingDown:
+            # System shutting down. Do nothing
+            return
+
         if exitcode == Hysteria.ExitCode.ConfigurationError:
             if not self.isConnecting():
                 # Protect connecting action. Mandatory
@@ -181,7 +224,27 @@ class ConnectAction(Action):
                 f'{Hysteria.name()}: {_("Core terminated unexpectedly")}'
             )
 
+    def Tun2socksExitCallback(self, exitcode):
+        if exitcode == Tun2socks.ExitCode.SystemShuttingDown:
+            # System shutting down. Do nothing
+            return
+
+        if not self.isConnecting():
+            # Protect connecting action. Mandatory
+            self.disconnectAction(
+                f'{Tun2socks.name()}: {_("Core terminated unexpectedly")}'
+            )
+        else:
+            self.coreRunning = False
+            self.disconnectReason = (
+                f'{Tun2socks.name()}: {_("Core terminated unexpectedly")}'
+            )
+
     def stopCore(self):
+        self.stopTun2socks()
+
+        self.TorRelay.stop()
+
         self.XrayCore.registerExitCallback(None)
         self.Hysteria.registerExitCallback(None)
 
@@ -189,8 +252,6 @@ class ConnectAction(Action):
         self.XrayCore.stop()
         self.Hysteria.stop()
 
-        self.TorRelay.stop()
-
         self.coreRunning = False
 
     def showConnectingProgressBar(self):
@@ -225,6 +286,13 @@ class ConnectAction(Action):
 
         APP().tray.RoutingAction.setDisabled(value)
 
+        if (PLATFORM == 'Windows' or PLATFORM == 'Darwin') and isAdministrator():
+            VPNModeAction = APP().tray.SettingsAction.getVPNModeAction()
+
+            assert VPNModeAction is not None
+
+            VPNModeAction.setDisabled(value)
+
     def setConnectingStatus(self, showProgressBar=True):
         if showProgressBar:
             self.showConnectingProgressBar()
@@ -267,7 +335,8 @@ class ConnectAction(Action):
         APP().Connect = Switch.OFF
         APP().tray.setPlainIcon()
 
-        self.proxyServer = ''
+        self.httpsProxyServer = ''
+        self.socksProxyServer = ''
 
         self.coreName = ''
         self.coreText = ''
@@ -325,21 +394,29 @@ class ConnectAction(Action):
         # Show the MessageBox and wait for user to close it
         self.configurationIcingBox.exec()
 
-    def errorHttpProxyConf(self):
-        self.httpProxyConfErrorBox.setIcon(MessageBox.Icon.Critical)
-        self.httpProxyConfErrorBox.setWindowTitle(_('Unable to connect'))
-        self.httpProxyConfErrorBox.setText(
+    def errorProxyConf(self, proxyType):
+        assert proxyType == 'http' or proxyType == 'socks'
+
+        self.configurationProxyErr.setIcon(MessageBox.Icon.Critical)
+        self.configurationProxyErr.setWindowTitle(_('Unable to connect'))
+        self.configurationProxyErr.setText(
             _(
-                f'{APPLICATION_NAME} cannot find any valid http proxy '
+                f'{APPLICATION_NAME} cannot find any valid {proxyType} proxy '
                 f'endpoint in your server configuration.'
             )
         )
-        self.httpProxyConfErrorBox.setInformativeText(
+        self.configurationProxyErr.setInformativeText(
             _('Please complete your server configuration.')
         )
 
         # Show the MessageBox and wait for user to close it
-        self.httpProxyConfErrorBox.exec()
+        self.configurationProxyErr.exec()
+
+    def errorHttpsProxyConf(self):
+        self.errorProxyConf('http')
+
+    def errorSocksProxyConf(self):
+        self.errorProxyConf('socks')
 
     @property
     def torRelayStorageObj(self):
@@ -347,8 +424,8 @@ class ConnectAction(Action):
         return APP().torRelaySettingsWidget.StorageObj
 
     def configureCore(self):
-        def validateProxyServer(server):
-            # Validate proxy server
+        def validateHttpsProxyServer(server):
+            # Validate https proxy server
             try:
                 host, port = server.split(':')
 
@@ -358,11 +435,30 @@ class ConnectAction(Action):
                 # Any non-exit exceptions
 
                 self.reset()
-                self.errorHttpProxyConf()
+                self.errorHttpsProxyConf()
 
                 return False
             else:
-                self.proxyServer = server
+                self.httpsProxyServer = server
+
+                return True
+
+        def validateSocksProxyServer(server):
+            # Validate socks proxy server
+            try:
+                host, port = server.split(':')
+
+                if int(port) < 0 or int(port) > 65535:
+                    raise ValueError
+            except Exception:
+                # Any non-exit exceptions
+
+                self.reset()
+                self.errorSocksProxyConf()
+
+                return False
+            else:
+                self.socksProxyServer = server
 
                 return True
 
@@ -374,34 +470,69 @@ class ConnectAction(Action):
         self.Hysteria.registerExitCallback(
             lambda exitcode: self.HysteriaExitCallback(exitcode)
         )
+        self.Tun2socks.registerExitCallback(
+            lambda exitcode: self.Tun2socksExitCallback(exitcode)
+        )
 
-        proxyServer = None
+        httpsProxyServer = None
+        socksProxyServer = None
 
         if Intellisense.getCoreType(self.coreJSON) == XrayCore.name():
             # Assuming is XrayCore configuration
-            proxyHost = None
-            proxyPort = None
+            httpsProxyHost = None
+            httpsProxyPort = None
+            socksProxyHost = None
+            socksProxyPort = None
+
+            if isVPNMode():
+                # Check socks inbound is valid
+                try:
+                    for inbound in self.coreJSON['inbounds']:
+                        if inbound['protocol'] == 'socks':
+                            socksProxyHost = inbound['listen']
+                            socksProxyPort = inbound['port']
+
+                            # Note: If there are multiple socks inbounds
+                            # satisfied, the first one will be chosen.
+                            break
+
+                    if socksProxyHost is None or socksProxyPort is None:
+                        # No HTTP proxy endpoint configured
+                        raise SocksProxyServerError
+
+                    socksProxyServer = f'{socksProxyHost}:{socksProxyPort}'
+                except (KeyError, SocksProxyServerError):
+                    self.reset()
+                    self.errorSocksProxyConf()
+
+                    # Return to caller
+                    return XrayCore.name()
+                else:
+                    # Validate socks proxy server
+                    if not validateSocksProxyServer(socksProxyServer):
+                        # Return to caller
+                        return XrayCore.name()
 
             try:
                 for inbound in self.coreJSON['inbounds']:
                     if inbound['protocol'] == 'http':
-                        proxyHost = inbound['listen']
-                        proxyPort = inbound['port']
+                        httpsProxyHost = inbound['listen']
+                        httpsProxyPort = inbound['port']
 
                         # Note: If there are multiple http inbounds
                         # satisfied, the first one will be chosen.
                         break
 
-                if proxyHost is None or proxyPort is None:
+                if httpsProxyHost is None or httpsProxyPort is None:
                     # No HTTP proxy endpoint configured
-                    raise HttpProxyServerError
+                    raise HttpsProxyServerError
 
-                proxyServer = f'{proxyHost}:{proxyPort}'
-            except (KeyError, HttpProxyServerError):
+                httpsProxyServer = f'{httpsProxyHost}:{httpsProxyPort}'
+            except (KeyError, HttpsProxyServerError):
                 self.reset()
-                self.errorHttpProxyConf()
+                self.errorHttpsProxyConf()
             else:
-                if validateProxyServer(proxyServer):
+                if validateHttpsProxyServer(httpsProxyServer):
                     routing = APP().Routing
 
                     logger.info(f'core {XrayCore.name()} configured')
@@ -463,7 +594,6 @@ class ConnectAction(Action):
                             logger.error('find Tor CLI in path failed')
 
                             self.coreRunning = False
-
                             self.disconnectReason = (
                                 f'{XrayCore.name()}: {_("Cannot find Tor CLI in PATH")}'
                             )
@@ -502,26 +632,57 @@ class ConnectAction(Action):
                         self.coreJSON, ensure_ascii=False, escape_forward_slashes=False
                     )
                     # Start core
-                    self.XrayCore.start(self.coreText)
+                    if self.coreJSON:
+                        self.XrayCore.start(self.coreText)
+
+                        if routing == 'Route My Traffic Through Tor':
+                            # Must start Tor Relay first since it will redirect proxy for us
+                            self.startTorRelay(XrayCore.name(), httpsProxyServer)
 
-                    if routing == 'Route My Traffic Through Tor':
-                        self.startTorRelay(XrayCore.name(), proxyServer)
+                        if isVPNMode():
+                            if PLATFORM == 'Windows' or PLATFORM == 'Darwin':
+                                # Currently VPN Mode is only supported on Windows and macOS
+                                self.startTun2socks()
+                    else:
+                        # Fast fail
+                        self.XrayCore.start(self.coreText, waitTime=1000)
 
             return XrayCore.name()
 
         if Intellisense.getCoreType(self.coreJSON) == Hysteria.name():
             # Assuming is Hysteria configuration
+
+            if isVPNMode():
+                # Check socks inbound is valid
+                try:
+                    socksProxyServer = self.coreJSON['socks5']['listen']
+
+                    if socksProxyServer is None:
+                        # No SOCKS proxy endpoint configured
+                        raise SocksProxyServerError
+                except (KeyError, SocksProxyServerError):
+                    self.reset()
+                    self.errorSocksProxyConf()
+
+                    # Return to caller
+                    return Hysteria.name()
+                else:
+                    # Validate socks proxy server
+                    if not validateSocksProxyServer(socksProxyServer):
+                        # Return to caller
+                        return Hysteria.name()
+
             try:
-                proxyServer = self.coreJSON['http']['listen']
+                httpsProxyServer = self.coreJSON['http']['listen']
 
-                if proxyServer is None:
+                if httpsProxyServer is None:
                     # No HTTP proxy endpoint configured
-                    raise HttpProxyServerError
-            except (KeyError, HttpProxyServerError):
+                    raise HttpsProxyServerError
+            except (KeyError, HttpsProxyServerError):
                 self.reset()
-                self.errorHttpProxyConf()
+                self.errorHttpsProxyConf()
             else:
-                if validateProxyServer(proxyServer):
+                if validateHttpsProxyServer(httpsProxyServer):
                     self.coreRunning = True
 
                     routing = APP().Routing
@@ -556,12 +717,11 @@ class ConnectAction(Action):
 
                             self.Hysteria.start(self.coreText, '', '')
 
-                            self.startTorRelay(Hysteria.name(), proxyServer)
+                            self.startTorRelay(Hysteria.name(), httpsProxyServer)
                         else:
                             logger.error('find Tor CLI in path failed')
 
                             self.coreRunning = False
-
                             self.disconnectReason = (
                                 f'{Hysteria.name()}: {_("Cannot find Tor CLI in PATH")}'
                             )
@@ -601,26 +761,206 @@ class ConnectAction(Action):
                             )
 
                             # Fast fail
-                            self.Hysteria.start('', '', '')
+                            self.coreJSON = {}
+                            self.coreText = ''
+
+                            self.Hysteria.start(self.coreText, '', '', waitTime=1000)
+
+                    if self.coreJSON:
+                        if isVPNMode():
+                            if PLATFORM == 'Windows' or PLATFORM == 'Darwin':
+                                # Currently VPN Mode is only supported on Windows and macOS
+                                self.startTun2socks()
 
             return Hysteria.name()
 
         # No matching core
         return ''
 
+    def startTun2socks(self, successCallback=None):
+        if not self.coreRunning:
+            # Core has exited. Do nothing
+            return
+
+        defaultGateway = list(
+            # Filter TUN Gateway
+            filter(
+                lambda x: x != APPLICATION_TUN_GATEWAY_ADDRESS,
+                RoutingTable.getDefaultGatewayAddress(),
+            )
+        )
+
+        if len(defaultGateway) != 1:
+            logger.error(f'found multiple gateway addresses: {defaultGateway}')
+
+            self.coreRunning = False
+            self.disconnectReason = (
+                _('Unable to connect') + ': ' + _('Multiple gateway addresses found')
+            )
+
+            return
+
+        coreAddr = Intellisense.getCoreAddr(self.coreJSON)
+
+        if not coreAddr:
+            logger.error(f'invalid server address: {coreAddr}')
+
+            self.coreRunning = False
+            self.disconnectReason = _('Server address invalid') + f': {coreAddr}'
+
+            return
+
+        def start():
+            assert RoutingTable.Relations
+
+            if PLATFORM == 'Darwin':
+                for source in [
+                    *list(f'{2 ** (8 - x)}.0.0.0/{x}' for x in range(8, 0, -1)),
+                    '198.18.0.0/15',
+                ]:
+                    RoutingTable.Relations.append(
+                        [source, APPLICATION_TUN_GATEWAY_ADDRESS]
+                    )
+
+            self.Tun2socks.start(
+                APPLICATION_TUN_DEVICE_NAME,
+                APPLICATION_TUN_NETWORK_INTERFACE_NAME,
+                'silent',
+                f'socks5://{self.socksProxyServer}',
+                '',
+            )
+
+            if PLATFORM == 'Windows':
+                RoutingTable.addRelations()
+                RoutingTable.setDeviceGatewayAddress(
+                    APPLICATION_TUN_DEVICE_NAME,
+                    APPLICATION_TUN_IP_ADDRESS,
+                    APPLICATION_TUN_GATEWAY_ADDRESS,
+                )
+
+            if PLATFORM == 'Darwin':
+                RoutingTable.setDeviceGatewayAddress(
+                    APPLICATION_TUN_DEVICE_NAME,
+                    APPLICATION_TUN_IP_ADDRESS,
+                    APPLICATION_TUN_GATEWAY_ADDRESS,
+                )
+                RoutingTable.addRelations()
+
+            if callable(successCallback):
+                successCallback()
+
+        if not isValidIPAddress(coreAddr):
+            logger.info(f'dns resolve uses proxy server {self.httpsProxyServer}')
+
+            # Checked. split should not throw exceptions
+            proxyHost, proxyPort = self.httpsProxyServer.split(':')
+
+            # Checked. int(proxyPort) should not throw exceptions
+            self.networkAccessManager.setProxy(
+                QNetworkProxy(
+                    QNetworkProxy.ProxyType.HttpProxy, proxyHost, int(proxyPort)
+                )
+            )
+
+            request = QNetworkRequest(
+                QtCore.QUrl(f'https://cloudflare-dns.com/dns-query?name={coreAddr}')
+            )
+            request.setRawHeader('accept'.encode(), 'application/dns-json'.encode())
+
+            self.networkReply = self.networkAccessManager.get(request)
+
+            @QtCore.Slot()
+            def finishedCallback():
+                if self.networkReply is None:
+                    # Interrupted externally. Do nothing
+                    logger.info(f'dns resolve for {coreAddr} interrupted externally')
+
+                    return
+
+                assert isinstance(self.networkReply, QNetworkReply)
+
+                if self.networkReply.error() != QNetworkReply.NetworkError.NoError:
+                    logger.error(
+                        f'DNS resolution for {coreAddr} failed. {self.networkReply.errorString()}'
+                    )
+
+                    self.coreRunning = False
+                    self.disconnectReason = _('DNS resolution failed') + f': {coreAddr}'
+                    # Reset reply
+                    self.networkReply = None
+                else:
+                    logger.info(f'dns resolve for {coreAddr} success')
+
+                    replyObject = ujson.loads(self.networkReply.readAll().data())
+
+                    # Reset reply
+                    self.networkReply = None
+
+                    for record in replyObject['Answer']:
+                        address = record['data']
+
+                        logger.info(f'{coreAddr} resolved to {address}')
+
+                        RoutingTable.Relations.append([address, defaultGateway[0]])
+
+                    start()
+
+            self.networkReply.finished.connect(finishedCallback)
+        else:
+            # Reset reply
+            self.networkReply = None
+
+            RoutingTable.Relations.append([coreAddr, defaultGateway[0]])
+
+            start()
+
+        self.waitForDNSResolutionIfNecessary()
+
+    def stopTun2socks(self):
+        self.Tun2socks.registerExitCallback(None)
+        self.Tun2socks.stop()
+
+    def waitForDNSResolutionIfNecessary(self, startCounter=0, timeout=10000, step=1):
+        # Wait for potentially DNS resolve in VPN Mode
+        if self.coreRunning and self.networkReply is not None:
+            logger.info('dns resolve in progress. Wait')
+        else:
+            return
+
+        while (
+            self.coreRunning
+            and startCounter < timeout
+            and self.networkReply is not None
+        ):
+            QTest.qWait(step)
+
+            startCounter += step
+
+        if self.networkReply is not None:
+            if self.coreRunning:
+                logger.error('DNS resolution timeout')
+
+                self.coreRunning = False
+                self.disconnectReason = _('DNS resolution timeout')
+
+            # Reset reply
+            self.networkReply = None
+
     def startTorRelay(self, core, proxyServer, startCounter=0, step=1):
         # Redirect Proxy
-        self.proxyServer = f'127.0.0.1:{self.torRelayStorageObj.get("httpsTunnelPort", DEFAULT_TOR_HTTPS_PORT)}'
+        self.httpsProxyServer = f'127.0.0.1:{self.torRelayStorageObj.get("httpsTunnelPort", DEFAULT_TOR_HTTPS_PORT)}'
+        self.socksProxyServer = f'127.0.0.1:{self.torRelayStorageObj.get("socksTunnelPort", DEFAULT_TOR_SOCKS_PORT)}'
 
         try:
             timeout = 1000 * int(
-                self.torRelayStorageObj.get('relayEstablishTimeout', 15)
+                self.torRelayStorageObj.get(
+                    'relayEstablishTimeout', DEFAULT_TOR_RELAY_ESTABLISH_TIMEOUT
+                )
             )
         except Exception:
             # Any non-exit exceptions
 
-            # 15s
-            timeout = 1000 * 15
+            timeout = 1000 * DEFAULT_TOR_RELAY_ESTABLISH_TIMEOUT
 
         logger.info(f'{TorRelay.name()} bootstrap timeout is {timeout // 1000}s')
 
@@ -665,9 +1005,10 @@ class ConnectAction(Action):
         self.testTime += 1
 
         logger.info(f'start connection test. Try: {selected}')
+        logger.info(f'connection test uses proxy server {self.httpsProxyServer}')
 
         # Checked. split should not throw exceptions
-        proxyHost, proxyPort = self.proxyServer.split(':')
+        proxyHost, proxyPort = self.httpsProxyServer.split(':')
 
         # Checked. int(proxyPort) should not throw exceptions
         self.networkAccessManager.setProxy(
@@ -795,6 +1136,9 @@ class ConnectAction(Action):
         # Connecting status
         self.setConnectingStatus(showProgressBar)
 
+        # Reset reply. Mandatory
+        self.networkReply = None
+
         # Configure connect
         self.coreName = self.configureCore()
 
@@ -806,7 +1150,7 @@ class ConnectAction(Action):
             return
 
         if not self.coreRunning:
-            # 1. No valid HTTP proxy endpoint. reset / disconnect has been called
+            # 1. No valid HTTP/Socks proxy endpoint. reset / disconnect has been called
 
             if self.isConnecting():
                 # 2. Core has exited
@@ -816,7 +1160,7 @@ class ConnectAction(Action):
             return
 
         try:
-            Proxy.set(self.proxyServer, PROXY_SERVER_BYPASS)
+            Proxy.set(self.httpsProxyServer, PROXY_SERVER_BYPASS)
         except Exception:
             # Any non-exit exceptions
 

Furious-GUI-0.2.5.dev0/Furious/Action/EditConfiguration.py

@@ -0,0 +1,32 @@
+# Copyright (C) 2023  Loren Eteval <loren.eteval@proton.me>
+#
+# This file is part of Furious.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from Furious.Gui.Action import Action
+from Furious.Utility.Constants import APP
+from Furious.Utility.Utility import bootstrapIcon
+from Furious.Utility.Translator import gettext as _
+
+
+class EditConfigurationAction(Action):
+    def __init__(self):
+        super().__init__(
+            _('Edit Configuration...'),
+            icon=bootstrapIcon('pencil-square.svg'),
+        )
+
+    def triggeredCallback(self, checked):
+        APP().ServerWidget.show()