claude-all-config 2.0.0

package/claude-suite/auth/gemini_auth.py

@@ -0,0 +1,80 @@
+import os
+import json
+import sys
+import logging
+
+# Configure logging to suppress stderr output from libraries
+logging.getLogger('google_auth_oauthlib').setLevel(logging.ERROR)
+logging.getLogger('werkzeug').setLevel(logging.ERROR)
+
+try:
+    from google_auth_oauthlib.flow import InstalledAppFlow
+except ImportError:
+    print("Error: 'google-auth-oauthlib' is required.")
+    print("Run: pip install google-auth-oauthlib")
+    sys.exit(1)
+
+# Scopes required for Vertex AI
+SCOPES = ['https://www.googleapis.com/auth/cloud-platform']
+# Standard location for ADC
+CREDENTIALS_PATH = os.path.expanduser('~/.config/gcloud/application_default_credentials.json')
+
+def main():
+    print("\n\033[1;34mGoogle Cloud Authentication Helper (No gcloud required)\033[0m")
+    
+    # 1. Client Secret
+    client_config = None
+    if len(sys.argv) > 1 and os.path.exists(sys.argv[1]):
+         client_config = sys.argv[1]
+    else:
+        print("\nTo login, you need an OAuth 2.0 Client ID (Desktop App).")
+        print("1. Go to https://console.cloud.google.com/apis/credentials")
+        print("2. Create Credentials > OAuth client ID > Application type: Desktop app")
+        print("3. Download the JSON file.")
+        print("-----------------------------------------------------")
+        path = input("Enter path to your client_secret.json: ").strip()
+        # Remove quotes if user added them
+        path = path.strip("'" ).strip('"')
+        
+        if os.path.exists(path):
+            client_config = path
+        else:
+            print(f"\033[1;31mError: File not found at {path}\033[0m")
+            return
+
+    # 2. Perform Auth
+    try:
+        print("\n\033[1;33mStarting terminal-based authentication...\033[0m")
+        print("(Copy the link below to your browser if it doesn't open automatically)")
+        flow = InstalledAppFlow.from_client_secrets_file(client_config, SCOPES)
+        # run_console for headless/terminal environments
+        creds = flow.run_console()
+    except Exception as e:
+        print(f"\nError during auth: {e}")
+        print("\n\033[1;33mTrying alternative method...\033[0m")
+        try:
+            # Try with open_browser=False
+            flow = InstalledAppFlow.from_client_secrets_file(client_config, SCOPES)
+            creds = flow.run_local_server(port=0, open_browser=False)
+        except Exception as e2:
+            print(f"\nError during auth: {e2}")
+            print("\n\033[1;31mAuthentication failed. Please ensure you have internet connection.\033[0m")
+            return
+
+    # 3. Save as ADC
+    # ADC format for user credentials
+    adc_data = {
+        "client_id": flow.client_config['client_id'],
+        "client_secret": flow.client_config['client_secret'],
+        "refresh_token": creds.refresh_token,
+        "type": "authorized_user"
+    }
+    
+    os.makedirs(os.path.dirname(CREDENTIALS_PATH), exist_ok=True)
+    with open(CREDENTIALS_PATH, 'w') as f:
+        json.dump(adc_data, f, indent=2)
+        
+    print(f"\n\033[1;32mSuccess! Credentials saved to: {CREDENTIALS_PATH}\033[0m")
+
+if __name__ == '__main__':
+    main()

package/claude-suite/auth/openai_auth.py

