machinaos 0.0.76 → 0.0.78

package/server/routers/twitter.py

@@ -1,365 +0,0 @@
-"""
-Twitter/X OAuth 2.0 callback and API routes.
-
-OAuth flow:
-1. Frontend calls WebSocket 'twitter_oauth_login' handler
-2. Backend generates authorization URL, opens browser
-3. User authorizes on Twitter
-4. Twitter redirects to /api/twitter/callback with code
-5. Backend exchanges code for tokens, stores them via auth_service
-6. Frontend polls WebSocket 'twitter_oauth_status' for completion
-
-Tokens stored as API keys with provider prefixes:
-- twitter_access_token: OAuth access token (expires in 2 hours)
-- twitter_refresh_token: OAuth refresh token (for token renewal)
-"""
-
-from typing import Optional
-
-from fastapi import APIRouter, Query, Request
-from fastapi.responses import HTMLResponse
-
-from core.container import container
-from core.logging import get_logger
-from services.twitter_oauth import TwitterOAuth, get_pending_state
-
-logger = get_logger(__name__)
-router = APIRouter(prefix="/api/twitter", tags=["twitter"])
-
-
-def get_auth_service():
-    """Get auth service for API key storage."""
-    return container.auth_service()
-
-
-@router.get("/callback")
-async def twitter_oauth_callback(
-    code: Optional[str] = Query(None),
-    state: Optional[str] = Query(None),
-    error: Optional[str] = Query(None),
-    error_description: Optional[str] = Query(None),
-):
-    """
-    Handle Twitter OAuth callback.
-
-    Twitter redirects here after user authorizes (or denies) the app.
-    We exchange the code for tokens and store them via auth_service.
-    """
-    # Handle authorization denied
-    if error:
-        logger.warning(f"Twitter OAuth denied: {error} - {error_description}")
-        return HTMLResponse(
-            content=_callback_html(
-                success=False,
-                error=error_description or error,
-            ),
-            status_code=200,
-        )
-
-    # Validate required parameters
-    if not code or not state:
-        logger.error("Twitter OAuth callback missing code or state")
-        return HTMLResponse(
-            content=_callback_html(
-                success=False,
-                error="Missing authorization code or state parameter",
-            ),
-            status_code=400,
-        )
-
-    # Verify state exists (CSRF protection)
-    pending_state = get_pending_state(state)
-    if not pending_state:
-        logger.error("Twitter OAuth callback with invalid/expired state")
-        return HTMLResponse(
-            content=_callback_html(
-                success=False,
-                error="Invalid or expired authorization state. Please try again.",
-            ),
-            status_code=400,
-        )
-
-    # Retrieve redirect_uri from state (set during auth initiation)
-    redirect_uri = pending_state.get("redirect_uri")
-    if not redirect_uri:
-        logger.error("Twitter OAuth callback missing redirect_uri in state")
-        return HTMLResponse(
-            content=_callback_html(
-                success=False,
-                error="Invalid state: missing redirect URI. Please try again.",
-            ),
-            status_code=400,
-        )
-
-    # Get stored client credentials to create OAuth instance
-    auth_service = get_auth_service()
-    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=redirect_uri,
-    )
-
-    # Exchange code for tokens
-    result = await oauth.exchange_code(code=code, state=state)
-
-    if not result.get("success"):
-        logger.error(f"Twitter token exchange failed: {result.get('error')}")
-        return HTMLResponse(
-            content=_callback_html(
-                success=False,
-                error=result.get("error", "Token exchange failed"),
-            ),
-            status_code=400,
-        )
-
-    # Get user info to display and store
-    access_token = result.get("access_token")
-    refresh_token = result.get("refresh_token")
-    user_info = await oauth.get_user_info(access_token)
-
-    if not user_info.get("success"):
-        logger.warning(f"Failed to get Twitter user info: {user_info.get('error')}")
-        username = "Unknown"
-    else:
-        username = user_info.get("username", "Unknown")
-
-    # Store encrypted OAuth tokens via auth_service
-    await auth_service.store_oauth_tokens(
-        provider="twitter",
-        access_token=access_token,
-        refresh_token=refresh_token or "",
-        email=f"@{username}",  # Use @username as identifier (Twitter doesn't provide email)
-        name=user_info.get("name", "") if user_info.get("success") else "",
-        scopes=",".join(result.get("scope", "").split()) if result.get("scope") else "",
-        customer_id="owner",
-    )
-
-    # Broadcast completion event to frontend
-    from services.status_broadcaster import get_status_broadcaster
-    broadcaster = get_status_broadcaster()
-
-    await broadcaster.broadcast({
-        "type": "twitter_oauth_complete",
-        "data": {
-            "success": True,
-            "username": username,
-            "user_id": user_info.get("id"),
-            "name": user_info.get("name"),
-            "profile_image_url": user_info.get("profile_image_url"),
-        }
-    })
-
-    logger.info(f"Twitter OAuth successful for @{username}")
-
-    return HTMLResponse(
-        content=_callback_html(
-            success=True,
-            username=username,
-        ),
-        status_code=200,
-    )
-
-
-@router.get("/status")
-async def get_twitter_status(request: Request):
-    """
-    Get Twitter connection status.
-
-    Returns whether the user is authenticated with Twitter.
-    """
-    from services.oauth_utils import get_redirect_uri
-
-    auth_service = get_auth_service()
-
-    # Try to get stored tokens via auth_service
-    tokens = await auth_service.get_oauth_tokens("twitter", customer_id="owner")
-
-    if not tokens:
-        return {
-            "connected": False,
-            "username": None,
-            "user_id": None,
-        }
-
-    access_token = tokens.get("access_token")
-    refresh_token = tokens.get("refresh_token")
-
-    # Get stored client credentials (these remain in auth_service as they're app-level)
-    client_id = await auth_service.get_api_key("twitter_client_id") or ""
-    client_secret = await auth_service.get_api_key("twitter_client_secret")
-    redirect_uri = get_redirect_uri(request, "twitter")
-
-    oauth = TwitterOAuth(
-        client_id=client_id,
-        client_secret=client_secret,
-        redirect_uri=redirect_uri,
-    )
-
-    # Verify token is still valid by getting user info
-    user_info = await oauth.get_user_info(access_token)
-
-    if not user_info.get("success"):
-        # Token may be expired, try to refresh
-        if refresh_token:
-            refresh_result = await oauth.refresh_access_token(refresh_token)
-            if refresh_result.get("success"):
-                # Store new tokens via auth_service
-                await auth_service.store_oauth_tokens(
-                    provider="twitter",
-                    access_token=refresh_result["access_token"],
-                    refresh_token=refresh_result.get("refresh_token") or refresh_token,
-                    email=tokens.get("email"),
-                    name=tokens.get("name"),
-                    scopes=tokens.get("scopes"),
-                    customer_id="owner",
-                )
-
-                # 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"),
-    }
-
-
-@router.post("/logout")
-async def twitter_logout(request: Request):
-    """
-    Disconnect Twitter by revoking tokens and clearing stored credentials.
-    """
-    from services.oauth_utils import get_redirect_uri
-
-    auth_service = get_auth_service()
-
-    # Get stored tokens via auth_service
-    tokens = await auth_service.get_oauth_tokens("twitter", customer_id="owner")
-
-    if tokens:
-        access_token = tokens.get("access_token")
-        refresh_token = tokens.get("refresh_token")
-
-        # Get client credentials for revocation (app-level, in auth_service)
-        client_id = await auth_service.get_api_key("twitter_client_id") or ""
-        client_secret = await auth_service.get_api_key("twitter_client_secret")
-        redirect_uri = get_redirect_uri(request, "twitter")
-
-        oauth = TwitterOAuth(
-            client_id=client_id,
-            client_secret=client_secret,
-            redirect_uri=redirect_uri,
-        )
-
-        # Revoke tokens
-        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 via auth_service
-    await auth_service.remove_oauth_tokens("twitter", customer_id="owner")
-
-    logger.info("Twitter disconnected and tokens revoked")
-
-    return {"success": True, "message": "Twitter disconnected"}
-
-
-def _callback_html(success: bool, username: str = None, error: str = None) -> str:
-    """Generate callback HTML page that closes itself and notifies parent."""
-    if success:
-        title = "Twitter Connected"
-        message = f"Successfully connected as @{username}!"
-        color = "#00ba7c"  # Green
-    else:
-        title = "Connection Failed"
-        message = error or "Failed to connect to Twitter"
-        color = "#f4212e"  # Red
-
-    escaped_error = error.replace("'", "\\'") if error else ""
-    return f"""
-<!DOCTYPE html>
-<html>
-<head>
-    <title>{title}</title>
-    <style>
-        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
-        body {{
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-            background: linear-gradient(135deg, #15202b 0%, #1a1a2e 100%);
-            min-height: 100vh;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            color: #fff;
-        }}
-        .container {{
-            text-align: center;
-            padding: 40px;
-            background: rgba(255, 255, 255, 0.05);
-            border-radius: 16px;
-            border: 1px solid rgba(255, 255, 255, 0.1);
-            max-width: 400px;
-        }}
-        .icon {{
-            width: 64px;
-            height: 64px;
-            margin-bottom: 20px;
-            color: {color};
-        }}
-        h1 {{
-            font-size: 24px;
-            margin-bottom: 12px;
-            color: {color};
-        }}
-        p {{
-            font-size: 16px;
-            color: rgba(255, 255, 255, 0.8);
-            margin-bottom: 20px;
-        }}
-        .close-text {{
-            font-size: 14px;
-            color: rgba(255, 255, 255, 0.5);
-        }}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <svg class="icon" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            {"<path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z'/>" if success else "<path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M10 14l2-2m0 0l2-2m-2 2l-2-2m2 2l2 2m7-2a9 9 0 11-18 0 9 9 0 0118 0z'/>"}
-        </svg>
-        <h1>{title}</h1>
-        <p>{message}</p>
-        <p class="close-text">This window will close automatically...</p>
-    </div>
-    <script>
-        // Notify parent window and close
-        if (window.opener) {{
-            window.opener.postMessage({{
-                type: 'twitter_oauth_callback',
-                success: {str(success).lower()},
-                {"username: '" + username + "'," if username else ""}
-                {"error: '" + escaped_error + "'," if error else ""}
-            }}, '*');
-        }}
-        // Close after 2 seconds
-        setTimeout(function() {{ window.close(); }}, 2000);
-    </script>
-</body>
-</html>
-"""

