flyshell 1.0.0__py3-none-any.whl

flyshell/__init__.py

@@ -0,0 +1,7 @@
+try:
+    from flyshell.abstract.base_plugin import BasePlugin
+    __all__ = ["BasePlugin"]
+except ImportError:
+    BasePlugin = None
+    __all__ = []
+    pass

flyshell/abstract/base_cmd.py

@@ -0,0 +1,26 @@
+# src\flyshell\abstract\base_cmd.py
+
+from typing import List, Optional, Tuple, Union
+
+class BaseCmd:
+    name: str = ""
+    description: str = ""
+    min_args: int = 0
+    options: Optional[str] = None
+    aliases: List[str] = []
+
+    def execute(self, args: List[str]) -> Union[int, Tuple[int, str], str, None]:
+        raise NotImplementedError(f"Command '{self.__class__.__name__}' has not implemented the execute method")
+
+    def help(self, prefix: str = ""):
+        full_name = f"{prefix} {self.name}".strip() if prefix else self.name
+        print(f"\nCommand: {full_name}")
+        if prefix:
+            print(f"Parent: Part of the '{prefix}' family of commands")
+        if self.aliases:
+            print(f"Aliases: {', '.join(self.aliases)}")
+        print(f"Description: {self.description}")
+        print(f"Required Arguments: {self.min_args}")
+        if self.options:
+            print(f"Accepted Arguments: {self.options}")
+        print()

flyshell/abstract/base_plugin.py

@@ -0,0 +1,75 @@
+# src\flyshell\abstract\base_plugin.py
+
+from flyshell.core import data
+from pathlib import Path
+
+class BasePlugin:
+    name: str = "Unnamed Plugin"
+    description: str = "No description provided."
+    version: str = "1.0.0"
+    author: str = "Unknown"
+    usage: str = ""
+    extended_help: str = ""
+
+    def __init__(self, context: dict):
+        self.context = context
+        self.plugin_name = context.get("plugin_name", self.name)
+        self.storage = context.get("storage", {})
+        self.on_load()
+
+    def on_load(self):
+        pass
+
+    def on_unload(self):
+        self.save_storage()
+
+    def execute(self, args: list):
+        raise NotImplementedError("Plugins must implement the execute method")
+
+    def help(self):
+        lines = [
+            f"\nPlugin: {self.name} (v{self.version})",
+            f"Description: {self.description}",
+            f"Author: {self.author}"
+        ]
+        if self.usage:
+            lines.append(f"Usage: {self.usage}")
+        if self.extended_help:
+            lines.append("\nDetails:")
+            lines.append(self.extended_help)
+        print("\n".join(lines))
+
+    def show_docs(self) -> bool:
+        plugin_path = self.context.get("file_path")
+        if plugin_path:
+            p = Path(plugin_path)
+            doc_file = (p.parent / "README.md") if p.is_file() else (p / "README.md")
+            if doc_file.exists():
+                print(f"\nDocumentation: {self.name}")
+                print(doc_file.read_text(encoding="utf-8"))
+                print("-" * 40)
+                return True
+        if self.__doc__:
+            print(f"\nDocumentation: {self.name}")
+            print(self.__doc__.strip())
+            print("-" * 40)
+            return True
+        return False
+
+    def get_data(self, key: str, default=None):
+        return self.storage.get(key, default)
+
+    def set_data(self, key: str, value):
+        self.storage[key] = value
+        self.save_storage()
+
+    def load_storage(self) -> dict:
+        fresh_data = data.get_all_plugin_data(self.plugin_name)
+        self.storage = fresh_data
+        self.context["storage"] = fresh_data
+        return self.storage
+
+    def save_storage(self):
+        for k, v in self.storage.items():
+            data.set_plugin_data(self.plugin_name, k, v)
+        self.context["storage"] = self.storage

flyshell/abstract/parent_cmd.py

