PyPI - janet-cli - Versions diffs - 0.2.2__py3-none-any.whl - Mend

janet-cli 0.2.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

janet/__init__.py +3 -0
janet/__main__.py +6 -0
janet/api/__init__.py +0 -0
janet/api/client.py +128 -0
janet/api/models.py +92 -0
janet/api/organizations.py +57 -0
janet/api/projects.py +57 -0
janet/api/tickets.py +125 -0
janet/auth/__init__.py +0 -0
janet/auth/callback_server.py +360 -0
janet/auth/oauth_flow.py +276 -0
janet/auth/token_manager.py +92 -0
janet/cli.py +602 -0
janet/config/__init__.py +0 -0
janet/config/manager.py +116 -0
janet/config/models.py +66 -0
janet/markdown/__init__.py +0 -0
janet/markdown/generator.py +272 -0
janet/markdown/yjs_converter.py +225 -0
janet/sync/__init__.py +0 -0
janet/sync/file_manager.py +199 -0
janet/sync/readme_generator.py +174 -0
janet/sync/sync_engine.py +271 -0
janet/utils/__init__.py +0 -0
janet/utils/console.py +39 -0
janet/utils/errors.py +49 -0
janet/utils/paths.py +66 -0
janet_cli-0.2.2.dist-info/METADATA +220 -0
janet_cli-0.2.2.dist-info/RECORD +33 -0
janet_cli-0.2.2.dist-info/WHEEL +5 -0
janet_cli-0.2.2.dist-info/entry_points.txt +2 -0
janet_cli-0.2.2.dist-info/licenses/LICENSE +21 -0
janet_cli-0.2.2.dist-info/top_level.txt +1 -0

janet/auth/callback_server.py ADDED Viewed

