db4e 0.16.0__py3-none-any.whl

db4e/Modules/InstallMgr.py

@@ -0,0 +1,272 @@
+"""
+db4e/Modules/InstallMgr.py
+
+   Database 4 Everything
+   Author: Nadim-Daniel Ghaznavi 
+   Copyright (c) 2024-2025 NadimGhaznavi <https://github.com/NadimGhaznavi/db4e>
+   License: GPL 3.0
+"""
+
+import os, shutil
+from datetime import datetime, timezone
+import getpass
+import subprocess
+
+from db4e.Modules.ConfigMgr import Config
+from db4e.Modules.DbMgr import DbMgr
+from db4e.Modules.DeploymentMgr import DeploymentMgr
+
+# The Mongo collection that houses the deployment records
+DEPL_COL = 'depl'
+
+class InstallMgr:
+
+    def __init__(self, config: Config):
+        self.ini = config
+        self.depl_mgr = DeploymentMgr(config)
+        self.db = DbMgr(config)
+
+    async def initial_setup(self, form_data: dict) -> dict:
+        # Track the progress of the initial install
+        results = []
+        # Validate the data
+        user_wallet = form_data['user_wallet']
+        db4e_group = form_data['db4e_group']
+        vendor_dir = form_data['vendor_dir']
+
+        db4e_rec = self.depl_mgr.get_deployment('db4e')
+        if db4e_rec:
+            # The Mongo record for 'db4e' exists: Assume we're doing a reinstall
+            results.append({'Db4E core': {'status': 'warn', 'msg': 'Db4E core already exists'}})
+            old_user_wallet = db4e_rec['user_wallet']
+            old_group = db4e_rec['group']
+            old_vendor_dir = db4e_rec['vendor_dir']
+
+            if user_wallet != old_user_wallet:
+                results.append({'Monero wallet': {'status': 'warn', 'msg': 'Old Monero wallet record'}})
+                db4e_rec['user_wallet'] = user_wallet
+                self.depl_mgr.update_deployent(db4e_rec)
+                results.append({'Monero wallet': {'status': 'good', 'msg': 'Updated Monero wallet'}})
+            if db4e_group != old_group:
+                results.append({'Db4E Group': {'status':'warn', 'msg': f'Old Db4E group ({old_group}) record'}})
+                os.environ['DB4E_OLD_GROUP'] = old_group
+            if vendor_dir != old_vendor_dir:
+                results.append({'Deployment directory': {'status':'warn', 'msg': f'Old deployment directory ({old_vendor_dir}) record'}})
+        else:
+            db4e_rec = self.db.get_new_rec('db4e')
+            db4e_rec['user_wallet'] = user_wallet
+            self.depl_mgr.add_deployment(db4e_rec)
+
+        # Create the vendor directory
+        if os.path.exists(vendor_dir):
+            results.append({'Deployment directory': {'status':'warn', 'msg': f'Found existing deployment directory ({vendor_dir})'}})
+            timestamp = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
+            try:
+                backup_vendor_dir = vendor_dir + '.' + timestamp
+                os.rename(vendor_dir, backup_vendor_dir)
+                results.append({'Deployment directory': {'status': 'warn', 'msg': f'Backed up old deployment directory ({backup_vendor_dir})'}})
+            except PermissionError:
+                results.append({'Deployment directory': {'status': 'error', 'msg': f'Failed to backup old deployment directory ({backup_vendor_dir})'}})
+                return results # Abort the install
+        try:
+            os.mkdir(vendor_dir)
+        except (PermissionError, FileNotFoundError, FileExistsError) as e:
+            error_msg = f'Failed to create directory ({vendor_dir}). Make sure you '
+            error_msg += 'have permission to create the directory and that the parent '
+            error_msg += 'directory exists\n\n'
+            error_msg += f'{e}'
+            results.append({'Deployment directory': {'status': 'error', 'msg': error_msg}})
+            return results # Abort the install
+
+        # Additional config settings
+        bin_dir              = self.ini.config['db4e']['bin_dir']
+        conf_dir             = self.ini.config['db4e']['conf_dir']
+        db4e_dir             = self.ini.config['db4e']['db4e_dir']
+        db4e_service_file    = self.ini.config['db4e']['service_file']
+        initial_setup_script = self.ini.config['db4e']['setup_script']
+        log_dir              = self.ini.config['db4e']['log_dir']
+        run_dir              = self.ini.config['db4e']['run_dir']
+        systemd_dir          = self.ini.config['db4e']['systemd_dir']
+        templates_dir        = self.ini.config['db4e']['template_dir']
+        p2pool_binary        = self.ini.config['p2pool']['process']
+        p2pool_service_file  = self.ini.config['p2pool']['service_file']
+        p2pool_start_script  = self.ini.config['p2pool']['start_script']
+        p2pool_socket_file   = self.ini.config['p2pool']['socket_file']
+        p2pool_version       = self.ini.config['p2pool']['version']
+        blockchain_dir       = self.ini.config['monerod']['blockchain_dir']
+        monerod_binary       = self.ini.config['monerod']['process']
+        monerod_service_file = self.ini.config['monerod']['service_file']
+        monerod_socket_file  = self.ini.config['monerod']['socket_file']
+        monerod_start_script = self.ini.config['monerod']['start_script']
+        monerod_version      = self.ini.config['monerod']['version']
+        xmrig_binary         = self.ini.config['xmrig']['process']
+        xmrig_service_file   = self.ini.config['xmrig']['service_file'] 
+        xmrig_version        = self.ini.config['xmrig']['version']
+
+        # The db4e user (the account used to run Db4E)
+        db4e_user = getpass.getuser()
+
+        # db4e, P2Pool, Monero daemon and XMRig directories
+        db4e_vendor_dir = 'db4e'
+        p2pool_dir = 'p2pool-' + str(p2pool_version)
+        monerod_dir = 'monerod-' + str(monerod_version)
+        xmrig_dir = 'xmrig-' + str(xmrig_version)
+
+        # Create the vendor directories
+        os.mkdir(os.path.join(vendor_dir, blockchain_dir))
+        os.mkdir(os.path.join(vendor_dir, db4e_vendor_dir))
+        os.mkdir(os.path.join(vendor_dir, db4e_vendor_dir, conf_dir))
+        os.mkdir(os.path.join(vendor_dir, p2pool_dir))
+        os.mkdir(os.path.join(vendor_dir, p2pool_dir, bin_dir))
+        os.mkdir(os.path.join(vendor_dir, p2pool_dir, conf_dir))
+        os.mkdir(os.path.join(vendor_dir, p2pool_dir, run_dir))
+        os.mkdir(os.path.join(vendor_dir, monerod_dir))
+        os.mkdir(os.path.join(vendor_dir, monerod_dir, bin_dir))
+        os.mkdir(os.path.join(vendor_dir, monerod_dir, conf_dir))
+        os.mkdir(os.path.join(vendor_dir, monerod_dir, run_dir))
+        os.mkdir(os.path.join(vendor_dir, monerod_dir, log_dir))
+        os.mkdir(os.path.join(vendor_dir, xmrig_dir))
+        os.mkdir(os.path.join(vendor_dir, xmrig_dir, bin_dir))
+        os.mkdir(os.path.join(vendor_dir, xmrig_dir, conf_dir))
+
+        # The Templates directory
+        tmpl_dir = os.path.join(os.path.dirname(__file__), '..', templates_dir)
+        # Fully qualifed directories
+        fq_db4e_dir = os.path.join(vendor_dir, db4e_vendor_dir)
+        fq_p2pool_dir = os.path.join(vendor_dir, p2pool_dir)
+        fq_monerod_dir = os.path.join(vendor_dir, monerod_dir)
+        fq_xmrig_dir = os.path.join(vendor_dir, xmrig_dir)
+
+        # Templates for the db4e, Monero daemon and P2pool services
+        fq_db4e_service_file    = os.path.join(tmpl_dir, 'db4e', systemd_dir, db4e_service_file)
+        fq_p2pool_service_file  = os.path.join(tmpl_dir, p2pool_dir, systemd_dir, p2pool_service_file)
+        fq_p2pool_socket_file   = os.path.join(tmpl_dir, p2pool_dir, systemd_dir, p2pool_socket_file)
+        fq_monerod_service_file = os.path.join(tmpl_dir, monerod_dir, systemd_dir, monerod_service_file)
+        fq_monerod_socket_file  = os.path.join(tmpl_dir, monerod_dir, systemd_dir, monerod_socket_file)
+        fq_xmrig_service_file   = os.path.join(tmpl_dir, xmrig_dir, systemd_dir, xmrig_service_file)
+
+        # P2Pool, Monerod daemon, XMRig binaries and start-scripts
+        fq_p2pool               = os.path.join(tmpl_dir, p2pool_dir, bin_dir, p2pool_binary)
+        fq_p2pool_start_script  = os.path.join(tmpl_dir, p2pool_dir, bin_dir, p2pool_start_script)
+        fq_monerod              = os.path.join(tmpl_dir, monerod_dir, bin_dir, monerod_binary)
+        fq_monerod_start_script = os.path.join(tmpl_dir, monerod_dir, bin_dir, monerod_start_script)
+        fq_xmrig                = os.path.join(tmpl_dir, xmrig_dir, bin_dir, xmrig_binary)
+
+        # Temp directory to house the systemd service files
+        tmp_dir = os.path.join('/tmp', 'db4e')
+        if os.path.exists(tmp_dir):
+            shutil.rmtree(tmp_dir)
+        os.mkdir(tmp_dir)
+
+        # Update the db4e service template with deployment values
+        fq_db4e_dir = os.path.join(vendor_dir, )
+        placeholders = {
+            'DB4E_USER': db4e_user,
+            'DB4E_GROUP': db4e_group,
+            'DB4E_DIR': fq_db4e_dir,
+        }
+        with open(fq_db4e_service_file, 'r') as f:
+            service_contents = f.read()
+            for key, val in placeholders.items():
+                service_contents = service_contents.replace(f'[[{key}]]', str(val))
+        tmp_service_file = os.path.join(tmp_dir, db4e_service_file)
+        with open(tmp_service_file, 'w') as f:
+            f.write(service_contents)
+
+        # Update the P2Pool service templates with deployment values
+        placeholders = {
+            'P2POOL_DIR': fq_p2pool_dir,
+            'DB4E_USER': db4e_user,
+            'DB4E_GROUP': db4e_group,
+        }
+        with open(fq_p2pool_service_file, 'r') as f:
+            service_contents = f.read()
+            for key, val in placeholders.items():
+                service_contents = service_contents.replace(f'[[{key}]]', str(val))
+        tmp_service_file = os.path.join(tmp_dir, p2pool_service_file)
+        with open(tmp_service_file, 'w') as f:
+            f.write(service_contents)
+        with open(fq_p2pool_socket_file, 'r') as f:
+            service_contents = f.read()
+            for key, val in placeholders.items():
+                service_contents = service_contents.replace(f'[[{key}]]', str(val))
+        tmp_service_file = os.path.join(tmp_dir, p2pool_socket_file)
+        with open(tmp_service_file, 'w') as f:
+            f.write(service_contents)
+
+        # Update the Monero daemon service templates with deployment values
+        placeholders = {
+            'MONEROD_DIR': fq_monerod_dir,
+            'DB4E_USER': db4e_user,
+            'DB4E_GROUP': db4e_group,
+        }
+        with open(fq_monerod_service_file, 'r') as f:
+            service_contents = f.read()
+            for key, val in placeholders.items():
+                service_contents = service_contents.replace(f'[[{key}]]', str(val))
+        tmp_service_file = os.path.join(tmp_dir, monerod_service_file)
+        with open(tmp_service_file, 'w') as f:
+            f.write(service_contents)
+        with open(fq_monerod_socket_file, 'r') as f:
+            service_contents = f.read()
+            for key, val in placeholders.items():
+                service_contents = service_contents.replace(f'[[{key}]]', str(val))
+        tmp_service_file = os.path.join(tmp_dir, monerod_socket_file)
+        with open(tmp_service_file, 'w') as f:
+            f.write(service_contents)
+
+        # Update the XMRig miner service template with deployment values
+        placeholders = {
+            'XMRIG_DIR': fq_xmrig_dir,
+            'DB4E_USER': db4e_user,
+            'DB4E_GROUP': db4e_group,
+        }
+        with open(fq_xmrig_service_file, 'r') as f:
+            service_contents = f.read()
+            for key, val in placeholders.items():
+                service_contents = service_contents.replace(f'[[{key}]]', str(val))
+        tmp_service_file = os.path.join(tmp_dir, xmrig_service_file)
+        with open(tmp_service_file, 'w') as f:
+            f.write(service_contents)
+
+        # Copy in the Monero daemon, P2Pool and XMRig binaries and startup scripts
+        shutil.copy(fq_p2pool, os.path.join(vendor_dir, p2pool_dir, bin_dir))
+        shutil.copy(fq_p2pool_start_script, os.path.join(vendor_dir, p2pool_dir, bin_dir))
+        shutil.copy(fq_monerod, os.path.join(vendor_dir, monerod_dir, bin_dir))
+        shutil.copy(fq_monerod_start_script, os.path.join(vendor_dir, monerod_dir, bin_dir))
+        shutil.copy(fq_xmrig, os.path.join(vendor_dir, xmrig_dir, bin_dir))
+
+        # Run the bin/db4e-installer.sh
+        db4e_install_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+        fq_initial_setup = os.path.join(db4e_install_dir, bin_dir, initial_setup_script)
+        try:
+            cmd_result = subprocess.run(
+                ['sudo', fq_initial_setup, db4e_dir, db4e_user, db4e_group, vendor_dir],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                input=b"",
+                timeout=10)
+            stdout = cmd_result.stdout.decode().strip()
+            stderr = cmd_result.stderr.decode().strip()
+
+            # Check the return code
+            if cmd_result.returncode != 0:
+                results.append({'Db4E core': {'status': 'error', 'msg': f'Service install failed.\n\n{stderr}'}})
+                return results
+            
+            installer_output = f'{stdout}'
+            results.append({'Db4E core': {'status': 'good', 'msg': installer_output}})
+            shutil.rmtree(tmp_dir)
+
+        except Exception as e:
+            results.append({'Db4E core': {'status': 'error', 'msg': f'Fatal error: {e}'}})
+
+        # Build the db4e deployment record
+        db4e_rec['enable'] = True
+        db4e_rec['group'] = db4e_group
+        db4e_rec['install_dir'] = db4e_install_dir
+        db4e_rec['user'] = db4e_user
+        db4e_rec['vendor_dir'] = vendor_dir
+        # Update the repo deployment record
+        self.depl_mgr.update_deployent(db4e_rec)
+        return results