@@ -0,0 +1,59 @@
+# src\flyshell\abstract\parent_cmd.py
+
+from flyshell.abstract.base_cmd import BaseCmd
+
+from typing import Dict, List, Optional, Tuple, Union
+
+class ParentCmd(BaseCmd):
+    min_args: int = 1
+    subcommands: Dict[str, BaseCmd] = {}
+
+    def __init__(self):
+        super().__init__() if hasattr(super(), "__init__") else None
+        self._sub_registry: Dict[str, BaseCmd] = {}
+        self._build_registry()
+
+    def _build_registry(self):
+        for cmd_obj in self.get_subcommands():
+            self._sub_registry[cmd_obj.name] = cmd_obj
+            for alias in getattr(cmd_obj, "aliases", []):
+                self._sub_registry[alias] = cmd_obj
+
+    def get_subcommands(self) -> List[BaseCmd]:
+        return []
+
+    def help(self):
+        print(f"\nCommand Family: {self.name}")
+        print(f"Description: {self.description}")
+        print(f"\nSubcommands of '{self.name}':")
+        seen = set()
+        for sub in self._sub_registry.values():
+            if sub in seen:
+                continue
+            seen.add(sub)
+            label = f"{sub.name} (alias: {', '.join(sub.aliases)})" if sub.aliases else sub.name
+            opt = f" [args: {sub.options}]" if sub.options else ""
+            print(f"{label} - {sub.description}{opt}")
+        print(f"\nFor subcommand assistance use '{self.name} <subcmd> -h' or '--help'\n")
+
+    def execute(self, args: List[str]) -> Union[int, Tuple[int, str], str, None]:
+        if not args or args[0] in ("-h", "--help"):
+            self.help()
+            return 0
+        sub_name = args[0].lower()
+        sub_args = args[1:]
+        if sub_name not in self._sub_registry:
+            print(f"\nCommand Error: Unknown subcommand '{sub_name}' for '{self.name}'.")
+            print(f"Use '{self.name} -h' or '--help' to see all valid subcommands.\n")
+            return 1
+        target = self._sub_registry[sub_name]
+        if "-h" in sub_args or "--help" in sub_args:
+            target.help(prefix=self.name)
+            return 0
+        if len(sub_args) < target.min_args:
+            print(f"\nCommand Error: '{self.name} {target.name}' requires at least {target.min_args} argument(s).")
+            if target.options:
+                print(f"Accepted arguments: {target.options}")
+            print()
+            return 1
+        return target.execute(sub_args)

flyshell/builtin/fs.py

