flyshell 1.0.0__py3-none-any.whl

flyshell/core/auth.py

@@ -0,0 +1,122 @@
+# src\flyshell\core\auth.py
+
+from flyshell.abstract.base_cmd import BaseCmd
+from flyshell.core import data
+
+import getpass
+import hashlib
+import re
+import secrets
+import sys
+
+def hash_password(password, salt=None):
+    if salt is None:
+        salt = secrets.token_bytes(16)
+    elif isinstance(salt, str):
+        salt = bytes.fromhex(salt)
+    pwd_hash = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 600000)
+    return pwd_hash.hex(), salt.hex()
+
+def verify_password(stored_hash: str, stored_salt: str, password: str) -> bool:
+    if not stored_hash or not stored_salt or not password:
+        return False
+    try:
+        salt_bytes = bytes.fromhex(stored_salt)
+        attempt_hash, _ = hash_password(password, salt_bytes)
+        return secrets.compare_digest(attempt_hash, stored_hash)
+    except (ValueError, TypeError):
+        return False
+
+def setup_acc() -> bool:
+    print("\nWelcome to Flyshell, New User!")
+    print("Please follow the prompts to create your Flyshell profile.")
+    while True:
+        username = input("Create Username: ").strip()
+        if not username:
+            print("\nAccount Error: Username cannot be empty.\n")
+        else:
+            print(f"\nUsername set as '{username}'\n")
+            break
+    i = 5
+    print("Your password MUST:")
+    print("- Contain at least 10 total characters")
+    print("- Contain 1 or more upper case letters")
+    print("- Contain 1 or more lower case letters")
+    print("- Contain 1 or more numbers")
+    print("- Contain 1 or more special characters\n")
+    while i > 0:
+        password = getpass.getpass("Create Password: ")
+        confirm = getpass.getpass("Confirm Password: ")
+        if password != confirm:
+            print("\nAccount Error: Passwords do not match.")
+            i -= 1
+            if i == 0:
+                print("Too many attempts.\n")
+                return False
+            print(f"You have {i} attempts remaining.\n")
+            continue
+        has_upper = any(char.isupper() for char in password)
+        has_lower = any(char.islower() for char in password)
+        has_digit = any(char.isdigit() for char in password)
+        has_speci = bool(re.search(r'[^a-zA-Z0-9]', password))
+        if len(password) >= 10 and has_upper and has_lower and has_digit and has_speci:
+            break
+        else:
+            print("\nAccount Error: Password does not meet required conditions.\n")
+            i -= 1
+            if i == 0:
+                print("Too many attempts.\n")
+                return False
+            print(f"You have {i} attempts remaining.\n")
+            continue
+    pwd_hash, salt = hash_password(password)
+    auth_data = {
+        "username": username,
+        "hash": pwd_hash,
+        "salt": salt
+    }
+    data.set_auth(username, pwd_hash, salt)
+    print("\nSUCCESS: Account created successfully!")
+    return True
+
+def login_flow(is_lock=False) -> bool:
+    auth_info = data.get_auth()
+    if not auth_info or "hash" not in auth_info:
+        if not setup_acc():
+            return False
+        auth_info = data.get_auth()
+    stored_user = auth_info.get("username", "User")
+    stored_hash = auth_info.get("hash")
+    stored_salt = auth_info.get("salt")
+    if is_lock:
+        input(f"\nFlyshell is locked. To unlock, press ENTER.")
+        print(f"\nWelcome back, {stored_user}!")
+    else:
+        print(f"\nWelcome, {stored_user}!")
+    i = 5
+    while i > 0:
+        entered_pwd = getpass.getpass("Enter Password: ")
+        if verify_password(stored_hash, stored_salt, entered_pwd):
+            if is_lock:
+                print()
+            return True
+        i -= 1
+        print(f"\nAccount Error: Password does not match.")
+        if i == 0:
+            print("Too many attempts.\n")
+            return False
+        print(f"You have {i} attempts remaining.\n")
+
+class Lock(BaseCmd):
+    name = "lock"
+    description = "Lock the Flyshell system"
+    min_args = 0
+    options = None
+    aliases = []
+
+    def execute(self, args):
+        if login_flow(is_lock=True):
+            return (0, "")
+        else:
+            print("\nShutting down...\n")
+            sys.exit(0)