db4e/Modules/PaneCatalogue.py

@@ -0,0 +1,37 @@
+"""
+db4e/Modules/PaneCatalogue.py
+
+   Database 4 Everything
+   Author: Nadim-Daniel Ghaznavi 
+   Copyright (c) 2024-2025 NadimGhaznavi <https://github.com/NadimGhaznavi/db4e>
+   License: GPL 3.0
+"""
+
+from textual.containers import Container
+
+from db4e.Panes.Welcome import Welcome
+from db4e.Panes.InitialSetup import InitialSetup
+from db4e.Panes.InstallResults import InstallResults
+from db4e.Panes.Db4E import Db4E
+
+
+REGISTRY = {
+    "Db4E": (Db4E, "Database 4 Everything", "Db4E Core"),
+    "InitialSetup": (InitialSetup, "Database 4 Everything", "Initial Setup"),
+    "InstallResults": (InstallResults, "Database 4 Everything", "Install Results"),
+    "Welcome": (Welcome, "Database 4 Everything", "Welcome"),
+}
+
+class PaneCatalogue:
+
+    def __init__(self):
+        self.registry = REGISTRY
+
+    def get_pane(self, pane_name: str, pane_data=None) -> Container:
+        pane_class, _, _ = self.registry[pane_name]
+        print(f"PaneCatalogue:get_pane(): {pane_name}")
+        return pane_class(id=pane_name, data=pane_data) if pane_data else pane_class(id=pane_name)
+
+    def get_metadata(self, pane_name: str) -> tuple[str, str]:
+        _, component, msg = self.registry.get(pane_name, (None, "", ""))
+        return component, msg

