vibecore 0.2.0a1__py3-none-any.whl → 0.3.0__py3-none-any.whl

vibecore/auth/storage.py

@@ -0,0 +1,111 @@
+"""Secure storage for authentication credentials."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from vibecore.auth.models import AnthropicAuth, ApiKeyCredentials, OAuthCredentials
+
+
+class SecureAuthStorage:
+    """Secure storage for authentication credentials."""
+
+    def __init__(self, app_name: str = "vibecore"):
+        """
+        Initialize secure storage.
+
+        Args:
+            app_name: Application name for storage directory.
+        """
+        # Store in user's local data directory
+        self.storage_path = Path.home() / ".local" / "share" / app_name / "auth.json"
+
+    async def save(self, provider: str, credentials: AnthropicAuth) -> None:
+        """
+        Save credentials securely.
+
+        Args:
+            provider: Provider name (e.g., "anthropic").
+            credentials: Authentication credentials.
+        """
+        # Ensure directory exists
+        self.storage_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Load existing data
+        data = await self._load_all()
+
+        # Convert credentials to dict
+        if isinstance(credentials, OAuthCredentials):
+            cred_dict = {
+                "type": "oauth",
+                "refresh": credentials.refresh,
+                "access": credentials.access,
+                "expires": credentials.expires,
+            }
+        elif isinstance(credentials, ApiKeyCredentials):
+            cred_dict = {"type": "api", "key": credentials.key}
+        else:
+            raise ValueError(f"Unknown credential type: {type(credentials)}")
+
+        # Update credentials
+        data[provider] = cred_dict
+
+        # Write with secure permissions (owner read/write only)
+        self.storage_path.write_text(json.dumps(data, indent=2))
+        os.chmod(self.storage_path, 0o600)
+
+    async def load(self, provider: str) -> AnthropicAuth | None:
+        """
+        Load credentials for a provider.
+
+        Args:
+            provider: Provider name.
+
+        Returns:
+            Authentication credentials or None if not found.
+        """
+        data = await self._load_all()
+        cred_dict = data.get(provider)
+
+        if not cred_dict:
+            return None
+
+        # Convert dict back to credentials object
+        if cred_dict.get("type") == "oauth":
+            return OAuthCredentials(
+                type="oauth",
+                refresh=cred_dict.get("refresh", ""),
+                access=cred_dict.get("access", ""),
+                expires=cred_dict.get("expires", 0),
+            )
+        elif cred_dict.get("type") == "api":
+            return ApiKeyCredentials(type="api", key=cred_dict.get("key", ""))
+
+        return None
+
+    async def remove(self, provider: str) -> None:
+        """
+        Remove credentials for a provider.
+
+        Args:
+            provider: Provider name.
+        """
+        data = await self._load_all()
+        data.pop(provider, None)
+        self.storage_path.write_text(json.dumps(data, indent=2))
+        os.chmod(self.storage_path, 0o600)
+
+    async def _load_all(self) -> dict[str, Any]:
+        """Load all stored credentials."""
+        if not self.storage_path.exists():
+            return {}
+
+        try:
+            return json.loads(self.storage_path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def exists(self) -> bool:
+        """Check if any credentials are stored."""
+        return self.storage_path.exists() and self.storage_path.stat().st_size > 2

vibecore/auth/token_manager.py

@@ -0,0 +1,131 @@
+"""Token management for OAuth authentication."""
+
+import asyncio
+import time
+
+import httpx
+
+from vibecore.auth.config import ANTHROPIC_CONFIG
+from vibecore.auth.models import OAuthCredentials
+from vibecore.auth.storage import SecureAuthStorage
+
+
+class TokenRefreshManager:
+    """Manages OAuth token refresh with automatic renewal."""
+
+    def __init__(self, storage: SecureAuthStorage):
+        """
+        Initialize token refresh manager.
+
+        Args:
+            storage: Secure storage for credentials.
+        """
+        self.storage = storage
+        self.refresh_lock = asyncio.Lock()
+        self.refresh_task: asyncio.Task | None = None
+
+    async def get_valid_token(self) -> str:
+        """
+        Get a valid access token, refreshing if necessary.
+
+        Returns:
+            Valid access token.
+
+        Raises:
+            ValueError: If not authenticated or refresh fails.
+        """
+        auth = await self.storage.load("anthropic")
+
+        if not auth:
+            raise ValueError("Not authenticated")
+
+        if auth.type == "api":  # API key auth
+            return auth.key  # type: ignore
+
+        # OAuth auth - check if token needs refresh
+        now = int(time.time() * 1000)
+        buffer_ms = ANTHROPIC_CONFIG.TOKEN_REFRESH_BUFFER_SECONDS * 1000
+        needs_refresh = not auth.access or auth.expires <= now + buffer_ms  # type: ignore
+
+        if not needs_refresh:
+            return auth.access  # type: ignore
+
+        # Refresh token with lock to prevent concurrent refreshes
+        async with self.refresh_lock:
+            # Re-check after acquiring lock
+            auth = await self.storage.load("anthropic")
+            if auth and auth.type == "oauth":
+                now = int(time.time() * 1000)
+                if auth.access and auth.expires > now + buffer_ms:  # type: ignore
+                    return auth.access  # type: ignore
+
+            # Perform refresh
+            if auth and auth.type == "oauth":
+                return await self._refresh_token(auth.refresh)  # type: ignore
+            else:
+                raise ValueError("Cannot refresh non-OAuth credentials")
+
+    async def _refresh_token(self, refresh_token: str) -> str:
+        """
+        Refresh the access token.
+
+        Args:
+            refresh_token: Refresh token.
+
+        Returns:
+            New access token.
+
+        Raises:
+            httpx.HTTPError: If refresh fails after retries.
+        """
+        last_error: Exception | None = None
+
+        # Retry logic
+        for attempt in range(ANTHROPIC_CONFIG.TOKEN_MAX_RETRY_ATTEMPTS):
+            try:
+                # Exponential backoff for retries
+                if attempt > 0:
+                    delay = ANTHROPIC_CONFIG.TOKEN_RETRY_DELAY_MS * (2 ** (attempt - 1)) / 1000
+                    await asyncio.sleep(delay)
+
+                # Make refresh request
+                async with httpx.AsyncClient() as client:
+                    response = await client.post(
+                        ANTHROPIC_CONFIG.TOKEN_EXCHANGE,
+                        headers={
+                            "Content-Type": "application/json",
+                            "Accept": "application/json",
+                        },
+                        json={
+                            "grant_type": "refresh_token",
+                            "refresh_token": refresh_token,
+                            "client_id": ANTHROPIC_CONFIG.OAUTH_CLIENT_ID,
+                        },
+                        timeout=30.0,
+                    )
+
+                    if response.status_code != 200:
+                        error_text = response.text
+                        raise httpx.HTTPError(f"Token refresh failed: {response.status_code} - {error_text}")
+
+                    tokens_data = response.json()
+
+                # Update stored credentials
+                new_credentials = OAuthCredentials(
+                    type="oauth",
+                    refresh=tokens_data.get("refresh_token", refresh_token),
+                    access=tokens_data["access_token"],
+                    expires=int(time.time() * 1000) + tokens_data["expires_in"] * 1000,
+                )
+
+                await self.storage.save("anthropic", new_credentials)
+                return tokens_data["access_token"]
+
+            except Exception as error:
+                last_error = error
+                print(f"Token refresh attempt {attempt + 1} failed: {error}")
+
+        # All retries failed
+        raise ValueError(
+            f"Token refresh failed after {ANTHROPIC_CONFIG.TOKEN_MAX_RETRY_ATTEMPTS} attempts: {last_error}"
+        )

vibecore/cli.py

@@ -1,6 +1,8 @@
 """Vibecore CLI interface using typer."""
 
+import asyncio
 import logging
+from importlib.metadata import version
 from pathlib import Path
 
 import typer
@@ -14,6 +16,21 @@ from vibecore.settings import settings
 
 app = typer.Typer()
 
+# Create auth subcommand group
+auth_app = typer.Typer(help="Manage Anthropic authentication")
+app.add_typer(auth_app, name="auth")
+
+
+def version_callback(value: bool):
+    """Handle --version flag."""
+    if value:
+        try:
+            pkg_version = version("vibecore")
+        except Exception:
+            pkg_version = "unknown"
+        typer.echo(f"vibecore {pkg_version}")
+        raise typer.Exit()
+
 
 def find_latest_session(project_path: Path | None = None, base_dir: Path | None = None) -> str | None:
     """Find the most recent session file for the current project."""
@@ -45,9 +62,15 @@ def find_latest_session(project_path: Path | None = None, base_dir: Path | None
     return session_files[0].stem
 
 
-@app.command()
-def run(
-    prompt: str | None = typer.Argument(None, help="Prompt text (requires -p flag)"),
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    prompt: str | None = typer.Option(
+        None,
+        "--prompt",
+        "-p",
+        help="Initial prompt to send to the agent (reads from stdin if -p is used without argument)",
+    ),
     continue_session: bool = typer.Option(
         False,
         "--continue",
@@ -63,11 +86,21 @@ def run(
     print_mode: bool = typer.Option(
         False,
         "--print",
-        "-p",
         help="Print response and exit (useful for pipes)",
     ),
+    version: bool | None = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit",
+    ),
 ):
     """Run the Vibecore TUI application."""
+    # If a subcommand was invoked, don't run the main app
+    if ctx.invoked_subcommand is not None:
+        return
+
     # Set up logging
     logging.basicConfig(
         level="WARNING",
@@ -78,14 +111,14 @@ def run(
     logger.addHandler(TextualHandler())
 
     # Create context
-    ctx = VibecoreContext()
+    vibecore_ctx = VibecoreContext()
 
     # Initialize MCP manager if configured
     mcp_servers = []
     if settings.mcp_servers:
         # Create MCP manager
         mcp_manager = MCPManager(settings.mcp_servers)
-        ctx.mcp_manager = mcp_manager
+        vibecore_ctx.mcp_manager = mcp_manager
 
         # Get the MCP servers from the manager
         mcp_servers = mcp_manager.servers
@@ -106,7 +139,7 @@ def run(
         typer.echo(f"Loading session: {session_to_load}")
 
     # Create app
-    app_instance = VibecoreApp(ctx, agent, session_id=session_to_load, print_mode=print_mode)
+    app_instance = VibecoreApp(vibecore_ctx, agent, session_id=session_to_load, print_mode=print_mode)
 
     if print_mode:
         # Run in print mode
@@ -122,10 +155,85 @@ def run(
         app_instance.run()
 
 
-def main():
+@auth_app.command("login")
+def auth_login(
+    provider: str = typer.Argument("anthropic", help="Authentication provider (currently only 'anthropic')"),
+    api_key: str = typer.Option(None, "--api-key", "-k", help="Use API key instead of OAuth"),
+    mode: str = typer.Option(
+        "max", "--mode", "-m", help="OAuth mode: 'max' for claude.ai, 'console' for console.anthropic.com"
+    ),
+):
+    """Authenticate with Anthropic Pro/Max or API key."""
+    if provider.lower() != "anthropic":
+        typer.echo(f"❌ Provider '{provider}' not supported. Currently only 'anthropic' is supported.")
+        raise typer.Exit(1)
+
+    from vibecore.auth.manager import AnthropicAuthManager
+
+    auth_manager = AnthropicAuthManager()
+
+    if api_key:
+        # API key authentication
+        success = asyncio.run(auth_manager.authenticate_with_api_key(api_key))
+        if not success:
+            raise typer.Exit(1)
+    else:
+        # OAuth Pro/Max authentication
+        success = asyncio.run(auth_manager.authenticate_pro_max(mode))
+        if not success:
+            raise typer.Exit(1)
+
+
+@auth_app.command("logout")
+def auth_logout(
+    provider: str = typer.Argument("anthropic", help="Authentication provider"),
+):
+    """Remove stored authentication."""
+    if provider.lower() != "anthropic":
+        typer.echo(f"❌ Provider '{provider}' not supported. Currently only 'anthropic' is supported.")
+        raise typer.Exit(1)
+
+    from vibecore.auth.manager import AnthropicAuthManager
+
+    auth_manager = AnthropicAuthManager()
+    asyncio.run(auth_manager.logout())
+
+
+@auth_app.command("status")
+def auth_status():
+    """Check authentication status."""
+    from vibecore.auth.manager import AnthropicAuthManager
+
+    auth_manager = AnthropicAuthManager()
+
+    if asyncio.run(auth_manager.is_authenticated()):
+        auth_type = asyncio.run(auth_manager.get_auth_type())
+        if auth_type == "oauth":
+            typer.echo("✅ Authenticated with Anthropic Pro/Max (OAuth)")
+        else:
+            typer.echo("✅ Authenticated with Anthropic API key")
+    else:
+        typer.echo("❌ Not authenticated with Anthropic")
+
+
+@auth_app.command("test")
+def auth_test():
+    """Test authentication by making a simple API call."""
+    from vibecore.auth.manager import AnthropicAuthManager
+
+    auth_manager = AnthropicAuthManager()
+
+    typer.echo("🔍 Testing authentication...")
+    success = asyncio.run(auth_manager.test_connection())
+
+    if not success:
+        raise typer.Exit(1)
+
+
+def cli_main():
     """Entry point for the CLI."""
     app()
 
 
 if __name__ == "__main__":
-    main()
+    cli_main()

vibecore/flow.py

@@ -0,0 +1,105 @@
+import asyncio
+import threading
+from collections.abc import Callable, Coroutine
+from typing import Protocol
+
+from agents import Agent
+from textual.pilot import Pilot
+
+from vibecore.context import VibecoreContext
+from vibecore.main import AppIsExiting, VibecoreApp
+from vibecore.widgets.core import MyTextArea
+from vibecore.widgets.messages import SystemMessage
+
+
+class UserInputFunc(Protocol):
+    """Protocol for user input function with optional prompt parameter."""
+
+    async def __call__(self, prompt: str = "") -> str:
+        """Get user input with optional prompt message.
+
+        Args:
+            prompt: Optional prompt to display before getting input.
+
+        Returns:
+            The user's input string.
+        """
+        ...
+
+
+async def flow(
+    agent: Agent,
+    logic: Callable[[VibecoreApp, VibecoreContext, UserInputFunc], Coroutine],
+    headless: bool = False,
+    shutdown: bool = False,
+    disable_user_input: bool = True,
+):
+    ctx = VibecoreContext()
+    app = VibecoreApp(ctx, agent, show_welcome=False)
+
+    app_ready_event = asyncio.Event()
+
+    def on_app_ready() -> None:
+        """Called when app is ready to process events."""
+        app_ready_event.set()
+
+    async def run_app(app: VibecoreApp) -> None:
+        """Run the apps message loop.
+
+        Args:
+            app: App to run.
+        """
+
+        with app._context():
+            try:
+                app._loop = asyncio.get_running_loop()
+                app._thread_id = threading.get_ident()
+                await app._process_messages(
+                    ready_callback=on_app_ready,
+                    headless=headless,
+                )
+            finally:
+                app_ready_event.set()
+
+    async def user_input(prompt: str = "") -> str:
+        if prompt:
+            await app.add_message(SystemMessage(prompt))
+        app.query_one(MyTextArea).disabled = False
+        app.query_one(MyTextArea).focus()
+        user_input = await app.wait_for_user_input()
+        if disable_user_input:
+            app.query_one(MyTextArea).disabled = True
+        return user_input
+
+    async def run_logic(app: VibecoreApp, ctx: VibecoreContext, user_input: UserInputFunc) -> None:
+        try:
+            await logic(app, ctx, user_input)
+        except AppIsExiting:
+            return
+
+    app_task = asyncio.create_task(run_app(app), name=f"with_app({app})")
+    await app_ready_event.wait()
+    pilot = Pilot(app)
+    logic_task: asyncio.Task | None = None
+
+    await pilot._wait_for_screen()
+    if disable_user_input:
+        app.query_one(MyTextArea).disabled = True
+    logic_task = asyncio.create_task(run_logic(app, ctx, user_input), name="logic_task")
+    done, pending = await asyncio.wait([logic_task, app_task], return_when=asyncio.FIRST_COMPLETED)
+
+    # If app has exited and logic is still running, cancel logic
+    if app_task in done and logic_task in pending:
+        logic_task.cancel()
+    # If logic is finished and app is still running
+    elif logic_task in done and app_task in pending:
+        if shutdown:
+            if not headless:
+                await pilot._wait_for_screen()
+                await asyncio.sleep(1.0)
+            app.exit()
+        else:
+            # Enable text input so users can interact freely
+            app.query_one(MyTextArea).disabled = False
+            # Wait until app is exited
+            await app_task

vibecore/handlers/stream_handler.py

@@ -15,6 +15,7 @@ from agents import (
     ToolCallOutputItem,
 )
 from openai.types.responses import (
+    ResponseCompletedEvent,
     ResponseFunctionToolCall,
     ResponseOutputItemAddedEvent,
     ResponseOutputItemDoneEvent,
@@ -123,6 +124,7 @@ class AgentStreamHandler:
         """
         match event:
             case RawResponsesStreamEvent(data=data):