@@ -0,0 +1,360 @@
+"""Local HTTP server for OAuth callback."""
+import threading
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Optional
+from janet.utils.console import console
+class CallbackHandler(BaseHTTPRequestHandler):
+    """HTTP request handler for OAuth callback."""
+    authorization_code: Optional[str] = None
+    error: Optional[str] = None
+    def do_GET(self) -> None:
+        """Handle GET request to callback URL."""
+        # Parse query parameters
+        parsed_url = urllib.parse.urlparse(self.path)
+        params = urllib.parse.parse_qs(parsed_url.query)
+        if "code" in params:
+            # Successful authorization
+            CallbackHandler.authorization_code = params["code"][0]
+            self.send_success_response()
+        elif "error" in params:
+            # Authorization error
+            CallbackHandler.error = params.get("error_description", ["Unknown error"])[0]
+            self.send_error_response()
+        else:
+            # Invalid callback
+            self.send_error_response("Invalid callback parameters")
+    def send_success_response(self) -> None:
+        """Send success HTML response."""
+        self.send_response(200)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        html = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Janet AI - Authentication Successful</title>
+            <link rel="icon" href="https://app.tryjanet.ai/logo-favicon.png">
+            <style>
+                * {
+                    margin: 0;
+                    padding: 0;
+                    box-sizing: border-box;
+                }
+                body {
+                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Helvetica', 'Arial', sans-serif;
+                    display: flex;
+                    justify-content: center;
+                    align-items: center;
+                    min-height: 100vh;
+                    background: #ffffff;
+                    color: #171717;
+                }
+                @media (prefers-color-scheme: dark) {
+                    body {
+                        background: rgb(38, 38, 38);
+                        color: #ededed;
+                    }
+                    .container {
+                        background: rgb(50, 50, 50) !important;
+                        border: 1px solid #333 !important;
+                    }
+                    h1 {
+                        color: #ededed !important;
+                    }
+                    p {
+                        color: #a3a3a3 !important;
+                    }
+                    .logo {
+                        filter: brightness(0) invert(1);
+                    }
+                }
+                .container {
+                    background: white;
+                    padding: 3rem 2rem;
+                    border-radius: 12px;
+                    border: 1px solid #e5e5e5;
+                    text-align: center;
+                    max-width: 480px;
+                    width: 90%;
+                    animation: fadeIn 0.3s ease-out;
+                }
+                .logo {
+                    width: 180px;
+                    height: auto;
+                    margin: 0 auto 2.5rem;
+                }
+                .success-icon {
+                    width: 64px;
+                    height: 64px;
+                    margin: 0 auto 1.5rem;
+                    background: #10b981;
+                    border-radius: 50%;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                }
+                .success-icon svg {
+                    width: 36px;
+                    height: 36px;
+                    color: white;
+                }
+                h1 {
+                    font-size: 1.5rem;
+                    font-weight: 600;
+                    color: #171717;
+                    margin-bottom: 0.75rem;
+                }
+                p {
+                    color: #737373;
+                    line-height: 1.6;
+                    font-size: 0.95rem;
+                }
+                @keyframes fadeIn {
+                    from {
+                        opacity: 0;
+                        transform: translateY(10px);
+                    }
+                    to {
+                        opacity: 1;
+                        transform: translateY(0);
+                    }
+                }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <img src="https://app.tryjanet.ai/Full%20Logo.svg" alt="Janet AI" class="logo">
+                <div class="success-icon">
+                    <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="3" d="M5 13l4 4L19 7" />
+                    </svg>
+                </div>
+                <h1>Authentication Successful</h1>
+                <p>Return to your terminal to continue.</p>
+            </div>
+        </body>
+        </html>
+        """
+        self.wfile.write(html.encode())
+    def send_error_response(self, error_message: str = "Authentication failed") -> None:
+        """Send error HTML response."""
+        self.send_response(400)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        html = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Janet AI - Authentication Failed</title>
+            <link rel="icon" href="https://app.tryjanet.ai/logo-favicon.png">
+            <style>
+                * {{
+                    margin: 0;
+                    padding: 0;
+                    box-sizing: border-box;
+                }}
+                body {{
+                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Helvetica', 'Arial', sans-serif;
+                    display: flex;
+                    justify-content: center;
+                    align-items: center;
+                    min-height: 100vh;
+                    background: #ffffff;
+                    color: #171717;
+                }}
+                @media (prefers-color-scheme: dark) {{
+                    body {{
+                        background: rgb(38, 38, 38);
+                        color: #ededed;
+                    }}
+                    .container {{
+                        background: rgb(50, 50, 50) !important;
+                        border: 1px solid #333 !important;
+                    }}
+                    h1 {{
+                        color: #ededed !important;
+                    }}
+                    p {{
+                        color: #a3a3a3 !important;
+                    }}
+                    .logo {{
+                        filter: brightness(0) invert(1);
+                    }}
+                }}
+                .container {{
+                    background: white;
+                    padding: 3rem 2rem;
+                    border-radius: 12px;
+                    border: 1px solid #e5e5e5;
+                    text-align: center;
+                    max-width: 480px;
+                    width: 90%;
+                    animation: fadeIn 0.3s ease-out;
+                }}
+                .logo {{
+                    width: 180px;
+                    height: auto;
+                    margin: 0 auto 2.5rem;
+                }}
+                .error-icon {{
+                    width: 64px;
+                    height: 64px;
+                    margin: 0 auto 1.5rem;
+                    background: #ef4444;
+                    border-radius: 50%;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                }}
+                .error-icon svg {{
+                    width: 36px;
+                    height: 36px;
+                    color: white;
+                }}
+                h1 {{
+                    font-size: 1.5rem;
+                    font-weight: 600;
+                    color: #171717;
+                    margin-bottom: 0.75rem;
+                }}
+                p {{
+                    color: #737373;
+                    line-height: 1.6;
+                    font-size: 0.95rem;
+                }}
+                @keyframes fadeIn {{
+                    from {{
+                        opacity: 0;
+                        transform: translateY(10px);
+                    }}
+                    to {{
+                        opacity: 1;
+                        transform: translateY(0);
+                    }}
+                }}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <img src="https://app.tryjanet.ai/Full%20Logo.svg" alt="Janet AI" class="logo">
+                <div class="error-icon">
+                    <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="3" d="M6 18L18 6M6 6l12 12" />
+                    </svg>
+                </div>
+                <h1>Authentication Failed</h1>
+                <p>Please return to your terminal and try again.</p>
+            </div>
+        </body>
+        </html>
+        """
+        self.wfile.write(html.encode())
+    def log_message(self, format: str, *args) -> None:
+        """Suppress default HTTP server logging."""
+        pass
+class CallbackServer:
+    """Lightweight HTTP server for OAuth callback."""
+    def __init__(self, port: int = 8765):
+        """
+        Initialize callback server.
+        Args:
+            port: Port to listen on (default: 8765)
+        """
+        self.port = port
+        self.server: Optional[HTTPServer] = None
+        self.thread: Optional[threading.Thread] = None
+    def start(self) -> None:
+        """Start server in background thread."""
+        # Reset state
+        CallbackHandler.authorization_code = None
+        CallbackHandler.error = None
+        # Try to start server on specified port, fallback to next ports if busy
+        # Use 127.0.0.1 instead of localhost for WorkOS compatibility
+        for attempt_port in range(self.port, self.port + 10):
+            try:
+                self.server = HTTPServer(("127.0.0.1", attempt_port), CallbackHandler)
+                self.port = attempt_port
+                break
+            except OSError:
+                continue
+        else:
+            raise RuntimeError("Failed to start callback server: all ports busy")
+        # Start server in background thread
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+    def wait_for_code(self, timeout: int = 300) -> str:
+        """
+        Wait for authorization code from callback.
+        Args:
+            timeout: Timeout in seconds (default: 5 minutes)
+        Returns:
+            Authorization code
+        Raises:
+            TimeoutError: If timeout reached
+            RuntimeError: If authorization error occurred
+        """
+        if not self.server:
+            raise RuntimeError("Server not started")
+        import time
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if CallbackHandler.authorization_code:
+                code = CallbackHandler.authorization_code
+                self.stop()
+                return code
+            if CallbackHandler.error:
+                error = CallbackHandler.error
+                self.stop()
+                raise RuntimeError(f"Authorization error: {error}")
+            time.sleep(0.1)
+        self.stop()
+        raise TimeoutError("Timeout waiting for authorization callback")
+    def stop(self) -> None:
+        """Stop the server."""
+        if self.server:
+            self.server.shutdown()
+            self.server = None
+    def get_redirect_uri(self) -> str:
+        """
+        Get the redirect URI for this server.
+        Returns:
+            Redirect URI string
+        """
+        # WorkOS requires 127.0.0.1 (not localhost) for http in production
+        return f"http://127.0.0.1:{self.port}/callback"

