lfx-confluence 0.1.0__py3-none-any.whl

lfx_confluence/__init__.py

@@ -0,0 +1 @@
+"""Connection-backed Confluence Cloud integration bundle."""

lfx_confluence/base.py

@@ -0,0 +1,44 @@
+"""Shared Confluence connection and trigger declarations."""
+
+from typing import ClassVar
+
+from lfx.base.triggers.base import BaseTriggerComponent
+from lfx.custom.custom_component.component import Component
+from lfx.integrations.telemetry import integration_action
+
+from lfx_confluence.client import ConfluenceClient
+from lfx_confluence.schema import READ, WRITE
+
+
+class ConfluenceActionComponent(Component):
+    icon = "Confluence"
+    capability_id: ClassVar[str] = ""
+
+    def client(self):
+        return ConfluenceClient(self.resolve_connection("connection"))
+
+    async def perform(self, method, path, *, body=None, params=None, write=False):
+        client = self.client()
+        try:
+            credential = await client.lease.get_credential()
+            async with integration_action(
+                self, provider="confluence", capability=self.capability_id, owner_kind=credential.owner_kind
+            ):
+                return await client.request(
+                    method, path, body=body, params=params, scopes=frozenset({READ, WRITE} if write else {READ})
+                )
+        finally:
+            await client.aclose()
+
+
+class ConfluencePageTriggerComponent(BaseTriggerComponent):
+    provider = "confluence"
+    needs_connection = True
+    icon = "Confluence"
+
+    def trigger_config(self):
+        return {
+            "connection": getattr(self, "connection", None),
+            "space_id": getattr(self, "space_id", ""),
+            "delivery_mode": "poll",
+        }

lfx_confluence/client.py