+                # log(f"RawResponsesStreamEvent data: {data.type}")
                 match data:
                     case ResponseOutputItemAddedEvent(item=ResponseReasoningItem() as item):
                         reasoning_id = item.id
@@ -180,7 +182,15 @@ class AgentStreamHandler:
                         else:
                             await self.handle_tool_call(tool_name, arguments, call_id)
 
+                    case ResponseCompletedEvent():
+                        # When in agent handoff or stop at tool situations, the tools should be in executing status.
+                        # We find all the executing status tool messages and mark them as success.
+                        for tool_message in self.tool_messages.values():
+                            if tool_message.status == MessageStatus.EXECUTING:
+                                tool_message.status = MessageStatus.SUCCESS
+
             case RunItemStreamEvent(item=item):
+                # log(f"RunItemStreamEvent item: {item.type}")
                 match item:
                     case ToolCallItem():
                         pass
@@ -196,6 +206,7 @@ class AgentStreamHandler:
                         await self.handle_message_complete()
 
             case AgentUpdatedStreamEvent(new_agent=new_agent):
+                # log(f"AgentUpdatedStreamEvent new_agent: {new_agent.name}")
                 await self.message_handler.handle_agent_update(new_agent)
 
     async def handle_task_tool_event(self, tool_name: str, tool_call_id: str, event: StreamEvent) -> None:

