machinaos 0.0.76 → 0.0.78

package/server/nodes/stripe/_source.py

@@ -0,0 +1,174 @@
+"""Stripe event source — supervised ``stripe listen`` daemon + the
+companion ``WebhookSource`` that receives forwarded events.
+
+Two cooperating sources:
+
+* :class:`StripeListenSource` (DaemonEventSource) keeps the CLI alive,
+  captures the ``whsec_…`` signing secret from its stderr banner.
+* :class:`StripeWebhookSource` (WebhookSource) is the actual event
+  producer — verifies the Stripe-Signature header on each forwarded
+  POST and turns the payload into a :class:`WorkflowEvent`.
+
+Module-level singletons (``get_listen_source`` / ``get_webhook_source``)
+plug into the framework registries from ``__init__.py``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import shlex
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from fastapi import Request
+
+from core.logging import get_logger
+from services.events import (
+    DaemonEventSource,
+    StripeVerifier,
+    WebhookSource,
+    WorkflowEvent,
+)
+
+from ._credentials import StripeCredential
+
+logger = get_logger(__name__)
+
+_SECRET_RE = re.compile(r"whsec_[A-Za-z0-9_]+")
+_SECRET_FIELD = "stripe_webhook_secret"
+
+
+def stripe_config_path() -> Path:
+    """Default location for the Stripe CLI's credentials file
+    (``~/.config/stripe/config.toml``, ``XDG_CONFIG_HOME``-aware)."""
+    base = os.environ.get("XDG_CONFIG_HOME")
+    return (Path(base) if base else Path.home() / ".config") / "stripe" / "config.toml"
+
+
+def is_logged_in() -> bool:
+    """Detect Stripe CLI login by sniffing its config file. Cheap
+    filesystem check — the CLI writes ``test_mode_api_key`` /
+    ``live_mode_api_key`` under a profile section on success."""
+    cfg = stripe_config_path()
+    if not cfg.exists():
+        return False
+    try:
+        return "_api_key" in cfg.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return False
+
+
+class StripeListenSource(DaemonEventSource):
+    """Supervises ``stripe listen`` and persists the captured webhook
+    signing secret. Emits no events itself — Stripe events arrive over
+    HTTP via :class:`StripeWebhookSource`."""
+
+    type = "stripe.listen"
+    process_name = "stripe-listen"
+    # Empty so DaemonEventSource skips its built-in PATH check; we
+    # do install + verification ourselves in start() via
+    # ensure_stripe_cli (which falls back to system PATH first, then
+    # workspace-local download).
+    binary_name = ""
+    workflow_namespace = "_stripe"
+    install_hint = "https://stripe.com/docs/stripe-cli#install"
+    credential = StripeCredential
+
+    def build_command(self, secrets: Dict) -> str:
+        # The CLI uses credentials it stored at ~/.config/stripe/config.toml
+        # (populated by `stripe login`). No --api-key flag here.
+        # Binary path is resolved by `ensure_stripe_cli` (called from
+        # the start() override below) and cached for sync access here.
+        # ``shlex.quote`` so Windows backslashes survive ProcessService's
+        # ``shlex.split`` round-trip (POSIX-mode parser eats raw ``\``).
+        from core.config import Settings
+        from ._install import stripe_cli_path
+
+        port = int(Settings().port)
+        binary = shlex.quote(str(stripe_cli_path() or "stripe"))
+        return (
+            f"{binary} listen --forward-to http://localhost:{port}/webhook/stripe "
+            f"--print-secret"
+        )
+
+    async def start(self) -> Dict[str, Any]:
+        """Ensure the CLI binary is downloaded before delegating to the
+        framework's daemon-start path (which calls ``build_command``)."""
+        from ._install import ensure_stripe_cli
+        try:
+            path = await ensure_stripe_cli()
+            logger.info("[Stripe] daemon start: CLI binary resolved at %s", path)
+        except Exception as e:
+            logger.warning("[Stripe] daemon start failed at install step: %s", e)
+            return {"success": False, "error": f"Stripe CLI install failed: {e}"}
+        return await super().start()
+
+    async def has_credential(self) -> bool:
+        """The Stripe CLI manages auth state in its own config file —
+        that's our 'credential' for the daemon's start gate."""
+        return is_logged_in()
+
+    def parse_line(self, stream: str, line: str) -> Optional[WorkflowEvent]:
+        if stream == "stderr" and (m := _SECRET_RE.search(line)):
+            secret = m.group(0)
+            logger.info("[Stripe] whsec_… signing secret detected in daemon stderr — persisting")
+            asyncio.create_task(self._persist_secret(secret))
+        return None
+
+    async def _persist_secret(self, secret: str) -> None:
+        try:
+            from services.plugin.deps import get_auth_service
+            await get_auth_service().store_api_key(_SECRET_FIELD, secret, models=[])
+            logger.info(
+                "[Stripe] webhook signing secret persisted (key=%s, len=%d)",
+                _SECRET_FIELD, len(secret),
+            )
+        except Exception as e:
+            logger.warning("[Stripe] persist secret failed: %s", e)
+
+
+class StripeWebhookSource(WebhookSource):
+    """HTTP receiver for Stripe-forwarded events."""
+
+    type = "stripe.webhook"
+    path = "stripe"
+    verifier = StripeVerifier
+    secret_field = _SECRET_FIELD
+    credential = StripeCredential
+
+    async def shape(self, request: Request, body: bytes, payload: dict) -> WorkflowEvent:
+        created = payload.get("created")
+        try:
+            time = datetime.fromtimestamp(int(created), tz=timezone.utc) if created else datetime.now(timezone.utc)
+        except (TypeError, ValueError):
+            time = datetime.now(timezone.utc)
+        account = payload.get("account") or "default"
+        return WorkflowEvent(
+            id=payload.get("id") or "",
+            type=f"stripe.{payload.get('type', 'unknown')}",
+            source=f"stripe://{account}",
+            time=time,
+            data=payload.get("data") or {},
+            subject=payload.get("type"),
+        )
+
+
+_listen: Optional[StripeListenSource] = None
+_webhook: Optional[StripeWebhookSource] = None
+
+
+def get_listen_source() -> StripeListenSource:
+    global _listen
+    if _listen is None:
+        _listen = StripeListenSource()
+    return _listen
+
+
+def get_webhook_source() -> StripeWebhookSource:
+    global _webhook
+    if _webhook is None:
+        _webhook = StripeWebhookSource()
+    return _webhook

