lkr-dev-cli 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

lkr/auth/main.py

@@ -9,27 +9,31 @@ from rich.table import Table
 
 from lkr.auth.oauth import OAuth2PKCE
 from lkr.auth_service import get_auth
-from lkr.logging import logger
+from lkr.logger import logger
 
 __all__ = ["group"]
 
 group = typer.Typer(name="auth", help="Authentication commands for LookML Repository")
 
+
 @group.callback()
 def callback(ctx: typer.Context):
     if ctx.invoked_subcommand == "whoami":
         return
-    if ctx.obj['ctx_lkr'].use_sdk == "api_key":
+    if ctx.obj["ctx_lkr"].use_sdk == "api_key":
         logger.error("API key authentication is not supported for auth commands")
         raise typer.Exit(1)
 
+
 @group.command()
 def login(
     ctx: typer.Context,
     instance_name: Annotated[
         str | None,
         typer.Option(
-            "-I", "--instance-name", help="Name of the Looker instance to login or switch to"
+            "-I",
+            "--instance-name",
+            help="Name of the Looker instance to login or switch to",
         ),
     ] = None,
 ):
@@ -38,7 +42,7 @@ def login(
     """
     auth = get_auth(ctx)
     all_instances = auth.list_auth()
-    
+
     def do_switch(instance_name: str):
         auth.set_current_instance(instance_name)
         sdk = auth.get_current_sdk()
@@ -61,17 +65,19 @@ def login(
     else:
         options: List[questionary.Choice] = []
         max_name_length = 0
-        for (name, url, current, up) in all_instances:
+        for name, url, current, up in all_instances:
             max_name_length = max(max_name_length, len(name))
         options = [
-            questionary.Choice(title=f"{name:{max_name_length}} ({url})", value=name, checked=current)
+            questionary.Choice(
+                title=f"{name:{max_name_length}} ({url})", value=name, checked=current
+            )
             for name, url, current, up in all_instances
         ]
-        options.append(questionary.Choice(title="+ Add new instance", value="_add_new_instance"))
+        options.append(
+            questionary.Choice(title="+ Add new instance", value="_add_new_instance")
+        )
         picked = questionary.select(
-            "Select instance to login/switch to",
-            choices=options,
-            pointer=">"
+            "Select instance to login/switch to", choices=options, pointer=">"
         ).ask()
         if picked != "_add_new_instance":
             do_switch(picked)
@@ -88,17 +94,19 @@ def login(
             )
             use_production = typer.confirm("Use production mode?", default=False)
             instance_name = typer.prompt(
-                "Enter a name for this Looker instance", default=f"{'dev' if not use_production else 'prod'}-{parsed_url.netloc}"
+                "Enter a name for this Looker instance",
+                default=f"{'dev' if not use_production else 'prod'}-{parsed_url.netloc}",
             )
             # Ensure instance_name is str, not None
-            assert instance_name is not None, "Instance name must be set before adding auth."
+            assert instance_name is not None, (
+                "Instance name must be set before adding auth."
+            )
 
             def auth_callback(token: Union[AuthToken, AccessToken]):
                 auth.add_auth(instance_name, origin, token, use_production)
-            
+
             oauth = OAuth2PKCE(
-                new_token_callback=auth_callback,
-                use_production=use_production
+                new_token_callback=auth_callback, use_production=use_production
             )
             logger.info(f"Opening browser for authentication at {origin + '/auth'}...")
             login_response = oauth.initiate_login(origin)
@@ -114,13 +122,16 @@ def login(
                         logger.error("Failed to exchange authorization code for tokens")
                         raise typer.Exit(1)
                 except Exception as e:
-                    logger.error(f"Failed to exchange authorization code for tokens: {str(e)}")
+                    logger.error(
+                        f"Failed to exchange authorization code for tokens: {str(e)}"
+                    )
                     raise typer.Exit(1)
             else:
                 logger.error("Failed to receive authorization code")
                 raise typer.Exit(1)
             do_switch(instance_name)
 
+
 @group.command()
 def logout(
     ctx: typer.Context,
@@ -132,9 +143,7 @@ def logout(
     ] = None,
     all: Annotated[
         bool,
-        typer.Option(
-            "--all", help="Logout from all instances"
-        ),
+        typer.Option("--all", help="Logout from all instances"),
     ] = False,
 ):
     """
@@ -156,7 +165,7 @@ def logout(
         logger.info("Logout cancelled")
         raise typer.Exit()
 
-    if instance_name:   
+    if instance_name:
         logger.info(f"Logging out from instance: {instance_name}")
         auth.delete_auth(instance_name=instance_name)
     else:
@@ -198,7 +207,12 @@ def list(ctx: typer.Context):
         raise typer.Exit(1)
     table = Table(" ", "Instance", "URL", "Production")
     for instance in all_instances:
-        table.add_row("*" if instance[2] else " ", instance[0], instance[1], "Yes" if instance[3] else "No")
+        table.add_row(
+            "*" if instance[2] else " ",
+            instance[0],
+            instance[1],
+            "Yes" if instance[3] else "No",
+        )
     console.print(table)
 
 

lkr/auth/oauth.py

@@ -10,7 +10,7 @@ import webbrowser
 from typing import Optional, TypedDict
 from urllib.parse import parse_qs
 
-from lkr.types import NewTokenCallback
+from lkr.custom_types import NewTokenCallback
 
 
 def kill_process_on_port(port: int, retries: int = 5, delay: float = 1) -> None:
@@ -19,21 +19,23 @@ def kill_process_on_port(port: int, retries: int = 5, delay: float = 1) -> None:
         # Try to create a socket binding to check if port is in use
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        sock.bind(('localhost', port))
+        sock.bind(("localhost", port))
         sock.close()
         return  # Port is free, no need to kill anything
     except socket.error:
         # Port is in use, try to kill the process
-        if os.name == 'posix':  # macOS/Linux
-            os.system(f'lsof -ti tcp:{port} | xargs kill -9 2>/dev/null')
-        elif os.name == 'nt':  # Windows
-            os.system(f'for /f "tokens=5" %a in (\'netstat -aon ^| find ":{port}"\') do taskkill /F /PID %a 2>nul')
+        if os.name == "posix":  # macOS/Linux
+            os.system(f"lsof -ti tcp:{port} | xargs kill -9 2>/dev/null")
+        elif os.name == "nt":  # Windows
+            os.system(
+                f'for /f "tokens=5" %a in (\'netstat -aon ^| find ":{port}"\') do taskkill /F /PID %a 2>nul'
+            )
         # After killing, wait for the port to be free
         for _ in range(retries):
             try:
                 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                sock.bind(('localhost', port))
+                sock.bind(("localhost", port))
                 sock.close()
                 return
             except socket.error:
@@ -45,19 +47,21 @@ class OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
     def do_GET(self):
         """Handle the callback from OAuth authorization"""
         self.send_response(200)
-        self.send_header('Content-type', 'text/html')
+        self.send_header("Content-type", "text/html")
         self.end_headers()
-        
+
         # Parse the authorization code from query parameters
         query_components = parse_qs(urllib.parse.urlparse(self.path).query)
-        
+
         # Store the code in the server instance
-        if 'code' in query_components:
-            self.server.auth_code = query_components['code'][0] # type: ignore
-        
+        if "code" in query_components:
+            self.server.auth_code = query_components["code"][0]  # type: ignore
+
         # Display a success message to the user
-        self.wfile.write(b"Authentication successful! You can close this window.")
-        
+        self.wfile.write(
+            b"Successfully authenticated to Looker OAuth! You can close this window."
+        )
+
         # Shutdown the server
         threading.Thread(target=self.server.shutdown).start()
 
@@ -65,18 +69,22 @@ class OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
         """Suppress logging of requests"""
         pass
 
+
 class OAuthCallbackServer(socketserver.TCPServer):
     def __init__(self, server_address):
         super().__init__(server_address, OAuthCallbackHandler)
         self.auth_code: str | None = None
 
+
 class LoginResponse(TypedDict):
     auth_code: Optional[str]
     code_verifier: Optional[str]
 
+
 class OAuth2PKCE:
     def __init__(self, new_token_callback: NewTokenCallback, use_production: bool):
         from lkr.auth_service import DbOAuthSession
+
         self.auth_code: Optional[str] = None
         self.state = secrets.token_urlsafe(16)
         self.new_token_callback: NewTokenCallback = new_token_callback
@@ -85,7 +93,7 @@ class OAuth2PKCE:
         self.server: OAuthCallbackServer | None = None
         self.port: int = 8000
         self.use_production: bool = use_production
-        
+
     def cleanup(self):
         """Clean up the server and its thread."""
         if self.server:
@@ -100,51 +108,91 @@ class OAuth2PKCE:
         """
         Initiates the OAuth2 PKCE login flow by opening the browser with the authorization URL
         and starting a local server to catch the callback.
-        
+
         Returns:
             Optional[str]: The authorization code if successful, None otherwise
         """
         from lkr.auth_service import get_auth_session
-        
+
         # Kill any process using port 8000
         kill_process_on_port(self.port)
-        
-        # Start the local server
-        self.server = OAuthCallbackServer(('localhost', self.port))
-        
+
+        # Wait until the port is actually free and we can bind the real server (up to 20 seconds)
+        server_created = False
+        last_exception = None
+        for _ in range(20):  # 20 x 1s = 20s
+            try:
+                self.server = OAuthCallbackServer(("localhost", self.port))
+                server_created = True
+                break
+            except OSError as e:
+                if getattr(e, "errno", None) == 48 or "Address already in use" in str(
+                    e
+                ):
+                    last_exception = e
+                    time.sleep(1)
+                else:
+                    raise
+        if not server_created:
+            import logging
+
+            logging.error(
+                f"Failed to bind to port {self.port} after waiting: {last_exception}"
+            )
+            raise RuntimeError(
+                f"Failed to bind to port {self.port} after waiting: {last_exception}"
+            )
+
         # Start the server in a separate thread
+        if self.server is None:
+            raise RuntimeError("Internal error: server was not created successfully.")
         self.server_thread = threading.Thread(target=self.server.serve_forever)
         self.server_thread.daemon = True
         self.server_thread.start()
 
         # Construct and open the OAuth URL
-        self.auth_session = get_auth_session(base_url, self.new_token_callback, use_production=self.use_production)
-        oauth_url = self.auth_session.create_auth_code_request_url('cors_api', self.state)
-        
+        self.auth_session = get_auth_session(
+            base_url, self.new_token_callback, use_production=self.use_production
+        )
+        oauth_url = self.auth_session.create_auth_code_request_url(
+            "cors_api", self.state
+        )
+
         webbrowser.open(oauth_url)
-        
+
         # Wait for the callback
         self.server_thread.join()
-        
+
         # Get the authorization code
-        return LoginResponse(auth_code=self.server.auth_code, code_verifier=self.auth_session.code_verifier)
+        if self.server is None:
+            raise RuntimeError("Internal error: server was not created successfully.")
+        return LoginResponse(
+            auth_code=self.server.auth_code,
+            code_verifier=self.auth_session.code_verifier,
+        )
 
     def exchange_code_for_token(self):
         """
         Exchange the authorization code for access and refresh tokens.
-        
+
         Args:
             base_url: The base URL of the Looker instance
             client_id: The OAuth client ID
-            
+
         Returns:
             Dict containing access_token, refresh_token, token_type, and expires_in
         """
         if not self.auth_code:
-            raise ValueError("No authorization code available. Must call initiate_login first.")
+            raise ValueError(
+                "No authorization code available. Must call initiate_login first."
+            )
         if not self.auth_session:
-            raise ValueError("No auth session available. Must call initiate_login first.")
-        self.auth_session.redeem_auth_code(self.auth_code, self.auth_session.code_verifier)
+            raise ValueError(
+                "No auth session available. Must call initiate_login first."
+            )
+        self.auth_session.redeem_auth_code(
+            self.auth_code, self.auth_session.code_verifier
+        )
         self.cleanup()
         return self.auth_session.token
 

lkr/auth_service.py

@@ -1,26 +1,28 @@
 import json
 import os
 import sqlite3
+import types
 from datetime import datetime, timedelta, timezone
 from typing import List, Self, Tuple, Union
 
+import requests
 import typer
 from looker_sdk.rtl import serialize
 from looker_sdk.rtl.api_settings import ApiSettings, SettingsConfig
 from looker_sdk.rtl.auth_session import AuthSession, CryptoHash, OAuthSession
 from looker_sdk.rtl.auth_token import AccessToken, AuthToken
 from looker_sdk.rtl.requests_transport import RequestsTransport
-from looker_sdk.rtl.transport import HttpMethod
+from looker_sdk.rtl.transport import LOOKER_API_ID, HttpMethod
 from looker_sdk.sdk.api40.methods import Looker40SDK
 from pydantic import BaseModel, Field, computed_field
 from pydash import get
 
 from lkr.classes import LkrCtxObj, LookerApiKey
 from lkr.constants import LOOKER_API_VERSION, OAUTH_CLIENT_ID, OAUTH_REDIRECT_URI
-from lkr.logging import logger
-from lkr.types import NewTokenCallback
+from lkr.custom_types import NewTokenCallback
+from lkr.logger import logger
 
-__all__ = ["get_auth"]
+__all__ = ["get_auth", "ApiKeyAuthSession", "DbOAuthSession"]
 
 
 def get_auth(ctx: typer.Context | LkrCtxObj) -> Union["SqlLiteAuth", "ApiKeyAuth"]:
@@ -33,7 +35,7 @@ def get_auth(ctx: typer.Context | LkrCtxObj) -> Union["SqlLiteAuth", "ApiKeyAuth
             raise typer.Exit(1)
     if lkr_ctx.use_sdk == "api_key" and lkr_ctx.api_key:
         logger.info("Using API key authentication")
-        return ApiKeyAuth(lkr_ctx.api_key)
+        return ApiKeyAuth(lkr_ctx.api_key, use_production=lkr_ctx.use_production)
     else:
         return SqlLiteAuth(lkr_ctx)
 
@@ -43,7 +45,6 @@ class ApiKeyApiSettings(ApiSettings):
         self.api_key = api_key
         super().__init__()
         self.agent_tag = "lkr-cli-api-key"
-        self.headers = {"X-Looker-AppId": "lkr-cli"}
 
     def read_config(self) -> SettingsConfig:
         return SettingsConfig(
@@ -58,7 +59,6 @@ class OAuthApiSettings(ApiSettings):
         self.base_url = base_url
         super().__init__()
         self.agent_tag = "lkr-cli-oauth"
-        self.headers = {"X-Looker-AppId": "lkr-cli"}
 
     def read_config(self) -> SettingsConfig:
         return SettingsConfig(
@@ -70,6 +70,36 @@ class OAuthApiSettings(ApiSettings):
         )
 
 
+class ApiKeyAuthSession(AuthSession):
+    def __init__(self, *args, use_production: bool, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.use_production = use_production
+
+    def _login(self, *args, **kwargs):
+        super()._login(*args, **kwargs)
+        if not self.use_production:
+            self._switch_to_dev_mode()
+
+    def _switch_to_dev_mode(self):
+        logger.debug("Switching to dev mode")
+        config = self.settings.read_config()
+        if "base_url" in config:
+            url = f"{config['base_url']}/api/{LOOKER_API_VERSION}/session"
+            return self.transport.request(
+                method=HttpMethod.PATCH,
+                path=url,
+                body=json.dumps({"workspace_id": "dev"}).encode("utf-8"),
+                transport_options={
+                    "headers": {
+                        "Content-Type": "application/json",
+                        "Authorization": f"Bearer {self.token.access_token}",
+                    }
+                },
+            )
+        else:
+            raise ValueError("Base URL not found in settings")
+
+
 class DbOAuthSession(OAuthSession):
     def __init__(
         self,
@@ -121,7 +151,7 @@ def get_auth_session(
     access_token: AccessToken | None = None,
 ) -> DbOAuthSession:
     settings = OAuthApiSettings(base_url)
-    transport = RequestsTransport.configure(settings)
+    transport = MonkeyPatchTransport.configure(settings)
     auth = DbOAuthSession(
         settings=settings,
         transport=transport,
@@ -137,18 +167,19 @@ def get_auth_session(
     return auth
 
 
-def init_api_key_sdk(api_key: LookerApiKey) -> Looker40SDK:
+def init_api_key_sdk(api_key: LookerApiKey, use_production: bool) -> Looker40SDK:
     from looker_sdk.rtl import serialize
 
     settings = ApiKeyApiSettings(api_key)
     settings.is_configured()
     transport = RequestsTransport.configure(settings)
     return Looker40SDK(
-        auth=AuthSession(
+        auth=ApiKeyAuthSession(
             settings,
             transport,
             serialize.deserialize40,  # type: ignore
             LOOKER_API_VERSION,
+            use_production=use_production,
         ),
         deserialize=serialize.deserialize40,  # type: ignore
         serialize=serialize.serialize40,  # type: ignore
@@ -157,6 +188,29 @@ def init_api_key_sdk(api_key: LookerApiKey) -> Looker40SDK:
     )
 
 
+# monkey patch to remove the LOOKER_API_ID header when exchanging the code for a token
+def monkey_patch_prepare_request(session: requests.Session):
+    original_prepare_request = session.prepare_request
+
+    def prepare_request(self, request, *args, **kwargs):
+        x = original_prepare_request(request, *args, **kwargs)
+        if (
+            x.headers.get(LOOKER_API_ID)
+            and x.path_url.endswith("/api/token")
+            and request.method == "POST"
+        ):
+            x.headers.pop(LOOKER_API_ID)
+        return x
+
+    session.prepare_request = types.MethodType(prepare_request, session)
+
+
+class MonkeyPatchTransport(RequestsTransport):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        monkey_patch_prepare_request(self.session)
+
+
 def init_oauth_sdk(
     base_url: str,
     new_token_callback: NewTokenCallback,
@@ -167,7 +221,8 @@ def init_oauth_sdk(
     """Default dependency configuration"""
     settings = OAuthApiSettings(base_url)
     settings.is_configured()
-    transport = RequestsTransport.configure(settings)
+    transport = MonkeyPatchTransport.configure(settings)
+
     auth = get_auth_session(
         base_url,
         new_token_callback,
@@ -395,9 +450,7 @@ class SqlLiteAuth:
             return current_auth.instance_name
         return None
 
-    def get_current_sdk(
-        self, prompt_refresh_invalid_token: bool = False
-    ) -> Looker40SDK:
+    def get_current_sdk(self, prompt_refresh_invalid_token: bool = True) -> Looker40SDK:
         current_auth = self._get_current_auth()
         if current_auth:
             if not current_auth.valid_refresh_token:
@@ -471,7 +524,7 @@ class SqlLiteAuth:
             if not token:
                 raise InvalidRefreshTokenError(current_auth.instance_name)
             else:
-                from lkr.logging import logger
+                from lkr.logger import logger
 
                 logger.info(
                     f"Successfully refreshed token for {current_auth.instance_name}"
@@ -480,8 +533,9 @@ class SqlLiteAuth:
 
 
 class ApiKeyAuth:
-    def __init__(self, api_key: LookerApiKey):
+    def __init__(self, api_key: LookerApiKey, use_production: bool):
         self.api_key = api_key
+        self.use_production = use_production
 
     def __enter__(self):
         return self
@@ -518,7 +572,7 @@ class ApiKeyAuth:
         )
 
     def get_current_sdk(self, **kwargs) -> Looker40SDK:
-        return init_api_key_sdk(self.api_key)
+        return init_api_key_sdk(self.api_key, self.use_production)
 
     def get_current_instance(self) -> str | None:
         raise NotImplementedError(

lkr/classes.py

@@ -13,24 +13,25 @@ class LookerApiKey(BaseModel):
     def from_env(cls):
         try:
             return cls(
-                client_id=os.environ.get("LOOKERSDK_CLIENT_ID"), # type: ignore
-                client_secret=os.environ.get("LOOKERSDK_CLIENT_SECRET"), # type: ignore
-                base_url=os.environ.get("LOOKERSDK_BASE_URL"), # type: ignore
+                client_id=os.environ.get("LOOKERSDK_CLIENT_ID"),  # type: ignore
+                client_secret=os.environ.get("LOOKERSDK_CLIENT_SECRET"),  # type: ignore
+                base_url=os.environ.get("LOOKERSDK_BASE_URL"),  # type: ignore
             )
         except Exception:
             return None
 
-        
+
 class LkrCtxObj(BaseModel):
     api_key: LookerApiKey | None
     force_oauth: bool = False
-    
+    use_production: bool = True
+
     @property
     def use_sdk(self) -> Literal["oauth", "api_key"]:
         if self.force_oauth:
             return "oauth"
         return "api_key" if self.api_key else "oauth"
-    
+
     def __init__(self, api_key: LookerApiKey | None = None, *args, **kwargs):
         super().__init__(api_key=api_key, *args, **kwargs)
         if not self.api_key:

lkr/{logging.py → logger.py}

@@ -6,16 +6,18 @@ from rich.console import Console
 from rich.logging import RichHandler
 from rich.theme import Theme
 
-from lkr.types import LogLevel
+from lkr.custom_types import LogLevel
 
 # Define a custom theme for our logging
-theme = Theme({
-    "logging.level.debug": "dim blue",
-    "logging.level.info": "bold green",
-    "logging.level.warning": "bold yellow",
-    "logging.level.error": "bold red",
-    "logging.level.critical": "bold white on red",
-})
+theme = Theme(
+    {
+        "logging.level.debug": "dim blue",
+        "logging.level.info": "bold green",
+        "logging.level.warning": "bold yellow",
+        "logging.level.error": "bold red",
+        "logging.level.critical": "bold white on red",
+    }
+)
 
 # Create a console for logging
 console = Console(theme=theme)
@@ -36,7 +38,9 @@ log_level = os.getenv("LOG_LEVEL", DEFAULT_LOG_LEVEL).upper()
 
 # Configure the root logger
 logging.basicConfig(
-    level=getattr(logging, log_level, logging.INFO),  # Fallback to INFO if invalid level
+    level=getattr(
+        logging, log_level, logging.INFO
+    ),  # Fallback to INFO if invalid level
     format="%(message)s",
     datefmt="[%X]",
     handlers=[handler],
@@ -51,9 +55,12 @@ requests_logger = logging.getLogger("looker_sdk.rtl.requests_transport")
 if log_level != "DEBUG":
     requests_logger.setLevel(logging.WARNING)
 
+
 def set_log_level(level: LogLevel):
     """Set the logging level for the application."""
     logger.setLevel(getattr(logging, level.value))
     logging.getLogger("lkr.structured").setLevel(getattr(logging, level.value))
     # Update requests_transport logger level based on the new level
-    requests_logger.setLevel(logging.DEBUG if level == LogLevel.DEBUG else logging.WARNING) 
+    requests_logger.setLevel(
+        logging.DEBUG if level == LogLevel.DEBUG else logging.WARNING
+    )

lkr/main.py

@@ -1,14 +1,14 @@
 import os
-from typing import Annotated
+from typing import Annotated, Optional
 
 import typer
 
 from lkr.auth.main import group as auth_group
 from lkr.classes import LkrCtxObj
-from lkr.logging import logger
+from lkr.custom_types import LogLevel
+from lkr.logger import logger
 from lkr.mcp.main import group as mcp_group
 from lkr.observability.main import group as observability_group
-from lkr.types import LogLevel
 
 app = typer.Typer(
     name="lkr", help="LookML Repository CLI", add_completion=True, no_args_is_help=True
@@ -30,6 +30,7 @@ def callback(
     log_level: Annotated[LogLevel | None, typer.Option(envvar="LOG_LEVEL")] = None,
     quiet: Annotated[bool, typer.Option("--quiet")] = False,
     force_oauth: Annotated[bool, typer.Option("--force-oauth")] = False,
+    dev: Annotated[Optional[bool], typer.Option("--dev")] = None,
 ):
     if client_id:
         os.environ["LOOKERSDK_CLIENT_ID"] = client_id
@@ -43,13 +44,22 @@ def callback(
     # Initialize ctx.obj as a dictionary if it's None
     if ctx.obj is None:
         ctx.obj = {}
-    ctx.obj["ctx_lkr"] = LkrCtxObj(force_oauth=force_oauth)
+
+    ctx_obj = LkrCtxObj(
+        force_oauth=force_oauth,
+        use_production=not dev if dev is not None else True,
+    )
+    ctx.obj["ctx_lkr"] = ctx_obj
+    # if the user passes --dev, but lkrCtxObj.use_sdk is oauth, then we need to log a warning saying we're ignoring the --dev flag
+    if dev and ctx_obj.use_sdk == "oauth":
+        logger.warning("Ignoring --dev flag because OAuth token tracks dev/prod mode.")
+
     if log_level:
-        from lkr.logging import set_log_level
+        from lkr.logger import set_log_level
 
         set_log_level(log_level)
     if quiet:
-        from lkr.logging import set_log_level
+        from lkr.logger import set_log_level
 
         set_log_level(LogLevel.ERROR)
 

lkr/mcp/main.py

@@ -17,7 +17,7 @@ from pydash import get
 
 from lkr.auth_service import get_auth
 from lkr.classes import LkrCtxObj
-from lkr.logging import logger
+from lkr.logger import logger
 
 __all__ = ["group"]
 
@@ -101,7 +101,7 @@ class SpectaclesRequest(BaseModel):
 
 
 def get_mcp_sdk(ctx: LkrCtxObj | typer.Context):
-    sdk = get_auth(ctx).get_current_sdk()
+    sdk = get_auth(ctx).get_current_sdk(prompt_refresh_invalid_token=False)
     sdk.auth.settings.agent_tag += "-mcp"
     return sdk
 

lkr/observability/classes.py

@@ -8,7 +8,7 @@ from looker_sdk.sdk.api40.methods import LookerSDK
 from looker_sdk.sdk.api40.models import EmbedSsoParams
 from pydantic import BaseModel, ConfigDict, Field
 
-from lkr.logging import structured_logger
+from lkr.logger import structured_logger
 
 DEFAULT_PERMISSIONS = [
     "access_data",
@@ -84,14 +84,6 @@ class LogEvent(BaseModel):
     dashboard_id: str
 
 
-class EventCollector:
-    def __init__(self):
-        self.events = []
-
-    def log_event(self, event: dict[str, Any], event_type: str):
-        self.events.append(LogEvent(**event, event_type=event_type))
-
-
 class ObservabilityCtxObj(BaseModel):
     event_prefix: str = Field(
         default="lkr-observability", description="The prefix of the event", min_length=1

lkr/observability/embed_container.html

@@ -32,10 +32,12 @@
         const urlParams = new URLSearchParams(window.location.search);
         const iframeUrl = urlParams.get('iframe_url');
         const origin = new URL(iframeUrl).origin;
-        console.log(origin)
-        console.log(iframeUrl)
         const sessionId = urlParams.get('session_id');
+        const debug = urlParams.get('debug');
         // Set the iframe source
+        if (debug) {
+            console.log({debug, iframeUrl, origin, sessionId})
+        }
         document.getElementById('looker-iframe').src = iframeUrl;
 
         // Track which events we've received
@@ -55,7 +57,7 @@
                 return;
             }
             const {type, ...data} = JSON.parse(event.data)
-            if (!trackedEvents.has(type)) {
+            if (!trackedEvents.has(type) && !debug) {
                 return;
             }
             if (type) {
@@ -65,6 +67,9 @@
                     event_data: data,
                     timestamp: now.toISOString(),
                 };
+                if (debug) {
+                    console.log(eventData)
+                }
                 // Send event data to the server
                 fetch(`/log_event?session_id=${sessionId}`, {
                     method: 'POST',

lkr/observability/main.py

@@ -17,7 +17,7 @@ from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
 
-from lkr.logging import structured_logger
+from lkr.logger import structured_logger
 from lkr.observability.classes import (
     EmbedSDKObj,
     IframeRequestEvent,
@@ -158,14 +158,30 @@ def health_check(
             params.model_dump(mode="json"), "health_check_start", session_id
         )
         chrome_options = Options()
+        chrome_options.set_capability("goog:loggingPrefs", {"browser": "ALL"})
         chrome_options.add_argument("--headless=new")
         chrome_options.add_argument("--no-sandbox")
+        chrome_options.add_argument("--disable-dev-shm-usage")
+        chrome_options.add_argument("--disable-gpu")
+        chrome_options.add_argument("--enable-logging")
+        chrome_options.add_argument("--v=1")
+
+        chrome_options.add_experimental_option(
+            "prefs",
+            {
+                "profile.default_content_settings.cookies": 1,
+                "profile.cookie_controls_mode": 0,
+            },
+        )
         driver = webdriver.Chrome(options=chrome_options)
         url = observability_ctx.sdk.create_sso_embed_url(
             body=params.to_embed_sso_params(
                 observability_ctx.origin, observability_ctx.base_url or ""
             )
         )
+        observability_ctx.log_event(
+            {"sso_url": url.url}, "create_sso_embed_url", session_id
+        )
 
         if not (url and url.url):
             raise HTTPException(status_code=500, detail="No URL found")
@@ -175,11 +191,16 @@ def health_check(
         else:
             quoted_url = quote(url.url, safe="")
             embed_url = f"{observability_ctx.origin}/?iframe_url={quoted_url}&session_id={session_id}"
-            if True:
-                driver.get(embed_url)
-                WebDriverWait(driver, observability_ctx.timeout).until(
-                    EC.presence_of_element_located((By.ID, "completion-indicator"))
-                )
+            driver.get(embed_url)
+            observability_ctx.log_event(
+                {"url": embed_url}, "chromium_driver_get", session_id
+            )
+            WebDriverWait(driver, observability_ctx.timeout).until(
+                EC.presence_of_element_located((By.ID, "completion-indicator"))
+            )
+            observability_ctx.log_event(
+                {"session_id": session_id}, "chromium_driver_get_complete", session_id
+            )
 
     except TimeoutException:
         observability_ctx.log_event(
@@ -209,6 +230,9 @@ def health_check(
             session_id,
         )
     finally:
+        observability_ctx.log_event(
+            {"session_id": session_id}, "health_check_complete", session_id
+        )
         if driver:
             driver.quit()
         if not redirect:

lkr/{embed/observability → observability}/utils.py

@@ -3,10 +3,9 @@ import re
 from datetime import datetime, timezone
 from typing import Dict, List, Tuple
 
-from pydantic import BaseModel, Field
 from pydash import set_
 
-from lkr.logging import logger
+from lkr.logger import logger
 
 MAX_SESSION_LENGTH = 2592000
 
@@ -75,30 +74,6 @@ def format_attributes(
 def now():
     return datetime.now(timezone.utc)
 
+
 def ms_diff(start: datetime):
     return int((now() - start).total_seconds() * 1000)
-
-class LogEventResponse(BaseModel):
-    timestamp: datetime = Field(default_factory=now)
-    event_name: str
-    event_prefix: str
-
-    def make_previous(self):
-        return dict(
-            previous_event_name=self.event_name,
-            previous_event_timestamp=self.timestamp,
-            previous_event_duration_ms=ms_diff(self.timestamp),
-        )
-
-def log_event(event_name: str, prefix: str, **kwargs):
-    if "timestamp" not in kwargs:
-        kwargs["timestamp"] = now().isoformat()
-    logger.info(
-        f"{prefix}:{event_name}",
-        **kwargs
-    )
-    return LogEventResponse(
-        timestamp=datetime.fromisoformat(kwargs["timestamp"]), 
-        event_name=event_name, 
-        event_prefix=prefix
-    )

{lkr_dev_cli-0.0.22.dist-info → lkr_dev_cli-0.0.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lkr-dev-cli
-Version: 0.0.22
+Version: 0.0.24
 Summary: lkr: a command line interface for looker
 Author: bwebs
 License-Expression: MIT

lkr_dev_cli-0.0.24.dist-info/RECORD

@@ -0,0 +1,21 @@
+lkr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lkr/auth_service.py,sha256=NIGlSVtzS3ajpWYx2gTJVDknuF_KxwYsJEj88Hc05dQ,19887
+lkr/classes.py,sha256=f2TJOXFta0s8LJLEXOqPdWPLg-EIIntUSDS6gDOon7M,1163
+lkr/constants.py,sha256=DdCfsV6q8wgs2iHpIQeb6oDP_2XejusEHyPvCbaM3yY,108
+lkr/custom_types.py,sha256=feJ-W2U61PJTiotMLuZJqxrotA53er95kO1O30mooy4,323
+lkr/exceptions.py,sha256=M_aR4YaCZtY4wyxhcoqJCVkxVu9z3Wwo5KgSDyOoEnI,210
+lkr/logger.py,sha256=wLEVluF-2lVMPJ228D7O4-shHaydEGXmn47j567nUgw,1887
+lkr/main.py,sha256=wpnSiCpIScEi-jmrLuwcSJrMX3tMkuaYNwlvNkVf5N8,2375
+lkr/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lkr/auth/main.py,sha256=7tWGPWokzbBnrX1enZ9YP4rdDJqYBlGfuYe0Wg-fXT4,7532
+lkr/auth/oauth.py,sha256=n2yAcccdBZaloGVtFRTwCPBfh1cvVYNbXLsFCxmWc5M,7207
+lkr/mcp/main.py,sha256=fz7Bvbkj1CTD185lGwNdMYP7bOTDadWL1xdD4JZW8qQ,22886
+lkr/observability/classes.py,sha256=LgGuUnY-J1csPrlAKnw4PPOqOfbvaOx2cxENlQgJYcE,5816
+lkr/observability/embed_container.html,sha256=IcDG-QVsYYNGQGrkDrx9OMZ2Pmo4C8oAjRHddFQ7Tlw,2939
+lkr/observability/main.py,sha256=XbejIdqhNNUMqHVezb5EnLaJ32dO9-Bt0o5d8lc0kyw,9544
+lkr/observability/utils.py,sha256=UpaBrp_ufaXLoz4p3xG3K6lHKBpP9wBhvP8rDmeGoWg,2148
+lkr_dev_cli-0.0.24.dist-info/METADATA,sha256=PKOjKBiQqRlg4nfYzcFjbjYHSzaRNCslIlBiBGaaZPw,10663
+lkr_dev_cli-0.0.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lkr_dev_cli-0.0.24.dist-info/entry_points.txt,sha256=nn2sFMGDpwUVE61ZUpbDPnQZkW7Gc08nV-tyLGo8q34,37
+lkr_dev_cli-0.0.24.dist-info/licenses/LICENSE,sha256=hKnCOORW1JRE_M2vStz8dblS5u1iR-2VpqS9xagKNa0,1063
+lkr_dev_cli-0.0.24.dist-info/RECORD,,

lkr_dev_cli-0.0.22.dist-info/RECORD

@@ -1,21 +0,0 @@
-lkr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lkr/auth_service.py,sha256=_enIsYxpL1IILtBfNG4YAA_H9cqwnwcvrGMyfmzgH7U,17815
-lkr/classes.py,sha256=0NKttc5kAhW_omuxwnN9Jy6oQnRKgI7b2c7HZUfI0lc,1144
-lkr/constants.py,sha256=DdCfsV6q8wgs2iHpIQeb6oDP_2XejusEHyPvCbaM3yY,108
-lkr/exceptions.py,sha256=M_aR4YaCZtY4wyxhcoqJCVkxVu9z3Wwo5KgSDyOoEnI,210
-lkr/logging.py,sha256=bBGdxkVrUidRTJAvqGHyQ5KS6IJGYDCoool5tTB_JxM,1822
-lkr/main.py,sha256=5m036LAS4PTLIzpWW5ohxIs2FGYtVf-OwYnTmtrpnxU,1933
-lkr/types.py,sha256=feJ-W2U61PJTiotMLuZJqxrotA53er95kO1O30mooy4,323
-lkr/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lkr/auth/main.py,sha256=ebGp-NdgULodHaDrLKspnGSFf_sOkV2Vanil1NbOJKY,7382
-lkr/auth/oauth.py,sha256=-QCb7YGIqmuTiy6SZcUTbVZrDo7itOpUUOK1VuvfMqM,5987
-lkr/embed/observability/utils.py,sha256=Hv3g60cI03cQwyEe8QV7bUMssE6pyrZKnDyl9rxm5b8,2915
-lkr/mcp/main.py,sha256=39VO0_bdscrCW7BC3kdlgjfIWaNigpT38HZ74_Drm-A,22853
-lkr/observability/classes.py,sha256=5kQnHxa3pgUartrbccuG0yMClfoFqYCXY8iCTJTZvgk,6025
-lkr/observability/embed_container.html,sha256=BMzV_jfBhcussUExf0KccOmOTAO3UEV7SuZ4lznQ0no,2758
-lkr/observability/main.py,sha256=6xAcaW4ruxGZDiGHNTi0oIaQnI6HhKxsjCZ5jq_ldsE,8557
-lkr_dev_cli-0.0.22.dist-info/METADATA,sha256=Yp81tfskRQC4vKRCecxXGmmBK7eiT5Djf_fBzj9VFyo,10663
-lkr_dev_cli-0.0.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lkr_dev_cli-0.0.22.dist-info/entry_points.txt,sha256=nn2sFMGDpwUVE61ZUpbDPnQZkW7Gc08nV-tyLGo8q34,37
-lkr_dev_cli-0.0.22.dist-info/licenses/LICENSE,sha256=hKnCOORW1JRE_M2vStz8dblS5u1iR-2VpqS9xagKNa0,1063
-lkr_dev_cli-0.0.22.dist-info/RECORD,,