@@ -0,0 +1,161 @@
+# src\flyshell\builtin\fs.py
+
+from flyshell.abstract.base_cmd import BaseCmd
+from flyshell.abstract.parent_cmd import ParentCmd
+from flyshell.core import data
+
+import os
+import sys
+import time
+
+class FsDel(BaseCmd):
+    name = "del"
+    description = "Delete / purge an area of Flyshell system storage"
+    min_args = 1
+    options = "'history', 'all', 'plugin <file>'"
+    aliases = ["purge"]
+    def execute(self, args):
+        if len(args) < 1:
+            return (1, "\nCommand Error: 'fs del' requires a target.\n")
+        target = args[0].lower()
+        match target:
+            case "history":
+                choice = input("\nAre you sure you want to clear all command history? [y/n]: ").strip().lower()
+                if choice == "y":
+                    data.clear_history()
+                    return (0, "\nCommand history purged successfully.\n")
+                return (1, "\nAction cancelled.\n")
+            case "config":
+                if len(args) < 2:
+                    return (1, "\nCommand Error: Please specify a configuration key to delete.\n")
+                key = args[1]
+                if data.delete_config(key):
+                    return (0, f"\nConfig setting '{key}' deleted.\n")
+                return (1, f"\nConfig Error: Setting '{key}' not found.\n")
+            case "plugin":
+                if len(args) < 2:
+                    return (1, "\nCommand Error: Please specify a plugin name to purge.\n")
+                plugin_name = args[1]
+                choice = input(f"\nAre you sure you want to purge all data for plugin '{plugin_name}'? [y/n]: ").strip().lower()
+                if choice == "y":
+                    if data.purge_plugin(plugin_name):
+                        return (0, f"\nPlugin '{plugin_name}' and its storage purged successfully.\n")
+                    return (1, f"\nPlugin Error: No data found for plugin '{plugin_name}'.\n")
+                return (1, "\nAction cancelled.\n")
+            case "all":
+                choice = input("\n⚠️ WARNING: This will wipe history, configurations, and plugin data. Proceed? [y/n]: ").strip().lower()
+                if choice == "y":
+                    data.clear_history()
+                    for name in list(data.PLUGINS.keys()):
+                        data.purge_plugin(name)
+                    return (0, "\nAll non-auth system data purged successfully.\n")
+                return (1, "\nAction cancelled.\n")
+            case _:
+                return (1, f"\nCommand Error: Unknown target '{target}'.\n")
+
+class FsInfo(BaseCmd):
+    name = "info"
+    description = "Display Flyshell system information"
+    min_args = 0
+    options = None
+    aliases = []
+
+    def execute(self, args):
+        return (0, (
+            "\nFlyshell System Information:\n"
+            "System Name: Flyshell\n"
+            f"System Version: {data.VERSION}\n"
+            f"System Build: {data.BUILD}\n"
+            f"Host Operating System: '{data.HOST_OS}'\n"
+            f"Installed Plugin Count: {len(data.PLUGINS)}\n"
+            "Original Release Date: 8th August 2026\n"
+        ))
+
+class FsLicence(BaseCmd):
+    name = "licence"
+    description = "Display Flyshell licence conditions"
+    min_args = 0
+    options = None
+    aliases = ["license"]
+
+    def execute(self, args):
+        return (0, (
+            "\nFlyshell Licensing Information:\n"
+            "Flyshell is licensed under the MIT Licence\n\n"
+            "Copyright (c) 2026 kianodev\n\n"
+            "Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files [the 'Software'], to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\n"
+            "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\n"
+            "THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
+        ))
+
+class FsPlugins(BaseCmd):
+    name = "plugins"
+    description = "Display installed plugins and their details"
+    min_args = 0
+    options = None
+    aliases = ["plugin"]
+
+    def execute(self, args):
+        lines = ["\nInstalled Plugins:"]
+        if data.PLUGINS:
+            for name, plugin in data.PLUGINS.items():
+                p_name = getattr(plugin, "name", name)
+                p_desc = getattr(plugin, "description", "No description provided.")
+                lines.append(f"Plugin '{name}' [{p_name}]: {p_desc}")
+        else:
+            lines.append("No plugins installed.")
+        lines.append(f"\nTotal available plugins: {len(data.PLUGINS)}\n")
+        return (0, "\n".join(lines))
+
+class FsStatus(BaseCmd):
+    name = "status"
+    description = "Return Flyshell status and runtime details"
+    min_args = 0
+    options = None
+    aliases = []
+
+    def execute(self, args):
+        uptime = int(time.time() - data.SESSION_START_TIME)
+        mins, secs = divmod(uptime, 60)
+        hours, mins = divmod(mins, 60)
+        uptime_str = f"{hours}h {mins}m {secs}s"
+        auth_data = data.get_auth() or {}
+        current_user = auth_data.get("username", "Unknown")
+        cmd_history = data.get_history()
+        total_history_count = len(cmd_history) if isinstance(cmd_history, list) else 0
+        storage_size_str = data.get_storage_size()
+        return (0, (
+            "\nFlyshell System Status:\n"
+            f"User: '{current_user}'\n"
+            f"Session Uptime: {uptime_str}\n"
+            f"Commands (Session): {data.SESSION_CMD_COUNT}\n"
+            f"Commands (Lifetime): {total_history_count}\n"
+            f"Working Directory: '{os.getcwd()}'\n"
+            f"Storage File Size: {storage_size_str}\n"
+            f"Python Environment: v{sys.version.split()[0]}\n"
+            f"\nFlyshell Version {data.VERSION} (Build {data.BUILD})\n"
+        ))
+
+class FsVersion(BaseCmd):
+    name = "version"
+    description = "Return Flyshell version and build"
+    min_args = 0
+    options = None
+    aliases = []
+    def execute(self, args):
+        return (0, f"\nYou are on Flyshell Version {data.VERSION} (Build {data.BUILD})\n")
+
+class Fs(ParentCmd):
+    name = "fs"
+    description = "Execute core Flyshell control and utility functions"
+    aliases = []
+
+    def get_subcommands(self):
+        return [
+            FsDel(),
+            FsInfo(),
+            FsLicence(),
+            FsPlugins(),
+            FsStatus(),
+            FsVersion(),
+        ]

flyshell/builtin/system.py