package/server/nodes/stripe/stripe_action.py

@@ -0,0 +1,81 @@
+"""Stripe Action — pass-through over the Stripe CLI."""
+
+from __future__ import annotations
+
+import shlex
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.events import run_cli_command
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+from ._credentials import StripeCredential
+
+
+class StripeActionParams(BaseModel):
+    command: str = Field(
+        default="",
+        description=(
+            "Stripe CLI command, exactly as you would type after 'stripe '. "
+            "Examples: 'customers create --email a@b.com', 'charges list --limit 10', "
+            "'trigger charge.succeeded'. Reference: https://stripe.com/docs/cli"
+        ),
+    )
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class StripeActionOutput(BaseModel):
+    command: Optional[str] = None
+    success: Optional[bool] = None
+    result: Optional[Any] = None
+    stdout: Optional[str] = None
+    error: Optional[str] = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class StripeActionNode(ActionNode):
+    type = "stripeAction"
+    display_name = "Stripe"
+    subtitle = "CLI Command"
+    group = ("payments", "tool")
+    description = "Run any Stripe CLI command (customers, charges, payment_intents, refunds, invoices, trigger, …)"
+    component_kind = "square"
+    handles = (
+        {"name": "input-main", "kind": "input", "position": "left",
+         "label": "Input", "role": "main"},
+        {"name": "output-main", "kind": "output", "position": "right",
+         "label": "Output", "role": "main"},
+    )
+    annotations = {"destructive": False, "readonly": False, "open_world": True}
+    credentials = (StripeCredential,)
+    task_queue = TaskQueue.REST_API
+    usable_as_tool = True
+
+    Params = StripeActionParams
+    Output = StripeActionOutput
+
+    @Operation("run", cost={"service": "stripe", "action": "run", "count": 1})
+    async def run(self, ctx: NodeContext, params: StripeActionParams) -> Any:
+        from ._install import ensure_stripe_cli
+
+        cmd = params.command.strip()
+        if not cmd:
+            raise RuntimeError("command is required (e.g. 'customers create --email a@b.com')")
+        try:
+            binary = str(await ensure_stripe_cli())
+        except Exception as e:
+            raise RuntimeError(f"Stripe CLI install failed: {e}")
+        # No credential= — Stripe CLI reads its own creds from
+        # ~/.config/stripe/config.toml after `stripe login`.
+        result = await run_cli_command(binary=binary, argv=shlex.split(cmd))
+        if not result["success"]:
+            raise RuntimeError(result.get("error") or "Stripe CLI invocation failed")
+        return {
+            "command": cmd,
+            "success": True,
+            "result": result.get("result"),
+            "stdout": result.get("stdout"),
+        }

