escobar 0.1.90__py3-none-any.whl → 0.1.91__py3-none-any.whl

escobar/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '0.1.90'
+__version__ = VERSION = '0.1.91'

escobar/handlers.py

@@ -6,8 +6,6 @@ import websockets
 import ssl
 import logging
 import time
-import threading
-import psutil
 from urllib.parse import urlparse, urlunparse
 from jupyter_server.base.handlers import JupyterHandler
 from jupyter_server.utils import url_path_join
@@ -17,10 +15,58 @@ import tornado.websocket
 import aiohttp
 from traitlets.config import LoggingConfigurable
 import mimetypes
+import requests
+from google.oauth2 import id_token
+from google.auth.transport import requests as google_requests
 
 # Default proxy port
 DEFAULT_PROXY_PORT = 3000
 
+
+class OAuthCallbackHandler(JupyterHandler):
+    """
+    Handler for /static/oauth-callback.html endpoint.
+    Serves the OAuth callback HTML file for Google authentication.
+    """
+    
+    async def get(self):
+        """Handle GET requests to serve the OAuth callback HTML"""
+        try:
+            # Get the path to the static directory
+            import os
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            project_root = os.path.dirname(current_dir)
+            callback_file_path = os.path.join(project_root, 'static', 'oauth-callback.html')
+            
+            self.log.info(f"🔐 CALLBACK: Serving OAuth callback from: {callback_file_path}")
+            
+            # Check if file exists
+            if not os.path.exists(callback_file_path):
+                self.log.error(f"🔐 CALLBACK: OAuth callback file not found: {callback_file_path}")
+                self.set_status(404)
+                self.finish("OAuth callback file not found")
+                return
+            
+            # Read and serve the HTML file
+            with open(callback_file_path, 'r', encoding='utf-8') as f:
+                html_content = f.read()
+            
+            # Set proper headers
+            self.set_header('Content-Type', 'text/html; charset=UTF-8')
+            self.set_header('Cache-Control', 'no-cache, no-store, must-revalidate')
+            self.set_header('Pragma', 'no-cache')
+            self.set_header('Expires', '0')
+            
+            # Write the HTML content
+            self.write(html_content)
+            self.log.info(f"🔐 CALLBACK: Successfully served OAuth callback HTML")
+            
+        except Exception as e:
+            self.log.error(f"🔐 CALLBACK: Error serving OAuth callback: {e}")
+            self.set_status(500)
+            self.finish(f"Error serving OAuth callback: {str(e)}")
+
+
 class ProxyHandler(JupyterHandler):
     """
     Handler for /proxy endpoint.
@@ -154,91 +200,8 @@ class ProxyHandler(JupyterHandler):
 class WebSocketProxyHandler(tornado.websocket.WebSocketHandler):
     """
     WebSocket proxy handler that forwards connections from /ws to target server