@@ -0,0 +1,154 @@
+"""Fixed-origin Confluence requests with credential checks and bounded responses."""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from typing import TYPE_CHECKING
+
+import httpx
+from lfx.integrations.errors import (
+    AuthExpiredError,
+    ConnectionNotAuthorizedError,
+    IntegrationNetworkError,
+    ProviderUnavailableError,
+    RateLimitedError,
+    ResourceNotFoundError,
+    ScopeMissingError,
+)
+from lfx.utils.ssrf_httpx import ssrf_protected_strict_httpx_client_kwargs_for_url
+from lfx.utils.ssrf_protection import SSRFProtectionError
+from lfx.utils.url_redaction import suppress_sensitive_http_logs
+
+from lfx_confluence.schema import API_ORIGIN, READ, cloud_id, invalid
+
+if TYPE_CHECKING:
+    from lfx.integrations.models import CredentialLease
+
+_PATH = re.compile(r"/wiki/api/v2/pages(?:/[1-9][0-9]{0,18})?\Z")
+MAX_REQUEST_BYTES = 1048576
+MAX_RESPONSE_BYTES = 2 * 1024 * 1024
+
+
+def http_client(transport=None) -> httpx.AsyncClient:
+    try:
+        kwargs = (
+            ssrf_protected_strict_httpx_client_kwargs_for_url(API_ORIGIN)[1]
+            if transport is None
+            else {"transport": transport}
+        )
+    except SSRFProtectionError:
+        raise IntegrationNetworkError(provider="confluence", reason="connection", host="api.atlassian.com") from None
+    kwargs["follow_redirects"] = False
+    return httpx.AsyncClient(timeout=20, trust_env=False, **kwargs)
+
+
+async def send(http: httpx.AsyncClient, method: str, path: str, token: str, *, body=None, params=None):
+    if not path.startswith("/") or "?" in path or "#" in path or ".." in path or "\\" in path or "%" in path:
+        msg = "Unsupported Confluence API resource."
+        raise invalid(msg)
+    content = json.dumps(body, ensure_ascii=False).encode() if body is not None else None
+    if content is not None and len(content) > MAX_REQUEST_BYTES:
+        msg = "The Confluence request exceeds 1 MiB."
+        raise invalid(msg)
+    try:
+        async with (
+            suppress_sensitive_http_logs(),
+            http.stream(
+                method,
+                API_ORIGIN + path,
+                content=content,
+                params=params,
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+            ) as response,
+        ):
+            raw = bytearray()
+            async for part in response.aiter_bytes():
+                raw.extend(part)
+                if len(raw) > MAX_RESPONSE_BYTES:
+                    raise ProviderUnavailableError(provider="confluence")
+            status = response.status_code
+            if status == httpx.codes.UNAUTHORIZED:
+                raise AuthExpiredError(provider="confluence")
+            if status == httpx.codes.FORBIDDEN:
+                raise ConnectionNotAuthorizedError(provider="confluence", reason="provider")
+            if status == httpx.codes.NOT_FOUND:
+                raise ResourceNotFoundError(provider="confluence")
+            if status == httpx.codes.TOO_MANY_REQUESTS:
+                try:
+                    delay = float(response.headers.get("Retry-After", "60"))
+                except (ValueError, OverflowError):
+                    delay = 60.0
+                raise RateLimitedError(
+                    provider="confluence", retry_after=max(0, min(delay, 86400)) if math.isfinite(delay) else 60.0
+                )
+            if (
+                status >= httpx.codes.INTERNAL_SERVER_ERROR
+                or httpx.codes.MULTIPLE_CHOICES <= status < httpx.codes.BAD_REQUEST
+            ):
+                raise ProviderUnavailableError(provider="confluence", http_status=status)
+            if status >= httpx.codes.BAD_REQUEST:
+                msg = "Confluence rejected this operation. Check the page fields and account permissions."
+                raise invalid(msg)
+            if status not in {200, 201, 204}:
+                raise ProviderUnavailableError(provider="confluence")
+            if not raw and status == httpx.codes.NO_CONTENT:
+                return {}
+            try:
+                value = json.loads(raw)
+            except (ValueError, UnicodeDecodeError):
+                raise ProviderUnavailableError(provider="confluence") from None
+            if not isinstance(value, (dict, list)):
+                raise ProviderUnavailableError(provider="confluence")
+            return value
+    except httpx.RequestError:
+        raise IntegrationNetworkError(provider="confluence", reason="connection", host="api.atlassian.com") from None
+
+
+class ConfluenceClient:
+    def __init__(self, lease: CredentialLease, *, transport=None):
+        self.lease = lease
+        self.site = cloud_id()
+        self.http = http_client(transport)
+
+    async def aclose(self):
+        await self.http.aclose()
+
+    async def _check(self, scopes):
+        credential = await self.lease.get_credential()
+        if (
+            credential.provider != "confluence"
+            or credential.identity != "user_delegated"
+            or credential.account is None
+            or credential.account.tenant_id != self.site
+        ):
+            raise ConnectionNotAuthorizedError(provider="confluence", reason="provider")
+        if not credential.scopes_verified or not scopes <= credential.granted_scopes:
+            raise ScopeMissingError(
+                frozenset(scopes), provider="confluence", scopes_verified=credential.scopes_verified
+            )
+
+    async def request(self, method, path, *, body=None, params=None, scopes=frozenset({READ})):
+        if not _PATH.fullmatch(path):
+            msg = "Unsupported Confluence API resource."
+            raise invalid(msg)
+        await self._check(scopes)
+        token = await self.lease.get_token()
+        for attempt in range(2):
+            try:
+                return await send(
+                    self.http, method, f"/ex/confluence/{self.site}" + path, token, body=body, params=params
+                )
+            except AuthExpiredError:
+                if attempt:
+                    raise
+                token = await self.lease.get_token_after_auth_error(
+                    AuthExpiredError(provider="confluence"), rejected_token=token
+                )
+                await self._check(scopes)
+        raise AuthExpiredError(provider="confluence")

lfx_confluence/components/__init__.py

@@ -0,0 +1 @@
+"""Confluence integration components."""

lfx_confluence/components/confluence_integrations/__init__.py

