llms-py 3.0.0b1__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

llms/main.py

@@ -9,18 +9,20 @@
 import argparse
 import asyncio
 import base64
-from datetime import datetime
 import hashlib
+import importlib.util
 import json
 import mimetypes
 import os
 import re
 import secrets
+import shutil
 import site
 import subprocess
 import sys
 import time
 import traceback
+from datetime import datetime
 from importlib import resources  # Py≥3.9  (pip install importlib_resources for 3.7/3.8)
 from io import BytesIO
 from pathlib import Path
@@ -36,8 +38,9 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.0b1"
+VERSION = "3.0.0b2"
 _ROOT = None
+DEBUG = True  # os.getenv("PYPI_SERVICESTACK") is not None
 g_config_path = None
 g_ui_path = None
 g_config = None
@@ -48,14 +51,25 @@ g_logprefix = ""
 g_default_model = ""
 g_sessions = {}  # OAuth session storage: {session_token: {userId, userName, displayName, profileUrl, email, created}}
 g_oauth_states = {}  # CSRF protection: {state: {created, redirect_uri}}
+g_app = None  # ExtensionsContext Singleton
 
 
 def _log(message):
-    """Helper method for logging from the global polling task."""
     if g_verbose:
         print(f"{g_logprefix}{message}", flush=True)
 
 
+def _dbg(message):
+    if DEBUG:
+        print(f"DEBUG: {message}", flush=True)
+
+
+def _err(message, e):
+    print(f"ERROR: {message}: {e}", flush=True)
+    if g_verbose:
+        print(traceback.format_exc(), flush=True)
+
+
 def printdump(obj):
     args = obj.__dict__ if hasattr(obj, "__dict__") else obj
     print(json.dumps(args, indent=2))
@@ -581,55 +595,6 @@ class OpenAiCompatible:
             return self.provider_model(last_part)
         return None
 
-    def validate_modalities(self, chat):
-        model_id = chat.get("model")
-        if not model_id or not self.models:
-            return
-
-        model_info = None
-        # Try to find model info using provider_model logic (already resolved to ID)
-        if model_id in self.models:
-            model_info = self.models[model_id]
-        else:
-            # Fallback scan
-            for m_id, m_info in self.models.items():
-                if m_id == model_id or m_info.get("id") == model_id:
-                    model_info = m_info
-                    break
-
-        print(f"DEBUG: Validate modalities: model={model_id}, found_info={model_info is not None}")
-        if model_info:
-            print(f"DEBUG: Modalities: {model_info.get('modalities')}")
-
-        if not model_info:
-            return
-
-        modalities = model_info.get("modalities", {})
-        input_modalities = modalities.get("input", [])
-
-        # Check for unsupported modalities
-        has_audio = False
-        has_image = False
-        for message in chat.get("messages", []):
-            content = message.get("content")
-            if isinstance(content, list):
-                for item in content:
-                    type_ = item.get("type")
-                    if type_ == "input_audio" or "input_audio" in item:
-                        has_audio = True
-                    elif type_ == "image_url" or "image_url" in item:
-                        has_image = True
-
-        if has_audio and "audio" not in input_modalities:
-            raise Exception(
-                f"Model '{model_id}' does not support audio input. Supported modalities: {', '.join(input_modalities)}"
-            )
-
-        if has_image and "image" not in input_modalities:
-            raise Exception(
-                f"Model '{model_id}' does not support image input. Supported modalities: {', '.join(input_modalities)}"
-            )
-
     def to_response(self, response, chat, started_at):
         if "metadata" not in response:
             response["metadata"] = {}
@@ -644,8 +609,6 @@ class OpenAiCompatible:
     async def chat(self, chat):
         chat["model"] = self.provider_model(chat["model"]) or chat["model"]
 
-        self.validate_modalities(chat)
-
         # with open(os.path.join(os.path.dirname(__file__), 'chat.wip.json'), "w") as f:
         #     f.write(json.dumps(chat, indent=2))
 
@@ -941,11 +904,10 @@ class OllamaProvider(OpenAiCompatible):
                 ) as response:
                     data = await response_json(response)
                     for model in data.get("models", []):
-                        name = model["model"]
-                        if name.endswith(":latest"):
-                            name = name[:-7]
-                        model_id = name.replace(":", "-")
-                        ret[model_id] = name
+                        model_id = model["model"]
+                        if model_id.endswith(":latest"):
+                            model_id = model_id[:-7]
+                        ret[model_id] = model_id
                     _log(f"Loaded Ollama models: {ret}")
         except Exception as e:
             _log(f"Error getting Ollama models: {e}")