-    Enhanced with comprehensive logging for debugging intermittent connection issues
     """
     
-    # Class-level connection tracking
-    _connection_count = 0
-    _active_connections = {}
-    
-    def _log_system_state(self, context=""):
-        """Log current system state for debugging"""
-        try:
-            # System resource information
-            cpu_percent = psutil.cpu_percent(interval=0.1)
-            memory = psutil.virtual_memory()
-            
-            print(f"[ESCOBAR-WS] === SYSTEM STATE {context} ===")
-            print(f"[ESCOBAR-WS] CPU Usage: {cpu_percent}%")
-            print(f"[ESCOBAR-WS] Memory Usage: {memory.percent}% ({memory.used / 1024 / 1024:.1f}MB used)")
-            print(f"[ESCOBAR-WS] Active Connections: {len(self._active_connections)}")
-            print(f"[ESCOBAR-WS] Total Connections Created: {self._connection_count}")
-            print(f"[ESCOBAR-WS] Current Thread: {threading.current_thread().name}")
-            print(f"[ESCOBAR-WS] === END SYSTEM STATE ===")
-        except Exception as e:
-            print(f"[ESCOBAR-WS] Error logging system state: {e}")
-    
-    def _log_connection_lifecycle(self, event, details=None):
-        """Log connection lifecycle events with timing"""
-        timestamp = time.time()
-        connection_id = getattr(self, 'connection_id', 'UNKNOWN')
-        
-        print(f"[ESCOBAR-WS] === CONNECTION LIFECYCLE EVENT ===")
-        print(f"[ESCOBAR-WS] Event: {event}")
-        print(f"[ESCOBAR-WS] Connection ID: {connection_id}")
-        print(f"[ESCOBAR-WS] Timestamp: {timestamp}")
-        print(f"[ESCOBAR-WS] Human Time: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp))}")
-        if details:
-            print(f"[ESCOBAR-WS] Details: {details}")
-        print(f"[ESCOBAR-WS] === END LIFECYCLE EVENT ===")
-    
-    def _log_message_timing(self, direction, message_size, start_time=None):
-        """Log message timing and throughput"""
-        current_time = time.time()
-        
-        print(f"[ESCOBAR-WS] === MESSAGE TIMING ===")
-        print(f"[ESCOBAR-WS] Direction: {direction}")
-        print(f"[ESCOBAR-WS] Message Size: {message_size} bytes")
-        print(f"[ESCOBAR-WS] Timestamp: {current_time}")
-        
-        if start_time:
-            duration = current_time - start_time
-            throughput = message_size / duration if duration > 0 else 0
-            print(f"[ESCOBAR-WS] Processing Duration: {duration:.4f}s")
-            print(f"[ESCOBAR-WS] Throughput: {throughput:.2f} bytes/sec")
-        
-        print(f"[ESCOBAR-WS] === END MESSAGE TIMING ===")
-    
-    def _log_target_connection_health(self):
-        """Log target connection health metrics"""
-        if not self.target_ws:
-            print(f"[ESCOBAR-WS] === TARGET HEALTH: NO CONNECTION ===")
-            return
-        
-        print(f"[ESCOBAR-WS] === TARGET CONNECTION HEALTH ===")
-        try:
-            print(f"[ESCOBAR-WS] Target State: {self.target_ws.state}")
-            print(f"[ESCOBAR-WS] Target State Name: {self.target_ws.state.name}")
-            print(f"[ESCOBAR-WS] Target State Value: {self.target_ws.state.value}")
-            
-            # Check if we can access additional properties
-            if hasattr(self.target_ws, 'ping_interval'):
-                print(f"[ESCOBAR-WS] Ping Interval: {self.target_ws.ping_interval}")
-            if hasattr(self.target_ws, 'ping_timeout'):
-                print(f"[ESCOBAR-WS] Ping Timeout: {self.target_ws.ping_timeout}")
-            if hasattr(self.target_ws, 'close_timeout'):
-                print(f"[ESCOBAR-WS] Close Timeout: {self.target_ws.close_timeout}")
-                
-        except Exception as e:
-            print(f"[ESCOBAR-WS] Error checking target health: {e}")
-        
-        print(f"[ESCOBAR-WS] === END TARGET HEALTH ===")
-    
-    def _generate_connection_id(self):
-        """Generate unique connection ID for tracking"""
-        WebSocketProxyHandler._connection_count += 1
-        return f"CONN-{WebSocketProxyHandler._connection_count}-{int(time.time())}"
-    
     def _resolve_target_url_for_docker(self, url):
         """
         Resolve target URL for Docker environment.
@@ -269,16 +232,11 @@ class WebSocketProxyHandler(tornado.websocket.WebSocketHandler):
         # Determine if we're in Docker
         is_docker = dockerenv_exists or docker_env or cgroup_docker
         
-        print(f"[ESCOBAR-WS] Docker detection indicators: {docker_indicators}")
-        print(f"[ESCOBAR-WS] Final Docker detection result: {is_docker}")
-        
         if not is_docker:
-            print(f"[ESCOBAR-WS] Not in Docker container, using original URL: {url}")
             return url
         
         # Parse the URL to extract components
         parsed = urlparse(url)
-        print(f"[ESCOBAR-WS] Parsed URL - hostname: '{parsed.hostname}', netloc: '{parsed.netloc}'")
         
         # Check if hostname is localhost or 127.0.0.1
         if parsed.hostname in ['localhost', '127.0.0.1']:
@@ -287,10 +245,7 @@ class WebSocketProxyHandler(tornado.websocket.WebSocketHandler):
             new_parsed = parsed._replace(netloc=new_netloc)
             new_url = urlunparse(new_parsed)
             