@@ -0,0 +1,124 @@
+# src\flyshell\builtin\system.py
+
+from flyshell.abstract.base_cmd import BaseCmd
+from flyshell.core import auth, data
+
+import getpass
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+class Cd(BaseCmd):
+    name = "cd"
+    description = "Change the current working directory"
+    min_args = 0
+    options = "Directory name (default is Home)"
+    aliases = []
+
+    def execute(self, args):
+        target = os.path.expanduser(" ".join(args)) if args else os.path.expanduser("~")
+        try:
+            os.chdir(target)
+            return (0, f"\nSwitched directory to '{os.getcwd()}'\n")
+        except FileNotFoundError:
+            return (1, f"\nCommand Error: Directory '{target}' not found.\n")
+        except PermissionError:
+            return (1, f"\nSystem Error: Permission denied. Cannot access '{target}'\n")
+        except OSError as e:
+            return (1, f"\nCommand Error: Invalid path syntax '{target}'. ({e.strerror})\n")
+
+class Dir(BaseCmd):
+    name = "dir"
+    description = "List all files in the current working directory"
+    min_args = 0
+    options = None
+    aliases = ["ls"]
+
+    def execute(self, args):
+        try:
+            current_path = os.getcwd()
+            items = os.listdir(current_path)
+            lines = [f"\nDirectory: '{current_path}'"]
+            for item in items:
+                if os.path.isdir(os.path.join(current_path, item)):
+                    lines.append(f"[DIR] {item}/")
+                else:
+                    lines.append(f"[FILE] {item}")
+            lines.append(f"\nTotal items in directory: {len(items)}\n")
+            return (0, "\n".join(lines))
+        except Exception as e:
+            return (1, f"\nSystem Error: Unable to list directory ({e})\n")
+
+class OpenFile(BaseCmd):
+    name = "open"
+    description = "Open the specified file path"
+    min_args = 1
+    options = "File path"
+    aliases = []
+
+    def execute(self, args):
+        target = " ".join(args).strip().strip('"\'')
+        if not target:
+            return (0, "")
+        is_path = os.path.exists(target)
+        is_url = target.startswith(("http://", "https://"))
+        is_bin = shutil.which(target) is not None
+        if not (is_path or is_url or is_bin):
+            return (1, f"\nCommand Error: File or application '{target}' could not be found.\n")
+        try:
+            if data.HOST_OS == "Windows":
+                os.startfile(target)
+            elif data.HOST_OS == "Darwin":
+                subprocess.Popen(["open", target], stderr=subprocess.DEVNULL)
+            else:
+                subprocess.Popen(["xdg-open", target], stderr=subprocess.DEVNULL)
+            return (0, f"\nSUCCESS! Launched '{target}' application or file.\n")
+        except Exception as e:
+            return (1, f"\nSystem Error: Failed to open '{target}': {e}\n")
+
+class SysExe(BaseCmd):
+    name = "sys"
+    description = "Execute the subsequent command on the host system"
+    min_args = 1
+    options = "Any host command"
+    aliases = []
+
+    def execute(self, args):
+        if args[0] in ["-f", "--force"]:
+            override = True
+            args = args[1:]
+            if not args:
+                return (1, "\nCommand Error: 'sys' requires at least 1 parameter(s).\n")
+        else:
+            override = False
+        cmd = " ".join(args).strip().strip('"\'')
+        cmd_normalised = " ".join(cmd.lower().split())
+        BLOCKED_COMMANDS = {"format", "diskpart", "dd"}
+        is_blocked = any(re.search(rf"\b{re.escape(b)}\b", cmd_normalised) for b in BLOCKED_COMMANDS)
+        DANGER_COMMANDS = {"del", "rmdir", "rd", "rm", "taskkill", "killall"}
+        is_dangerous = any(re.search(rf"\b{re.escape(d)}\b", cmd_normalised) for d in DANGER_COMMANDS)
+        if is_blocked:
+            return (1, (
+                "\nSecurity Error: Flyshell has blocked execution of this command.\n"
+                f"This command '{cmd}' is permanently restricted by Flyshell safety policy.\n"
+                "Flyshell has blocked your command to prevent damage to your computer.\n"
+            ))
+        elif is_dangerous and not override:
+            password = getpass.getpass("\nThis command is restricted. To execute, enter your password: ")
+            auth_info = data.get_auth() or {}
+            stored_hash = auth_info.get("hash")
+            stored_salt = auth_info.get("salt")
+            if not auth.verify_password(stored_hash, stored_salt, password):
+                return (1, "\nAccount Error: Password does not match.\n")
+        try:
+            print()
+            result = subprocess.run(cmd, shell=True)
+            print()
+            return (result.returncode, "")
+        except KeyboardInterrupt:
+            print()
+            return (130, "")
+        except Exception as e:
+            return (1, f"\nCommand Error: Failed to run host command ({e})\n")