@@ -1228,20 +1190,6 @@ class GoogleProvider(OpenAiCompatible):
             return self.to_response(response, chat, started_at)
 
 
-ALL_PROVIDERS = [
-    OpenAiCompatible,
-    OpenAiProvider,
-    AnthropicProvider,
-    MistralProvider,
-    GroqProvider,
-    XaiProvider,
-    CodestralProvider,
-    GoogleProvider,
-    OllamaProvider,
-    LMStudioProvider,
-]
-
-
 def get_provider_model(model_name):
     for provider in g_handlers.values():
         provider_model = provider.provider_model(model_name)
@@ -1487,7 +1435,7 @@ def create_provider(provider):
         _log(f"Provider {provider_label} is missing 'npm' sdk")
         return None
 
-    for provider_type in ALL_PROVIDERS:
+    for provider_type in g_app.all_providers:
         if provider_type.sdk == npm_sdk:
             kwargs = create_provider_kwargs(provider)
             return provider_type(**kwargs)
@@ -2059,8 +2007,240 @@ async def watch_config_files(config_path, ui_path, interval=1):
                 pass
 
 
+def get_session_token(request):
+    return request.query.get("session") or request.headers.get("X-Session-Token") or request.cookies.get("llms-token")
+
+
+class AppExtensions:
+    """
+    APIs extensions can use to extend the app
+    """
+
+    def __init__(self, cli_args, extra_args):
+        self.cli_args = cli_args
+        self.extra_args = extra_args
+        self.ui_extensions = []
+        self.chat_request_filters = []
+        self.chat_response_filters = []
+        self.server_add_get = []
+        self.server_add_post = []
+        self.all_providers = [
+            OpenAiCompatible,
+            OpenAiProvider,
+            AnthropicProvider,
+            MistralProvider,
+            GroqProvider,
+            XaiProvider,
+            CodestralProvider,
+            GoogleProvider,
+            OllamaProvider,
+            LMStudioProvider,
+        ]
+
+
+class ExtensionContext:
+    def __init__(self, app, path):
+        self.app = app
+        self.path = path
+        self.name = os.path.basename(path)
+        self.ext_prefix = f"/ext/{self.name}"
+
+    def log(self, message):
+        print(f"[{self.name}] {message}", flush=True)
+
+    def dbg(self, message):
+        if DEBUG:
+            print(f"DEBUG [{self.name}]: {message}", flush=True)
+
+    def err(self, message, e):
+        print(f"ERROR [{self.name}]: {message}", e)
+        if g_verbose:
+            print(traceback.format_exc(), flush=True)
+
+    def add_provider(self, provider):
+        self.log(f"Registered provider: {provider}")
+        self.app.all_providers.append(provider)
+
+    def register_ui_extension(self, index):
+        path = os.path.join(self.ext_prefix, index)
+        self.log(f"Registered UI extension: {path}")
+        self.app.ui_extensions.append({"id": self.name, "path": path})
+
+    def register_chat_request_filter(self, handler):
+        self.log(f"Registered chat request filter: {handler}")
+        self.app.chat_request_filters.append(handler)
+
+    def register_chat_response_filter(self, handler):
+        self.log(f"Registered chat response filter: {handler}")
+        self.app.chat_response_filters.append(handler)
+
+    def add_static_files(self, ext_dir):
+        self.log(f"Registered static files: {ext_dir}")
+
+        async def serve_static(request):
+            path = request.match_info["path"]
+            file_path = os.path.join(ext_dir, path)
+            if os.path.exists(file_path):
+                return web.FileResponse(file_path)
+            return web.Response(status=404)
+
+        self.app.server_add_get.append((os.path.join(self.ext_prefix, "{path:.*}"), serve_static, {}))
+
+    def add_get(self, path, handler, **kwargs):
+        self.dbg(f"Registered GET: {os.path.join(self.ext_prefix, path)}")
+        self.app.server_add_get.append((os.path.join(self.ext_prefix, path), handler, kwargs))
+
+    def add_post(self, path, handler, **kwargs):
+        self.dbg(f"Registered POST: {os.path.join(self.ext_prefix, path)}")
+        self.app.server_add_post.append((os.path.join(self.ext_prefix, path), handler, kwargs))
+
+    def get_config(self):
+        return g_config
+
+    def chat_completion(self, chat):
+        return chat_completion(chat)
+
+    def get_providers(self):
+        return g_handlers
+
+    def get_provider(self, name):
+        return g_handlers.get(name)
+
+    def get_session(self, request):
+        session_token = get_session_token(request)
+
+        if not session_token or session_token not in g_sessions:
+            return None
+
+        session_data = g_sessions[session_token]
+        return session_data
+
+    def get_username(self, request):
+        session = self.get_session(request)
+        if session:
+            return session.get("userName")
+        return None
+
+
+def get_extensions_path():
+    return os.path.join(Path.home(), ".llms", "extensions")
+
+
+def init_extensions(parser):
+    extensions_path = get_extensions_path()
+    os.makedirs(extensions_path, exist_ok=True)
+
+    for item in os.listdir(extensions_path):
+        item_path = os.path.join(extensions_path, item)
+        if os.path.isdir(item_path):
+            try:
+                # check for __parser__ function if exists in __init.__.py and call it with parser
+                init_file = os.path.join(item_path, "__init__.py")
+                if os.path.exists(init_file):
+                    spec = importlib.util.spec_from_file_location(item, init_file)
+                    if spec and spec.loader:
+                        module = importlib.util.module_from_spec(spec)
+                        sys.modules[item] = module
+                        spec.loader.exec_module(module)
+
+                        parser_func = getattr(module, "__parser__", None)
+                        if callable(parser_func):
+                            parser_func(parser)
+                            _log(f"Extension {item} parser loaded")
+            except Exception as e:
+                _err(f"Failed to load extension {item} parser", e)
+
+
+def install_extensions():
+    """
+    Scans ensure ~/.llms/extensions/ for directories with __init__.py and loads them as extensions.
+    Calls the `__install__(ctx)` function in the extension module.
+    """
+    extensions_path = get_extensions_path()
+    os.makedirs(extensions_path, exist_ok=True)
+
+    ext_count = len(os.listdir(extensions_path))
+    if ext_count == 0:
+        _log("No extensions found")
+        return
+
+    _log(f"Installing {ext_count} extension{'' if ext_count == 1 else 's'}...")
+
+    sys.path.append(extensions_path)
+
+    for item in os.listdir(extensions_path):
+        item_path = os.path.join(extensions_path, item)
+        if os.path.isdir(item_path):
+            init_file = os.path.join(item_path, "__init__.py")
+            if os.path.exists(init_file):
+                ctx = ExtensionContext(g_app, item_path)
+                try:
+                    spec = importlib.util.spec_from_file_location(item, init_file)
+                    if spec and spec.loader:
+                        module = importlib.util.module_from_spec(spec)
+                        sys.modules[item] = module
+                        spec.loader.exec_module(module)
+
+                        install_func = getattr(module, "__install__", None)
+                        if callable(install_func):
+                            install_func(ctx)
+                            _log(f"Extension {item} installed")
+                        else:
+                            _dbg(f"Extension {item} has no __install__ function")
+                    else:
+                        _dbg(f"Extension {item} has no __init__.py")
+
+                    # if ui folder exists, serve as static files at /ext/{item}/
+                    ui_path = os.path.join(item_path, "ui")
+                    if os.path.exists(ui_path):
+                        ctx.add_static_files(ui_path)
+
+                        # Register UI extension if index.mjs exists (/ext/{item}/index.mjs)
+                        if os.path.exists(os.path.join(ui_path, "index.mjs")):
+                            ctx.register_ui_extension("index.mjs")
+
+                except Exception as e:
+                    _err(f"Failed to install extension {item}", e)
+            else:
+                _dbg(f"Extension {init_file} not found")
+        else:
+            _dbg(f"Extension {item} not found: {item_path} is not a directory {os.path.exists(item_path)}")
+
+
+def run_extension_cli():
+    """
+    Run the CLI for an extension.
+    """
+    extensions_path = get_extensions_path()
+    os.makedirs(extensions_path, exist_ok=True)
+
+    for item in os.listdir(extensions_path):
+        item_path = os.path.join(extensions_path, item)
+        if os.path.isdir(item_path):
+            init_file = os.path.join(item_path, "__init__.py")
+            if os.path.exists(init_file):
+                ctx = ExtensionContext(g_app, item_path)
+                try:
+                    spec = importlib.util.spec_from_file_location(item, init_file)
+                    if spec and spec.loader:
+                        module = importlib.util.module_from_spec(spec)
+                        sys.modules[item] = module
+                        spec.loader.exec_module(module)
+
+                    # Check for __run__ function if exists in __init__.py and call it with ctx
+                    run_func = getattr(module, "__run__", None)
+                    if callable(run_func):
+                        handled = run_func(ctx)
+                        _log(f"Extension {item} was run")
+                        return handled
+
+                except Exception as e:
+                    _err(f"Failed to run extension {item}", e)
+                    return False
+
+
 def main():