-            print(f"[ESCOBAR-WS] Docker hostname resolution: {url} → {new_url}")
             return new_url
-        else:
-            print(f"[ESCOBAR-WS] Docker container detected, but hostname '{parsed.hostname}' is not localhost/127.0.0.1, keeping original: {url}")
         
         return url
     
@@ -299,25 +254,6 @@ class WebSocketProxyHandler(tornado.websocket.WebSocketHandler):
         super().__init__(*args, **kwargs)
         self.target_ws = None
         
-        # Generate unique connection ID for tracking
-        self.connection_id = self._generate_connection_id()
-        self.connection_start_time = time.time()
-        
-        # Add to active connections tracking
-        WebSocketProxyHandler._active_connections[self.connection_id] = {
-            'start_time': self.connection_start_time,
-            'handler': self
-        }
-        
-        # Log connection creation
-        self._log_connection_lifecycle("HANDLER_CREATED", {
-            'connection_id': self.connection_id,
-            'total_connections': len(WebSocketProxyHandler._active_connections)
-        })
-        
-        # Log system state at connection creation
-        self._log_system_state("CONNECTION_INIT")
-        
         # Debug environment information
         print(f"[ESCOBAR-WS] Environment WEBSOCKET_PROXY_TARGET: {os.getenv('WEBSOCKET_PROXY_TARGET', 'NOT_SET')}")
         print(f"[ESCOBAR-WS] Running in container: {os.path.exists('/.dockerenv')}")
@@ -336,39 +272,28 @@ class WebSocketProxyHandler(tornado.websocket.WebSocketHandler):
         print(f"[ESCOBAR-WS] All WEBSOCKET environment vars: {websocket_env_vars}")
         
         self.is_closing = False
-        self.message_count_sent = 0
-        self.message_count_received = 0
-        self.last_activity_time = time.time()
     
     def _get_user_bonnie_url(self):
         """
         Get user-configured Bonnie URL from bonnie_url query parameter.
         This allows the frontend to override the environment variable.
         """
-        print(f"[ESCOBAR-WS] === READING USER BONNIE URL FROM QUERY PARAMETER ===")
-        
         try:
             # Get the bonnieUrl from query parameters
             bonnie_url = self.get_argument('bonnie_url', None)
-            print(f"[ESCOBAR-WS] bonnie_url query parameter value: '{bonnie_url}'")
             
             if bonnie_url and bonnie_url.strip():
                 # Validate that it's a WebSocket URL
                 if bonnie_url.startswith(('ws://', 'wss://')):
-                    print(f"[ESCOBAR-WS] Valid user Bonnie URL from query parameter: {bonnie_url}")
                     return bonnie_url.strip()
                 else:
-                    print(f"[ESCOBAR-WS] Invalid Bonnie URL format (must start with ws:// or wss://): {bonnie_url}")
                     return None
             else:
-                print(f"[ESCOBAR-WS] No bonnie_url query parameter provided")
                 return None
                 
         except Exception as e:
             print(f"[ESCOBAR-WS] Error reading bonnie_url query parameter: {e}")
             return None