db4e/Modules/PaneMgr.py

@@ -0,0 +1,67 @@
+"""
+db4e/Modules/PaneMgr.py
+
+   Database 4 Everything
+   Author: Nadim-Daniel Ghaznavi 
+   Copyright (c) 2024-2025 NadimGhaznavi <https://github.com/NadimGhaznavi/db4e>
+   License: GPL 3.0
+"""
+
+from dataclasses import dataclass, field
+from textual.css.query import NoMatches
+from textual.widget import Widget
+from textual.widgets import ContentSwitcher
+from textual.reactive import reactive
+
+from db4e.Modules.ConfigMgr import Config
+from db4e.Modules.PaneCatalogue import PaneCatalogue
+from db4e.Messages.UpdateTopBar import UpdateTopBar
+
+@dataclass
+class PaneState:
+    name: str = ""
+    data: dict = field(default_factory=dict)
+
+class PaneMgr(Widget):
+    pane_state = reactive(PaneState(), always_update=True)
+
+    def __init__(self, config: Config, catalogue: PaneCatalogue, initialized_flag: bool):
+        super().__init__()
+        self.config = config
+        self.catalogue = catalogue
+        self.initialized_flag = initialized_flag
+        self.panes = {}
+
+    def compose(self):
+        with ContentSwitcher(initial=self.pane_state.name, id="content_switcher"):
+            for pane_name in self.catalogue.registry:
+                # Instantiate each pane once, store a reference
+                pane = self.catalogue.get_pane(pane_name)
+                self.panes[pane_name] = pane
+                yield pane
+
+    async def on_mount(self) -> None:
+        initial = PaneState(name='Welcome' if self.initialized_flag else 'InitialSetup', data={})
+        self.set_pane(initial.name, initial.data)
+
+    def set_pane(self, name: str, data: dict | None = None):
+        self.pane_state = PaneState(name, data)
+        # If the pane supports set_data, update it with new data
+        print(f"PaneMgr:set_pane(): {name}, {data}")
+        if data and name in self.panes:
+            pane = self.panes[name]
+            if hasattr(pane, "set_data"):
+                pane.set_data(data)
+
+    def watch_pane_state(self, old: PaneState, new: PaneState):
+        try:
+            content_switcher = self.query_one("#content_switcher", ContentSwitcher)
+        except NoMatches:
+            return
+        
+        content_switcher.current = new.name
+
+        # Create a message to update the TopBar's title and sub_title
+        title, sub_title = self.catalogue.get_metadata(new.name)
+        self.post_message(UpdateTopBar(self, title=title, sub_title=sub_title))
+