package/server/nodes/stripe/stripe_receive.py

@@ -0,0 +1,92 @@
+"""Stripe Receive — fires when StripeWebhookSource accepts a verified
+forwarded event."""
+
+from __future__ import annotations
+
+from typing import Callable, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.events import BaseTriggerParams, WebhookTriggerNode, WorkflowEvent
+
+from ._credentials import StripeCredential
+from ._source import StripeWebhookSource
+
+
+_PREFIX = "stripe."
+
+
+class StripeReceiveParams(BaseTriggerParams):
+    livemode_filter: Literal["all", "test", "live"] = Field(
+        default="all",
+        description="Filter by livemode flag on the event.",
+    )
+
+
+class StripeReceiveOutput(BaseModel):
+    event_id: Optional[str] = None
+    event_type: Optional[str] = None
+    created: Optional[int] = None
+    livemode: Optional[bool] = None
+    api_version: Optional[str] = None
+    request_id: Optional[str] = None
+    account: Optional[str] = None
+    data: Optional[dict] = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class StripeReceiveNode(WebhookTriggerNode):
+    type = "stripeReceive"
+    display_name = "Stripe Receive"
+    subtitle = "Webhook Event"
+    group = ("payments", "trigger")
+    description = "Trigger workflow when Stripe webhook event arrives"
+    component_kind = "trigger"
+    handles = (
+        {"name": "output-main", "kind": "output", "position": "right",
+         "label": "Output", "role": "main"},
+    )
+    credentials = (StripeCredential,)
+    webhook_source = StripeWebhookSource
+    event_type_prefix = _PREFIX
+    Params = StripeReceiveParams
+    Output = StripeReceiveOutput
+
+    def _extra_filter(
+        self, params: StripeReceiveParams,
+    ) -> Optional[Callable[[WorkflowEvent], bool]]:
+        if params.livemode_filter == "all":
+            return None
+        target_live = params.livemode_filter == "live"
+
+        def matches(ev: WorkflowEvent) -> bool:
+            payload = ev.data if isinstance(ev.data, dict) else {}
+            return bool(payload.get("livemode")) is target_live
+
+        return matches
+
+    async def _check_precondition(self) -> Optional[str]:
+        from ._source import get_listen_source
+        if not get_listen_source()._started:
+            return "Stripe daemon not running. Add Stripe API key in Credentials and connect."
+        return None
+
+    def shape_output(self, event: WorkflowEvent) -> Dict:
+        payload = event.data if isinstance(event.data, dict) else {}
+        stripe_type = event.type[len(_PREFIX):] if event.type.startswith(_PREFIX) else event.type
+        request = payload.get("request")
+        request_id = request.get("id") if isinstance(request, dict) else request
+        nested = payload.get("data")
+        return {
+            "event_id": event.id,
+            "event_type": stripe_type,
+            "created": payload.get("created"),
+            "livemode": payload.get("livemode"),
+            "api_version": payload.get("api_version"),
+            "request_id": request_id,
+            "account": payload.get("account") or (
+                event.source.split("://", 1)[1] if "://" in event.source else None
+            ),
+            "data": nested if isinstance(nested, dict) else payload,
+        }

package/server/nodes/telegram/_credentials.py