flyshell/builtin/utils.py

@@ -0,0 +1,113 @@
+# src\flyshell\builtin\utils.py
+
+from flyshell.abstract.base_cmd import BaseCmd
+from flyshell.core import data
+
+import os
+import signal
+import subprocess
+import sys
+import time
+
+class Clear(BaseCmd):
+    name = "clear"
+    description = "Clear the screen"
+    min_args = 0
+    options = None
+    aliases = ["cls"]
+
+    def execute(self, args):
+        return (0, "\033[H\033[2J")
+
+class History(BaseCmd):
+    name = "history"
+    description = "View command history"
+    min_args = 0
+    options = "Entry count (default is 10)"
+    aliases = []
+
+    def execute(self, args):
+        limit = 10
+        if args:
+            sub_arg = args[0].lower()
+            if sub_arg == "all":
+                limit = None
+            elif sub_arg.isdigit():
+                limit = int(sub_arg)
+            else:
+                return (1, f"\nCommand Error: Invalid argument '{args[0]}'\n")
+        history_entries = data.get_history(limit)
+        if not history_entries:
+            return (0, "\nHistory is empty.\n")
+        lines = [
+            "\nCommand History:",
+            f"Showing last {len(history_entries)} entries.\n"
+        ]
+        for i, entry in enumerate(history_entries, start=1):
+            cmd = entry.get("command", "")
+            time_str = entry.get("timestamp", "")
+            date_part, time_part = time_str.rstrip("Z").split("T")
+            lines.append(f"#{i}: {cmd} [at {date_part} @ {time_part} UTC]")
+        lines.append("")
+        return (0, "\n".join(lines))
+
+class Kill(BaseCmd):
+    name = "kill"
+    description = "Shut down the Flyshell system"
+    min_args = 0
+    options = None
+    aliases = []
+
+    def execute(self, args):
+        choice = input("\nAre you sure [y/n]?: ").strip().lower()
+        if choice == "y":
+            print("\nShutting down...")
+            sys.exit(0)
+        else:
+            return (1, "\nAction cancelled.\n")
+
+class Reboot(BaseCmd):
+    name = "reboot"
+    description = "Reboot the Flyshell system"
+    min_args = 0
+    options = None
+    aliases = ["restart"]
+
+    def execute(self, args):
+        print("\nRestarting Flyshell...\n")
+        is_direct_script = (
+            sys.argv[0].lower().endswith(".exe") 
+            or os.path.basename(sys.argv[0]) == "flyshell"
+        )
+        if is_direct_script:
+            cmd = sys.argv
+        else:
+            cmd = [sys.executable] + sys.argv
+        if data.HOST_OS == "Windows":
+            old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+            try:
+                p = subprocess.run(cmd)
+                sys.exit(p.returncode)
+            finally:
+                signal.signal(signal.SIGINT, old_handler)
+        else:
+            os.execv(cmd[0], cmd)
+
+class Sleep(BaseCmd):
+    name = "sleep"
+    description = "Sleep the system for a specified time"
+    min_args = 1
+    options = "Duration (secs)"
+    aliases = []
+
+    def execute(self, args):
+        if not args or not args[0].replace(".", "", 1).isdigit():
+            return (1, f"\nCommand Error: Invalid argument '{args[0] if args else ''}'\n")
+        secs = float(args[0])
+        try:
+            print(f"\nPausing Flyshell for {secs} second(s).")
+            print("Press Ctrl+C to cancel.\n")
+            time.sleep(secs)
+            return (0, "\nReturning...\n")
+        except KeyboardInterrupt:
+            return (1, "\nSleep cancelled.\n")