flyshell 1.2.3__tar.gz → 1.2.5__tar.gz

{flyshell-1.2.3/src/flyshell.egg-info → flyshell-1.2.5}/PKG-INFO

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

{flyshell-1.2.3 → flyshell-1.2.5}/src/flyshell/abstract/base_plugin.py

@@ -12,19 +12,25 @@ 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
 
     def on_unload(self):
-        self.save_storage()
+        pass
 
     def execute(self, args: list):
         raise NotImplementedError("Plugins must implement the execute method")

{flyshell-1.2.3 → flyshell-1.2.5}/src/flyshell/constants.py

@@ -5,8 +5,8 @@ import os
 import platform
 import time
 
-BUILD = 128
-VERSION = "1.2.3"
+BUILD = 130
+VERSION = "1.2.5"
 
 
 def _resolve_app_dir() -> Path:

{flyshell-1.2.3 → flyshell-1.2.5}/src/flyshell/core/directory.py

@@ -160,6 +160,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
@@ -176,6 +186,8 @@ def _execute_single(raw_cmd: str) -> int:
         finally:
             if hasattr(plugin, "on_unload"):
                 plugin.on_unload()
+            if hasattr(plugin, "save_storage"):
+                plugin.save_storage()
     else:
         print(
             f"\nCommand Error: '{cmd_name}' is not a recognised command. Use 'cmds' for help.\n"

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

@@ -0,0 +1,40 @@
+# src\flyshell\core\env.py
+
+from flyshell import constants as c
+from pathlib import Path
+
+
+def get_env_path() -> Path:
+    return c.APP_DIR / "flyshell_keys.env"
+
+
+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
+            key, val = line.split("=", 1)
+            entries[key.strip()] = val.strip().strip("\"'")
+        return entries
+
+
+def get_plugin_api_keys(plugin_dir_name: str) -> dict[str, str]:
+    all_env = read_env_file()
+    prefix = f"{plugin_dir_name}_".lower()
+    plugin_keys = {}
+    for raw_k, val in all_env.items():
+        if raw_k.lower().startswith(prefix):
+            key_name = raw_k[len(prefix) :]
+            plugin_keys[key_name] = val
+    return plugin_keys

{flyshell-1.2.3 → flyshell-1.2.5}/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.3 → flyshell-1.2.5/src/flyshell.egg-info}/PKG-INFO

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

{flyshell-1.2.3 → flyshell-1.2.5}/src/flyshell.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ 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_security.py

flyshell-1.2.5/tests/test_env_keys.py

@@ -0,0 +1,115 @@
+# 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

flyshell-1.2.3/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()