vibecore/main.py

@@ -30,7 +30,11 @@ from vibecore.widgets.core import AppFooter, MainScroll, MyTextArea
 from vibecore.widgets.info import Welcome
 from vibecore.widgets.messages import AgentMessage, BaseMessage, MessageStatus, SystemMessage, UserMessage
 
-AgentStatus = Literal["idle", "running"]
+AgentStatus = Literal["idle", "running", "waiting_user_input"]
+
+
+class AppIsExiting(Exception):
+    pass
 
 
 def detect_reasoning_effort(prompt: str) -> Literal["low", "medium", "high"] | None:
@@ -82,6 +86,7 @@ class VibecoreApp(App):
         agent: Agent,
         session_id: str | None = None,
         print_mode: bool = False,
+        show_welcome: bool = True,
     ) -> None:
         """Initialize the Vibecore app with context and agent.
 
@@ -90,6 +95,7 @@ class VibecoreApp(App):
             agent: The Agent instance to use
             session_id: Optional session ID to load existing session
             print_mode: Whether to run in print mode (useful for pipes)
+            show_welcome: Whether to show the welcome message (default: True)
         """
         self.context = context
         self.context.app = self  # Set the app reference in context
@@ -99,6 +105,7 @@ class VibecoreApp(App):
         self.current_worker: Worker[None] | None = None
         self._session_id_provided = session_id is not None  # Track if continuing session
         self.print_mode = print_mode