-        finally:
-            print(f"[ESCOBAR-WS] === END BONNIE URL QUERY PARAMETER READ ===")
     
     def _get_target_url(self):
         """
@@ -482,136 +407,38 @@ class WebSocketProxyHandler(tornado.websocket.WebSocketHandler):
     
     async def on_message(self, message):
         """Called when a message is received from the client"""
-        print(f"[ESCOBAR-WS] === CLIENT MESSAGE RECEIVED ===")
-        print(f"[ESCOBAR-WS] Message length: {len(message)}")
-        print(f"[ESCOBAR-WS] Message type: {type(message)}")
-        print(f"[ESCOBAR-WS] Message preview: {message[:500]}...")
-        print(f"[ESCOBAR-WS] Target WS exists: {self.target_ws is not None}")
-        print(f"[ESCOBAR-WS] Is closing: {self.is_closing}")
-        
         if self.target_ws and not self.is_closing:
-            # Enhanced debugging before forwarding
-            print(f"[ESCOBAR-WS] === PRE-FORWARD DIAGNOSTICS ===")
-            print(f"[ESCOBAR-WS] Target WS type: {type(self.target_ws)}")
-            print(f"[ESCOBAR-WS] Target WS state: {getattr(self.target_ws, 'state', 'NO_STATE_ATTR')}")
-            
-            # Check if connection is actually open
-            try:
-                is_open = self.target_ws.state.name == 'OPEN'
-                print(f"[ESCOBAR-WS] Target WS is OPEN: {is_open}")
-            except AttributeError:
-                print(f"[ESCOBAR-WS] Cannot check target WS state - no state attribute")
-                is_open = True  # Assume open and let send() fail with proper error
-            
-            # Check connection properties
-            try:
-                print(f"[ESCOBAR-WS] Target WS closed property: {getattr(self.target_ws, 'closed', 'NO_CLOSED_ATTR')}")
-            except:
-                print(f"[ESCOBAR-WS] Cannot access target WS closed property")
-            
-            # Message type analysis
-            if isinstance(message, str):
-                print(f"[ESCOBAR-WS] Message is TEXT (string)")
-            elif isinstance(message, bytes):
-                print(f"[ESCOBAR-WS] Message is BINARY (bytes)")
-            else:
-                print(f"[ESCOBAR-WS] Message is UNKNOWN type: {type(message)}")
-            
-            print(f"[ESCOBAR-WS] === ATTEMPTING MESSAGE FORWARD ===")
-            
             try:
                 # Forward message to target server
                 await self.target_ws.send(message)
-                print(f"[ESCOBAR-WS] ✅ Message successfully forwarded to target")
                 logging.debug(f"Forwarded message to target: {message[:100]}...")
             except Exception as e:
-                print(f"[ESCOBAR-WS] ❌ CRITICAL ERROR forwarding message to target:")
-                print(f"[ESCOBAR-WS]   Exception type: {type(e).__name__}")
-                print(f"[ESCOBAR-WS]   Exception message: {str(e)}")
-                print(f"[ESCOBAR-WS]   Exception args: {getattr(e, 'args', 'NO_ARGS')}")
-                
-                # Check target connection state after error
-                try:
-                    print(f"[ESCOBAR-WS]   Target WS state after error: {self.target_ws.state}")
-                except:
-                    print(f"[ESCOBAR-WS]   Cannot check target WS state after error")
-                
-                # Additional exception details
-                if hasattr(e, '__dict__'):
-                    print(f"[ESCOBAR-WS]   Exception attributes: {e.__dict__}")
-                if hasattr(e, 'errno'):
-                    print(f"[ESCOBAR-WS]   Errno: {e.errno}")
-                if hasattr(e, 'strerror'):
-                    print(f"[ESCOBAR-WS]   Strerror: {e.strerror}")
-                
-                # Import specific exception types for better diagnosis
-                import websockets.exceptions
-                if isinstance(e, websockets.exceptions.ConnectionClosed):
-                    print(f"[ESCOBAR-WS]   ConnectionClosed - code: {e.code}, reason: {e.reason}")
-                elif isinstance(e, websockets.exceptions.InvalidState):
-                    print(f"[ESCOBAR-WS]   InvalidState - connection in wrong state")
-                elif isinstance(e, websockets.exceptions.PayloadTooBig):
-                    print(f"[ESCOBAR-WS]   PayloadTooBig - message too large")
-                
+                print(f"[ESCOBAR-WS] ERROR forwarding message to target:")
+                print(f"[ESCOBAR-WS]   Error: {str(e)}")
+                print(f"[ESCOBAR-WS]   Error type: {type(e).__name__}")
                 logging.error(f"Error forwarding message to target: {str(e)}")
-                
-                # Don't close immediately - let's see if we can recover
-                print(f"[ESCOBAR-WS]   Closing client connection due to forward error")
-                self.close(code=1011, reason=f"Target forward error: {type(e).__name__}")
-        else:
-            print(f"[ESCOBAR-WS] Cannot forward message - target_ws: {self.target_ws}, is_closing: {self.is_closing}")
-        print(f"[ESCOBAR-WS] === END CLIENT MESSAGE ===")
+                self.close(code=1011, reason="Target connection error")
     
     async def _forward_from_target(self):
         """Forward messages from target server to client"""
-        print(f"[ESCOBAR-WS] === STARTING TARGET MESSAGE FORWARDING ===")
-        print(f"[ESCOBAR-WS] Target WS state: {self.target_ws.state if self.target_ws else 'None'}")
-        
         try:
-            message_count = 0
             async for message in self.target_ws:
-                message_count += 1
-                print(f"[ESCOBAR-WS] === TARGET MESSAGE #{message_count} ===")
-                print(f"[ESCOBAR-WS] Message length: {len(message)}")
-                print(f"[ESCOBAR-WS] Message type: {type(message)}")
-                print(f"[ESCOBAR-WS] Message preview: {message[:500]}...")
-                print(f"[ESCOBAR-WS] Is closing: {self.is_closing}")
-                
                 if not self.is_closing:
-                    print(f"[ESCOBAR-WS] Forwarding message to client")
                     # Forward message to client
                     self.write_message(message)
-                    print(f"[ESCOBAR-WS] Message successfully forwarded to client")
                     logging.debug(f"Forwarded message from target: {message[:100]}...")
                 else:
-                    print(f"[ESCOBAR-WS] Breaking forwarding loop - connection is closing")
                     break
-                print(f"[ESCOBAR-WS] === END TARGET MESSAGE #{message_count} ===")
                 
         except websockets.exceptions.ConnectionClosed as e:
-            print(f"[ESCOBAR-WS] === TARGET CONNECTION CLOSED DETAILS ===")
-            print(f"[ESCOBAR-WS] Target websocket connection closed")
-            print(f"[ESCOBAR-WS] Close code: {getattr(e, 'code', 'NO_CODE')}")
-            print(f"[ESCOBAR-WS] Close reason: {getattr(e, 'reason', 'NO_REASON')}")
-            print(f"[ESCOBAR-WS] Exception type: {type(e).__name__}")
-            print(f"[ESCOBAR-WS] Exception str: {str(e)}")
-            print(f"[ESCOBAR-WS] Target WS final state: {getattr(self.target_ws, 'state', 'NO_STATE') if self.target_ws else 'NO_TARGET_WS'}")
-            print(f"[ESCOBAR-WS] Messages processed before disconnect: {message_count}")
-            print(f"[ESCOBAR-WS] === END TARGET CONNECTION CLOSED DETAILS ===")
-            
             logging.info(f"Target websocket connection closed - code: {getattr(e, 'code', 'NO_CODE')}, reason: {getattr(e, 'reason', 'NO_REASON')}")
             
             if not self.is_closing:
-                print(f"[ESCOBAR-WS] Closing client connection due to target disconnect")
                 self.close(code=1011, reason="Target server disconnected")
         except Exception as e:
             print(f"[ESCOBAR-WS] === TARGET MESSAGE FORWARDING ERROR ===")
             print(f"[ESCOBAR-WS] Error: {str(e)}")
             print(f"[ESCOBAR-WS] Error type: {type(e).__name__}")
-            print(f"[ESCOBAR-WS] Messages processed before error: {message_count}")
-            print(f"[ESCOBAR-WS] Target WS state: {getattr(self.target_ws, 'state', 'NO_STATE') if self.target_ws else 'NO_TARGET_WS'}")
-            if hasattr(e, '__dict__'):
-                print(f"[ESCOBAR-WS] Error attributes: {e.__dict__}")
             if hasattr(e, 'errno'):
                 print(f"[ESCOBAR-WS] Errno: {e.errno}")
             if hasattr(e, 'strerror'):
@@ -620,66 +447,37 @@ class WebSocketProxyHandler(tornado.websocket.WebSocketHandler):
             
             logging.error(f"Error receiving from target websocket: {str(e)}")
             if not self.is_closing:
-                print(f"[ESCOBAR-WS] Closing client connection due to target error")
                 self.close(code=1011, reason="Target connection error")
-        
-        print(f"[ESCOBAR-WS] === TARGET MESSAGE FORWARDING ENDED ===")
     
     def on_close(self):
         """Called when websocket connection is closed"""
-        print(f"[ESCOBAR-WS] === CLIENT CONNECTION CLOSED ===")
-        print(f"[ESCOBAR-WS] Setting is_closing flag to True")
         self.is_closing = True
-        print(f"[ESCOBAR-WS] Target WS exists: {self.target_ws is not None}")
         
         logging.info("WebSocket connection closed")
         
         # Close target connection if it exists
         if self.target_ws:
-            print(f"[ESCOBAR-WS] Scheduling target connection cleanup")
             asyncio.create_task(self._close_target_connection())
-        else:
-            print(f"[ESCOBAR-WS] No target connection to clean up")
-        
-        print(f"[ESCOBAR-WS] === END CLIENT CONNECTION CLOSED ===")
     
     async def _close_target_connection(self):
         """Safely close the target websocket connection"""
-        print(f"[ESCOBAR-WS] === CLOSING TARGET CONNECTION ===")
         try:
             if self.target_ws:
-                print(f"[ESCOBAR-WS] Target WS exists, checking state")
-                print(f"[ESCOBAR-WS] Target WS type: {type(self.target_ws)}")
-                print(f"[ESCOBAR-WS] Target WS state: {getattr(self.target_ws, 'state', 'NO_STATE_ATTR')}")
-                
                 # Check if connection is already closed using the correct websockets library API
                 try:
                     is_closed = self.target_ws.state.name == 'CLOSED'
-                    print(f"[ESCOBAR-WS] Target WS is closed: {is_closed}")
                 except AttributeError:
                     # Fallback: just try to close it regardless of state
-                    print(f"[ESCOBAR-WS] Cannot check state, will attempt to close anyway")
                     is_closed = False
                 
                 if not is_closed:
-                    print(f"[ESCOBAR-WS] Target WS is open, closing it")
                     await self.target_ws.close()
-                    print(f"[ESCOBAR-WS] Target connection closed successfully")
                     logging.info("Target websocket connection closed")
-                else:
-                    print(f"[ESCOBAR-WS] Target WS already closed")
-            else:
-                print(f"[ESCOBAR-WS] No target WS to close")
         except Exception as e:
             print(f"[ESCOBAR-WS] ERROR closing target connection:")
             print(f"[ESCOBAR-WS]   Error: {str(e)}")
             print(f"[ESCOBAR-WS]   Error type: {type(e).__name__}")
-            print(f"[ESCOBAR-WS]   Target WS type: {type(self.target_ws) if self.target_ws else 'None'}")
-            if hasattr(e, '__dict__'):
-                print(f"[ESCOBAR-WS]   Error attributes: {e.__dict__}")
             logging.error(f"Error closing target websocket: {str(e)}")
-        
-        print(f"[ESCOBAR-WS] === END CLOSING TARGET CONNECTION ===")
 
 
 def setup_handlers(web_app):
@@ -747,9 +545,14 @@ def setup_handlers(web_app):
     for pattern in ws_patterns:
         print(f"[ESCOBAR-WS]   - {pattern}")
     
+    # Register the OAuth callback endpoint
+    oauth_callback_pattern = url_path_join(base_url, "static", "oauth-callback.html")
+    print(f"[ESCOBAR-WS] OAuth callback pattern: {oauth_callback_pattern}")
+    
     # Build handlers list with all WebSocket patterns
     handlers = [
         (proxy_pattern, ProxyHandler),
+        (oauth_callback_pattern, OAuthCallbackHandler),
         *[(pattern, WebSocketProxyHandler) for pattern in ws_patterns]
     ]
     

escobar/labextension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escobar",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "description": "AI CHAT EXTENSION",
   "keywords": [
     "jupyter",
@@ -123,7 +123,7 @@
     "outputDir": "escobar/labextension",
     "schemaDir": "schema",
     "_build": {
-      "load": "static/remoteEntry.c9a1accf3c70050fa880.js",
+      "load": "static/remoteEntry.48a97be89d680e21e498.js",
       "extension": "./extension",
       "style": "./style"
     }

escobar/labextension/schemas/escobar/package.json.orig

@@ -1,6 +1,6 @@
 {
   "name": "escobar",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "description": "AI CHAT EXTENSION",
   "keywords": [
     "jupyter",

escobar/labextension/schemas/escobar/plugin.json

@@ -38,8 +38,8 @@
     },
     "googleClientId": {
       "type": "string",
-      "title": "Google OAuth Client ID",
-      "description": "Google OAuth 2.0 Client ID for authentication. Get this from Google Cloud Console.",
+      "title": "Google Client ID",
+      "description": "Google OAuth Client ID for authentication. Get this from Google Cloud Console.",
       "default": ""
     }
   },