machinaos 0.0.21 → 0.0.23

package/server/routers/websocket.py

@@ -1045,6 +1045,163 @@ async def handle_claude_oauth_status(data: Dict[str, Any], websocket: WebSocket)
     return get_claude_credentials()
 
 
+# ============================================================================
+# Twitter OAuth Handlers
+# ============================================================================
+
+@ws_handler()
+async def handle_twitter_oauth_login(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """
+    Initiate Twitter OAuth 2.0 with PKCE flow.
+
+    Opens browser to Twitter authorization page. After user authorizes,
+    Twitter redirects to /api/twitter/callback which stores tokens.
+    """
+    import webbrowser
+    from services.twitter_oauth import TwitterOAuth
+
+    auth_service = container.auth_service()
+
+    # Get stored client credentials (configured via Credentials Modal)
+    client_id = await auth_service.get_api_key("twitter_client_id")
+    client_secret = await auth_service.get_api_key("twitter_client_secret")
+
+    if not client_id:
+        return {
+            "success": False,
+            "error": "Twitter Client ID not configured. Add your Twitter API credentials first."
+        }
+
+    # Create OAuth instance and generate authorization URL
+    oauth = TwitterOAuth(
+        client_id=client_id,
+        client_secret=client_secret,
+        redirect_uri="http://localhost:3010/api/twitter/callback",
+    )
+
+    auth_data = oauth.generate_authorization_url()
+
+    # Open browser to authorization URL
+    webbrowser.open(auth_data["url"])
+
+    return {
+        "success": True,
+        "message": "Opening Twitter authorization in browser...",
+        "state": auth_data["state"],
+    }
+
+
+@ws_handler()
+async def handle_twitter_oauth_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """
+    Check Twitter OAuth connection status.
+
+    Returns connection status and user info if connected.
+    """
+    from services.twitter_oauth import TwitterOAuth
+
+    auth_service = container.auth_service()
+
+    # Check for stored access token
+    access_token = await auth_service.get_api_key("twitter_access_token")
+
+    if not access_token:
+        return {
+            "connected": False,
+            "username": None,
+            "user_id": None,
+        }
+
+    # Get client credentials for API calls
+    client_id = await auth_service.get_api_key("twitter_client_id") or ""
+    client_secret = await auth_service.get_api_key("twitter_client_secret")
+
+    oauth = TwitterOAuth(
+        client_id=client_id,
+        client_secret=client_secret,
+        redirect_uri="http://localhost:3010/api/twitter/callback",
+    )
+
+    # Verify token by getting user info
+    user_info = await oauth.get_user_info(access_token)
+
+    if not user_info.get("success"):
+        # Try to refresh token
+        refresh_token = await auth_service.get_api_key("twitter_refresh_token")
+        if refresh_token:
+            refresh_result = await oauth.refresh_access_token(refresh_token)
+            if refresh_result.get("success"):
+                # Store new tokens
+                await auth_service.store_api_key(
+                    provider="twitter_access_token",
+                    api_key=refresh_result["access_token"],
+                    models=[],
+                    session_id="default"
+                )
+                if refresh_result.get("refresh_token"):
+                    await auth_service.store_api_key(
+                        provider="twitter_refresh_token",
+                        api_key=refresh_result["refresh_token"],
+                        models=[],
+                        session_id="default"
+                    )
+                # Retry user info
+                user_info = await oauth.get_user_info(refresh_result["access_token"])
+
+    if not user_info.get("success"):
+        return {
+            "connected": False,
+            "username": None,
+            "user_id": None,
+            "error": user_info.get("error"),
+        }
+
+    return {
+        "connected": True,
+        "username": user_info.get("username"),
+        "user_id": user_info.get("id"),
+        "name": user_info.get("name"),
+        "profile_image_url": user_info.get("profile_image_url"),
+        "verified": user_info.get("verified"),
+    }
+
+
+@ws_handler()
+async def handle_twitter_logout(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """
+    Disconnect Twitter by revoking tokens and clearing stored credentials.
+    """
+    from services.twitter_oauth import TwitterOAuth
+
+    auth_service = container.auth_service()
+
+    # Get stored tokens
+    access_token = await auth_service.get_api_key("twitter_access_token")
+    refresh_token = await auth_service.get_api_key("twitter_refresh_token")
+    client_id = await auth_service.get_api_key("twitter_client_id") or ""
+    client_secret = await auth_service.get_api_key("twitter_client_secret")
+
+    # Revoke tokens if we have them
+    if access_token or refresh_token:
+        oauth = TwitterOAuth(
+            client_id=client_id,
+            client_secret=client_secret,
+            redirect_uri="http://localhost:3010/api/twitter/callback",
+        )
+
+        if access_token:
+            await oauth.revoke_token(access_token, "access_token")
+        if refresh_token:
+            await oauth.revoke_token(refresh_token, "refresh_token")
+
+    # Clear stored credentials
+    await auth_service.remove_api_key("twitter_access_token")
+    await auth_service.remove_api_key("twitter_refresh_token")
+    await auth_service.remove_api_key("twitter_user_info")
+
+    return {"success": True, "message": "Twitter disconnected"}
+
+
 @ws_handler("url")
 async def handle_test_ai_proxy(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
     """Test connectivity to an AI proxy server."""
@@ -2059,6 +2216,149 @@ async def handle_configure_compaction(data: Dict[str, Any], websocket: WebSocket
     return {"success": success}
 
 
+@ws_handler()
+async def handle_get_provider_usage_summary(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get aggregated token usage and cost by provider for Credentials Modal."""
+    database = container.database()
+    providers = await database.get_provider_usage_summary()
+    return {"success": True, "providers": providers}
+
+
+# ============================================================================
+# Agent Team Handlers
+# ============================================================================
+
+@ws_handler("workflow_id", "team_lead_node_id")
+async def handle_create_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Create a new agent team."""
+    from services.agent_team import get_agent_team_service
+    service = get_agent_team_service()
+    team = await service.create_team(
+        team_lead_node_id=data["team_lead_node_id"],
+        teammate_node_ids=data.get("teammates", []),
+        workflow_id=data["workflow_id"],
+        config=data.get("config")
+    )
+    return {"team": team} if team else {"success": False, "error": "Failed to create team"}
+
+
+@ws_handler("team_id")
+async def handle_get_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get team info."""
+    database = container.database()
+    team = await database.get_team(data["team_id"])
+    return {"team": team} if team else {"success": False, "error": "Team not found"}
+
+
+@ws_handler()
+async def handle_get_team_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get team status with stats.
+
+    Can provide team_id directly, or team_lead_node_id to find active team.
+    """
+    from services.agent_team import get_agent_team_service
+
+    try:
+        service = get_agent_team_service()
+    except RuntimeError:
+        # Service not initialized - no active teams
+        return {"status": {"members": [], "task_count": 0, "completed_count": 0, "active_count": 0, "pending_count": 0, "failed_count": 0, "active_tasks": []}}
+
+    team_id = data.get("team_id")
+
+    # If no team_id, try to find by team_lead_node_id
+    if not team_id and data.get("team_lead_node_id"):
+        # Look up active team for this workflow (most recent)
+        # This is a simple approach - check if there's an active team with this lead
+        # For now, return empty status - teams are created when AI Employee runs
+        return {"status": {"members": [], "task_count": 0, "completed_count": 0, "active_count": 0, "pending_count": 0, "failed_count": 0, "active_tasks": [], "message": "No active team yet"}}
+
+    if not team_id:
+        return {"status": {"members": [], "task_count": 0, "completed_count": 0, "active_count": 0, "pending_count": 0, "failed_count": 0, "active_tasks": [], "message": "No team connected"}}
+
+    status = await service.get_team_status(team_id)
+    return {"status": status}
+
+
+@ws_handler("team_id")
+async def handle_dissolve_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Dissolve a team."""
+    from services.agent_team import get_agent_team_service
+    service = get_agent_team_service()
+    success = await service.dissolve_team(data["team_id"], data.get("workflow_id"))
+    return {"success": success}
+
+
+@ws_handler("team_id", "title", "created_by")
+async def handle_add_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Add task to team."""
+    from services.agent_team import get_agent_team_service
+    service = get_agent_team_service()
+    task = await service.add_task(
+        team_id=data["team_id"],
+        title=data["title"],
+        created_by=data["created_by"],
+        description=data.get("description"),
+        priority=data.get("priority", 3),
+        depends_on=data.get("depends_on")
+    )
+    return {"task": task} if task else {"success": False, "error": "Failed to add task"}
+
+
+@ws_handler("team_id", "task_id", "agent_node_id")
+async def handle_claim_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Claim a task."""
+    from services.agent_team import get_agent_team_service
+    service = get_agent_team_service()
+    task = await service.claim_task(data["team_id"], data["task_id"], data["agent_node_id"])
+    return {"task": task} if task else {"success": False, "error": "Task unavailable"}
+
+
+@ws_handler("team_id", "task_id")
+async def handle_complete_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Complete a task."""
+    from services.agent_team import get_agent_team_service
+    service = get_agent_team_service()
+    success = await service.complete_task(data["team_id"], data["task_id"], data.get("result"))
+    return {"success": success}
+
+
+@ws_handler("team_id")
+async def handle_get_team_tasks(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get team tasks."""
+    database = container.database()
+    tasks = await database.get_team_tasks(data["team_id"], data.get("status"))
+    return {"tasks": tasks}
+
+
+@ws_handler("team_id", "from_agent", "content")
+async def handle_send_team_message(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Send message in team."""
+    from services.agent_team import get_agent_team_service
+    service = get_agent_team_service()
+    msg = await service.send_message(
+        team_id=data["team_id"],
+        from_agent=data["from_agent"],
+        content=data["content"],
+        to_agent=data.get("to_agent"),
+        message_type=data.get("message_type", "direct")
+    )
+    return {"message": msg} if msg else {"success": False, "error": "Failed to send message"}
+
+
+@ws_handler("team_id")
+async def handle_get_team_messages(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get team messages."""
+    from services.agent_team import get_agent_team_service
+    service = get_agent_team_service()
+    messages = await service.get_messages(
+        team_id=data["team_id"],
+        agent_node_id=data.get("agent_node_id"),
+        unread_only=data.get("unread_only", False)
+    )
+    return {"messages": messages}
+
+
 # ============================================================================
 # Message Router
 # ============================================================================
@@ -2123,6 +2423,11 @@ MESSAGE_HANDLERS: Dict[str, MessageHandler] = {
     "claude_oauth_login": handle_claude_oauth_login,
     "claude_oauth_status": handle_claude_oauth_status,
 
+    # Twitter OAuth operations
+    "twitter_oauth_login": handle_twitter_oauth_login,
+    "twitter_oauth_status": handle_twitter_oauth_status,
+    "twitter_logout": handle_twitter_logout,
+
     # Android operations
     "get_android_devices": handle_get_android_devices,
     "execute_android_action": handle_execute_android_action,
@@ -2195,6 +2500,21 @@ MESSAGE_HANDLERS: Dict[str, MessageHandler] = {
     # Compaction
     "get_compaction_stats": handle_get_compaction_stats,
     "configure_compaction": handle_configure_compaction,
+
+    # Provider Usage Summary
+    "get_provider_usage_summary": handle_get_provider_usage_summary,
+
+    # Agent Teams
+    "create_team": handle_create_team,
+    "get_team": handle_get_team,
+    "get_team_status": handle_get_team_status,
+    "dissolve_team": handle_dissolve_team,
+    "add_team_task": handle_add_team_task,
+    "claim_team_task": handle_claim_team_task,
+    "complete_team_task": handle_complete_team_task,
+    "get_team_tasks": handle_get_team_tasks,
+    "send_team_message": handle_send_team_message,
+    "get_team_messages": handle_get_team_messages,
 }
 
 

package/server/services/agent_team.py

@@ -0,0 +1,266 @@
+"""Agent Team Service - Claude SDK Agent Teams pattern.
+
+Coordinates multi-agent teams with shared task lists and messaging.
+Teams are scoped to specific workflow executions.
+"""
+
+import uuid
+from typing import Dict, Any, List, Optional
+from core.database import Database
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class AgentTeamService:
+    """Service for managing agent teams.
+
+    Teams are workflow-specific - each team belongs to a workflow execution.
+    """
+
+    def __init__(self, database: Database, broadcaster=None):
+        self.database = database
+        self.broadcaster = broadcaster
+        # Track active teams per workflow
+        self._active_teams: Dict[str, str] = {}  # workflow_id -> team_id
+
+    # -------------------------------------------------------------------------
+    # Team Lifecycle
+    # -------------------------------------------------------------------------
+
+    async def create_team(
+        self,
+        team_lead_node_id: str,
+        teammate_node_ids: List[Dict[str, Any]],
+        workflow_id: str,
+        config: Optional[Dict[str, Any]] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Create a team with lead and teammates.
+
+        Args:
+            team_lead_node_id: Node ID of the team lead agent
+            teammate_node_ids: List of {node_id, node_type, label} for teammates
+            workflow_id: Workflow containing the team
+            config: Team configuration (mode: parallel/sequential/hybrid)
+
+        Returns:
+            Team dict or None on failure
+        """
+        team_id = f"team_{uuid.uuid4().hex[:12]}"
+
+        # Create team
+        team = await self.database.create_team(
+            team_id=team_id,
+            workflow_id=workflow_id,
+            team_lead_node_id=team_lead_node_id,
+            config=config or {"mode": "parallel"}
+        )
+        if not team:
+            return None
+
+        # Add team lead as member
+        await self.database.add_team_member(
+            team_id=team_id,
+            agent_node_id=team_lead_node_id,
+            agent_type="orchestrator_agent",
+            role="team_lead"
+        )
+
+        # Add teammates
+        for teammate in teammate_node_ids:
+            await self.database.add_team_member(
+                team_id=team_id,
+                agent_node_id=teammate["node_id"],
+                agent_type=teammate.get("node_type", "agent"),
+                agent_label=teammate.get("label"),
+                role="teammate"
+            )
+
+        # Broadcast team creation
+        if self.broadcaster:
+            await self.broadcaster.broadcast_team_event(team_id, "team_created", {
+                "team_id": team_id,
+                "workflow_id": workflow_id,
+                "member_count": len(teammate_node_ids) + 1
+            })
+
+        # Track active team for this workflow
+        self._active_teams[workflow_id] = team_id
+
+        logger.info(f"[Teams] Created team {team_id} with {len(teammate_node_ids)} teammates")
+        return {"team_id": team_id, **team}
+
+    def get_active_team_for_workflow(self, workflow_id: str) -> Optional[str]:
+        """Get the active team ID for a workflow."""
+        return self._active_teams.get(workflow_id)
+
+    async def dissolve_team(self, team_id: str, workflow_id: Optional[str] = None) -> bool:
+        """Dissolve a team."""
+        success = await self.database.update_team_status(team_id, "dissolved")
+        if success:
+            # Remove from active teams tracking
+            if workflow_id and workflow_id in self._active_teams:
+                del self._active_teams[workflow_id]
+            if self.broadcaster:
+                await self.broadcaster.broadcast_team_event(team_id, "team_dissolved", {"team_id": team_id})
+        return success
+
+    async def get_team_status(self, team_id: str) -> Dict[str, Any]:
+        """Get comprehensive team status."""
+        return await self.database.get_team_stats(team_id)
+
+    # -------------------------------------------------------------------------
+    # Task Management
+    # -------------------------------------------------------------------------
+
+    async def add_task(
+        self,
+        team_id: str,
+        title: str,
+        created_by: str,
+        description: Optional[str] = None,
+        priority: int = 3,
+        depends_on: Optional[List[str]] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Add a task to the shared task list."""
+        task_id = f"task_{uuid.uuid4().hex[:12]}"
+
+        task = await self.database.add_team_task(
+            task_id=task_id,
+            team_id=team_id,
+            title=title,
+            created_by=created_by,
+            description=description,
+            priority=priority,
+            depends_on=depends_on
+        )
+
+        if task and self.broadcaster:
+            await self.broadcaster.broadcast_team_event(team_id, "task_added", task)
+
+        return task
+
+    async def claim_task(self, team_id: str, task_id: str, agent_node_id: str) -> Optional[Dict[str, Any]]:
+        """Claim a task for an agent."""
+        # Update member status to working
+        await self.database.update_member_status(team_id, agent_node_id, "working")
+
+        task = await self.database.claim_task(task_id, agent_node_id)
+
+        if task and self.broadcaster:
+            await self.broadcaster.broadcast_team_event(team_id, "task_claimed", {
+                **task, "claimed_by": agent_node_id
+            })
+
+        return task
+
+    async def complete_task(self, team_id: str, task_id: str, result: Optional[Dict[str, Any]] = None) -> bool:
+        """Mark a task as completed."""
+        # Get task to find assigned agent
+        tasks = await self.database.get_team_tasks(team_id)
+        task = next((t for t in tasks if t["id"] == task_id), None)
+
+        success = await self.database.complete_task(task_id, result)
+
+        if success:
+            # Update member status back to idle
+            if task and task.get("assigned_to"):
+                await self.database.update_member_status(team_id, task["assigned_to"], "idle")
+
+            if self.broadcaster:
+                await self.broadcaster.broadcast_team_event(team_id, "task_completed", {
+                    "task_id": task_id, "result": result
+                })
+
+        return success
+
+    async def fail_task(self, team_id: str, task_id: str, error: str) -> bool:
+        """Mark a task as failed."""
+        tasks = await self.database.get_team_tasks(team_id)
+        task = next((t for t in tasks if t["id"] == task_id), None)
+
+        success = await self.database.fail_task(task_id, error)
+
+        if success:
+            if task and task.get("assigned_to"):
+                await self.database.update_member_status(team_id, task["assigned_to"], "idle")
+
+            if self.broadcaster:
+                await self.broadcaster.broadcast_team_event(team_id, "task_failed", {
+                    "task_id": task_id, "error": error
+                })
+
+        return success
+
+    async def get_claimable_tasks(self, team_id: str) -> List[Dict[str, Any]]:
+        """Get tasks ready to be claimed."""
+        return await self.database.get_claimable_tasks(team_id)
+
+    async def is_team_done(self, team_id: str) -> bool:
+        """Check if all tasks are completed/failed."""
+        tasks = await self.database.get_team_tasks(team_id)
+        if not tasks:
+            return True
+        return all(t["status"] in ("completed", "failed", "skipped") for t in tasks)
+
+    # -------------------------------------------------------------------------
+    # Messaging
+    # -------------------------------------------------------------------------
+
+    async def send_message(
+        self,
+        team_id: str,
+        from_agent: str,
+        content: str,
+        to_agent: Optional[str] = None,
+        message_type: str = "direct"
+    ) -> Optional[Dict[str, Any]]:
+        """Send a message to a specific agent or broadcast."""
+        msg = await self.database.add_agent_message(
+            team_id=team_id,
+            from_agent=from_agent,
+            content=content,
+            message_type=message_type if to_agent else "broadcast",
+            to_agent=to_agent
+        )
+
+        if msg and self.broadcaster:
+            await self.broadcaster.broadcast_team_event(team_id, "team_message", msg)
+
+        return msg
+
+    async def broadcast(self, team_id: str, from_agent: str, content: str) -> Optional[Dict[str, Any]]:
+        """Broadcast message to all team members."""
+        return await self.send_message(team_id, from_agent, content, to_agent=None)
+
+    async def get_messages(
+        self,
+        team_id: str,
+        agent_node_id: Optional[str] = None,
+        unread_only: bool = False
+    ) -> List[Dict[str, Any]]:
+        """Get messages for a team or specific agent."""
+        return await self.database.get_agent_messages(team_id, agent_node_id, unread_only)
+
+    async def mark_read(self, team_id: str, agent_node_id: str) -> int:
+        """Mark all messages as read for an agent."""
+        return await self.database.mark_messages_read(team_id, agent_node_id)
+
+
+# Singleton instance
+_service: Optional[AgentTeamService] = None
+
+
+def get_agent_team_service() -> AgentTeamService:
+    """Get the singleton AgentTeamService instance."""
+    global _service
+    if _service is None:
+        raise RuntimeError("AgentTeamService not initialized. Call init_agent_team_service first.")
+    return _service
+
+
+def init_agent_team_service(database: Database, broadcaster=None) -> AgentTeamService:
+    """Initialize the singleton AgentTeamService."""
+    global _service
+    _service = AgentTeamService(database, broadcaster)
+    return _service

package/server/services/ai.py

@@ -2917,6 +2917,49 @@ class AIService:
 
             return TaskManagerSchema
 
+        # Twitter Send tool schema (dual-purpose: workflow node + AI tool)
+        if node_type == 'twitterSend':
+            class TwitterSendSchema(BaseModel):
+                """Post tweets, replies, retweets, and likes on Twitter/X."""
+                action: str = Field(
+                    default="tweet",
+                    description="Action: tweet, reply, retweet, like, unlike, delete"
+                )
+                text: Optional[str] = Field(
+                    default=None,
+                    description="Tweet text (max 280 chars). Required for tweet/reply."
+                )
+                tweet_id: Optional[str] = Field(
+                    default=None,
+                    description="Tweet ID for reply/retweet/like/unlike/delete actions."
+                )
+                reply_to_id: Optional[str] = Field(
+                    default=None,
+                    description="Tweet ID to reply to (alias for tweet_id when action=reply)."
+                )
+
+            return TwitterSendSchema
+
+        # Twitter Search tool schema (dual-purpose: workflow node + AI tool)
+        if node_type == 'twitterSearch':
+            class TwitterSearchSchema(BaseModel):
+                """Search recent tweets on Twitter/X."""
+                query: str = Field(description="Search query (supports X search operators)")
+                max_results: int = Field(default=10, description="Max results (10-100)")
+
+            return TwitterSearchSchema
+
+        # Twitter User tool schema (dual-purpose: workflow node + AI tool)
+        if node_type == 'twitterUser':
+            class TwitterUserSchema(BaseModel):
+                """Look up Twitter/X user profiles and social connections."""
+                operation: str = Field(default="me", description="Operation: me, by_username, by_id, followers, following")
+                username: Optional[str] = Field(default=None, description="Twitter username (without @) for by_username")
+                user_id: Optional[str] = Field(default=None, description="Twitter user ID for by_id/followers/following")
+                max_results: int = Field(default=100, description="Max results for followers/following (1-1000)")
+
+            return TwitterUserSchema
+
         # Check delegated tasks schema (built-in tool for result retrieval)
         if node_type == '_builtin_check_delegated_tasks':
             class CheckDelegatedTasksSchema(BaseModel):