flyshell 1.2.4__tar.gz → 1.2.6__tar.gz

{flyshell-1.2.4/src/flyshell.egg-info → flyshell-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flyshell
-Version: 1.2.4
+Version: 1.2.6
 Summary: A modular, zero-dependency command-line environment in Python.
 License: MIT
 Requires-Python: >=3.10

{flyshell-1.2.4 → flyshell-1.2.6}/src/flyshell/abstract/base_plugin.py

@@ -12,14 +12,20 @@ class BasePlugin:
     identifier: str = ""
     usage: str = ""
     extended_help: str = ""
-    requires_api = False
+    requires_api: bool = False
+    api_keys: list = []
 
     def __init__(self, context: dict):
         self.context = context
         self.plugin_name = context.get("plugin_name", self.name)
         self.storage = context.get("storage", {})
+        self.api_keys_data = context.get("api_keys", {})
+        self.env_file_path = context.get("env_path", None)
         self.on_load()
 
+    def get_api_key(self, key_name: str, default=None):
+        return self.api_keys_data.get(key_name, default)
+
     def on_load(self):
         pass
 

flyshell-1.2.6/src/flyshell/builtin/pkg.py

@@ -0,0 +1,33 @@
+# src\flyshell\builtin\pkg.py
+
+from typing import List, Tuple
+from flyshell.abstract.base_cmd import BaseCmd
+from flyshell.abstract.parent_cmd import ParentCmd
+from flyshell.core import env
+
+
+class PkgApi(BaseCmd):
+    name: str = "api"
+    description: str = "View configured package/plugin API keys"
+    min_args: int = 0
+    options: str = "Package name"
+    aliases: List[str] = ["keys"]
+
+    def execute(self, args: List[str]) -> Tuple[int, str]:
+        if not args:
+            code, output = env.get_all_keys()
+        else:
+            package_name = args[0]
+            code, output = env.get_plugin_keys_formatted(package_name)
+        return (code, f"\n{output}\n")
+
+
+class Pkg(ParentCmd):
+    name: str = "pkg"
+    description: str = "Manage Flyshell packages, plugins, and dependencies"
+    aliases: List[str] = ["package"]
+
+    def get_subcommands(self) -> List[BaseCmd]:
+        return [
+            PkgApi(),
+        ]

{flyshell-1.2.4 → flyshell-1.2.6}/src/flyshell/constants.py

@@ -5,8 +5,8 @@ import os
 import platform
 import time
 
-BUILD = 129
-VERSION = "1.2.4"
+BUILD = 131
+VERSION = "1.2.6"
 
 
 def _resolve_app_dir() -> Path:
@@ -53,6 +53,7 @@ REQUIRED_COMPONENTS = [
     "builtin",
     "builtin/diskops.py",
     "builtin/fs.py",
+    "builtin/pkg.py",
     "builtin/system.py",
     "builtin/utils.py",
     "constants.py",

{flyshell-1.2.4 → flyshell-1.2.6}/src/flyshell/core/directory.py

@@ -3,7 +3,7 @@
 from flyshell import constants as c
 from flyshell.abstract.base_cmd import BaseCmd
 from flyshell.abstract.parent_cmd import ParentCmd
-from flyshell.builtin import diskops, fs, system, utils
+from flyshell.builtin import diskops, fs, pkg, system, utils
 from flyshell.core import auth, data
 
 from datetime import datetime, timezone
@@ -64,6 +64,7 @@ INSTALLED_COMMANDS: list[BaseCmd] = [
     diskops.MkDir(),
     diskops.Move(),
     system.OpenFile(),
+    pkg.Pkg(),
     utils.Reboot(),
     diskops.Rename(),
     diskops.Rm(),
@@ -160,6 +161,16 @@ def _execute_single(raw_cmd: str) -> int:
     elif cmd_name in c.PLUGINS:
         log(raw_cmd)
         plugin = c.PLUGINS[cmd_name]
+        required_keys = getattr(plugin, "api_keys", [])
+        available_keys = getattr(plugin, "api_keys_data", {})
+        missing = [k for k in required_keys if k not in available_keys]
+        if missing:
+            env_path = getattr(plugin, "env_file_path", "flyshell_keys.env")
+            print(
+                f"\nPlugin Error: Cannot execute '{cmd_name}'. Missing required API key(s): {', '.join(missing)}"
+            )
+            print(f"Define them in {env_path} and retry.\n")
+            return 1
         try:
             result = plugin.execute(args)
             return result if isinstance(result, int) else 0

flyshell-1.2.6/src/flyshell/core/env.py

@@ -0,0 +1,129 @@
+# src/flyshell/core/env.py
+
+from pathlib import Path
+from flyshell import constants as c
+
+
+def get_env_path() -> Path:
+    primary = c.APP_DIR / "flyshell_keys.env"
+    if primary.exists():
+        return primary
+    fallback = c.APP_DIR / ".env"
+    if fallback.exists():
+        return fallback
+    return primary
+
+
+def create_env():
+    env_path = get_env_path()
+    if not env_path.exists():
+        env_path.touch()
+
+
+def read_env_file() -> dict[str, str]:
+    env_path = get_env_path()
+    if not env_path.exists():
+        return {}
+    entries = {}
+    with open(env_path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            raw_k, raw_v = line.split("=", 1)
+            clean_k = raw_k.strip().replace("[", "").replace("]", "")
+            clean_v = raw_v.strip().strip("\"'").replace("[", "").replace("]", "")
+            if clean_k:
+                entries[clean_k] = clean_v
+    return entries
+
+
+def _resolve_plugin_dir_name(target_name: str) -> tuple[str, object | None]:
+    """Resolves an identifier, display name, or dir name to (dir_name, plugin_instance)."""
+    target_lower = target_name.strip().lower()
+    if hasattr(c, "PLUGINS"):
+        if target_lower in c.PLUGINS:
+            plugin = c.PLUGINS[target_lower]
+            dir_name = plugin.context.get("plugin_dir_name") or target_lower
+            dir_name = (
+                Path(dir_name).stem
+                if "\\" in str(dir_name) or "/" in str(dir_name)
+                else str(dir_name)
+            )
+            return (dir_name, plugin)
+        for cmd_name, plugin in c.PLUGINS.items():
+            p_display = getattr(plugin, "name", "").lower()
+            p_dir = str(plugin.context.get("plugin_dir_name", "")).lower()
+            p_dir_clean = Path(p_dir).stem
+            if target_lower in (cmd_name.lower(), p_display, p_dir, p_dir_clean):
+                resolved_dir = plugin.context.get("plugin_dir_name") or cmd_name
+                resolved_dir = (
+                    Path(resolved_dir).stem
+                    if "\\" in str(resolved_dir) or "/" in str(resolved_dir)
+                    else str(resolved_dir)
+                )
+                return (resolved_dir, plugin)
+    return (target_name.strip(), None)
+
+
+def get_plugin_api_keys(plugin_name_or_dir: str) -> dict[str, str]:
+    all_env = read_env_file()
+    dir_name, _ = _resolve_plugin_dir_name(plugin_name_or_dir)
+    prefixes = {
+        f"{dir_name.lower()}_",
+        f"{plugin_name_or_dir.strip().lower()}_",
+    }
+    plugin_keys = {}
+    for raw_k, val in all_env.items():
+        k_lower = raw_k.lower()
+        for prefix in prefixes:
+            if k_lower.startswith(prefix):
+                key_name = raw_k[len(prefix) :]
+                plugin_keys[key_name] = val
+                break
+    return plugin_keys
+
+
+def get_all_keys() -> tuple[int, str]:
+    """Retrieve and display all configured API keys in the environment."""
+    env_path = get_env_path()
+    if not env_path.exists():
+        return (1, f"File Config Error: Environment file not found at '{env_path}'.")
+    try:
+        all_env = read_env_file()
+        if not all_env:
+            return (0, "No API keys configured.")
+        lines = ["Configured API keys:"]
+        for k, v in sorted(all_env.items()):
+            lines.append(f"{k} = {v}")
+        return (0, "\n".join(lines))
+    except Exception as e:
+        return (1, f"File Error: An unknown error occurred: {e}")
+
+
+def get_plugin_keys_formatted(target_name: str) -> tuple[int, str]:
+    if not target_name or not isinstance(target_name, str):
+        return (1, "Command Error: A valid plugin name must be provided.")
+    env_path = get_env_path()
+    if not env_path.exists():
+        return (1, f"File Config Error: Environment file not found at '{env_path}'.")
+    dir_name, plugin = _resolve_plugin_dir_name(target_name)
+    configured_keys = get_plugin_api_keys(target_name)
+    required_keys = getattr(plugin, "api_keys", []) if plugin else []
+    if not configured_keys and not required_keys:
+        return (0, f"No API keys found or required for plugin '{target_name}'.")
+    lines = [f"API Keys for plugin '{target_name}' (folder: '{dir_name}'):"]
+    lower_configured = {k.lower(): (k, v) for k, v in configured_keys.items()}
+    seen_keys = set()
+    for req in required_keys:
+        req_lower = req.lower()
+        seen_keys.add(req_lower)
+        if req_lower in lower_configured:
+            orig_k, val = lower_configured[req_lower]
+            lines.append(f"{orig_k} = {val} [Required]")
+        else:
+            lines.append(f"{req} = [MISSING / NOT SET] [Required]")
+    for k_lower, (orig_k, val) in sorted(lower_configured.items()):
+        if k_lower not in seen_keys:
+            lines.append(f"{orig_k} = {val} [Optional/Extra]")
+    return (0, "\n".join(lines))

{flyshell-1.2.4 → flyshell-1.2.6}/src/flyshell/core/loader.py

@@ -2,7 +2,7 @@
 
 from flyshell import constants as c
 from flyshell.abstract.base_plugin import BasePlugin
-from flyshell.core import data
+from flyshell.core import data, env
 from flyshell.core.directory import RESERVED_NAMES
 
 from pathlib import Path
@@ -50,15 +50,24 @@ def scan_plugins(plugin_folder=None):
             for _, obj in inspect.getmembers(module, inspect.isclass):
                 if issubclass(obj, BasePlugin) and obj is not BasePlugin:
                     resolved_name = getattr(obj, "identifier", None) or default_name
-
-                    # Also verify the resolved identifier doesn't conflict with a reserved name
                     if resolved_name in RESERVED_NAMES:
                         print(
                             f"\n⚠️ Collision Error - Plugin '{resolved_name}' conflicts with a built-in Flyshell command and will not be loaded."
                         )
                         break
-
-                    ctx = build_context(resolved_name, file_path)
+                    ctx = build_context(resolved_name, default_name, file_path)
+                    required_keys = getattr(obj, "api_keys", [])
+                    found_keys = ctx["api_keys"]
+                    missing_keys = [k for k in required_keys if k not in found_keys]
+                    if missing_keys:
+                        env_file = ctx["env_path"]
+                        print(
+                            f"\n⚠️ API Key Error - Plugin '{resolved_name}' is missing required key(s): {', '.join(missing_keys)}"
+                        )
+                        print(f"Please define them in: {env_file} as:")
+                        for mk in missing_keys:
+                            print(f"{default_name}_{mk}=<your_key>")
+                        break
                     instance = obj(ctx)
                     candidates.setdefault(resolved_name, []).append(
                         (instance, file_path)
@@ -92,11 +101,15 @@ def scan_plugins(plugin_folder=None):
         print("\nNo plugins loaded.")
 
 
-def build_context(plugin_name, file_path=None):
+def build_context(plugin_name, default_name, file_path=None):
     plugin_storage = data.get_all_plugin_data(plugin_name)
+    api_keys = env.get_plugin_api_keys(str(default_name))
     context = {
         "plugin_name": plugin_name,
+        "plugin_dir_name": str(default_name),
         "file_path": str(file_path) if file_path else None,
+        "env_path": str(env.get_env_path()),
+        "api_keys": api_keys,
         "metadata": {"host_os": c.HOST_OS, "version": c.VERSION, "build": c.BUILD},
         "storage": plugin_storage,
     }

{flyshell-1.2.4 → flyshell-1.2.6/src/flyshell.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flyshell
-Version: 1.2.4
+Version: 1.2.6
 Summary: A modular, zero-dependency command-line environment in Python.
 License: MIT
 Requires-Python: >=3.10

{flyshell-1.2.4 → flyshell-1.2.6}/src/flyshell.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/flyshell/abstract/parent_cmd.py
 src/flyshell/builtin/__init__.py
 src/flyshell/builtin/diskops.py
 src/flyshell/builtin/fs.py
+src/flyshell/builtin/pkg.py
 src/flyshell/builtin/system.py
 src/flyshell/builtin/utils.py
 src/flyshell/core/__init__.py
@@ -30,7 +31,9 @@ tests/test_auth.py
 tests/test_data.py
 tests/test_directory.py
 tests/test_diskops.py
+tests/test_env_keys.py
 tests/test_fs.py
 tests/test_loader.py
+tests/test_pkg.py
 tests/test_security.py
 tests/test_utils.py

flyshell-1.2.6/tests/test_env_keys.py

@@ -0,0 +1,153 @@
+# tests\test_env_keys.py
+
+# tests/test_env_api_keys.py
+
+from flyshell import constants as c
+from flyshell.abstract.base_plugin import BasePlugin
+from flyshell.core import directory, env, loader
+
+import pytest
+
+
+@pytest.fixture
+def mock_env_file(tmp_path, monkeypatch):
+    """Sets up a temporary flyshell_keys.env and points env/c.APP_DIR to it."""
+    env_file = tmp_path / "flyshell_keys.env"
+    monkeypatch.setattr(c, "APP_DIR", tmp_path)
+    monkeypatch.setattr(env, "get_env_path", lambda: env_file)
+    return env_file
+
+
+def test_env_read_and_key_parsing(mock_env_file):
+    mock_env_file.write_text(
+        "# Comments should be ignored\n"
+        "sample_api_token=secret_123\n"
+        'sample_secondary_key="another_val"\n'
+        "otherplugin_key=val\n"
+        "invalid_line_without_equals\n"
+    )
+    keys = env.get_plugin_api_keys("sample")
+    assert keys == {
+        "api_token": "secret_123",
+        "secondary_key": "another_val",
+    }
+    assert "key" not in keys
+
+
+def test_extra_keys_are_included(mock_env_file):
+    mock_env_file.write_text(
+        "myplug_required_one=abc\n"
+        "myplug_bonus_feature=xyz\n"
+        "myplug_third_param=12345\n"
+    )
+    keys = env.get_plugin_api_keys("myplug")
+    assert keys == {
+        "required_one": "abc",
+        "bonus_feature": "xyz",
+        "third_param": "12345",
+    }
+
+
+def test_loader_populates_context_correctly(tmp_path, mock_env_file, monkeypatch):
+    mock_env_file.write_text("dummy_token=token123\n")
+    plugin_file = tmp_path / "dummy.py"
+    plugin_file.write_text(
+        "from flyshell.abstract.base_plugin import BasePlugin\n"
+        "class DummyPlugin(BasePlugin):\n"
+        "    api_keys = ['token']\n"
+        "    def execute(self, args): return 0\n"
+    )
+    monkeypatch.setattr(c, "USER_PLUGIN_DIR", tmp_path)
+    loader.scan_plugins(plugin_folder=tmp_path)
+    assert "dummy" in c.PLUGINS
+    plugin = c.PLUGINS["dummy"]
+    assert plugin.context["plugin_name"] == "dummy"
+    assert plugin.context["plugin_dir_name"] == "dummy"
+    assert plugin.context["file_path"] == str(plugin_file)
+    assert plugin.context["env_path"] == str(mock_env_file)
+    assert plugin.api_keys_data == {"token": "token123"}
+    assert plugin.get_api_key("token") == "token123"
+
+
+def test_loader_rejects_plugin_with_missing_keys(
+    tmp_path, mock_env_file, monkeypatch, capsys
+):
+    mock_env_file.write_text("needkey_first=val1\n")
+    plugin_file = tmp_path / "needkey.py"
+    plugin_file.write_text(
+        "from flyshell.abstract.base_plugin import BasePlugin\n"
+        "class NeedKeyPlugin(BasePlugin):\n"
+        "    api_keys = ['first', 'second']\n"
+        "    def execute(self, args): return 0\n"
+    )
+    monkeypatch.setattr(c, "USER_PLUGIN_DIR", tmp_path)
+    loader.scan_plugins(plugin_folder=tmp_path)
+    assert "needkey" not in c.PLUGINS
+    out = capsys.readouterr().out
+    assert "API Key Error" in out
+    assert "second" in out
+
+
+def test_directory_execute_fallback_when_keys_missing(
+    mock_env_file, monkeypatch, capsys
+):
+    class IncompletePlugin(BasePlugin):
+        api_keys = ["secret_key"]
+        executed = False
+
+        def execute(self, args):
+            self.executed = True
+            return 0
+
+    ctx = {
+        "plugin_name": "broken_keys",
+        "plugin_dir_name": "broken_keys",
+        "file_path": None,
+        "env_path": str(mock_env_file),
+        "api_keys": {},
+    }
+    instance = IncompletePlugin(ctx)
+    monkeypatch.setitem(c.PLUGINS, "broken_keys", instance)
+    exit_code = directory._execute_single("broken_keys")
+    assert exit_code == 1
+    assert instance.executed is False
+    out = capsys.readouterr().out
+    assert "Missing required API key(s): secret_key" in out
+
+
+def test_get_all_keys_success(mock_env_file):
+    mock_env_file.write_text("pluginA_token=123\npluginB_secret=xyz\n")
+    code, output = env.get_all_keys()
+    assert code == 0
+    assert "pluginA_token = 123" in output
+    assert "pluginB_secret = xyz" in output
+
+
+def test_get_all_keys_empty_file(mock_env_file):
+    mock_env_file.write_text("")
+    code, output = env.get_all_keys()
+    assert code == 0
+    assert "No API keys configured." in output
+
+
+def test_get_all_keys_missing_file(tmp_path, monkeypatch):
+    missing_path = tmp_path / "does_not_exist.env"
+    monkeypatch.setattr(env, "get_env_path", lambda: missing_path)
+    code, output = env.get_all_keys()
+    assert code == 1
+    assert "Environment file not found" in output
+
+
+def test_get_plugin_keys_formatted_success(mock_env_file):
+    mock_env_file.write_text("weather_api_key=token123\nweather_units=metric\n")
+    code, output = env.get_plugin_keys_formatted("weather")
+    assert code == 0
+    assert "weather" in output
+    assert "api_key = token123" in output
+    assert "units = metric" in output
+
+
+def test_get_plugin_keys_formatted_invalid_input():
+    code, output = env.get_plugin_keys_formatted("")
+    assert code == 1
+    assert "valid plugin name" in output

flyshell-1.2.6/tests/test_pkg.py

@@ -0,0 +1,50 @@
+# tests/test_pkg.py
+
+from flyshell import constants as c
+from flyshell.builtin import pkg
+from flyshell.core import env
+
+import pytest
+
+
+@pytest.fixture
+def mock_env_file(tmp_path, monkeypatch):
+    c.PLUGINS.clear()
+    env_file = tmp_path / "flyshell_keys.env"
+    monkeypatch.setattr(c, "APP_DIR", tmp_path)
+    monkeypatch.setattr(env, "get_env_path", lambda: env_file)
+    yield env_file
+    c.PLUGINS.clear()
+
+
+def test_pkg_dispatches_help_on_empty_args(capsys):
+    parent = pkg.Pkg()
+    code, msg = parent.execute([])
+    assert code == 0
+    out = capsys.readouterr().out
+    assert "Command Family: pkg" in out
+    assert "api (alias: keys)" in out
+
+
+def test_pkg_unknown_subcommand():
+    parent = pkg.Pkg()
+    code, msg = parent.execute(["unknown_cmd"])
+    assert code == 1
+    assert "Unknown subcommand 'unknown_cmd'" in msg
+
+
+def test_pkg_api_all_keys(mock_env_file):
+    mock_env_file.write_text("dummy_token=123\n")
+    parent = pkg.Pkg()
+    code, msg = parent.execute(["api"])
+    assert code == 0
+    assert "dummy_token = 123" in msg
+
+
+def test_pkg_api_plugin_keys(mock_env_file):
+    mock_env_file.write_text("weather_key=secret\nother_key=skip\n")
+    parent = pkg.Pkg()
+    code, msg = parent.execute(["api", "weather"])
+    assert code == 0
+    assert "key = secret" in msg
+    assert "other_key" not in msg

flyshell-1.2.4/src/flyshell/core/env.py

@@ -1,9 +0,0 @@
-# src\flyshell\core\env.py
-
-from flyshell import constants as c
-
-
-def create_env():
-    env_path = c.APP_DIR / "flyshell_keys.env"
-    if not env_path.exists():
-        env_path.touch()