@@ -0,0 +1,138 @@
+import sys
+import os
+import json
+import webbrowser
+import requests
+import hashlib
+import base64
+import secrets
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import urlparse, parse_qs
+import threading
+
+# Configuration
+# This Client ID is widely used/found in OpenAI's public SDKs or assumed for CLI apps.
+# If this fails, it means OpenAI has restricted it or rotated it.
+CLIENT_ID = "pdlLIX2Y72MIl2rhLhTE9VV9bN905kBh" # Common Auth0 Client ID for OpenAI
+AUTH_DOMAIN = "auth0.openai.com"
+REDIRECT_URI = "http://localhost:3000/callback"
+SCOPE = "openid profile email offline_access"
+AUDIENCE = "https://api.openai.com/v1"
+
+CREDENTIALS_PATH = os.path.expanduser('~/.config/openai/credentials.json')
+
+class OAuthCallbackHandler(BaseHTTPRequestHandler):
+    code = None
+    
+    def do_GET(self):
+        query = urlparse(self.path).query
+        params = parse_qs(query)
+        
+        if 'code' in params:
+            OAuthCallbackHandler.code = params['code'][0]
+            self.send_response(200)
+            self.send_header('Content-type', 'text/html')
+            self.end_headers()
+            self.wfile.write(b"<html><body><h1>Login Successful!</h1><p>You can close this tab and return to the terminal.</p></body></html>")
+        else:
+            self.send_response(400)
+            self.wfile.write(b"Missing code parameter.")
+            
+    def log_message(self, format, *args):
+        return # Suppress logging
+
+def generate_pkce_pair():
+    verifier = secrets.token_urlsafe(32)
+    digest = hashlib.sha256(verifier.encode()).digest()
+    challenge = base64.urlsafe_b64encode(digest).decode().rstrip('=')
+    return verifier, challenge
+
+def main():
+    print("\n\033[1;35mOpenAI OAuth Helper (Experimental)\033[0m")
+
+    try:
+        # PKCE
+        code_verifier, code_challenge = generate_pkce_pair()
+
+        # Start Listener with error handling
+        try:
+            server = HTTPServer(('localhost', 3000), OAuthCallbackHandler)
+            server_thread = threading.Thread(target=server.handle_request)
+            server_thread.start()
+        except OSError as e:
+            print(f"\n\033[1;31mError: Failed to start callback server: {e}\033[0m")
+            print("Please make sure port 3000 is available.")
+            return
+
+        # Construct Auth URL
+        auth_url = (
+            f"https://{AUTH_DOMAIN}/authorize?"
+            f"response_type=code&"
+            f"client_id={CLIENT_ID}&"
+            f"redirect_uri={REDIRECT_URI}&"
+            f"scope={SCOPE}&"
+            f"audience={AUDIENCE}&"
+            f"code_challenge={code_challenge}&"
+            f"code_challenge_method=S256"
+        )
+
+        print("\n1. Opening browser for login...")
+        print(f"URL: {auth_url}")
+
+        try:
+            webbrowser.open(auth_url)
+        except Exception as e:
+            print(f"\n\033[1;33mWarning: Could not open browser automatically: {e}\033[0m")
+            print("Please manually open the URL above in your browser.")
+
+        print("\n2. Waiting for callback...")
+        server_thread.join(timeout=120)  # 2 minute timeout
+
+        if not OAuthCallbackHandler.code:
+            print("\n\033[1;31mError: Failed to capture authorization code or timeout expired.\033[0m")
+            print("Please try again and make sure to complete the authentication within 2 minutes.")
+            return
+
+        print("\n3. Exchanging code for tokens...")
+
+        token_url = f"https://{AUTH_DOMAIN}/oauth/token"
+        payload = {
+            "grant_type": "authorization_code",
+            "client_id": CLIENT_ID,
+            "code_verifier": code_verifier,
+            "code": OAuthCallbackHandler.code,
+            "redirect_uri": REDIRECT_URI,
+        }
+
+        try:
+            response = requests.post(token_url, json=payload, timeout=30)
+            response.raise_for_status()  # Raise exception for HTTP errors
+        except requests.exceptions.RequestException as e:
+            print(f"\n\033[1;31mError: Failed to exchange code for tokens: {e}\033[0m")
+            if hasattr(e, 'response') and e.response is not None:
+                print(f"Response: {e.response.text}")
+            return
+
+        tokens = response.json()
+
+        # Save credentials with error handling
+        try:
+            os.makedirs(os.path.dirname(CREDENTIALS_PATH), exist_ok=True)
+            with open(CREDENTIALS_PATH, 'w') as f:
+                json.dump(tokens, f, indent=2)
+
+            print(f"\n\033[1;32mSuccess! Access Token acquired.\033[0m")
+            print(f"Saved to: {CREDENTIALS_PATH}")
+            print("Note: This token is a standard JWT access token, not a 'sk-' API key.")
+            print("Use it as a Bearer token in headers.")
+        except IOError as e:
+            print(f"\n\033[1;33mWarning: Could not save credentials to file: {e}\033[0m")
+            print("However, the token was successfully acquired.")
+            print("Access Token:", tokens.get('access_token', 'Not available'))
+
+    except Exception as e:
+        print(f"\n\033[1;31mUnexpected error during authentication: {e}\033[0m")
+        return
+
+if __name__ == "__main__":
+    main()