db4e/Panes/Db4E.py

@@ -0,0 +1,73 @@
+"""
+db4e/Panes/Db4E.py
+
+   Database 4 Everything
+   Author: Nadim-Daniel Ghaznavi 
+   Copyright (c) 2024-2025 NadimGhaznavi <https://github.com/NadimGhaznavi/db4e>
+   License: GPL 3.0
+"""
+from textual.widgets import Label, MarkdownViewer, Input, Button
+from textual.containers import Container, Vertical, Horizontal
+from textual.app import ComposeResult
+
+from db4e.Messages.SubmitFormData import SubmitFormData
+
+STATIC_CONTENT = """Welcome to the *Database 4 Everything Db4E Core* configuration screen.
+On this screen uou can update your *Monero wallet* and relocate the *deployment directory*.
+"""
+
+class Db4E(Container):
+
+    def set_data(self, db4e_rec):
+
+        rec_2_biz = {
+            'group': 'Db4E Group',
+            'install_dir': 'Install Directory',
+            'user': 'Db4E User',
+            'user_wallet': 'Monero Wallet',
+            'vendor_dir': 'Deployment Directory'
+        }
+
+        db4e_user_name = rec_2_biz['user']
+        db4e_user = db4e_rec['user']
+        db4e_group_name = rec_2_biz['group']
+        db4e_group = db4e_rec['group']
+        install_dir_name = rec_2_biz['install_dir']
+        install_dir = db4e_rec['install_dir']
+        vendor_dir_name = rec_2_biz['vendor_dir']
+        vendor_dir = db4e_rec['vendor_dir']
+        user_wallet_name = rec_2_biz['user_wallet']
+        user_wallet = db4e_rec['user_wallet']
+
+        yield Vertical(
+            MarkdownViewer(STATIC_CONTENT, show_table_of_contents=False, classes="form_intro"),
+
+            Vertical(
+                Horizontal(
+                    Label(db4e_user_name, id="db4e_user_name_label"),
+                    Label(db4e_user, id="db4e_user")),
+                Horizontal(
+                    Label(db4e_group_name, id="db4e_group_name_label"),
+                    Label(db4e_group, id="db4e_group")),
+                Horizontal(
+                    Label(install_dir_name, id="install_dir_name_label"),
+                    Label(install_dir, id="install_dir")),
+                Horizontal(
+                    Label(vendor_dir_name, id="vendor_dir_name_label"),
+                    Input(id="db4e_vendor_dir_input", restrict=r"/[a-zA-Z0-9/_.\- ]*", value=vendor_dir, compact=True)),
+                Horizontal(
+                    Label(user_wallet_name, id="user_wallet_name_label"),
+                    Input(id="db4e_user_wallet_input", restrict=r"[a-zA-Z0-9]*", value=user_wallet, compact=True)),
+                id="db4e_update_form"),
+
+            Button(label="Update", id="db4e_update_button"))
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        form_data = {
+            "to_module": "DeploymentMgr",
+            "to_method": "update_deployment",
+            "user_wallet": self.query_one("#initial_setup_user_wallet_input", Input).value,
+            "vendor_dir": self.query_one("#initial_setup_vendor_dir_input", Input).value,
+        }
+        self.app.post_message(SubmitFormData(self, form_data))
+