@@ -0,0 +1,18 @@
+"""Stable Confluence integration component identities."""
+
+from .actions import (
+    ConfluenceCreatePageComponent,
+    ConfluenceReadPageComponent,
+    ConfluenceSearchPagesComponent,
+    ConfluenceUpdatePageComponent,
+)
+from .triggers import ConfluenceOnPageCreatedTriggerComponent, ConfluenceOnPageUpdatedTriggerComponent
+
+__all__ = [
+    "ConfluenceCreatePageComponent",
+    "ConfluenceOnPageCreatedTriggerComponent",
+    "ConfluenceOnPageUpdatedTriggerComponent",
+    "ConfluenceReadPageComponent",
+    "ConfluenceSearchPagesComponent",
+    "ConfluenceUpdatePageComponent",
+]

lfx_confluence/components/confluence_integrations/actions.py

@@ -0,0 +1,156 @@
+"""Explicit page actions with approved spaces and optimistic content versions."""
+
+from lfx.io import IntInput, MessageTextInput, MultilineInput, Output
+from lfx.schema.data import Data
+
+from lfx_confluence.base import ConfluenceActionComponent
+from lfx_confluence.manifest import connection_input
+from lfx_confluence.schema import (
+    MAX_VERSION,
+    approved_space,
+    invalid,
+    list_params,
+    numeric_id,
+    page_data,
+    page_list,
+    text,
+)
+
+
+def space_input():
+    return MessageTextInput(
+        name="space_id",
+        display_name="Space ID",
+        required=True,
+        info="An operator-approved numeric Confluence space ID.",
+    )
+
+
+class ConfluenceSearchPagesComponent(ConfluenceActionComponent):
+    display_name = "Confluence: Search Pages"
+    description = "List published pages in one approved space, optionally matching an exact title."
+    name = "ConfluenceSearchPages"
+    capability_id = "confluence.page.search"
+    inputs = [
+        connection_input(capability_id),
+        space_input(),
+        MessageTextInput(name="title", display_name="Exact Title"),
+        MessageTextInput(name="cursor", display_name="Next Page Cursor", advanced=True),
+    ]
+    outputs = [Output(display_name="Pages", name="pages", method="search_pages")]
+
+    async def search_pages(self) -> Data:
+        space = approved_space(self.space_id)
+        title = getattr(self, "title", "") or ""
+        result = await self.perform(
+            "GET",
+            "/wiki/api/v2/pages",
+            params=list_params(space, title=title, cursor=getattr(self, "cursor", "") or ""),
+        )
+        pages, cursor = page_list(result, space=space)
+        if title and any(page["title"] != title for page in pages):
+            msg = "Confluence returned a page outside the exact title filter."
+            raise invalid(msg)
+        return Data(data={"pages": pages, "next_cursor": cursor})
+
+
+class ConfluenceReadPageComponent(ConfluenceActionComponent):
+    display_name = "Confluence: Read Page"
+    description = "Read one current page and its storage body from an approved space."
+    name = "ConfluenceReadPage"
+    capability_id = "confluence.page.read"
+    inputs = [
+        connection_input(capability_id),
+        space_input(),
+        MessageTextInput(name="page_id", display_name="Page ID", required=True),
+    ]
+    outputs = [Output(display_name="Page", name="page", method="read_page")]
+
+    async def read_page(self) -> Data:
+        space, identifier = approved_space(self.space_id), numeric_id(self.page_id)
+        result = await self.perform(
+            "GET", f"/wiki/api/v2/pages/{identifier}", params={"body-format": "storage", "status": "current"}
+        )
+        return Data(data=page_data(result, space=space, identifier=identifier, include_body=True))
+
+
+class ConfluenceCreatePageComponent(ConfluenceActionComponent):
+    display_name = "Confluence: Create Page"
+    description = "Publish one page with a storage-format body in an approved space."
+    name = "ConfluenceCreatePage"
+    capability_id = "confluence.page.create"
+    inputs = [
+        connection_input(capability_id),
+        space_input(),
+        MessageTextInput(name="title", display_name="Title", required=True),
+        MultilineInput(name="body_storage", display_name="Storage Body", required=True),
+        MessageTextInput(name="parent_id", display_name="Parent Page ID", advanced=True),
+    ]
+    outputs = [Output(display_name="Page", name="page", method="create_page")]
+
+    async def create_page(self) -> Data:
+        space = approved_space(self.space_id)
+        body = {
+            "spaceId": space,
+            "status": "current",
+            "title": text(self.title, maximum=255),
+            "body": {"representation": "storage", "value": text(self.body_storage, maximum=524288, required=False)},
+        }
+        parent = getattr(self, "parent_id", "")
+        if parent:
+            parent = numeric_id(parent)
+            existing = await self.perform("GET", f"/wiki/api/v2/pages/{parent}", params={"status": "current"})
+            page_data(existing, space=space, identifier=parent)
+            body["parentId"] = parent
+        result = await self.perform("POST", "/wiki/api/v2/pages", body=body, write=True)
+        return Data(data=page_data(result, space=space))
+
+
+class ConfluenceUpdatePageComponent(ConfluenceActionComponent):
+    display_name = "Confluence: Update Page"
+    description = "Replace a published page only when its current version matches the expected version."
+    name = "ConfluenceUpdatePage"
+    capability_id = "confluence.page.update"
+    inputs = [
+        connection_input(capability_id),
+        space_input(),
+        MessageTextInput(name="page_id", display_name="Page ID", required=True),
+        IntInput(name="expected_version", display_name="Expected Current Version", required=True, value=1),
+        MessageTextInput(name="title", display_name="Title", required=True),
+        MultilineInput(name="body_storage", display_name="Storage Body", required=True),
+    ]
+    outputs = [Output(display_name="Page", name="page", method="update_page")]
+
+    async def update_page(self) -> Data:
+        space, identifier = approved_space(self.space_id), numeric_id(self.page_id)
+        expected = self.expected_version
+        if type(expected) is not int or not 1 <= expected < MAX_VERSION:
+            msg = "Provide the expected positive current page version."
+            raise invalid(msg)
+        title = text(self.title, maximum=255)
+        storage = text(self.body_storage, maximum=524288, required=False)
+        current = page_data(
+            await self.perform("GET", f"/wiki/api/v2/pages/{identifier}", params={"status": "current"}),
+            space=space,
+            identifier=identifier,
+        )
+        if current["version"] != expected:
+            msg = "The page changed. Read its current version before submitting another update."
+            raise invalid(msg)
+        result = await self.perform(
+            "PUT",
+            f"/wiki/api/v2/pages/{identifier}",
+            body={
+                "id": identifier,
+                "status": "current",
+                "title": title,
+                "body": {"representation": "storage", "value": storage},
+                "version": {"number": expected + 1},
+            },
+            write=True,
+        )
+        updated = page_data(result, space=space, identifier=identifier)
+        if updated["version"] != expected + 1:
+            msg = "Confluence returned an unexpected updated page version."
+            raise invalid(msg)
+        return Data(data=updated)