flyshell/core/console.py

@@ -0,0 +1,64 @@
+# src\flyshell\core\console.py
+
+from flyshell.core import data
+from flyshell.core.directory import execute_line
+
+import os
+import random
+import sys
+
+readline = None
+
+def check_readline() -> bool:
+    global readline
+    try:
+        import readline
+        return True
+    except ImportError:
+        try:
+            import pyreadline3 as readline
+            return True
+        except ImportError:
+            readline = None
+            return False
+
+def load_history():
+    if not readline:
+        return
+    history_entries = data.get_history(limit=100)
+    for entry in history_entries:
+        if isinstance(entry, dict) and "command" in entry:
+            readline.add_history(entry["command"])
+
+def boot():
+    load_history()
+    print("\033[H\033[2J", end="")
+    print(f"\nBoot successful, welcome to Flyshell! (Version {data.VERSION})")
+    user_info = data.get_auth() or {}
+    username = user_info.get("username")
+    GREETINGS = [
+        f"Hi {username}, what's it going to be today?",
+        f"The mic is yours, {username}, go and blow me away!",
+        f"Hey {username}, let's get this party started!",
+        f"What's up, {username}? Let's go!",
+        f"I'm awaiting your first command, {username}!",
+        f"How's it going {username}? I'm here to help.",
+        f"{username}, it's your call! Show me what you've got, what are we doing today?",
+        f"My wish is your command, {username}! (unless it's not on my command list)",
+        f"I have goods for you {username}, it's called a Command Interface.",
+        f"I'm your boss! Wait, no... sorry... you, {username}, are my boss!",
+    ]
+    greeting = random.choice(GREETINGS)
+    print(f"\n{greeting}\n")
+    while True:
+        try:
+            folder = os.path.basename(os.getcwd())
+            raw_cmd = input(f"Flyshell [v{data.VERSION}] ({folder})>>")
+            if not raw_cmd.strip():
+                continue
+            execute_line(raw_cmd)
+        except KeyboardInterrupt:
+            print()
+        except EOFError:
+            print("\n\nFlyshell session closed.\n")
+            sys.exit(0)

flyshell/core/data.py

