agentgraph-connector-slack 0.5.0__py3-none-any.whl

agentgraph_connector_slack/__init__.py

@@ -0,0 +1,608 @@
+"""Slack connector with OAuth and browser-session authentication."""
+
+from __future__ import annotations
+
+import logging
+import re
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import httpx
+
+from agentgraph.connectors.base import (
+    BaseConnector,
+    ConnectorAccount,
+    EdgeRecord,
+    EntityBatch,
+    EntityRecord,
+    FetchPolicy,
+    PersonRecord,
+    ResourceType,
+    SourceReference,
+    get_known_channel_syncs,
+)
+from agentgraph.graph.upsert import upsert_batch
+from agentgraph_connector_slack.auth import (
+    SlackBrowserCredentials,
+    account_id_for_team,
+    list_slack_accounts,
+    load_slack_creds,
+    slack_headers,
+)
+
+logger = logging.getLogger(__name__)
+
+SLACK_API = "https://slack.com/api"
+_STALE_AFTER = 5 * 60  # 5 minutes
+_PADDING_MESSAGES = 20  # messages to fetch on first visit as immediate context
+_SLACK_CHANNEL_URL_RE = re.compile(
+    r"https://app\.slack\.com/client/(?P<workspace_id>[A-Z0-9]+)/(?P<channel_id>[A-Z0-9]+)"
+)
+
+
+def _team_id_from_token(account_id: str | None = None) -> str | None:
+    """Extract the Slack team ID from the stored credentials."""
+    try:
+        creds = load_slack_creds(account_id)
+    except RuntimeError:
+        return None
+    if creds.team_id:
+        return creds.team_id
+    if not isinstance(creds, SlackBrowserCredentials):
+        return None
+    parts = creds.xoxc_token.split("-")
+    return parts[1] if len(parts) >= 2 else None
+
+
+def _channel_ref(team_id: str, channel_id: str) -> str:
+    return f"{team_id}/{channel_id}"
+
+
+def _message_ref(team_id: str, channel_id: str, ts: str) -> str:
+    return f"{team_id}/{channel_id}:{ts}"
+
+
+def _user_ref(team_id: str, user_id: str) -> str:
+    return f"{team_id}/{user_id}"
+
+
+def _split_channel_ref(resource_id: str) -> tuple[str, str]:
+    team_id, _, channel_id = resource_id.partition("/")
+    if not team_id or not channel_id:
+        raise ValueError(f"Slack resource must be workspace-qualified: {resource_id}")
+    return team_id, channel_id
+
+
+def _normalise_channel_ref(resource_id: str, account_id: str | None = None) -> str:
+    if "/" in resource_id:
+        return resource_id
+    team_id = _team_id_from_token(account_id)
+    if not team_id:
+        raise ValueError(f"Slack resource must be workspace-qualified: {resource_id}")
+    return _channel_ref(team_id, resource_id)
+
+
+async def _api_get(
+    client: httpx.AsyncClient,
+    method: str,
+    account_id: str | None = None,
+    **params: Any,
+) -> dict[str, Any]:
+    for attempt in range(2):
+        resp = await client.get(
+            f"{SLACK_API}/{method}",
+            headers=await slack_headers(
+                account_id,
+                force_refresh=attempt == 1,
+                client=client,
+            ),
+            params=params,
+        )
+        resp.raise_for_status()
+        data: dict[str, Any] = resp.json()
+        if data.get("ok"):
+            return data
+        if data.get("error") != "token_expired" or attempt == 1:
+            raise RuntimeError(f"Slack API error on {method}: {data.get('error', 'unknown')}")
+    raise RuntimeError(f"Slack API error on {method}: token_expired")
+
+
+async def _fetch_channel_info(client: httpx.AsyncClient, channel_id: str, account_id: str | None = None) -> dict[str, Any]:
+    data = await _api_get(client, "conversations.info", account_id=account_id, channel=channel_id)
+    return data.get("channel", {})  # type: ignore[return-value]
+
+
+async def _fetch_user(client: httpx.AsyncClient, user_id: str, account_id: str | None = None) -> dict[str, Any]:
+    data = await _api_get(client, "users.info", account_id=account_id, user=user_id)
+    return data.get("user", {})  # type: ignore[return-value]
+
+
+def _ts_to_dt(ts: str) -> datetime:
+    return datetime.fromtimestamp(float(ts), tz=UTC)
+
+
+def _parse_mentions(text: str) -> list[str]:
+    """Extract <@UXXXXXXX> user IDs from message text."""
+    import re
+    return re.findall(r"<@([A-Z0-9]+)>", text)
+
+
+def _parse_channel_mentions(text: str) -> list[str]:
+    """Extract <#CXXXXXXX> channel IDs from message text."""
+    import re
+    return re.findall(r"<#([A-Z0-9]+)(?:\|[^>]*)?>", text)
+
+
+class SlackConnector(BaseConnector):
+    source = "slack"
+    fetch_policy = FetchPolicy(stale_after_seconds=_STALE_AFTER)
+    poll_interval: timedelta | None = timedelta(minutes=5)  # type: ignore[assignment]
+    url_patterns = ["https://app.slack.com/*"]
+    auth_label = "slack"
+    auth_description = "Slack workspace channels and DMs: Channel and Message entities with thread replies, authors, and user/channel mentions."
+    onboard_prompt = "Set up Slack?"
+
+    @classmethod
+    def run_auth_flow(
+        cls,
+        account_id: str | None = None,
+        add: bool = False,
+        args: list[str] | None = None,
+    ) -> None:
+        from agentgraph_connector_slack.auth import run_interactive_auth_flow
+
+        if args:
+            cls.run_auth_flow_with_args(args, account_id=account_id, add=add)
+            return
+        run_interactive_auth_flow(account_id=account_id, add=add)
+
+    @classmethod
+    def run_auth_flow_with_args(
+        cls,
+        args: list[str],
+        account_id: str | None = None,
+        add: bool = False,
+    ) -> None:
+        from agentgraph_connector_slack.auth import (
+            run_cookie_flow,
+            run_guided_oauth_flow,
+            run_interactive_auth_flow,
+        )
+
+        method: str | None = None
+        client_id: str | None = None
+        xoxc_token: str | None = None
+        d_cookie: str | None = None
+        index = 0
+        while index < len(args):
+            arg = args[index]
+            if arg in {"--method", "--client-id", "--xoxc-token", "--d-cookie"}:
+                if index + 1 >= len(args):
+                    raise ValueError(f"{arg} requires a value")
+                value = args[index + 1]
+                index += 1
+            elif any(arg.startswith(f"{option}=") for option in (
+                "--method", "--client-id", "--xoxc-token", "--d-cookie"
+            )):
+                option, value = arg.split("=", 1)
+                arg = option
+            else:
+                raise ValueError(f"Unknown Slack authentication option: {arg}")
+            if arg == "--method":
+                method = value
+            elif arg == "--client-id":
+                client_id = value.strip()
+                if not client_id:
+                    raise ValueError("--client-id requires a non-empty value")
+            elif arg == "--xoxc-token":
+                xoxc_token = value
+            else:
+                d_cookie = value
+            index += 1
+
+        if method not in {None, "oauth", "browser"}:
+            raise ValueError("Slack auth method must be 'oauth' or 'browser'")
+        browser_options = xoxc_token is not None or d_cookie is not None
+        if method == "oauth" and browser_options:
+            raise ValueError("--xoxc-token and --d-cookie cannot be used with --method oauth")
+        if method == "browser" and client_id is not None:
+            raise ValueError("--client-id cannot be used with --method browser")
+        selected_method = method or (
+            "browser" if browser_options else "oauth" if client_id is not None else None
+        )
+        if selected_method is None:
+            run_interactive_auth_flow(account_id=account_id, add=add)
+            return
+        if selected_method == "browser":
+            run_cookie_flow(
+                account_id=account_id,
+                add=add,
+                xoxc_token=xoxc_token,
+                d_cookie=d_cookie,
+            )
+            return
+        run_guided_oauth_flow(account_id=account_id, add=add, client_id=client_id)
+
+    @classmethod
+    def get_authenticated_user(cls) -> str | None:
+        try:
+            creds = load_slack_creds()
+            if creds.team_name and creds.user_id:
+                return f"{creds.team_name} / {creds.user_id}"
+            return creds.user_id
+        except Exception:
+            return None
+
+    @classmethod
+    def list_accounts(cls) -> list[ConnectorAccount]:
+        return [
+            ConnectorAccount(
+                account_id=str(account["account_id"]),
+                label=str(account["label"]),
+                auth_group=cls.auth_label or cls.source,
+                source=cls.source,
+                user_id=account.get("user_id"),
+                workspace_id=account.get("team_id"),
+                email=account.get("email"),
+                auth_method=account.get("auth_method"),
+            )
+            for account in list_slack_accounts()
+        ]
+
+    @classmethod
+    async def verify_auth(cls, account_id: str | None = None) -> tuple[str, str | None]:
+        try:
+            credentials = load_slack_creds(account_id)
+        except RuntimeError:
+            return ("missing", None)
+        except Exception as exc:
+            return ("invalid", str(exc))
+        try:
+            async with httpx.AsyncClient(timeout=10) as client:
+                data = await _api_get(client, "auth.test", account_id=account_id)
+        except Exception as exc:
+            return ("invalid", str(exc))
+        team_name = data.get("team") or credentials.team_name or credentials.team_id
+        user_id = data.get("user_id") or credentials.user_id
+        detail = f"{team_name} / {user_id}" if team_name and user_id else user_id or team_name
+        return ("ok", str(detail) if detail else "authenticated")
+
+    @classmethod
+    def current_user_ids(cls) -> list[str]:
+        ids: list[str] = []
+        for account in list_slack_accounts():
+            team_id = account.get("team_id")
+            user_id = account.get("user_id")
+            if team_id and user_id:
+                ids.append(f"slack:{team_id}/{user_id}")
+        return ids
+
+    def can_handle(self, url: str) -> bool:
+        return self.resolve_url(url) is not None
+
+    def resolve_url(self, url: str) -> SourceReference | None:
+        match = _SLACK_CHANNEL_URL_RE.match(url)
+        if match is None:
+            return None
+        return SourceReference(
+            source=self.source,
+            resource_type="channel",
+            resource_id=f"{match.group('workspace_id')}/{match.group('channel_id')}",
+        )
+
+    async def fetch(
+        self,
+        resource_type: ResourceType,
+        resource_id: str,
+        meta: dict[str, str] | None = None,
+        account_id: str | None = None,
+    ) -> EntityBatch:
+        last_sync = await self.last_synced_at(resource_id)
+        decision = self.fetch_policy.decide(last_sync)
+
+        if decision == FetchPolicy.FRESH:
+            logger.debug("slack/%s is fresh — updating last_accessed only", resource_id)
+            await _touch_last_accessed(resource_id)
+            return EntityBatch()
+
+        oldest: str | None = None
+        if decision == FetchPolicy.INCREMENTAL and last_sync:
+            oldest = str(last_sync.timestamp())
+
+        resource_id = _normalise_channel_ref(resource_id, account_id)
+        team_id, _ = _split_channel_ref(resource_id)
+        selected_account_id = account_id or account_id_for_team(team_id)
+        logger.info("Fetching Slack channel %s (policy=%s)", resource_id, decision)
+        batch = await _fetch_channel(resource_id, oldest=oldest, account_id=selected_account_id)
+        await upsert_batch(batch)
+        return batch
+
+    async def poll(
+        self,
+        cursor: dict[str, Any],
+        account_id: str | None = None,
+    ) -> tuple[EntityBatch, dict[str, Any]]:
+        channel_rows = await get_known_channel_syncs("slack", account_id=account_id)
+        combined = EntityBatch()
+        for channel_id, synced_at in channel_rows:
+            oldest = str(synced_at.timestamp()) if synced_at else None
+            try:
+                batch = await _fetch_channel(channel_id, oldest=oldest, account_id=account_id)
+                combined.entities.extend(batch.entities)
+                combined.persons.extend(batch.persons)
+                combined.edges.extend(batch.edges)
+            except Exception:
+                logger.exception("slack poll: failed to fetch channel %s", channel_id)
+        return combined, cursor
+
+
+async def _touch_last_accessed(channel_id: str) -> None:
+    from agentgraph.core.context import get_backend
+
+    backend = get_backend()
+    entity = await backend.get_entity_by_platform("slack", channel_id)
+    if entity:
+        # Re-upsert the same entity to bump last_accessed via the normal path.
+        # The cheapest way is just a stub upsert which only updates last_accessed.
+        await backend.upsert_stub_entity("Channel", "slack", channel_id)
+
+
+async def _fetch_thread_replies(
+    client: httpx.AsyncClient,
+    channel_ref: str,
+    thread_ts: str,
+    entities: list[EntityRecord],
+    persons: list[PersonRecord],
+    edges: list[EdgeRecord],
+    seen_users: set[str],
+    team_id: str | None = None,
+    account_id: str | None = None,
+) -> None:
+    """Fetch replies to a threaded message and add them to the batch in-place."""
+    if team_id is None:
+        return
+    _, channel_id = _split_channel_ref(channel_ref)
+    try:
+        data = await _api_get(
+            client, "conversations.replies", account_id=account_id, channel=channel_id, ts=thread_ts
+        )
+    except Exception as exc:
+        logger.warning("Could not fetch replies for %s:%s: %s", channel_id, thread_ts, exc)
+        return
+
+    reply_messages: list[dict[str, Any]] = data.get("messages", [])
+
+    for reply in reply_messages:
+        ts: str = reply.get("ts", "")
+        if not ts or ts == thread_ts:
+            continue  # skip the parent message Slack echoes back
+
+        user_id: str = reply.get("user", "")
+        text: str = reply.get("text", "")
+
+        reply_meta: dict[str, Any] = {"team_id": team_id, "channel_id": channel_id, "ts": ts, "thread_ts": thread_ts}
+        if team_id:
+            ts_compact = ts.replace(".", "")
+            reply_meta["web_url"] = f"https://app.slack.com/client/{team_id}/{channel_id}/p{ts_compact}"
+        if account_id:
+            reply_meta["account_id"] = account_id
+        entities.append(EntityRecord(
+            entity_type="Message",
+            platform="slack",
+            platform_entity_id=_message_ref(team_id, channel_id, ts),
+            content=text,
+            created_at=_ts_to_dt(ts),
+            updated_at=_ts_to_dt(ts),
+            metadata=reply_meta,
+        ))
+
+        edges.append(EdgeRecord(
+            edge_type="replied_to",
+            source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+            target_platform_entity_id=_message_ref(team_id, channel_id, thread_ts),
+            platform="slack",
+        ))
+        edges.append(EdgeRecord(
+            edge_type="posted_in",
+            source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+            target_platform_entity_id=channel_ref,
+            platform="slack",
+        ))
+
+        if user_id and user_id not in seen_users:
+            seen_users.add(user_id)
+            try:
+                user_info = await _fetch_user(client, user_id, account_id=account_id)
+                profile = user_info.get("profile", {})
+                persons.append(PersonRecord(
+                    platform="slack",
+                    platform_user_id=_user_ref(team_id, user_id),
+                    platform_username=user_info.get("name"),
+                    canonical_email=profile.get("email") or None,
+                    display_name=profile.get("real_name") or None,
+                ))
+            except Exception:
+                logger.debug("Could not fetch user %s", user_id)
+
+        if user_id:
+            edges.append(EdgeRecord(
+                edge_type="authored",
+                source_platform_user_id=_user_ref(team_id, user_id),
+                target_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                platform="slack",
+            ))
+
+        for mentioned_id in _parse_mentions(text):
+            if mentioned_id not in seen_users:
+                seen_users.add(mentioned_id)
+                try:
+                    user_info = await _fetch_user(client, mentioned_id, account_id=account_id)
+                    profile = user_info.get("profile", {})
+                    persons.append(PersonRecord(
+                        platform="slack",
+                        platform_user_id=_user_ref(team_id, mentioned_id),
+                        platform_username=user_info.get("name"),
+                        canonical_email=profile.get("email") or None,
+                        display_name=profile.get("real_name") or None,
+                    ))
+                except Exception:
+                    logger.debug("Could not fetch user %s", mentioned_id)
+            edges.append(EdgeRecord(
+                edge_type="mentions",
+                source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                target_platform_user_id=_user_ref(team_id, mentioned_id),
+                platform="slack",
+            ))
+
+        for mentioned_channel_id in _parse_channel_mentions(text):
+            edges.append(EdgeRecord(
+                edge_type="mentions",
+                source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                target_platform_entity_id=_channel_ref(team_id, mentioned_channel_id),
+                platform="slack",
+            ))
+
+
+async def _fetch_channel(channel_ref: str, oldest: str | None = None, account_id: str | None = None) -> EntityBatch:
+    entities: list[EntityRecord] = []
+    persons: list[PersonRecord] = []
+    edges: list[EdgeRecord] = []
+    seen_users: set[str] = set()
+
+    team_id, channel_id = _split_channel_ref(channel_ref)
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        # Channel entity
+        channel_info = await _fetch_channel_info(client, channel_id, account_id=account_id)
+        channel_name = channel_info.get("name", channel_id)
+
+        channel_meta: dict[str, Any] = {"team_id": team_id, "channel_id": channel_id}
+        if team_id:
+            channel_meta["web_url"] = f"https://app.slack.com/client/{team_id}/{channel_id}"
+        if account_id:
+            channel_meta["account_id"] = account_id
+        channel_entity = EntityRecord(
+            entity_type="Channel",
+            platform="slack",
+            platform_entity_id=channel_ref,
+            title=f"#{channel_name}",
+            updated_at=datetime.now(UTC),
+            metadata=channel_meta,
+        )
+        entities.append(channel_entity)
+
+        # Fetch messages
+        params: dict[str, Any] = {"channel": channel_id, "limit": 100}
+        if oldest:
+            params["oldest"] = oldest
+
+        data = await _api_get(client, "conversations.history", account_id=account_id, **params)
+        messages: list[dict[str, Any]] = data.get("messages", [])
+
+        for msg in messages:
+            user_id: str = msg.get("user", "")
+            ts: str = msg.get("ts", "")
+            text: str = msg.get("text", "")
+            thread_ts: str | None = msg.get("thread_ts")
+            reply_count: int = msg.get("reply_count", 0)
+
+            if not ts:
+                continue
+
+            msg_meta: dict[str, Any] = {"team_id": team_id, "channel_id": channel_id, "ts": ts}
+            if team_id:
+                ts_compact = ts.replace(".", "")
+                msg_meta["web_url"] = f"https://app.slack.com/client/{team_id}/{channel_id}/p{ts_compact}"
+            if account_id:
+                msg_meta["account_id"] = account_id
+            msg_entity = EntityRecord(
+                entity_type="Message",
+                platform="slack",
+                platform_entity_id=_message_ref(team_id, channel_id, ts),
+                content=text,
+                created_at=_ts_to_dt(ts),
+                updated_at=_ts_to_dt(ts),
+                metadata=msg_meta,
+            )
+            entities.append(msg_entity)
+
+            # posted_in edge: message → channel
+            edges.append(EdgeRecord(
+                edge_type="posted_in",
+                source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                target_platform_entity_id=channel_ref,
+                platform="slack",
+            ))
+
+            # Thread reply edge (this message is itself a reply)
+            if thread_ts and thread_ts != ts:
+                edges.append(EdgeRecord(
+                    edge_type="replied_to",
+                    source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                    target_platform_entity_id=_message_ref(team_id, channel_id, thread_ts),
+                    platform="slack",
+                ))
+
+            # Author
+            if user_id and user_id not in seen_users:
+                seen_users.add(user_id)
+                user_info = await _fetch_user(client, user_id, account_id=account_id)
+                profile = user_info.get("profile", {})
+                persons.append(PersonRecord(
+                    platform="slack",
+                    platform_user_id=_user_ref(team_id, user_id),
+                    platform_username=user_info.get("name"),
+                    canonical_email=profile.get("email") or None,
+                    display_name=profile.get("real_name") or None,
+                ))
+
+            if user_id:
+                edges.append(EdgeRecord(
+                edge_type="authored",
+                source_platform_user_id=_user_ref(team_id, user_id),
+                target_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                    platform="slack",
+                ))
+
+            # User mention edges
+            for mentioned_id in _parse_mentions(text):
+                if mentioned_id not in seen_users:
+                    seen_users.add(mentioned_id)
+                    try:
+                        user_info = await _fetch_user(client, mentioned_id, account_id=account_id)
+                        profile = user_info.get("profile", {})
+                        persons.append(PersonRecord(
+                            platform="slack",
+                            platform_user_id=_user_ref(team_id, mentioned_id),
+                            platform_username=user_info.get("name"),
+                            canonical_email=profile.get("email") or None,
+                            display_name=profile.get("real_name") or None,
+                        ))
+                    except Exception:
+                        logger.debug("Could not fetch user %s", mentioned_id)
+                edges.append(EdgeRecord(
+                    edge_type="mentions",
+                    source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                    target_platform_user_id=_user_ref(team_id, mentioned_id),
+                    platform="slack",
+                ))
+
+            # Channel mention edges
+            for mentioned_channel_id in _parse_channel_mentions(text):
+                edges.append(EdgeRecord(
+                    edge_type="mentions",
+                    source_platform_entity_id=_message_ref(team_id, channel_id, ts),
+                    target_platform_entity_id=_channel_ref(team_id, mentioned_channel_id),
+                    platform="slack",
+                ))
+
+            # Fetch thread replies for messages that have them
+            if reply_count > 0 and not (thread_ts and thread_ts != ts):
+                await _fetch_thread_replies(
+                    client, channel_ref, ts, entities, persons, edges, seen_users, team_id=team_id, account_id=account_id
+                )
+
+    batch = EntityBatch(entities=entities, persons=persons, edges=edges)
+    for entity in batch.entities[:]:
+        batch.add_stubs_from(entity)
+    return batch