lfx_confluence/components/confluence_integrations/capabilities.v1.json

@@ -0,0 +1,160 @@
+{
+  "schema_version": 1,
+  "provider_id": "confluence",
+  "display_name": "Confluence Cloud",
+  "icon": "Confluence",
+  "docs_url": "https://docs.langflow.org/next/bundles-confluence",
+  "auth_profiles": [
+    {
+      "id": "user",
+      "kind": "oauth2_authorization_code",
+      "identity": "user_delegated",
+      "supports_pkce": false,
+      "supports_refresh": true,
+      "default_scopes": [
+        "offline_access",
+        "read:confluence-user",
+        "read:page:confluence",
+        "write:page:confluence"
+      ],
+      "client_type_by_context": {
+        "hosted": "confidential",
+        "self_managed": "confidential"
+      },
+      "owner_by_context": {
+        "hosted": "either",
+        "self_managed": "customer"
+      }
+    }
+  ],
+  "capabilities": [
+    {
+      "id": "confluence.page.search",
+      "display_name": "Confluence: Search Pages",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "read:page:confluence",
+        "read:confluence-user"
+      ],
+      "policy_keys": [
+        "integrations.confluence.page.search"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed"
+      ],
+      "risk": "read",
+      "component_ref": "ConfluenceSearchPagesComponent"
+    },
+    {
+      "id": "confluence.page.read",
+      "display_name": "Confluence: Read Page",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "read:page:confluence",
+        "read:confluence-user"
+      ],
+      "policy_keys": [
+        "integrations.confluence.page.read"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed"
+      ],
+      "risk": "read",
+      "component_ref": "ConfluenceReadPageComponent"
+    },
+    {
+      "id": "confluence.page.create",
+      "display_name": "Confluence: Create Page",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "read:page:confluence",
+        "write:page:confluence",
+        "read:confluence-user"
+      ],
+      "policy_keys": [
+        "integrations.confluence.page.create"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed"
+      ],
+      "risk": "write",
+      "component_ref": "ConfluenceCreatePageComponent"
+    },
+    {
+      "id": "confluence.page.update",
+      "display_name": "Confluence: Update Page",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "read:page:confluence",
+        "write:page:confluence",
+        "read:confluence-user"
+      ],
+      "policy_keys": [
+        "integrations.confluence.page.update"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed"
+      ],
+      "risk": "write",
+      "component_ref": "ConfluenceUpdatePageComponent"
+    },
+    {
+      "id": "confluence.trigger.created",
+      "display_name": "Confluence: On Page Created",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "read:page:confluence",
+        "offline_access",
+        "read:confluence-user"
+      ],
+      "policy_keys": [
+        "integrations.confluence.trigger.created"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "self_managed"
+      ],
+      "risk": "read",
+      "component_ref": "ConfluenceOnPageCreatedTriggerComponent"
+    },
+    {
+      "id": "confluence.trigger.updated",
+      "display_name": "Confluence: On Page Updated",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "read:page:confluence",
+        "offline_access",
+        "read:confluence-user"
+      ],
+      "policy_keys": [
+        "integrations.confluence.trigger.updated"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "self_managed"
+      ],
+      "risk": "read",
+      "component_ref": "ConfluenceOnPageUpdatedTriggerComponent"
+    }
+  ]
+}