package/server/services/claude_code_service.py

@@ -1,106 +0,0 @@
-"""Claude Code service - manages CLI execution with session persistence."""
-
-import asyncio
-import json
-import os
-import shutil
-from typing import Any, Dict, List, Optional
-
-from core.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-def _find_claude_cmd() -> List[str]:
-    """Find claude CLI cross-platform."""
-    if shutil.which("claude"):
-        return ["claude"]
-    npx = shutil.which("npx")
-    if npx:
-        return [npx, "-y", "@anthropic-ai/claude-code"]
-    raise FileNotFoundError("Neither 'claude' nor 'npx' found in PATH")
-
-
-class ClaudeCodeService:
-    """Executes tasks via Claude Code CLI with session tracking."""
-
-    def __init__(self):
-        self._session_map: Dict[str, str] = {}  # node_id -> session_id
-
-    async def execute(
-        self,
-        prompt: str,
-        node_id: str = "",
-        model: str = "claude-sonnet-4-6",
-        cwd: Optional[str] = None,
-        allowed_tools: str = "Read,Edit,Bash,Glob,Grep,Write",
-        max_turns: int = 10,
-        max_budget_usd: float = 5.0,
-        system_prompt: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Run claude CLI and return parsed JSON result."""
-        cmd = _find_claude_cmd() + [
-            "-p", prompt,
-            "--output-format", "json",
-            "--model", model,
-            "--max-turns", str(max_turns),
-            "--allowedTools", allowed_tools,
-        ]
-
-        if max_budget_usd > 0:
-            cmd += ["--max-budget-usd", str(max_budget_usd)]
-
-        # Resume existing session for this node
-        session_id = self._session_map.get(node_id)
-        if session_id:
-            cmd += ["--resume", session_id]
-
-        if system_prompt:
-            cmd += ["--append-system-prompt", system_prompt]
-
-        if not cwd:
-            from core.config import Settings
-            cwd = os.path.join(Settings().workspace_base_resolved, 'default')
-            os.makedirs(cwd, exist_ok=True)
-        work_dir = cwd
-
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            cwd=work_dir,
-        )
-        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=300)
-
-        if proc.returncode != 0:
-            err = stderr.decode("utf-8", errors="replace").strip()
-            logger.error("Claude Code failed (exit %d): %s", proc.returncode, err)
-            raise RuntimeError(err or f"Exit code {proc.returncode}")
-
-        raw = stdout.decode("utf-8", errors="replace").strip()
-        try:
-            data = json.loads(raw)
-        except json.JSONDecodeError:
-            data = {"result": raw}
-
-        # Track session for future resume
-        if data.get("session_id") and node_id:
-            self._session_map[node_id] = data["session_id"]
-
-        return data
-
-    def get_session_id(self, node_id: str) -> Optional[str]:
-        return self._session_map.get(node_id)
-
-    def clear_session(self, node_id: str) -> None:
-        self._session_map.pop(node_id, None)
-
-
-_instance: Optional[ClaudeCodeService] = None
-
-
-def get_claude_code_service() -> ClaudeCodeService:
-    global _instance
-    if _instance is None:
-        _instance = ClaudeCodeService()
-    return _instance

package/server/services/memory.py

@@ -1,159 +0,0 @@
-"""Markdown-based conversation memory helpers.
-
-Parse, append, trim, and archive conversation history stored in markdown format.
-Used by AI Agent and Chat Agent for persistent memory across turns.
-"""
-
-import re
-from datetime import datetime
-from typing import Dict, Any, List
-
-from langchain_core.messages import HumanMessage, AIMessage, BaseMessage
-
-from core.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-def parse_memory_markdown(content: str) -> List[BaseMessage]:
-    """Parse markdown memory content into LangChain messages.
-
-    Markdown format:
-    ### **Human** (timestamp)
-    message content
-
-    ### **Assistant** (timestamp)
-    response content
-    """
-    messages = []
-    pattern = r'### \*\*(Human|Assistant)\*\*[^\n]*\n(.*?)(?=\n### \*\*|$)'
-    for role, text in re.findall(pattern, content, re.DOTALL):
-        text = text.strip()
-        if text:
-            msg_class = HumanMessage if role == 'Human' else AIMessage
-            messages.append(msg_class(content=text))
-    return messages
-
-
-def append_to_memory_markdown(content: str, role: str, message: str) -> str:
-    """Append a message to markdown memory content."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    label = "Human" if role == "human" else "Assistant"
-    entry = f"\n### **{label}** ({ts})\n{message}\n"
-    # Remove empty state message if present
-    return content.replace("*No messages yet.*\n", "") + entry
-
-
-def trim_markdown_window(content: str, window_size: int) -> tuple:
-    """Keep last N message pairs, return (trimmed_content, removed_texts).
-
-    Args:
-        content: Full markdown content
-        window_size: Number of message PAIRS to keep (human+assistant)
-
-    Returns:
-        Tuple of (trimmed markdown, list of removed message texts for archival)
-    """
-    pattern = r'(### \*\*(Human|Assistant)\*\*[^\n]*\n.*?)(?=\n### \*\*|$)'
-    blocks = [m[0] for m in re.findall(pattern, content, re.DOTALL)]
-
-    if len(blocks) <= window_size * 2:
-        return content, []
-
-    keep = blocks[-(window_size * 2):]
-    removed = blocks[:-(window_size * 2)]
-
-    # Extract text from removed blocks for vector storage
-    removed_texts = []
-    for block in removed:
-        match = re.search(r'\n(.*)$', block, re.DOTALL)
-        if match:
-            removed_texts.append(match.group(1).strip())
-
-    return "# Conversation History\n" + "\n".join(keep), removed_texts
-
-
-# Global cache for vector stores per session (InMemoryVectorStore)
-_memory_vector_stores: Dict[str, Any] = {}
-
-
-def get_memory_vector_store(session_id: str):
-    """Get or create InMemoryVectorStore for a session."""
-    if session_id not in _memory_vector_stores:
-        try:
-            from langchain_core.vectorstores import InMemoryVectorStore
-            from langchain_huggingface import HuggingFaceEmbeddings
-
-            embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-en-v1.5")
-            _memory_vector_stores[session_id] = InMemoryVectorStore(embeddings)
-            logger.debug(f"[Memory] Created vector store for session '{session_id}'")
-        except ImportError as e:
-            logger.warning(f"[Memory] Vector store not available: {e}")
-            return None
-    return _memory_vector_stores[session_id]
-
-
-def clear_agent_session_state(
-    session_id: str,
-    workflow_id: str = None,
-    clear_long_term: bool = False,
-) -> Dict[str, Any]:
-    """Clear every store keyed by an agent's conversational scope.
-
-    "Memory" from the user's perspective is not just the markdown
-    transcript — it's every piece of state an agent reuses across
-    iterations of a conversation. ``simpleMemory.memory_content`` is the
-    visible part; the long-term vector store and ``TodoService``
-    plan-work-update lists are the invisible parts that quietly bloat
-    subsequent runs (notably ``task_agent``, whose default skill bundle
-    instructs the LLM to read accumulated todos every run).
-
-    ``TodoService`` is keyed by ``ctx.workflow_id or ctx.node_id or
-    "default"`` (see ``server/nodes/tool/write_todos.py``). We clear all
-    three candidate keys to match whichever fallback the agent actually
-    used at write time.
-
-    Args:
-        session_id: ``simpleMemory`` node's ``session_id`` parameter.
-        workflow_id: Active workflow id (passed by the frontend so we
-            can clear ``TodoService`` entries written under it).
-        clear_long_term: When ``True``, drop the per-session vector
-            store too.
-
-    Returns:
-        Dict with ``cleared_vector_store`` (bool) and ``cleared_todo_keys``
-        (list[str]) for caller-visible diagnostics. Markdown reset is
-        signalled by returning the default content, owned by the WS
-        handler so the wire shape stays in one place.
-    """
-    # The live vector-store cache lives in ``services.ai`` (the dict in
-    # this module is dormant — nothing imports it). Lazy import keeps
-    # ``services.ai``'s heavy LangChain deps off the hot path.
-    from services.ai import _memory_vector_stores as _live_vector_stores
-    from services.todo_service import get_todo_service
-
-    cleared_vector_store = False
-    if clear_long_term and session_id in _live_vector_stores:
-        del _live_vector_stores[session_id]
-        cleared_vector_store = True
-        logger.info(f"[Memory] Cleared vector store for session '{session_id}'")
-
-    todo_service = get_todo_service()
-    cleared_todo_keys: List[str] = []
-    seen = set()
-    for key in (workflow_id, session_id, "default"):
-        if key and key not in seen:
-            seen.add(key)
-            todo_service.clear(key)
-            cleared_todo_keys.append(key)
-
-    logger.info(
-        "[Memory] Cleared agent session state session=%s workflow_id=%s "
-        "vector_store=%s todo_keys=%s",
-        session_id, workflow_id, cleared_vector_store, cleared_todo_keys,
-    )
-
-    return {
-        "cleared_vector_store": cleared_vector_store,
-        "cleared_todo_keys": cleared_todo_keys,
-    }