@@ -0,0 +1,234 @@
+# src\flyshell\core\data.py
+
+BUILD = 99
+VERSION = "1.0.0"
+
+from pathlib import Path
+import json
+import os
+import platform
+import sqlite3
+import time
+
+HOST_OS = platform.system()
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+def get_app_dir() -> Path:
+    home = Path.home()
+    if HOST_OS == "Windows":
+        base = Path(os.environ.get("APPDATA", home / "AppData" / "Roaming"))
+    elif HOST_OS == "Darwin":
+        base = home / "Library" / "Application Support"
+    else:
+        base = Path(os.environ.get("XDG_DATA_HOME", home / ".local" / "share"))
+    app_dir = base / "Flyshell"
+    app_dir.mkdir(parents=True, exist_ok=True)
+    return app_dir
+
+APP_DIR = get_app_dir()
+FILE_PATH = APP_DIR / "flyshell.db"
+USER_PLUGIN_DIR = APP_DIR / "plugins"
+
+SESSION_START_TIME = time.time()
+SESSION_CMD_COUNT = 0
+PLUGINS = {}
+
+def get_storage_size() -> str:
+    if not FILE_PATH.exists():
+        return "File not found"
+    num_bytes = float(FILE_PATH.stat().st_size)
+    for unit in ["B", "KB", "MB", "GB"]:
+        if num_bytes < 1024.0:
+            return f"{int(num_bytes)} {unit}" if unit == "B" else f"{num_bytes:.2f} {unit}"
+        num_bytes /= 1024.0
+    return f"{num_bytes:.2f} TB"
+
+def _get_connection(filename=FILE_PATH):
+    conn = sqlite3.connect(filename)
+    conn.execute("PRAGMA foreign_keys = ON;")
+    return conn
+
+INITIALISED = set()
+
+def initialise(filename=FILE_PATH):
+    global INITIALISED
+    target = str(filename)
+    if target in INITIALISED:
+        return
+    with _get_connection(filename) as conn:
+        conn.execute("PRAGMA foreign_keys = ON;")
+        current_version = conn.execute("PRAGMA user_version;").fetchone()[0]
+        if current_version == 0:
+            with conn:
+                conn.execute("""
+                    CREATE TABLE IF NOT EXISTS auth (
+                        id INTEGER PRIMARY KEY CHECK (id = 1),
+                        username TEXT NOT NULL,
+                        hash TEXT NOT NULL,
+                        salt TEXT NOT NULL,
+                        created_at TEXT NOT NULL
+                    );
+                """)
+                conn.execute("""
+                    CREATE TABLE IF NOT EXISTS cmd_history (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        command TEXT NOT NULL,
+                        timestamp TEXT NOT NULL
+                    );
+                """)
+                conn.execute("""
+                    CREATE TABLE IF NOT EXISTS core_config (
+                        key TEXT PRIMARY KEY,
+                        value TEXT NOT NULL
+                    );
+                """)
+                conn.execute("""
+                    CREATE TABLE IF NOT EXISTS plugins (
+                        plugin_name TEXT PRIMARY KEY,
+                        installed_at TEXT NOT NULL,
+                        is_enabled INTEGER NOT NULL DEFAULT 1
+                    );
+                """)
+                conn.execute("""
+                    CREATE TABLE IF NOT EXISTS plugin_kv (
+                        plugin_name TEXT NOT NULL,
+                        key TEXT NOT NULL,
+                        value TEXT NOT NULL,
+                        PRIMARY KEY (plugin_name, key),
+                        FOREIGN KEY (plugin_name) REFERENCES plugins(plugin_name) ON DELETE CASCADE
+                    );
+                """)
+                conn.execute("PRAGMA user_version = 1;")
+    INITIALISED.add(target)
+
+def get_auth(filename=FILE_PATH) -> dict | None:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        row = conn.execute("SELECT username, hash, salt, created_at FROM auth WHERE id = 1").fetchone()
+        if not row:
+            return None
+        return {"username": row[0], "hash": row[1], "salt": row[2], "created_at": row[3]}
+
+def set_auth(username: str, pwd_hash: str, salt: str, filename=FILE_PATH) -> None:
+    initialise(filename)
+    now_utc = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    with _get_connection(filename) as conn:
+        with conn:
+            conn.execute("""
+                INSERT OR REPLACE INTO auth (id, username, hash, salt, created_at)
+                VALUES (1, ?, ?, ?, ?)
+            """, (username, pwd_hash, salt, now_utc))
+
+def clear_auth(filename=FILE_PATH) -> bool:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        with conn:
+            cursor = conn.execute("DELETE FROM auth WHERE id = 1")
+            return cursor.rowcount > 0
+
+def append_history(cmd: str, timestamp: str, filename=FILE_PATH) -> None:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        with conn:
+            conn.execute("INSERT INTO cmd_history (command, timestamp) VALUES (?, ?)", (cmd, timestamp))
+
+def get_history(limit: int | None = None, filename=FILE_PATH) -> list[dict]:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        if limit is not None and limit > 0:
+            query = "SELECT command, timestamp FROM cmd_history ORDER BY id DESC LIMIT ?"
+            rows = conn.execute(query, (limit,)).fetchall()
+            rows.reverse()
+        else:
+            query = "SELECT command, timestamp FROM cmd_history ORDER BY id ASC"
+            rows = conn.execute(query).fetchall()
+        return [{"command": r[0], "timestamp": r[1]} for r in rows]
+
+def clear_history(filename=FILE_PATH) -> bool:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        with conn:
+            conn.execute("DELETE FROM cmd_history")
+            return True
+
+def get_config(key: str, default=None, filename=FILE_PATH):
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        row = conn.execute("SELECT value FROM core_config WHERE key = ?", (key,)).fetchone()
+        if not row:
+            return default
+        try:
+            return json.loads(row[0])
+        except (ValueError, TypeError):
+            return row[0]
+
+def set_config(key: str, value, filename=FILE_PATH) -> None:
+    initialise(filename)
+    serialized = json.dumps(value)
+    with _get_connection(filename) as conn:
+        with conn:
+            conn.execute("""
+                INSERT OR REPLACE INTO core_config (key, value)
+                VALUES (?, ?)
+            """, (key, serialized))
+
+def delete_config(key: str, filename=FILE_PATH) -> bool:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        with conn:
+            cursor = conn.execute("DELETE FROM core_config WHERE key = ?", (key,))
+            return cursor.rowcount > 0
+
+def register_plugin(plugin_name: str, filename=FILE_PATH) -> None:
+    initialise(filename)
+    now_utc = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    with _get_connection(filename) as conn:
+        with conn:
+            conn.execute("""
+                INSERT OR IGNORE INTO plugins (plugin_name, installed_at, is_enabled)
+                VALUES (?, ?, 1)
+            """, (plugin_name, now_utc))
+
+def get_plugin_data(plugin_name: str, key: str, default=None, filename=FILE_PATH):
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        row = conn.execute("""
+            SELECT value FROM plugin_kv WHERE plugin_name = ? AND key = ?
+        """, (plugin_name, key)).fetchone()
+        if not row:
+            return default
+        try:
+            return json.loads(row[0])
+        except (ValueError, TypeError):
+            return row[0]
+
+def set_plugin_data(plugin_name: str, key: str, value, filename=FILE_PATH) -> None:
+    initialise(filename)
+    register_plugin(plugin_name, filename=filename)
+    serialized = json.dumps(value)
+    with _get_connection(filename) as conn:
+        with conn:
+            conn.execute("""
+                INSERT OR REPLACE INTO plugin_kv (plugin_name, key, value)
+                VALUES (?, ?, ?)
+            """, (plugin_name, key, serialized))
+
+def get_all_plugin_data(plugin_name: str, filename=FILE_PATH) -> dict:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        rows = conn.execute("SELECT key, value FROM plugin_kv WHERE plugin_name = ?", (plugin_name,)).fetchall()
+        result = {}
+        for k, v in rows:
+            try:
+                result[k] = json.loads(v)
+            except (ValueError, TypeError):
+                result[k] = v
+        return result
+
+def purge_plugin(plugin_name: str, filename=FILE_PATH) -> bool:
+    initialise(filename)
+    with _get_connection(filename) as conn:
+        with conn:
+            cursor = conn.execute("DELETE FROM plugins WHERE plugin_name = ?", (plugin_name,))
+            return cursor.rowcount > 0