lfx_confluence/components/confluence_integrations/triggers.py

@@ -0,0 +1,41 @@
+"""Declarations for authenticated latest-state page polling."""
+
+from lfx.io import MessageTextInput
+
+from lfx_confluence.base import ConfluencePageTriggerComponent
+from lfx_confluence.manifest import connection_input
+
+
+class ConfluenceOnPageCreatedTriggerComponent(ConfluencePageTriggerComponent):
+    display_name = "Confluence: On Page Created"
+    description = (
+        "Observe newly created pages after an initial approved-space baseline. "
+        "Moved old pages do not count as creation."
+    )
+    name = "ConfluenceOnPageCreatedTrigger"
+    trigger_kind = "confluence.page_created"
+    inputs = [
+        connection_input("confluence.trigger.created", required=False),
+        MessageTextInput(
+            name="space_id",
+            display_name="Space ID",
+            required=True,
+            info="An approved numeric space ID with at most 5000 observed pages.",
+        ),
+    ]
+
+
+class ConfluenceOnPageUpdatedTriggerComponent(ConfluencePageTriggerComponent):
+    display_name = "Confluence: On Page Updated"
+    description = "Observe version changes of previously seen published pages. Intermediate edits can be missed."
+    name = "ConfluenceOnPageUpdatedTrigger"
+    trigger_kind = "confluence.page_updated"
+    inputs = [
+        connection_input("confluence.trigger.updated", required=False),
+        MessageTextInput(
+            name="space_id",
+            display_name="Space ID",
+            required=True,
+            info="An approved numeric space ID with at most 5000 observed pages.",
+        ),
+    ]