-    global _ROOT, g_verbose, g_default_model, g_logprefix, g_providers, g_config, g_config_path, g_ui_path
+    global _ROOT, g_verbose, g_default_model, g_logprefix, g_providers, g_config, g_config_path, g_ui_path, g_app
 
     parser = argparse.ArgumentParser(description=f"llms v{VERSION}")
     parser.add_argument("--config", default=None, help="Path to config file", metavar="FILE")
@@ -2102,8 +2282,30 @@ def main():
     parser.add_argument("--logprefix", default="", help="Prefix used in log messages", metavar="PREFIX")
     parser.add_argument("--verbose", action="store_true", help="Verbose output")
 
+    parser.add_argument(
+        "--add",
+        nargs="?",
+        const="ls",
+        default=None,
+        help="Install an extension (lists available extensions if no name provided)",
+        metavar="EXTENSION",
+    )
+    parser.add_argument(
+        "--remove",
+        nargs="?",
+        const="ls",
+        default=None,
+        help="Remove an extension (lists installed extensions if no name provided)",
+        metavar="EXTENSION",
+    )
+
+    # Load parser extensions, go through all extensions and load their parser arguments
+    init_extensions(parser)
+
     cli_args, extra_args = parser.parse_known_args()
 
+    g_app = AppExtensions(cli_args, extra_args)
+
     # Check for verbose mode from CLI argument or environment variables
     verbose_env = os.environ.get("VERBOSE", "").lower()
     if cli_args.verbose or verbose_env in ("1", "true"):