+        self.show_welcome = show_welcome
         self.message_queue: deque[str] = deque()  # Queue for user messages
 
         # Initialize session based on settings
@@ -124,7 +131,8 @@ class VibecoreApp(App):
         yield Header()
         yield AppFooter()
         with MainScroll(id="messages"):
-            yield Welcome()
+            if self.show_welcome:
+                yield Welcome()
 
     async def on_mount(self) -> None:
         """Called when the app is mounted."""
@@ -162,6 +170,8 @@ class VibecoreApp(App):
         Args:
             message: The message to add
         """
+        if not self.is_running:
+            raise AppIsExiting("App is not running")
         main_scroll = self.query_one("#messages", MainScroll)
         await main_scroll.mount(message)
 
@@ -225,6 +235,14 @@ class VibecoreApp(App):
         else:
             footer.hide_loading()
 
+    async def wait_for_user_input(self) -> str:
+        """Used in flow mode. See examples/basic_agent.py"""
+        self.agent_status = "waiting_user_input"
+        self.user_input_event = asyncio.Event()
+        await self.user_input_event.wait()
+        user_input = self.message_queue.pop()
+        return user_input
+
     async def on_my_text_area_user_message(self, event: MyTextArea.UserMessage) -> None:
         """Handle user messages from the text area."""
         if event.text:
@@ -248,8 +266,11 @@ class VibecoreApp(App):
             await self.add_message(user_message)
             user_message.scroll_visible()
 
-            # If agent is running, queue the message
+            if self.agent_status == "waiting_user_input":
+                self.message_queue.append(event.text)
+                self.user_input_event.set()
             if self.agent_status == "running":
+                # If agent is running, queue the message
                 self.message_queue.append(event.text)
                 log(f"Message queued: {event.text}")
                 footer = self.query_one(AppFooter)
@@ -268,7 +289,7 @@ class VibecoreApp(App):
                 if reasoning_effort is not None:
                     # Create a copy of the agent with updated model settings
                     current_settings = self.agent.model_settings or ModelSettings()
-                    new_reasoning = Reasoning(effort=reasoning_effort, summary="auto")
+                    new_reasoning = Reasoning(effort=reasoning_effort, summary=settings.reasoning_summary)
                     updated_settings = ModelSettings(
                         include_usage=current_settings.include_usage,
                         reasoning=new_reasoning,
@@ -496,8 +517,9 @@ class VibecoreApp(App):
         for welcome in main_scroll.query("Welcome"):
             welcome.remove()
 
-        # Add welcome widget back
-        await main_scroll.mount(Welcome())
+        # Add welcome widget back if show_welcome is True
+        if self.show_welcome:
+            await main_scroll.mount(Welcome())
 
         # Show system message to confirm the clear operation
         system_message = SystemMessage(f"✨ Session cleared! Started new session: {new_session_id}")