db4e/Panes/InitialSetup.py

@@ -0,0 +1,70 @@
+"""
+db4e/Panes/InitialSetup.py
+
+   Database 4 Everything
+   Author: Nadim-Daniel Ghaznavi 
+   Copyright (c) 2024-2025 NadimGhaznavi <https://github.com/NadimGhaznavi/db4e>
+   License: GPL 3.0
+"""
+from textual.widgets import Label, MarkdownViewer, Input, Button
+from textual.containers import Container, Vertical, Horizontal
+from textual.app import ComposeResult
+
+from db4e.Messages.SubmitFormData import SubmitFormData
+from db4e.Messages.RefreshNavPane import RefreshNavPane
+
+#from db4e.Messages.SubmitFormData import SubmitFormData
+
+STATIC_CONTENT = """Welcome to the *Database 4 Everything* initial setup screen. 
+
+| Field                | Description                                        | Example          |
+| -------------------- | ---------------------------------------------------|----------------- |
+| Monero wallet        | Where your mining payments will be sent            | 48aTDJfRH2JLc... |
+| Linux group          | A Linux group name                                 | db4e             |
+| Deployment directory | A directory for programs, configuration files etc. | /opt/db4e        |
+
+The *Linux group* will be created and the user who is running this program will be added. The 
+*deployment directory* will be created and *Monero*, *P2Pool* and *XMRig* will be installed
+into this directory.
+
+Additionally, the `/etc/sudoers` will be updated to allow Db4E to start and stop Monero, P2Pool
+and XMRig. `Systemd` services will be added for these three elements and a *Db4E* service will also
+be installed. Finally, the *sticky bit* will be set on the XMRig executible so it runs as root to
+access MSRs for optimal performance.
+
+You must have *sudo* access to the root user account. This is normally already setup in a default 
+Linux installation. You will be prompted for your password, since the installer runs as root.
+"""
+
+MAX_GROUP_LENGTH = 20
+
+class InitialSetup(Container):
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            MarkdownViewer(STATIC_CONTENT, show_table_of_contents=False, classes="form_intro"),
+
+            Vertical(
+                Horizontal(
+                    Label("Linux Group:", id="initial_setup_db4e_group_label"),
+                    Input(id="initial_setup_db4e_group_input", restrict=r"[a-z0-9]*", max_length=MAX_GROUP_LENGTH, compact=True)),
+                Horizontal(
+                    Label("Deployment Directory:", id="initial_setup_vendor_dir_label"),
+                    Input(id="initial_setup_vendor_dir_input", restrict=r"/[a-zA-Z0-9/_.\- ]*", compact=True)),
+                Horizontal(
+                    Label("Wallet:", id="initial_setup_user_wallet_label"), 
+                    Input(id="initial_setup_user_wallet_input", restrict=r"[a-zA-Z0-9]*", compact=True)),
+                id="initial_setup_form"),
+
+            Button(label="Proceed", id="initial_setup_button"))
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        form_data = {
+            "to_module": "InstallMgr",
+            "to_method": "initial_setup",
+            "user_wallet": self.query_one("#initial_setup_user_wallet_input", Input).value,
+            "db4e_group": self.query_one("#initial_setup_db4e_group_input", Input).value,
+            "vendor_dir": self.query_one("#initial_setup_vendor_dir_input", Input).value,
+        }
+        self.app.post_message(SubmitFormData(self, form_data))
+        self.app.post_message(RefreshNavPane(self))