lfx_confluence/extension.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-confluence",
+  "version": "0.1.0",
+  "name": "Confluence Integrations",
+  "description": "Confluence Cloud page actions and latest-state polling triggers.",
+  "lfx": {
+    "compat": [
+      "1"
+    ]
+  },
+  "bundles": [
+    {
+      "name": "confluence_integrations",
+      "path": "components/confluence_integrations"
+    }
+  ],
+  "integrations": [
+    {
+      "provider_id": "confluence",
+      "bundle": "confluence_integrations",
+      "path": "capabilities.v1.json"
+    }
+  ]
+}

lfx_confluence/manifest.py

@@ -0,0 +1,31 @@
+"""Bundle capability metadata and connection requirements."""
+
+from functools import lru_cache
+from pathlib import Path
+
+from lfx.custom.custom_component.component import Component  # noqa: F401
+from lfx.integrations.capabilities import IntegrationCapabilityManifest
+from lfx.io import ConnectionRefInput
+
+
+@lru_cache(maxsize=1)
+def load_manifest():
+    return IntegrationCapabilityManifest.model_validate_json(
+        (Path(__file__).parent / "components/confluence_integrations/capabilities.v1.json").read_text()
+    )
+
+
+def connection_input(capability, *, required=True):
+    declared = next(item for item in load_manifest().capabilities if item.id == capability)
+    return ConnectionRefInput(
+        name="connection",
+        display_name="Confluence Connection",
+        provider="confluence",
+        auth_profile_id="user",
+        identity_kind="user",
+        ownership_mode="user",
+        required_scopes=list(declared.required_scopes),
+        capabilities=[capability],
+        required=required,
+        info="Use an owned Confluence Cloud OAuth connection for the operator-configured site.",
+    )

lfx_confluence/schema.py