@@ -2187,8 +2389,105 @@ def main():
         print(f"Updated {home_providers_path}")
         exit(0)
 
+    if cli_args.add is not None:
+        if cli_args.add == "ls":
+
+            async def list_extensions():
+                print("\nAvailable extensions:")
+                text = await get_text("https://api.github.com/orgs/llmspy/repos?per_page=100&sort=updated")
+                repos = json.loads(text)
+                max_name_length = 0
+                for repo in repos:
+                    max_name_length = max(max_name_length, len(repo["name"]))
+
+                for repo in repos:
+                    print(f"  {repo['name']:<{max_name_length + 2}} {repo['description']}")
+
+                print("\nUsage:")
+                print("  llms --add <extension>")
+                print("  llms --add <github-user>/<repo>")
+
+            asyncio.run(list_extensions())
+            exit(0)
+
+        async def install_extension(name):
+            # Determine git URL and target directory name
+            if "/" in name:
+                git_url = f"https://github.com/{name}"
+                target_name = name.split("/")[-1]
+            else:
+                git_url = f"https://github.com/llmspy/{name}"
+                target_name = name
+
+            # check extension is not already installed
+            extensions_path = get_extensions_path()
+            target_path = os.path.join(extensions_path, target_name)
+
+            if os.path.exists(target_path):
+                print(f"Extension {target_name} is already installed at {target_path}")
+                return
+
+            print(f"Installing extension: {name}")
+            print(f"Cloning from {git_url} to {target_path}...")
+
+            try:
+                subprocess.run(["git", "clone", git_url, target_path], check=True)
+
+                # Check for requirements.txt
+                requirements_path = os.path.join(target_path, "requirements.txt")
+                if os.path.exists(requirements_path):
+                    print(f"Installing dependencies from {requirements_path}...")
+                    subprocess.run(
+                        [sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], cwd=target_path, check=True
+                    )
+                    print("Dependencies installed successfully.")
+
+                print(f"Extension {target_name} installed successfully.")
+
+            except subprocess.CalledProcessError as e:
+                print(f"Failed to install extension: {e}")
+                # cleanup if clone failed but directory was created (unlikely with simple git clone but good practice)
+                if os.path.exists(target_path) and not os.listdir(target_path):
+                    os.rmdir(target_path)
+
+        asyncio.run(install_extension(cli_args.add))
+        exit(0)
+
+    if cli_args.remove is not None:
+        if cli_args.remove == "ls":
+            # List installed extensions
+            extensions_path = get_extensions_path()
+            extensions = os.listdir(extensions_path)
+            if len(extensions) == 0:
+                print("No extensions installed.")
+                exit(0)
+            print("Installed extensions:")
+            for extension in extensions:
+                print(f"  {extension}")
+            exit(0)
+        # Remove an extension
+        extension_name = cli_args.remove
+        extensions_path = get_extensions_path()
+        target_path = os.path.join(extensions_path, extension_name)
+
+        if not os.path.exists(target_path):
+            print(f"Extension {extension_name} not found at {target_path}")
+            exit(1)
+
+        print(f"Removing extension: {extension_name}...")
+        try:
+            shutil.rmtree(target_path)
+            print(f"Extension {extension_name} removed successfully.")
+        except Exception as e:
+            print(f"Failed to remove extension: {e}")
+            exit(1)
+
+        exit(0)
+
     asyncio.run(reload_providers())
 