db4e/Panes/InstallResults.py

@@ -0,0 +1,36 @@
+"""
+db4e/Panes/InstallResults.py
+
+   Database 4 Everything
+   Author: Nadim-Daniel Ghaznavi 
+   Copyright (c) 2024-2025 NadimGhaznavi <https://github.com/NadimGhaznavi/db4e>
+   License: GPL 3.0
+"""
+from rich import box
+from rich.table import Table
+from textual.app import ComposeResult
+from textual.widgets import Static
+from textual.containers import Container
+
+from db4e.Messages.RefreshNavPane import RefreshNavPane
+
+class InstallResults(Container):
+
+    def set_data(self, task_list):
+
+        table = Table(show_header=True, header_style="bold cyan", style="bold green", box=box.SIMPLE)
+        table.add_column("Component", width=25)
+        table.add_column("Message")
+
+        for task in task_list:
+            for category, msg_dict in task.items():
+                message = msg_dict["msg"]
+                if msg_dict["status"] == "good":
+                    table.add_row(f"✅ [green]{category}[/]", f"[green]{message}[/]")
+                elif msg_dict["status"] == "warn":
+                    table.add_row(f"⚠️  [yellow]{category}[/]", f"[yellow]{message}[/]")
+                elif msg_dict["status"] == "error":
+                    table.add_row(f"💥 [red]{category}[/]", f"[red]{message}[/]")
+
+        self.mount(Static(table))
+        self.app.post_message(RefreshNavPane(self))

db4e/Panes/Welcome.py

@@ -0,0 +1,20 @@
+"""
+db4e/Panes/Welcome.py
+
+   Database 4 Everything
+   Author: Nadim-Daniel Ghaznavi 
+   Copyright (c) 2024-2025 NadimGhaznavi <https://github.com/NadimGhaznavi/db4e>
+   License: GPL 3.0
+"""
+from textual.widgets import Label, Static
+from textual.containers import Container
+from textual.app import ComposeResult
+from textual.message import Message
+
+#from db4e.Messages.TopBarUpdate import TopBarUpdate
+
+class Welcome(Container):
+
+    def compose(self) -> ComposeResult:
+        yield Label('Welcome Pane')
+        yield Static('Welcome Pane - Static')