flyshell/core/directory.py

@@ -0,0 +1,242 @@
+# src\flyshell\core\directory.py
+
+from flyshell.abstract.base_cmd import BaseCmd
+from flyshell.abstract.parent_cmd import ParentCmd
+from flyshell.builtin import fs, system, utils
+from flyshell.core import auth, data
+
+from datetime import datetime, timezone
+import shlex
+
+
+class Cmds(BaseCmd):
+    name = "cmds"
+    description = "List all available commands and their functions"
+    min_args = 0
+    options = None
+    aliases = ["help"]
+
+    def execute(self, args):
+        lines = ["\nAvailable Commands:"]
+        seen_cmds = set()
+        for cmd in COMMAND_REGISTRY.values():
+            if cmd in seen_cmds:
+                continue
+            seen_cmds.add(cmd)
+            cmd_label = f"{cmd.name} (alias: {', '.join(cmd.aliases)})" if cmd.aliases else cmd.name
+            if not cmd.options:
+                lines.append(f"\n{cmd_label}: {cmd.description} (Requires {cmd.min_args} parameter(s))")
+            else:
+                lines.append(f"\n{cmd_label}: {cmd.description} (Requires {cmd.min_args} parameter(s)) [args: {cmd.options}]")
+
+        lines.append(f"\nTotal available commands: {len(seen_cmds)}")
+        lines.append("Use '-h' or '--help' after any command to reveal its specific help list.")
+        lines.append("Flyshell also supports ;, && and || command chaining. Give it a go!\n")
+        return (0, "\n".join(lines))
+
+INSTALLED_COMMANDS: list[BaseCmd] = [
+    system.Cd(),
+    Cmds(),
+    utils.Clear(),
+    system.Dir(),
+    fs.Fs(),
+    utils.History(),
+    utils.Kill(),
+    auth.Lock(),
+    system.OpenFile(),
+    utils.Reboot(),
+    utils.Sleep(),
+    system.SysExe(),
+]
+COMMAND_REGISTRY: dict[str, BaseCmd] = {}
+for cmd_obj in INSTALLED_COMMANDS:
+    COMMAND_REGISTRY[cmd_obj.name] = cmd_obj
+    for alias_name in cmd_obj.aliases:
+        COMMAND_REGISTRY[alias_name] = cmd_obj
+
+def log(cmd):
+    utc_now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    data.append_history(cmd, utc_now)
+
+def _execute_single(raw_cmd: str) -> int:
+    try:
+        posix_mode = False if data.HOST_OS == "Windows" else True
+        cmd = shlex.split(raw_cmd, posix=posix_mode)
+    except ValueError as e:
+        print("\nCommand Error: Invalid syntax.")
+        print(f"Details: {e}\n")
+        return 1
+    if not cmd:
+        return 0
+    cmd_name = cmd[0]
+    args = cmd[1:]
+    if "-h" in args or "--help" in args:
+        if cmd_name in COMMAND_REGISTRY:
+            command = COMMAND_REGISTRY[cmd_name]
+            if isinstance(command, ParentCmd):
+                return command.execute(args)
+            command.help()
+            return 0
+        elif cmd_name in data.PLUGINS:
+            plugin = data.PLUGINS[cmd_name]
+            if hasattr(plugin, "help"):
+                plugin.help()
+                print()
+                return 0
+            else:
+                print(f"\nPlugin Error: Plugin '{cmd_name}' does not provide help details.\n")
+                return 1
+    if "-d" in args or "--docs" in args:
+        if cmd_name in data.PLUGINS:
+            plugin = data.PLUGINS[cmd_name]
+            if hasattr(plugin, "show_docs") and plugin.show_docs():
+                return 0
+            print(f"\nPlugin Error: Plugin '{cmd_name}' has not provided documentation.\n")
+            return 1
+    if cmd_name in COMMAND_REGISTRY:
+        command = COMMAND_REGISTRY[cmd_name]
+        if len(args) < command.min_args:
+            print(f"\nCommand Error: '{cmd_name}' requires at least {command.min_args} parameter(s).\n")
+            return 1
+        if cmd[0] != "history":
+            log(raw_cmd)
+        try:
+            result = command.execute(args)
+        except Exception as e:
+            print(f"\nCommand Error: Failed during execution of '{cmd_name}'.")
+            print(f"Details: {e}\n")
+            return 1
+        data.SESSION_CMD_COUNT += 1
+        if isinstance(result, tuple):
+            code, message = result
+            if message:
+                print(message)
+            return code
+        elif isinstance(result, int):
+            return result
+        elif isinstance(result, str):
+            if result:
+                print(result)
+            return 0
+        return 0
+    elif cmd_name in data.PLUGINS:
+        log(raw_cmd)
+        plugin = data.PLUGINS[cmd_name]
+        try:
+            result = plugin.execute(args)
+            return result if isinstance(result, int) else 0
+        except NotImplementedError:
+            print(f"\nPlugin Error: '{cmd_name}' has not implemented the execute method.\n")
+            return 1
+        except Exception as e:
+            print(f"\nPlugin Error: '{cmd_name}' crashed unexpectedly.")
+            print(f"Details: {e}")
+            print("Returning to main Flyshell interface...\n")
+            return 1
+        finally:
+            if hasattr(plugin, "on_unload"):
+                plugin.on_unload()
+    else:
+        print(f"\nCommand Error: '{cmd_name}' is not a recognised command. Use 'cmds' for help.\n")
+        return 1
+
+def _parse_commands(raw_cmd: str) -> list:
+    chain = []
+    current = []
+    in_single_quote = False
+    in_double_quote = False
+    escape = False
+    i = 0
+    n = len(raw_cmd)
+    pending_op = None
+    while i < n:
+        char = raw_cmd[i]
+        if escape:
+            current.append(char)
+            escape = False
+            i += 1
+            continue
+        is_windows = (data.HOST_OS == "Windows")
+        if char == "\\":
+            if not is_windows:
+                escape = True
+                i += 1
+                continue
+            else:
+                if i + 1 < n and raw_cmd[i + 1] in ('"', "'"):
+                    escape = True
+                    i += 1
+                    continue
+                current.append(char)
+                i += 1
+                continue
+        if char == "'" and not in_double_quote:
+            in_single_quote = not in_single_quote
+            current.append(char)
+            i += 1
+            continue
+        if char == '"' and not in_single_quote:
+            in_double_quote = not in_double_quote
+            current.append(char)
+            i += 1
+            continue
+        if not in_single_quote and not in_double_quote:
+            if raw_cmd[i:i+2] in ("&&", "||"):
+                op = raw_cmd[i:i+2]
+                cmd_str = "".join(current).strip()
+                if cmd_str:
+                    chain.append((pending_op, cmd_str))
+                pending_op = op
+                current = []
+                i += 2
+                continue
+            if char == ";":
+                cmd_str = "".join(current).strip()
+                if cmd_str:
+                    chain.append((pending_op, cmd_str))
+                pending_op = ";"
+                current = []
+                i += 1
+                continue
+        current.append(char)
+        i += 1
+    if in_single_quote or in_double_quote:
+        quote_char = "'" if in_single_quote else '"'
+        print(f"\nSyntax Error: Unclosed {quote_char} quote detected.\n")
+        return []
+    if escape:
+        print("\nSyntax Error: Dangling '\\' escape character at end of command.\n")
+        return []
+    final_cmd = "".join(current).strip()
+    if final_cmd:
+        chain.append((pending_op, final_cmd))
+    return chain
+
+def execute_line(raw_cmd: str):
+    chain = _parse_commands(raw_cmd)
+    if not chain:
+        return
+    last_code = 0
+    skipped_last = False
+    for i, (prev_op, cmd_str) in enumerate(chain):
+        should_run = True
+        if prev_op == ";":
+            should_run = True
+            skipped_last = False
+        elif skipped_last:
+            if prev_op == "&&":
+                should_run = False
+            elif prev_op == "||":
+                should_run = True
+        else:
+            if prev_op == "&&" and last_code != 0:
+                should_run = False
+            elif prev_op == "||" and last_code == 0:
+                should_run = False
+        if should_run:
+            if i > 0:
+                print("-" * 40)
+            last_code = _execute_single(cmd_str)
+            skipped_last = False
+        else:
+            skipped_last = True