@@ -0,0 +1,172 @@
+"""Fixed deployment identity and bounded Confluence page targets."""
+
+from __future__ import annotations
+
+import os
+import re
+from datetime import datetime, timezone
+from urllib.parse import parse_qsl, urlsplit
+from uuid import UUID
+
+from lfx.integrations.errors import InvalidRequestError
+
+API_ORIGIN = "https://api.atlassian.com"
+READ = "read:page:confluence"
+WRITE = "write:page:confluence"
+USER = "read:confluence-user"
+SCOPES = frozenset({READ, WRITE, USER, "offline_access"})
+PAGE_SIZE = 100
+MAX_PAGES = 50
+MAX_ITEMS = 5000
+MAX_CURSOR = 8192
+MAX_VERSION = 2147483647
+MAX_SPACES = 100
+
+
+def invalid(message):
+    return InvalidRequestError(message, provider="confluence")
+
+
+def cloud_id():
+    value = os.environ.get("LANGFLOW_CONFLUENCE_CLOUD_ID", "")
+    try:
+        if str(UUID(value)) != value:
+            raise ValueError
+    except (ValueError, AttributeError):
+        msg = "Configure one canonical lowercase Confluence Cloud site UUID on the server."
+        raise invalid(msg) from None
+    return value
+
+
+def numeric_id(value):
+    if not isinstance(value, str) or not re.fullmatch(r"[1-9][0-9]{0,18}", value):
+        msg = "Use a positive Confluence numeric ID within 19 digits."
+        raise invalid(msg)
+    return value
+
+
+def approved_space(value):
+    value = numeric_id(value)
+    configured = os.environ.get("LANGFLOW_CONFLUENCE_SPACE_IDS", "").split(",")
+    if not 1 <= len(configured) <= MAX_SPACES or any(
+        not re.fullmatch(r"[1-9][0-9]{0,18}", item) for item in configured
+    ):
+        msg = "Configure one to 100 approved Confluence space IDs as a comma-separated server setting."
+        raise invalid(msg)
+    if value not in configured:
+        msg = "This Confluence space is not approved by the deployment operator."
+        raise invalid(msg)
+    return value
+
+
+def text(value, *, maximum=32768, required=True):
+    try:
+        valid = (
+            isinstance(value, str) and len(value.encode("utf-8")) <= maximum and (not required or bool(value.strip()))
+        )
+    except UnicodeEncodeError:
+        valid = False
+    if not valid:
+        msg = "Provide text within the documented size limit."
+        raise invalid(msg)
+    return value
+
+
+def timestamp(value):
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        if parsed.tzinfo is None:
+            raise ValueError
+        return parsed.astimezone(timezone.utc)
+    except (AttributeError, ValueError, TypeError, OverflowError):
+        msg = "Confluence returned an invalid page timestamp."
+        raise invalid(msg) from None
+
+
+def page_data(value, *, space, identifier=None, include_body=False):
+    if not isinstance(value, dict) or not isinstance(value.get("version"), dict):
+        msg = "Confluence returned an invalid page."
+        raise invalid(msg)
+    page_id = numeric_id(value.get("id"))
+    if value.get("spaceId") != approved_space(space) or (identifier is not None and page_id != identifier):
+        msg = "Confluence returned a page outside the selected target."
+        raise invalid(msg)
+    version = value["version"].get("number")
+    if type(version) is not int or not 1 <= version <= MAX_VERSION or value.get("status") != "current":
+        msg = "Confluence returned an invalid current page version."
+        raise invalid(msg)
+    result = {
+        "id": page_id,
+        "space_id": space,
+        "title": text(value.get("title"), maximum=4096),
+        "created_at": timestamp(value.get("createdAt")).isoformat(),
+        "updated_at": timestamp(value["version"].get("createdAt")).isoformat(),
+        "version": version,
+    }
+    if include_body:
+        body = value.get("body", {}).get("storage") if isinstance(value.get("body"), dict) else None
+        if not isinstance(body, dict):
+            msg = "Confluence returned no storage page body."
+            raise invalid(msg)
+        result["body_storage"] = text(body.get("value"), maximum=1048576, required=False)
+    return result
+
+
+def list_params(space, *, title="", cursor=""):
+    result = {
+        "space-id": approved_space(space),
+        "status": "current",
+        "sort": "id",
+        "subtype": "page",
+        "limit": PAGE_SIZE,
+    }
+    if title:
+        result["title"] = text(title, maximum=255)
+    if cursor:
+        result["cursor"] = text(cursor, maximum=MAX_CURSOR)
+    return result
+
+
+def next_cursor(result):
+    links = result.get("_links", {}) if isinstance(result, dict) else None
+    if not isinstance(links, dict):
+        msg = "Confluence returned malformed page links."
+        raise invalid(msg)
+    link = links.get("next")
+    if link is None or link == "":
+        return ""
+    link = text(link, maximum=MAX_CURSOR + 4096)
+    parts = urlsplit(link)
+    allowed = {"/wiki/api/v2/pages", f"/ex/confluence/{cloud_id()}/wiki/api/v2/pages"}
+    if (parts.scheme or parts.netloc) and f"{parts.scheme}://{parts.netloc}" != API_ORIGIN:
+        msg = "Confluence returned an unsafe pagination origin."
+        raise invalid(msg)
+    if parts.path not in allowed or parts.fragment or parts.username or parts.password:
+        msg = "Confluence returned an unrelated pagination resource."
+        raise invalid(msg)
+    try:
+        pairs = parse_qsl(parts.query, strict_parsing=True, max_num_fields=12)
+    except ValueError:
+        msg = "Confluence returned malformed pagination parameters."
+        raise invalid(msg) from None
+    cursors = [value for key, value in pairs if key == "cursor"]
+    if len(cursors) != 1:
+        msg = "Confluence returned no unique pagination cursor."
+        raise invalid(msg)
+    # Rebuild every request from approved space and fixed filters. Never follow the provider URL.
+    return text(cursors[0], maximum=MAX_CURSOR)
+
+
+def page_list(result, *, space):
+    if (
+        not isinstance(result, dict)
+        or not isinstance(result.get("results"), list)
+        or len(result["results"]) > PAGE_SIZE
+    ):
+        msg = "Confluence returned an invalid page list."
+        raise invalid(msg)
+    pages = [page_data(value, space=space) for value in result["results"]]
+    if len({value["id"] for value in pages}) != len(pages):
+        msg = "Confluence returned duplicate pages. Retry the complete snapshot."
+        raise invalid(msg)
+    return pages, next_cursor(result)