agentgraph_connector_slack/auth.py

@@ -0,0 +1,673 @@
+"""Slack OAuth and browser-session credentials."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import os
+import secrets
+import time
+import webbrowser
+from datetime import UTC, datetime, timedelta
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from typing import Annotated, Any, Literal, cast
+from urllib.parse import parse_qs, urlencode, urlparse
+from weakref import WeakKeyDictionary
+
+import httpx
+from pydantic import BaseModel, Field, TypeAdapter
+
+SLACK_TOKEN_URL = "https://slack.com/api/oauth.v2.user.access"
+SLACK_AUTHORIZE_URL = "https://slack.com/oauth/v2_user/authorize"
+DEFAULT_REDIRECT_URI = "http://localhost:8766/slack/oauth/callback"
+REQUIRED_SCOPES: frozenset[str] = frozenset({
+    "channels:history",
+    "channels:read",
+    "groups:history",
+    "groups:read",
+    "im:history",
+    "im:read",
+    "mpim:history",
+    "mpim:read",
+    "users:read",
+})
+OPTIONAL_SCOPES: frozenset[str] = frozenset({"users:read.email"})
+REFRESH_WINDOW = timedelta(minutes=5)
+
+
+class SlackBrowserCredentials(BaseModel):
+    auth_method: Literal["browser"] = "browser"
+    xoxc_token: str
+    d_cookie: str
+    user_id: str | None = None
+    team_id: str | None = None
+    team_name: str | None = None
+
+
+class SlackOAuthCredentials(BaseModel):
+    auth_method: Literal["oauth"] = "oauth"
+    access_token: str
+    refresh_token: str
+    expires_at: datetime
+    client_id: str
+    scopes: list[str]
+    user_id: str
+    team_id: str
+    team_name: str | None = None
+    email: str | None = None
+
+
+SlackCredential = Annotated[
+    SlackBrowserCredentials | SlackOAuthCredentials,
+    Field(discriminator="auth_method"),
+]
+_CREDENTIAL_ADAPTER: TypeAdapter[SlackCredential] = TypeAdapter(SlackCredential)
+
+# Backwards-compatible public name for callers that used the old model.
+SlackCredentials = SlackBrowserCredentials
+
+_refresh_locks: WeakKeyDictionary[
+    asyncio.AbstractEventLoop, dict[str, asyncio.Lock]
+] = WeakKeyDictionary()
+
+
+class SlackOAuthCallback(BaseModel):
+    code: str | None = None
+    state: str | None = None
+    error: str | None = None
+
+
+def parse_slack_credentials(raw: dict[str, Any]) -> SlackCredential:
+    """Parse stored credentials, treating pre-discriminator records as browser auth."""
+    data = dict(raw)
+    data.setdefault("auth_method", "browser")
+    return _CREDENTIAL_ADAPTER.validate_python(data)
+
+
+def load_slack_creds(account_id: str | None = None) -> SlackCredential:
+    from agentgraph.auth.credentials import load_platform_account
+
+    data = load_platform_account("slack", account_id)
+    if data is None:
+        raise RuntimeError("Slack credentials not configured. Run: agentgraph auth slack")
+    return parse_slack_credentials(data)
+
+
+def list_slack_accounts() -> list[dict[str, str | None]]:
+    from agentgraph.auth.credentials import load_platform_accounts
+
+    results: list[dict[str, str | None]] = []
+    for raw in load_platform_accounts("slack"):
+        try:
+            creds = parse_slack_credentials(raw)
+        except Exception:
+            continue
+        team_id = creds.team_id
+        user_id = creds.user_id
+        account_id = str(
+            raw.get("account_id")
+            or (f"slack:{team_id}:{user_id}" if team_id and user_id else "slack")
+        )
+        label = creds.team_name or team_id or account_id
+        results.append({
+            "account_id": account_id,
+            "team_id": team_id,
+            "user_id": user_id,
+            "label": label,
+            "auth_method": creds.auth_method,
+            "email": creds.email if isinstance(creds, SlackOAuthCredentials) else None,
+        })
+    return results
+
+
+def account_id_for_team(team_id: str) -> str | None:
+    for account in list_slack_accounts():
+        if account.get("team_id") == team_id:
+            return str(account["account_id"])
+    return None
+
+
+def validate_required_scopes(scopes: list[str] | str) -> list[str]:
+    granted = set(scopes.split(",") if isinstance(scopes, str) else scopes)
+    return sorted(REQUIRED_SCOPES - granted)
+
+
+def _oauth_values(data: dict[str, Any]) -> tuple[str, str, int, list[str]]:
+    authed_user = data.get("authed_user")
+    user_data = cast(dict[str, Any], authed_user) if isinstance(authed_user, dict) else {}
+    access_token = data.get("access_token") or user_data.get("access_token")
+    refresh_token = data.get("refresh_token") or user_data.get("refresh_token")
+    expires_in = data.get("expires_in") or user_data.get("expires_in")
+    raw_scopes = data.get("scope") or user_data.get("scope") or ""
+    if not isinstance(access_token, str) or not isinstance(refresh_token, str):
+        raise RuntimeError("Slack OAuth response did not include rotating user tokens")
+    if not isinstance(expires_in, int | float):
+        raise RuntimeError("Slack OAuth response did not include token expiry")
+    scopes = [scope for scope in str(raw_scopes).split(",") if scope]
+    return access_token, refresh_token, int(expires_in), scopes
+
+
+def _pkce_pair() -> tuple[str, str]:
+    verifier = secrets.token_urlsafe(64)
+    digest = hashlib.sha256(verifier.encode("ascii")).digest()
+    challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+    return verifier, challenge
+
+
+def _wait_for_oauth_callback(
+    redirect_uri: str,
+    *,
+    timeout_seconds: float = 300,
+) -> SlackOAuthCallback:
+    parsed = urlparse(redirect_uri)
+    if parsed.scheme != "http" or parsed.hostname not in {"localhost", "127.0.0.1"}:
+        raise ValueError("Slack OAuth redirect must use http://localhost or http://127.0.0.1")
+    if parsed.port is None:
+        raise ValueError("Slack OAuth redirect must include a local port")
+
+    result: SlackOAuthCallback | None = None
+    expected_path = parsed.path or "/"
+
+    class CallbackHandler(BaseHTTPRequestHandler):
+        def do_GET(self) -> None:  # noqa: N802
+            nonlocal result
+            request_url = urlparse(self.path)
+            if request_url.path != expected_path:
+                self.send_error(404)
+                return
+            query = parse_qs(request_url.query)
+            result = SlackOAuthCallback(
+                code=query.get("code", [None])[0],
+                state=query.get("state", [None])[0],
+                error=query.get("error", [None])[0],
+            )
+            body = b"Slack authorization received. You can close this window."
+            self.send_response(200)
+            self.send_header("Content-Type", "text/plain; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def log_message(self, format: str, *args: object) -> None:
+            _ = (format, args)
+
+    deadline = time.monotonic() + timeout_seconds
+    with HTTPServer((parsed.hostname, parsed.port), CallbackHandler) as server:
+        while result is None:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError(
+                    "Timed out waiting five minutes for Slack authorization. "
+                    "If you requested app approval, rerun this command after Slackbot "
+                    "confirms approval."
+                )
+            server.timeout = remaining
+            server.handle_request()
+    return result
+
+
+def _exchange_oauth_code(
+    *,
+    code: str,
+    verifier: str,
+    client_id: str,
+    redirect_uri: str,
+) -> dict[str, Any]:
+    response = httpx.post(
+        SLACK_TOKEN_URL,
+        data={
+            "grant_type": "authorization_code",
+            "code": code,
+            "code_verifier": verifier,
+            "client_id": client_id,
+            "redirect_uri": redirect_uri,
+        },
+        timeout=30,
+    )
+    response.raise_for_status()
+    data: dict[str, Any] = response.json()
+    if not data.get("ok"):
+        raise RuntimeError(f"Slack OAuth exchange failed: {data.get('error', 'unknown')}")
+    return data
+
+
+def _manifest_text() -> str:
+    manifest_path = Path(__file__).with_name("slack-app-manifest.json")
+    return manifest_path.read_text().rstrip()
+
+
+def _manifest_block() -> str:
+    return f"AgentGraph Slack app manifest (JSON):\n\n{_manifest_text()}\n"
+
+
+def _admin_setup_instructions() -> str:
+    return (
+        "\nCreate the AgentGraph Slack app:\n\n"
+        "  1. Open https://api.slack.com/apps\n"
+        "  2. Choose Create New App > From an app manifest.\n"
+        "  3. Select the workspace you want AgentGraph to connect to.\n"
+        "  4. Select the JSON tab and paste the manifest printed below.\n"
+        "  5. Create and approve the app. Email access is optional.\n"
+        "  6. Open Basic Information > App Credentials and copy the Client ID.\n\n"
+        f"{_manifest_block()}"
+    )
+
+
+def _member_creation_instructions() -> str:
+    return (
+        "\nCheck whether you can create the AgentGraph app:\n\n"
+        "  1. Open https://api.slack.com/apps\n"
+        "  2. Choose Create New App > From an app manifest.\n"
+        "  3. At Pick a workspace, look for the workspace you want AgentGraph "
+        "to connect to.\n"
+    )
+
+
+def _member_visible_workspace_instructions() -> str:
+    return (
+        "\nCreate the AgentGraph Slack app:\n\n"
+        "  1. Select that workspace and continue.\n"
+        "  2. Select the JSON tab and paste the manifest printed below.\n"
+        "  3. Review the configuration and choose Create.\n"
+        "  4. Open Basic Information > App Credentials and copy the Client ID.\n\n"
+        f"{_manifest_block()}"
+    )
+
+
+def _member_missing_workspace_instructions() -> str:
+    return (
+        "\nThe workspace is not available in Slack's app creation list.\n\n"
+        "Ask a Workspace Owner or app manager either to give you permission to\n"
+        "create internal apps, or to create and approve AgentGraph using the\n"
+        "JSON manifest below.\n\n"
+        "Example request:\n\n"
+        "Hi, I'd like to connect AgentGraph to Slack. AgentGraph indexes Slack "
+        "conversations that I can access into a local knowledge graph. Could you "
+        "either give me permission to create an internal Slack app, or create and "
+        "approve AgentGraph using the JSON manifest below? The required user scopes "
+        "read public channels, private channels, DMs, group DMs, and member profiles. "
+        "Email access is optional. Once the app is approved, please send me its "
+        "Client ID. No client secret is needed. More information: "
+        "https://simonexmachina.github.io/agent-graph/\n\n"
+        f"{_manifest_block()}\n"
+        "Slack cannot offer app approval until the app exists in the target\n"
+        "workspace. When the admin sends the Client ID, rerun:\n\n"
+        "  agentgraph auth slack --add --client-id <client-id>\n"
+    )
+
+
+def _authorization_instructions() -> str:
+    return (
+        "\nSlack may show one of these actions:\n\n"
+        "  Allow\n"
+        "    Continue authorization now.\n\n"
+        "  Request approval\n"
+        "    Submit the request and wait for a Workspace Owner or app manager.\n"
+        "    For Message for your Slack Admin, you can use:\n\n"
+        "      Hi, I'd like approval to connect AgentGraph to Slack. AgentGraph "
+        "creates a local, queryable graph of conversations I can already access "
+        "so my AI tools can search my work context. It requests read access to "
+        "public channels, private channels, DMs, group DMs, and member profiles; "
+        "email access is optional. More information: "
+        "https://simonexmachina.github.io/agent-graph/\n\n"
+        "    Rerun this command after Slackbot confirms approval, then enter the\n"
+        "    same Client ID.\n\n"
+        "  Installation blocked\n"
+        "    Contact a Workspace Owner or app manager. Workspace policy does not\n"
+        "    allow members to request this app.\n"
+    )
+
+
+def _available_oauth_client_id(account_id: str | None, *, add: bool) -> str | None:
+    if not add:
+        try:
+            existing = load_slack_creds(account_id)
+        except Exception:
+            existing = None
+        if isinstance(existing, SlackOAuthCredentials):
+            return existing.client_id
+    return os.environ.get("AGENTGRAPH_SLACK_CLIENT_ID", "").strip() or None
+
+
+def _prompt_oauth_client_id() -> str:
+    import typer
+
+    while True:
+        client_id = typer.prompt("Slack app Client ID").strip()
+        if client_id:
+            return client_id
+        typer.echo("Slack app Client ID cannot be empty.")
+
+
+def run_interactive_auth_flow(account_id: str | None = None, add: bool = False) -> None:
+    """Prompt for a Slack authentication method and run the selected flow."""
+    import click
+    import typer
+
+    typer.echo(
+        "\nChoose how to connect Slack:\n"
+        "  1. Slack user OAuth with PKCE [recommended]\n"
+        "  2. Browser session credentials (xoxc token + d cookie) [fallback]\n"
+    )
+    choice = typer.prompt(
+        "Authentication method",
+        type=click.Choice(["1", "2"]),
+        default="1",
+        show_default=False,
+    )
+    if choice == "2":
+        run_cookie_flow(account_id=account_id, add=add)
+        return
+    run_guided_oauth_flow(account_id=account_id, add=add)
+
+
+def run_guided_oauth_flow(
+    account_id: str | None = None,
+    add: bool = False,
+    *,
+    client_id: str | None = None,
+) -> None:
+    """Resolve an existing client or guide the user through Slack app setup."""
+    import click
+    import typer
+
+    resolved_client_id = client_id or _available_oauth_client_id(account_id, add=add)
+    if resolved_client_id is not None:
+        run_oauth_flow(account_id=account_id, add=add, client_id=resolved_client_id)
+        return
+
+    workspace_admin = typer.confirm(
+        "Do you have admin permission in the Slack workspace you want to connect?",
+        default=False,
+    )
+    if workspace_admin:
+        typer.echo(_admin_setup_instructions())
+        run_oauth_flow(
+            account_id=account_id,
+            add=add,
+            client_id=_prompt_oauth_client_id(),
+        )
+        return
+
+    typer.echo(
+        "\nHow would you like to continue?\n\n"
+        "  1. Enter a Client ID provided by a Slack admin\n"
+        "  2. Set up the AgentGraph Slack App\n"
+    )
+    choice = typer.prompt(
+        "Choice",
+        type=click.Choice(["1", "2"]),
+        default="1",
+        show_default=False,
+    )
+    if choice == "1":
+        run_oauth_flow(
+            account_id=account_id,
+            add=add,
+            client_id=_prompt_oauth_client_id(),
+        )
+        return
+
+    typer.echo(_member_creation_instructions())
+    workspace_visible = typer.confirm(
+        "Can you see the workspace you want in Slack's Pick a workspace list?",
+        default=False,
+    )
+    if not workspace_visible:
+        typer.echo(_member_missing_workspace_instructions())
+        return
+    typer.echo(_member_visible_workspace_instructions())
+    run_oauth_flow(
+        account_id=account_id,
+        add=add,
+        client_id=_prompt_oauth_client_id(),
+    )
+
+
+def run_oauth_flow(
+    account_id: str | None = None,
+    add: bool = False,
+    *,
+    client_id: str | None = None,
+) -> None:
+    """Authorize a Slack user with PKCE and store rotating credentials."""
+    import typer
+
+    resolved_client_id = client_id or _available_oauth_client_id(account_id, add=add)
+    if resolved_client_id is None:
+        resolved_client_id = _prompt_oauth_client_id()
+    verifier, challenge = _pkce_pair()
+    state = secrets.token_urlsafe(32)
+    authorize_url = f"{SLACK_AUTHORIZE_URL}?{urlencode({
+        'client_id': resolved_client_id,
+        'scope': ','.join(sorted(REQUIRED_SCOPES | OPTIONAL_SCOPES)),
+        'redirect_uri': DEFAULT_REDIRECT_URI,
+        'state': state,
+        'code_challenge': challenge,
+        'code_challenge_method': 'S256',
+    })}"
+    typer.echo(_authorization_instructions())
+    typer.echo(f"Opening Slack authorization in your browser:\n{authorize_url}")
+    webbrowser.open(authorize_url)
+    callback = _wait_for_oauth_callback(DEFAULT_REDIRECT_URI)
+    if not callback.state or not secrets.compare_digest(callback.state, state):
+        raise RuntimeError("Slack OAuth callback state did not match")
+    if callback.error:
+        raise RuntimeError(f"Slack OAuth authorization denied: {callback.error}")
+    if not callback.code:
+        raise RuntimeError("Slack OAuth callback did not include an authorization code")
+
+    data = _exchange_oauth_code(
+        code=callback.code,
+        verifier=verifier,
+        client_id=resolved_client_id,
+        redirect_uri=DEFAULT_REDIRECT_URI,
+    )
+    access_token, refresh_token, expires_in, scopes = _oauth_values(data)
+    missing_scopes = validate_required_scopes(scopes)
+    if missing_scopes:
+        raise RuntimeError(
+            "Slack authorization is missing required scopes: " + ", ".join(missing_scopes)
+        )
+    team = data.get("team")
+    team_data = cast(dict[str, Any], team) if isinstance(team, dict) else {}
+    authed_user = data.get("authed_user")
+    user_data = cast(dict[str, Any], authed_user) if isinstance(authed_user, dict) else {}
+    team_id = team_data.get("id")
+    user_id = user_data.get("id") or data.get("user_id")
+    if not isinstance(team_id, str) or not isinstance(user_id, str):
+        raise RuntimeError("Slack OAuth response did not identify the workspace and user")
+
+    email: str | None = None
+    if "users:read.email" in scopes:
+        try:
+            profile_response = httpx.get(
+                "https://slack.com/api/users.info",
+                headers={"Authorization": f"Bearer {access_token}"},
+                params={"user": user_id},
+                timeout=10,
+            )
+            profile_data: dict[str, Any] = profile_response.json()
+            raw_user = profile_data.get("user")
+            user_profile = cast(dict[str, Any], raw_user) if isinstance(raw_user, dict) else {}
+            raw_profile = user_profile.get("profile")
+            profile = cast(dict[str, Any], raw_profile) if isinstance(raw_profile, dict) else {}
+            raw_email = profile.get("email")
+            email = raw_email if isinstance(raw_email, str) else None
+        except Exception:
+            email = None
+
+    credentials = SlackOAuthCredentials(
+        access_token=access_token,
+        refresh_token=refresh_token,
+        expires_at=datetime.now(UTC) + timedelta(seconds=expires_in),
+        client_id=resolved_client_id,
+        scopes=scopes,
+        user_id=user_id,
+        team_id=team_id,
+        team_name=team_data.get("name") if isinstance(team_data.get("name"), str) else None,
+        email=email,
+    )
+    resolved_account_id = account_id or f"slack:{team_id}:{user_id}"
+    if account_id is not None and account_id != f"slack:{team_id}:{user_id}":
+        raise RuntimeError(
+            f"Slack identity {team_id}:{user_id} does not match requested account {account_id}"
+        )
+    from agentgraph.auth.credentials import upsert_platform_account
+
+    upsert_platform_account("slack", resolved_account_id, credentials, make_default=True)
+    from agentgraph.config import CREDENTIALS_FILE
+
+    typer.echo(f"Slack OAuth credentials saved to {CREDENTIALS_FILE} ({resolved_account_id})")
+
+
+async def refresh_oauth_credentials(
+    account_id: str | None = None,
+    *,
+    force: bool = False,
+    client: httpx.AsyncClient | None = None,
+) -> SlackOAuthCredentials:
+    """Refresh a rotating token once per account and persist the replacement atomically."""
+    initial = load_slack_creds(account_id)
+    if not isinstance(initial, SlackOAuthCredentials):
+        raise RuntimeError("Slack browser credentials cannot be refreshed")
+    resolved_id = account_id or f"slack:{initial.team_id}:{initial.user_id}"
+    locks = _refresh_locks.setdefault(asyncio.get_running_loop(), {})
+    lock = locks.setdefault(resolved_id, asyncio.Lock())
+    async with lock:
+        current = load_slack_creds(resolved_id)
+        if not isinstance(current, SlackOAuthCredentials):
+            raise RuntimeError("Slack OAuth credentials changed during refresh")
+        now = datetime.now(UTC)
+        expires_at = current.expires_at
+        if expires_at.tzinfo is None:
+            expires_at = expires_at.replace(tzinfo=UTC)
+        if force and current.access_token != initial.access_token:
+            return current
+        if not force and expires_at > now + REFRESH_WINDOW:
+            return current
+
+        owns_client = client is None
+        http = client or httpx.AsyncClient(timeout=30)
+        try:
+            response = await http.post(
+                SLACK_TOKEN_URL,
+                data={
+                    "grant_type": "refresh_token",
+                    "refresh_token": current.refresh_token,
+                    "client_id": current.client_id,
+                },
+            )
+            response.raise_for_status()
+            data: dict[str, Any] = response.json()
+        finally:
+            if owns_client:
+                await http.aclose()
+        if not data.get("ok"):
+            raise RuntimeError(f"Slack OAuth refresh failed: {data.get('error', 'unknown')}")
+
+        access_token, refresh_token, expires_in, returned_scopes = _oauth_values(data)
+        refreshed = current.model_copy(update={
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+            "expires_at": now + timedelta(seconds=expires_in),
+            "scopes": returned_scopes or current.scopes,
+        })
+        from agentgraph.auth.credentials import upsert_platform_account
+
+        upsert_platform_account("slack", resolved_id, refreshed, make_default=False)
+        return refreshed
+
+
+async def slack_headers(
+    account_id: str | None = None,
+    *,
+    force_refresh: bool = False,
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, str]:
+    creds = load_slack_creds(account_id)
+    if isinstance(creds, SlackOAuthCredentials):
+        expires_at = creds.expires_at
+        if expires_at.tzinfo is None:
+            expires_at = expires_at.replace(tzinfo=UTC)
+        if force_refresh or expires_at <= datetime.now(UTC) + REFRESH_WINDOW:
+            creds = await refresh_oauth_credentials(account_id, force=force_refresh, client=client)
+        return {
+            "Authorization": f"Bearer {creds.access_token}",
+            "Content-Type": "application/json",
+        }
+    return {
+        "Authorization": f"Bearer {creds.xoxc_token}",
+        "Cookie": f"d={creds.d_cookie}",
+        "Content-Type": "application/json",
+    }
+
+
+def run_cookie_flow(
+    account_id: str | None = None,
+    add: bool = False,
+    xoxc_token: str | None = None,
+    d_cookie: str | None = None,
+) -> None:
+    """Guide the user through extracting Slack browser-session credentials."""
+    import typer
+
+    from agentgraph.auth.credentials import save_platform, upsert_platform_account
+
+    if xoxc_token is None:
+        typer.echo(
+            "\nBrowser-session fallback selected. Open Slack in a browser, inspect a "
+            "slack.com/api request, and copy its xoxc token and d cookie.\n"
+        )
+        xoxc_token_val: str = typer.prompt("xoxc- token").strip()
+    else:
+        xoxc_token_val = xoxc_token
+    if not xoxc_token_val.startswith("xoxc-"):
+        typer.echo("Warning: token doesn't start with 'xoxc-' - double-check the value.")
+
+    d_cookie_val: str = typer.prompt("d cookie value").strip() if d_cookie is None else d_cookie
+    user_id: str | None = None
+    team_id: str | None = None
+    team_name: str | None = None
+    try:
+        response = httpx.get(
+            "https://slack.com/api/auth.test",
+            headers={
+                "Authorization": f"Bearer {xoxc_token_val}",
+                "Cookie": f"d={d_cookie_val}",
+            },
+            timeout=10,
+        )
+        data = response.json()
+        if data.get("ok"):
+            user_id = data.get("user_id")
+            team_id = data.get("team_id")
+            team_name = data.get("team")
+    except Exception:
+        pass
+
+    creds = SlackBrowserCredentials(
+        xoxc_token=xoxc_token_val,
+        d_cookie=d_cookie_val,
+        user_id=user_id,
+        team_id=team_id,
+        team_name=team_name,
+    )
+    resolved_account_id = account_id or (
+        f"slack:{team_id}:{user_id}" if team_id and user_id else "slack"
+    )
+    if not add and account_id is None and not list_slack_accounts():
+        save_platform(
+            "slack", {**creds.model_dump(mode="json"), "account_id": resolved_account_id}
+        )
+    else:
+        upsert_platform_account("slack", resolved_account_id, creds, make_default=True)
+    from agentgraph.config import CREDENTIALS_FILE
+
+    msg = f"\nSlack credentials saved to {CREDENTIALS_FILE}"
+    if user_id:
+        label = f"{team_name} / {user_id}" if team_name else user_id
+        msg += f" (authenticated as {label})"
+    typer.echo(msg)

agentgraph_connector_slack/slack-app-manifest.json

@@ -0,0 +1,37 @@
+{
+  "display_information": {
+    "name": "AgentGraph",
+    "description": "Local Slack indexing for AgentGraph",
+    "background_color": "#1f2937"
+  },
+  "oauth_config": {
+    "redirect_urls": [
+      "http://localhost:8766/slack/oauth/callback"
+    ],
+    "pkce_enabled": true,
+    "token_management_enabled": true,
+    "scopes": {
+      "user": [
+        "channels:history",
+        "channels:read",
+        "groups:history",
+        "groups:read",
+        "im:history",
+        "im:read",
+        "mpim:history",
+        "mpim:read",
+        "users:read",
+        "users:read.email"
+      ],
+      "user_optional": [
+        "users:read",
+        "users:read.email"
+      ]
+    }
+  },
+  "settings": {
+    "org_deploy_enabled": false,
+    "socket_mode_enabled": false,
+    "token_rotation_enabled": true
+  }
+}

agentgraph_connector_slack-0.5.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: agentgraph-connector-slack
+Version: 0.5.0
+Summary: Slack connector for AgentGraph
+Requires-Python: >=3.12
+Requires-Dist: agentgraph-server<0.6,>=0.5.0
+Requires-Dist: httpx>=0.28.1

agentgraph_connector_slack-0.5.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+agentgraph_connector_slack/__init__.py,sha256=efYHYC7tocl-iIWxffelYhRzEoCqLZlTmUC7X60R0wE,23688
+agentgraph_connector_slack/auth.py,sha256=mw7J11C2C2kz9I73nPeTvFh9cxBXeiRF8jwQPhylAi4,24955
+agentgraph_connector_slack/slack-app-manifest.json,sha256=-LX4xtVCK775-hkTZOICLZOL8mFC9ZBziQlk2OmJwO0,812
+agentgraph_connector_slack-0.5.0.dist-info/METADATA,sha256=ObbQfw9-Lwo_Z9JDjnaGT3tTDH8161EIP_oF--LlLiQ,208
+agentgraph_connector_slack-0.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+agentgraph_connector_slack-0.5.0.dist-info/entry_points.txt,sha256=HPakTuFBG2DKPJt9dQdMRpL94H-DBJYn4sUGqu1wvG4,74
+agentgraph_connector_slack-0.5.0.dist-info/top_level.txt,sha256=Ed5lxRW5zacXrCMqGSu_bFyz8dkNbNDAuoTIdRXGoTQ,27
+agentgraph_connector_slack-0.5.0.dist-info/RECORD,,

agentgraph_connector_slack-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agentgraph_connector_slack-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[agentgraph.connectors]
+slack = agentgraph_connector_slack:SlackConnector

agentgraph_connector_slack-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentgraph_connector_slack