@@ -5,7 +5,17 @@ Used by the two telegram plugins in this folder (telegram_send, telegram_receive
 
 from __future__ import annotations
 
-from services.plugin.credential import ApiKeyCredential
+import httpx
+
+from services.plugin.credential import ApiKeyCredential, ProbeResult
+
+
+# Telegram embeds the bot token in the URL path (``/bot<token>/getMe``)
+# rather than in a header / query / Authorization slot, so the
+# declarative ``probe_url`` shape doesn't fit. We override ``_probe``
+# directly but reuse :meth:`_handle_probe_response` from the base for
+# the 200-with-failure-envelope case.
+_TELEGRAM_API = "https://api.telegram.org"
 
 
 class TelegramCredential(ApiKeyCredential):
@@ -17,3 +27,44 @@ class TelegramCredential(ApiKeyCredential):
     key_location = "header"
     extra_fields = ("telegram_owner_chat_id",)
     docs_url = "https://core.telegram.org/bots"
+
+    @classmethod
+    async def _probe(cls, api_key: str) -> ProbeResult:
+        """Validate via ``GET /bot<token>/getMe``.
+
+        Telegram returns 401 for revoked tokens and 404 for malformed
+        tokens; both surface as :class:`httpx.HTTPStatusError` and the
+        base :meth:`Credential.validate` translates them via
+        :func:`classify_credential_error`. A 200 with ``{ok: false}`` is
+        rare but possible (legacy token shapes) and is caught in
+        :meth:`_handle_probe_response`.
+        """
+        url = f"{_TELEGRAM_API}/bot{api_key}/getMe"
+        async with httpx.AsyncClient(timeout=cls.probe_timeout_seconds) as client:
+            response = await client.get(url)
+        response.raise_for_status()
+        return cls._handle_probe_response(response)
+
+    @classmethod
+    def _handle_probe_response(cls, response: httpx.Response) -> ProbeResult:
+        payload = response.json()
+        if not payload.get("ok"):
+            return ProbeResult(
+                valid=False,
+                message=payload.get("description", "Telegram rejected the bot token"),
+            )
+        bot = payload.get("result") or {}
+        username = bot.get("username")
+        return ProbeResult(
+            valid=True,
+            message=(
+                f"Telegram bot token is valid (@{username})"
+                if username
+                else "Telegram bot token is valid"
+            ),
+            extra={
+                "bot_id": bot.get("id"),
+                "bot_username": username,
+                "bot_name": bot.get("first_name"),
+            },
+        )

package/server/nodes/telegram/_handlers.py

@@ -19,6 +19,8 @@ from typing import Any, Awaitable, Callable, Dict
 
 from fastapi import WebSocket
 
+from services.plugin.ws import ws_response
+
 from ._credentials import TelegramCredential
 from ._service import get_telegram_service
 
@@ -112,8 +114,15 @@ async def handle_telegram_status(data: Dict[str, Any], websocket: WebSocket) ->
     return {"success": True, "status": status}
 
 
+@ws_response
 async def handle_telegram_send(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
-    """Direct send via WebSocket (not via workflow node)."""
+    """Direct send via WebSocket (not via workflow node).
+
+    ``@ws_response`` collapses the catch-all ``try / except Exception``
+    block at the bottom of the function -- exceptions become
+    ``{success: False, error: str(e)}`` automatically. Early-return
+    validation stays since those are deterministic input checks.
+    """
     service = get_telegram_service()
     if not service.connected:
         return {"success": False, "error": "Telegram bot not connected"}
@@ -125,15 +134,11 @@ async def handle_telegram_send(data: Dict[str, Any], websocket: WebSocket) -> Di
     if dispatch is None:
         return {"success": False, "error": f"Unsupported message type: {message_type}"}
 
-    try:
-        coro_or_none, err = dispatch(service, data, data.get("parse_mode"))
-        if err:
-            return {"success": False, "error": err}
-        result = await coro_or_none
-        return {"success": True, "result": result}
-    except Exception as e:
-        logger.error(f"[Telegram] Send error: {e}")
-        return {"success": False, "error": str(e)}
+    coro_or_none, err = dispatch(service, data, data.get("parse_mode"))
+    if err:
+        return {"success": False, "error": err}
+    result = await coro_or_none
+    return {"success": True, "result": result}
 
 
 async def handle_telegram_reconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
@@ -155,26 +160,22 @@ async def handle_telegram_reconnect(data: Dict[str, Any], websocket: WebSocket)
     return await get_telegram_service().connect(secrets["api_key"])
 
 
+@ws_response
 async def handle_telegram_get_me(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
     service = get_telegram_service()
     if not service.connected:
         return {"success": False, "error": "Telegram bot not connected"}
-    try:
-        return {"success": True, "result": await service.get_me()}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
+    return {"success": True, "result": await service.get_me()}
 
 
+@ws_response
 async def handle_telegram_get_chat(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
     service = get_telegram_service()
     if not service.connected:
         return {"success": False, "error": "Telegram bot not connected"}
     if not data.get("chat_id"):
         return {"success": False, "error": "chat_id required"}
-    try:
-        return {"success": True, "result": await service.get_chat(data["chat_id"])}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
+    return {"success": True, "result": await service.get_chat(data["chat_id"])}
 
 
 # ---------------------------------------------------------------------------