lfx_confluence-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: lfx-confluence
+Version: 0.1.0
+Summary: Confluence Cloud page actions and bounded latest-state polling triggers.
+License: MIT
+Requires-Python: <3.16,>=3.10
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: lfx<2.0.0,>=1.14.0.dev0
+Description-Content-Type: text/markdown
+
+# Confluence Cloud integrations
+
+This preview bundle provides four page actions and two polling triggers for an approved Confluence Cloud site. The Confluence Integrations category is separate from legacy Confluence components, whose saved-flow identities are unchanged.
+
+Follow the [Confluence Cloud setup guide](https://docs.langflow.org/next/bundles-confluence) for Atlassian application registration, deployment configuration, connections, background runs, event identity, limits, and recovery. The maintained [guide source](../../../docs/docs/Components/bundles-confluence.mdx) ships with the next-version documentation.
+
+The [provider contract](../../../design/provider-integrations/contracts/confluence.v1.json) records capabilities and acceptance evidence. Live tenant authorization and production delivery acceptance remain unverified.

lfx_confluence-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+lfx_confluence/__init__.py,sha256=Kimsdx_uLzf22x4ZomvC6IHRj3eut2rjfa1oHd2-XK0,61
+lfx_confluence/base.py,sha256=ETEzH2F-mTtwTAi7LCmxCxvFIQDNSEPJ50uX-olR56E,1501
+lfx_confluence/client.py,sha256=o_E2TQNQUSqRnkvU9MEvBFwyYaCNfeyP_XPnuH27dkw,6398
+lfx_confluence/extension.json,sha256=p75xs6SakTmek5v67-433RNsyhBYrRc09Te443xhIBk,560
+lfx_confluence/manifest.py,sha256=vVVWvLTdaEXirt539rQW1mCK3Dt9Y27V6G0xZ5k7Gi8,1117
+lfx_confluence/schema.py,sha256=S0OurMsIE36JILNZ6g7qwbKe42ty8B6WdCPcKhEr7XA,6285
+lfx_confluence/components/__init__.py,sha256=xMJwKXJ_-DRq3wc-KogCLYqgvdpizDsRYqftP4EYXas,41
+lfx_confluence/components/confluence_integrations/__init__.py,sha256=ZSCuI5xVCmVH-w5h4lY1mGuOqieo6cPgyqw8Gzoutho,582
+lfx_confluence/components/confluence_integrations/actions.py,sha256=b65s2dMZForPTDkv3diG0QDNUWe9bZBq3bwrmCfWLGo,6624
+lfx_confluence/components/confluence_integrations/capabilities.v1.json,sha256=0w1iE89FTGBoQokbW8vRJ21er-_PPFP_9OUb-upiRpc,4263
+lfx_confluence/components/confluence_integrations/triggers.py,sha256=TjBeSWb-nz_Il6ZLKsiPicQbonyuixTvqiVlifCVVCg,1541
+lfx_confluence-0.1.0.dist-info/METADATA,sha256=GcnyOoXJJT5qoU0CD64wv-4NJZFrVj3rdxX1Y-jWvWs,1138
+lfx_confluence-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+lfx_confluence-0.1.0.dist-info/entry_points.txt,sha256=dzE4uxeVnPrX4nPvK2AfAOzf9s2OAi8TI0bQxoW83fE,154
+lfx_confluence-0.1.0.dist-info/RECORD,,

lfx_confluence-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lfx_confluence-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[langflow.extensions]
+lfx-confluence = lfx_confluence
+
+[langflow.trigger_providers]
+confluence = langflow.services.triggers.providers.confluence:PROVIDER