janet/auth/oauth_flow.py ADDED Viewed

@@ -0,0 +1,276 @@
+"""WorkOS OAuth PKCE flow implementation."""
+import base64
+import hashlib
+import os
+import secrets
+import urllib.parse
+import webbrowser
+from datetime import datetime, timedelta
+from typing import Dict
+import httpx
+from janet.auth.callback_server import CallbackServer
+from janet.config.manager import ConfigManager
+from janet.config.models import AuthConfig, OrganizationInfo
+from janet.utils.console import console, print_success, print_error, print_info
+from janet.utils.errors import AuthenticationError
+class OAuthFlow:
+    """Handles WorkOS OAuth PKCE flow."""
+    def __init__(self, config_manager: ConfigManager):
+        """
+        Initialize OAuth flow.
+        Args:
+            config_manager: Configuration manager instance
+        """
+        self.config_manager = config_manager
+        self.config = config_manager.get()
+        # WorkOS configuration
+        # For public distribution: Use production client ID (public, not secret)
+        # For development: Override with WORKOS_CLIENT_ID env var
+        self.client_id = os.getenv(
+            "WORKOS_CLIENT_ID",
+            "client_01K3HX06N4GEBHXP0SG87B183V"  # Janet AI CLI production client ID
+        )
+        self.workos_api_url = os.getenv("WORKOS_API_URL", "https://api.workos.com")
+        self.callback_server = CallbackServer(port=8765)
+    def start_login(self) -> Dict:
+        """
+        Start OAuth flow and return authentication tokens.
+        Returns:
+            Dictionary containing access token and user info
+        Raises:
+            AuthenticationError: If authentication fails
+        """
+        try:
+            # Generate PKCE verifier and challenge
+            verifier = self._generate_pkce_verifier()
+            challenge = self._generate_pkce_challenge(verifier)
+            # Start local callback server
+            self.callback_server.start()
+            redirect_uri = self.callback_server.get_redirect_uri()
+            # Build authorization URL
+            auth_url = self._build_auth_url(challenge, redirect_uri)
+            # Open browser for authentication
+            console.print(f"\n[bold]Opening browser for authentication...[/bold]")
+            console.print(f"If the browser doesn't open, visit:\n{auth_url}\n")
+            if not webbrowser.open(auth_url):
+                print_error("Failed to open browser. Please visit the URL above manually.")
+            # Wait for callback with authorization code
+            console.print("Waiting for authentication...")
+            try:
+                auth_code = self.callback_server.wait_for_code(timeout=300)
+            except TimeoutError:
+                raise AuthenticationError("Authentication timeout. Please try again.")
+            except RuntimeError as e:
+                raise AuthenticationError(f"Authentication failed: {e}")
+            print_success("Authorization code received!")
+            # Exchange code for tokens
+            print_info("Exchanging authorization code for access token...")
+            tokens = self._exchange_code_for_tokens(auth_code, verifier, redirect_uri)
+            # Save tokens to config
+            self._save_tokens(tokens)
+            print_success("Authentication successful!")
+            return tokens
+        except AuthenticationError:
+            raise
+        except Exception as e:
+            raise AuthenticationError(f"OAuth flow failed: {e}")
+    def _generate_pkce_verifier(self) -> str:
+        """
+        Generate PKCE code verifier.
+        Returns:
+            Base64-encoded random string
+        """
+        # Generate 43-128 character random string
+        random_bytes = secrets.token_bytes(32)
+        verifier = base64.urlsafe_b64encode(random_bytes).decode("utf-8").rstrip("=")
+        return verifier
+    def _generate_pkce_challenge(self, verifier: str) -> str:
+        """
+        Generate PKCE code challenge from verifier.
+        Args:
+            verifier: PKCE verifier
+        Returns:
+            Base64-encoded SHA256 hash of verifier
+        """
+        challenge_bytes = hashlib.sha256(verifier.encode("utf-8")).digest()
+        challenge = base64.urlsafe_b64encode(challenge_bytes).decode("utf-8").rstrip("=")
+        return challenge
+    def _build_auth_url(self, challenge: str, redirect_uri: str) -> str:
+        """
+        Build WorkOS authorization URL.
+        Args:
+            challenge: PKCE challenge
+            redirect_uri: OAuth callback URL
+        Returns:
+            Complete authorization URL
+        """
+        params = {
+            "client_id": self.client_id,
+            "redirect_uri": redirect_uri,
+            "response_type": "code",
+            "provider": "authkit",  # Use WorkOS AuthKit provider
+            "code_challenge": challenge,
+            "code_challenge_method": "S256",
+        }
+        query_string = urllib.parse.urlencode(params)
+        return f"{self.workos_api_url}/user_management/authorize?{query_string}"
+    def _exchange_code_for_tokens(
+        self, code: str, verifier: str, redirect_uri: str
+    ) -> Dict:
+        """
+        Exchange authorization code for access token.
+        Args:
+            code: Authorization code
+            verifier: PKCE verifier
+            redirect_uri: OAuth callback URL
+        Returns:
+            Token response dictionary
+        Raises:
+            AuthenticationError: If token exchange fails
+        """
+        token_url = f"{self.workos_api_url}/user_management/authenticate"
+        data = {
+            "client_id": self.client_id,
+            "code": code,
+            "code_verifier": verifier,
+            "grant_type": "authorization_code",
+            "redirect_uri": redirect_uri,
+        }
+        try:
+            response = httpx.post(token_url, data=data, timeout=30)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            error_detail = e.response.text
+            raise AuthenticationError(f"Token exchange failed: {error_detail}")
+        except Exception as e:
+            raise AuthenticationError(f"Token exchange failed: {e}")
+    def _save_tokens(self, tokens: Dict) -> None:
+        """
+        Save tokens to configuration.
+        Args:
+            tokens: Token response from WorkOS
+        """
+        # Extract token information
+        access_token = tokens.get("access_token")
+        refresh_token = tokens.get("refresh_token")
+        # WorkOS tokens typically expire in 1 hour
+        expires_in = tokens.get("expires_in", 3600)
+        expires_at = datetime.utcnow() + timedelta(seconds=expires_in)
+        # Extract user information from token
+        # For now, we'll get user info from a separate API call
+        user_info = self._get_user_info(access_token)
+        # Update config
+        config = self.config_manager.get()
+        config.auth = AuthConfig(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            user_id=user_info.get("id"),
+            user_email=user_info.get("email"),
+        )
+        self.config_manager.update(config)
+    def _get_user_info(self, access_token: str) -> Dict:
+        """
+        Get user information from access token.
+        Args:
+            access_token: Access token
+        Returns:
+            User information dictionary
+        """
+        # Use the Janet API to get user profile
+        api_base_url = self.config.api.base_url
+        headers = {"Authorization": f"Bearer {access_token}"}
+        try:
+            response = httpx.get(
+                f"{api_base_url}/api/v1/user/profile", headers=headers, timeout=30
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            # If user info fetch fails, return minimal info
+            console.print(f"[yellow]Warning: Could not fetch user info: {e}[/yellow]")
+            return {"id": "unknown", "email": "unknown"}
+    def refresh_token(self) -> None:
+        """
+        Refresh access token using refresh token.
+        Raises:
+            AuthenticationError: If refresh fails
+        """
+        config = self.config_manager.get()
+        if not config.auth.refresh_token:
+            raise AuthenticationError("No refresh token available. Please log in again.")
+        token_url = f"{self.workos_api_url}/user_management/authenticate"
+        data = {
+            "client_id": self.client_id,
+            "grant_type": "refresh_token",
+            "refresh_token": config.auth.refresh_token,
+        }
+        try:
+            response = httpx.post(token_url, data=data, timeout=30)
+            response.raise_for_status()
+            tokens = response.json()
+            # Update tokens
+            self._save_tokens(tokens)
+            print_info("Access token refreshed")
+        except httpx.HTTPStatusError as e:
+            error_detail = e.response.text
+            raise AuthenticationError(f"Token refresh failed: {error_detail}")
+        except Exception as e:
+            raise AuthenticationError(f"Token refresh failed: {e}")