+    install_extensions()
+
     # print names
     _log(f"enabled providers: {', '.join(g_handlers.keys())}")
 
@@ -2274,11 +2573,19 @@ def main():
 
             # Expand environment variables
             if client_id.startswith("$"):
-                client_id = os.environ.get(client_id[1:], "")
+                client_id = client_id[1:]
             if client_secret.startswith("$"):
-                client_secret = os.environ.get(client_secret[1:], "")
+                client_secret = client_secret[1:]
 
-            if not client_id or not client_secret:
+            client_id = os.environ.get(client_id, client_id)
+            client_secret = os.environ.get(client_secret, client_secret)
+
+            if (
+                not client_id
+                or not client_secret
+                or client_id == "GITHUB_CLIENT_ID"
+                or client_secret == "GITHUB_CLIENT_SECRET"
+            ):
                 print("ERROR: Authentication is enabled but GitHub OAuth is not properly configured.")
                 print("Please set GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET environment variables,")
                 print("or disable authentication by setting 'auth.enabled' to false in llms.json")
@@ -2299,7 +2606,7 @@ def main():
                 return True, None
 
             # Check for OAuth session token
-            session_token = request.query.get("session") or request.headers.get("X-Session-Token")
+            session_token = get_session_token(request)
             if session_token and session_token in g_sessions:
                 return True, g_sessions[session_token]
 
@@ -2329,13 +2636,32 @@ def main():
 
             try:
                 chat = await request.json()
+
+                # Apply pre-chat filters
+                context = {"request": request}
+                # Apply pre-chat filters
+                context = {"request": request}
+                for filter_func in g_app.chat_request_filters:
+                    chat = await filter_func(chat, context)
+
                 response = await chat_completion(chat)
+
+                # Apply post-chat filters
+                # Apply post-chat filters
+                for filter_func in g_app.chat_response_filters:
+                    response = await filter_func(response, context)
+
                 return web.json_response(response)
             except Exception as e:
                 return web.json_response({"error": str(e)}, status=500)
 
         app.router.add_post("/v1/chat/completions", chat_handler)
 
+        async def extensions_handler(request):
+            return web.json_response(g_app.ui_extensions)
+
+        app.router.add_get("/ext", extensions_handler)
+
         async def models_handler(request):
             return web.json_response(get_models())
 
@@ -2491,7 +2817,7 @@ def main():
                 except Exception:
                     return web.Response(text="403: Forbidden", status=403)
 
-                with open(info_path, "r") as f:
+                with open(info_path) as f:
                     content = f.read()
                 return web.Response(text=content, content_type="application/json")
 
@@ -2527,9 +2853,12 @@ def main():
 
             # Expand environment variables
             if client_id.startswith("$"):
-                client_id = os.environ.get(client_id[1:], "")
+                client_id = client_id[1:]
             if redirect_uri.startswith("$"):
-                redirect_uri = os.environ.get(redirect_uri[1:], "")
+                redirect_uri = redirect_uri[1:]
+
+            client_id = os.environ.get(client_id, client_id)
+            redirect_uri = os.environ.get(redirect_uri, redirect_uri)
 
             if not client_id:
                 return web.json_response({"error": "GitHub client_id not configured"}, status=500)
@@ -2562,7 +2891,9 @@ def main():
 
             # Expand environment variables
             if restrict_to.startswith("$"):
-                restrict_to = os.environ.get(restrict_to[1:], "")
+                restrict_to = restrict_to[1:]
+
+            restrict_to = os.environ.get(restrict_to, None if restrict_to == "GITHUB_USERS" else restrict_to)
 
             # If restrict_to is configured, validate the user
             if restrict_to:
@@ -2583,6 +2914,14 @@ def main():
             code = request.query.get("code")
             state = request.query.get("state")
 
+            # Handle malformed URLs where query params are appended with & instead of ?
+            if not code and "tail" in request.match_info:
+                tail = request.match_info["tail"]
+                if tail.startswith("&"):
+                    params = parse_qs(tail[1:])
+                    code = params.get("code", [None])[0]
+                    state = params.get("state", [None])[0]
+
             if not code or not state:
                 return web.Response(text="Missing code or state parameter", status=400)
 
@@ -2602,11 +2941,15 @@ def main():
 
             # Expand environment variables
             if client_id.startswith("$"):
-                client_id = os.environ.get(client_id[1:], "")
+                client_id = client_id[1:]
             if client_secret.startswith("$"):
-                client_secret = os.environ.get(client_secret[1:], "")
+                client_secret = client_secret[1:]
             if redirect_uri.startswith("$"):
-                redirect_uri = os.environ.get(redirect_uri[1:], "")
+                redirect_uri = redirect_uri[1:]
+
+            client_id = os.environ.get(client_id, client_id)
+            client_secret = os.environ.get(client_secret, client_secret)
+            redirect_uri = os.environ.get(redirect_uri, redirect_uri)
 
             if not client_id or not client_secret:
                 return web.json_response({"error": "GitHub OAuth credentials not configured"}, status=500)
@@ -2654,11 +2997,13 @@ def main():
             }
 
             # Redirect to UI with session token
-            return web.HTTPFound(f"/?session={session_token}")
+            response = web.HTTPFound(f"/?session={session_token}")
+            response.set_cookie("llms-token", session_token, httponly=True, path="/", max_age=86400)
+            return response
 
         async def session_handler(request):
             """Validate and return session info"""
-            session_token = request.query.get("session") or request.headers.get("X-Session-Token")
+            session_token = get_session_token(request)
 
             if not session_token or session_token not in g_sessions:
                 return web.json_response({"error": "Invalid or expired session"}, status=401)
@@ -2675,17 +3020,19 @@ def main():
 
         async def logout_handler(request):
             """End OAuth session"""
-            session_token = request.query.get("session") or request.headers.get("X-Session-Token")
+            session_token = get_session_token(request)
 
             if session_token and session_token in g_sessions:
                 del g_sessions[session_token]
 
-            return web.json_response({"success": True})
+            response = web.json_response({"success": True})
+            response.del_cookie("llms-token")
+            return response
 
         async def auth_handler(request):
             """Check authentication status and return user info"""
             # Check for OAuth session token
-            session_token = request.query.get("session") or request.headers.get("X-Session-Token")
+            session_token = get_session_token(request)
 
             if session_token and session_token in g_sessions:
                 session_data = g_sessions[session_token]
@@ -2722,6 +3069,7 @@ def main():
         app.router.add_get("/auth", auth_handler)
         app.router.add_get("/auth/github", github_auth_handler)
         app.router.add_get("/auth/github/callback", github_callback_handler)
+        app.router.add_get("/auth/github/callback{tail:.*}", github_callback_handler)
         app.router.add_get("/auth/session", session_handler)
         app.router.add_post("/auth/logout", logout_handler)
 
@@ -2775,6 +3123,12 @@ def main():
 
         app.router.add_get("/favicon.ico", not_found_handler)
 
+        # go through and register all g_app extensions
+        for handler in g_app.server_add_get:
+            app.router.add_get(handler[0], handler[1], **handler[2])
+        for handler in g_app.server_add_post:
+            app.router.add_post(handler[0], handler[1], **handler[2])
+
         # Serve index.html from root
         async def index_handler(request):
             index_content = read_resource_file_bytes("index.html")
@@ -2795,6 +3149,8 @@ def main():
 
         app.on_startup.append(start_background_tasks)
 
+        # go through and register all g_app extensions
+
         print(f"Starting server on port {port}...")
         web.run_app(app, host="0.0.0.0", port=port, print=_log)
         exit(0)
@@ -2922,8 +3278,11 @@ def main():
                 traceback.print_exc()
             exit(1)
 
-    # show usage from ArgumentParser
-    parser.print_help()
+    handled = run_extension_cli()
+
+    if not handled:
+        # show usage from ArgumentParser
+        parser.print_help()
 
 
 if __name__ == "__main__":