diff --git a/agentex/database/migrations/alembic/versions/2026_11_16_1200_slack_socket_mode_apps_f3a5c7e9b1d2.py b/agentex/database/migrations/alembic/versions/2026_11_16_1200_slack_socket_mode_apps_f3a5c7e9b1d2.py new file mode 100644 index 00000000..f9a31d0a --- /dev/null +++ b/agentex/database/migrations/alembic/versions/2026_11_16_1200_slack_socket_mode_apps_f3a5c7e9b1d2.py @@ -0,0 +1,48 @@ +"""slack socket mode apps + +Revision ID: f3a5c7e9b1d2 +Revises: e2f4a6c8b0d1 +Create Date: 2026-11-16 12:00:00.000000 + +Creates ``slack_socket_mode_apps``: one row per Slack app whose events agentex +receives over Socket Mode, attached to the app's Slack webhook trigger in +``agent_api_keys``. The table is new and empty, so its constraints build without +scanning anything; the foreign key briefly locks ``agent_api_keys`` and does not scan +it. IF NOT EXISTS makes a re-run a no-op. +""" + +from collections.abc import Sequence + +from alembic import op + +# revision identifiers, used by Alembic. +revision: str = "f3a5c7e9b1d2" +down_revision: str | None = "e2f4a6c8b0d1" +branch_labels: str | Sequence[str] | None = None +depends_on: str | Sequence[str] | None = None + + +def upgrade() -> None: + op.execute( + """ + CREATE TABLE IF NOT EXISTS slack_socket_mode_apps ( + id VARCHAR NOT NULL PRIMARY KEY, + agent_api_key_id VARCHAR NOT NULL, + agent_id VARCHAR(64) NOT NULL, + slack_app_id VARCHAR(256) NOT NULL, + app_token_encrypted VARCHAR NOT NULL, + forward_path VARCHAR NOT NULL, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now(), + CONSTRAINT uq_slack_socket_mode_apps_slack_app_id UNIQUE (slack_app_id), + CONSTRAINT uq_slack_socket_mode_apps_agent_api_key + UNIQUE (agent_api_key_id, agent_id), + CONSTRAINT fk_slack_socket_mode_apps_agent_api_key + FOREIGN KEY (agent_api_key_id, agent_id) + REFERENCES agent_api_keys (id, agent_id) ON DELETE CASCADE + ); + """ + ) + + +def downgrade() -> None: + op.execute("DROP TABLE IF EXISTS slack_socket_mode_apps;") diff --git a/agentex/docker-compose.yml b/agentex/docker-compose.yml index 8a2523df..f53a49be 100644 --- a/agentex/docker-compose.yml +++ b/agentex/docker-compose.yml @@ -160,6 +160,7 @@ services: - ENVIRONMENT=development - UVICORN_PORT=5003 - DATABASE_URL=postgresql://postgres:postgres@agentex-postgres:5432/agentex + - AGENTEX_CREDENTIAL_ENCRYPTION_KEY=${AGENTEX_CREDENTIAL_ENCRYPTION_KEY:-} - TEMPORAL_ADDRESS=agentex-temporal:7233 - REDIS_URL=redis://agentex-redis:6379 - MONGODB_URI=mongodb://agentex-mongodb:27017 @@ -276,6 +277,34 @@ services: user: root restart: unless-stopped + agentex-slack-socket-bridge: + container_name: agentex-slack-socket-bridge + profiles: ["slack-socket-mode"] + build: + context: .. + dockerfile: agentex/Dockerfile + target: dev + args: + SOURCE_DIR: agentex + environment: + - ENVIRONMENT=development + - DATABASE_URL=postgresql://postgres:postgres@agentex-postgres:5432/agentex + - AGENTEX_CREDENTIAL_ENCRYPTION_KEY=${AGENTEX_CREDENTIAL_ENCRYPTION_KEY:-} + ports: + - "5004:5004" + volumes: + - .:/app:cached + depends_on: + agentex-postgres: + condition: service_healthy + agentex: + condition: service_started + networks: + - agentex-network + command: python -m src.run_slack_socket_mode_bridge + user: root + restart: unless-stopped + volumes: agentex-temporal-postgres-data: agentex-postgres-data: diff --git a/agentex/docs/docs/development_guides/webhooks.md b/agentex/docs/docs/development_guides/webhooks.md index a80a6c98..3e2e38fa 100644 --- a/agentex/docs/docs/development_guides/webhooks.md +++ b/agentex/docs/docs/development_guides/webhooks.md @@ -177,6 +177,37 @@ curl -X POST $HOST/agent_api_keys \ }' ``` +#### Slack over Socket Mode + +If Slack cannot reach agentex over HTTP (for example, when agentex runs in a private network), agentex can receive the app's events over [Socket Mode](https://docs.slack.dev/apis/events-api/using-socket-mode) instead. +Enable Socket Mode on the app and create an app-level token as that guide describes, then register the trigger with that token. Registration connects to Slack once to check that the token belongs to the app named in `name`, and returns 400 if it does not: + +```bash +curl -X POST $HOST/agent_api_keys/webhook-trigger \ + -H "Content-Type: application/json" \ + -d '{ + "agent_name": "", + "source": "slack", + "name": "A123ABC456", + "secret": "abcdefg12345", + "forward_path": "slack/events", + "app_token": "xapp-..." + }' +``` + +The Slack Socket Mode bridge then holds one connection for the app and POSTs every Events API payload to `forward_path` on the agent, the same route and body an HTTP delivery would reach (`url_verification` never happens over a socket). +Each POST carries `X-Slack-Signature` and `X-Slack-Request-Timestamp` computed with the trigger's signing secret, so an agent that verifies Slack signatures itself accepts it as it would an HTTP delivery. +Slack's `retry_attempt` arrives as the usual `X-Slack-Retry-Num` and `X-Slack-Retry-Reason` headers. +An event is acknowledged only after the agent answers 2xx within 2.5 seconds, or answers with `X-Slack-No-Retry: 1` as it can over HTTP; otherwise Slack redelivers it. +Delivery is at least once: an event whose acknowledgement is lost, for example when a bridge replica stops mid-forward, reaches the agent again. +Interactivity and slash-command payloads are not forwarded. + +To switch an existing Slack trigger to Socket Mode, or change its token or forward path, `PUT /agent_api_keys//slack_socket_mode` with `app_token` and `forward_path`; it runs the same token check as registration. `DELETE /agent_api_keys//slack_socket_mode` turns Socket Mode off and keeps the trigger. The bridge applies either change within a minute. + +Operator notes: + +- The bridge is its own process, not part of the API: run `python -m src.run_slack_socket_mode_bridge` (from `agentex/`, the same image as the API, like the Temporal worker's `python -m src.temporal.run_worker`) as a separate Deployment with 2 replicas, one process each. It needs only `DATABASE_URL` and `AGENTEX_CREDENTIAL_ENCRYPTION_KEY`, which encrypts the stored app token; without that key it logs one error and exits. It does not connect to Temporal, MongoDB or Redis. + ### Deleting API Keys If you'd like to remove an existing API key for whatever reason, first grab its ID by listing the keys for the appropriate agent as above. diff --git a/agentex/openapi.yaml b/agentex/openapi.yaml index b9e0d51b..4a405f70 100644 --- a/agentex/openapi.yaml +++ b/agentex/openapi.yaml @@ -2858,6 +2858,69 @@ paths: application/json: schema: $ref: '#/components/schemas/HTTPValidationError' + /agent_api_keys/{id}/slack_socket_mode: + put: + tags: + - Agent APIKeys + summary: Serve a Slack trigger over Socket Mode + description: Turn Socket Mode on for an existing Slack trigger, or replace its + app token and forward path. The bridge picks the change up within a minute. + operationId: set_slack_socket_mode_agent_api_keys__id__slack_socket_mode_put + parameters: + - name: id + in: path + required: true + schema: + type: string + title: Id + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/SetSlackSocketModeRequest' + responses: + '200': + description: Successful Response + content: + application/json: + schema: + $ref: '#/components/schemas/SlackSocketMode' + '422': + description: Validation Error + content: + application/json: + schema: + $ref: '#/components/schemas/HTTPValidationError' + delete: + tags: + - Agent APIKeys + summary: Stop serving a Slack trigger over Socket Mode + description: Remove the trigger's app token. The trigger itself stays, and the + bridge closes its connection within a minute. + operationId: delete_slack_socket_mode_agent_api_keys__id__slack_socket_mode_delete + parameters: + - name: id + in: path + required: true + schema: + type: string + title: Id + responses: + '200': + description: Successful Response + content: + application/json: + schema: + type: string + title: Response Delete Slack Socket Mode Agent Api Keys Id Slack + Socket Mode Delete + '422': + description: Validation Error + content: + application/json: + schema: + $ref: '#/components/schemas/HTTPValidationError' /agent_api_keys/name/{name}: get: tags: @@ -5313,6 +5376,15 @@ components: an existing webhook secret. For Slack, this is required and must be the Slack app's Signing Secret. For Linear, this is required and must be the Linear OAuth app's webhook signing secret. + app_token: + anyOf: + - type: string + - type: 'null' + title: App Token + description: Slack only. The app's app-level token (xapp-..., scope connections:write). + When set, agentex receives the app's events over Socket Mode and forwards + them to forward_path, so the app needs no public Request URL. Stored encrypted + and never returned. base_url: anyOf: - type: string @@ -6390,6 +6462,25 @@ components: required: - content title: SendMessageRequest + SetSlackSocketModeRequest: + properties: + app_token: + type: string + title: App Token + description: The Slack app's app-level token (xapp-..., scope connections:write). + It must belong to the app the trigger is named for. Stored encrypted and + never returned. + forward_path: + type: string + title: Forward Path + description: Subpath of the agent each event is POSTed to, e.g. 'slack/events'. + type: object + required: + - app_token + - forward_path + title: SetSlackSocketModeRequest + description: Turn Socket Mode on for an existing Slack trigger, or replace its + settings. SkipRunScheduleRequest: properties: scheduled_time: @@ -6401,6 +6492,26 @@ components: required: - scheduled_time title: SkipRunScheduleRequest + SlackSocketMode: + properties: + key_id: + type: string + title: Key Id + description: The Slack trigger's agent API key id. + slack_app_id: + type: string + title: Slack App Id + description: The Slack app served over Socket Mode. + forward_path: + type: string + title: Forward Path + description: Subpath of the agent each event is POSTed to. + type: object + required: + - key_id + - slack_app_id + - forward_path + title: SlackSocketMode Span: properties: id: diff --git a/agentex/pyproject.toml b/agentex/pyproject.toml index 5e5ba384..9599dddd 100644 --- a/agentex/pyproject.toml +++ b/agentex/pyproject.toml @@ -42,6 +42,10 @@ dependencies = [ # (vulnerable OpenSSL bundled in the wheels). Floor kept at the patched minimum # so a re-resolve can't regress below it. "cryptography>=50.0.0", + # Socket Mode client for Slack webhook triggers. Its aiohttp backend reuses the + # aiohttp already pinned above; the [optional] extra is not wanted (it would pull + # websockets>=16, which conflicts with websockets~=14.2). + "slack-sdk>=3.44.1,<4", ] [dependency-groups] diff --git a/agentex/src/adapters/orm.py b/agentex/src/adapters/orm.py index a53718f8..95a5fe8d 100644 --- a/agentex/src/adapters/orm.py +++ b/agentex/src/adapters/orm.py @@ -5,11 +5,13 @@ Column, DateTime, ForeignKey, + ForeignKeyConstraint, Index, Integer, LargeBinary, String, Text, + UniqueConstraint, func, text, ) @@ -202,6 +204,32 @@ class AgentAPIKeyORM(BaseORM): ) +class SlackSocketModeAppORM(BaseORM): + __tablename__ = "slack_socket_mode_apps" + id = Column(String, primary_key=True, default=orm_id) + agent_api_key_id = Column(String, nullable=False) + agent_id = Column(String(64), nullable=False) + slack_app_id = Column(String(256), nullable=False) + app_token_encrypted = Column(String, nullable=False) + forward_path = Column(String, nullable=False) + created_at = Column(DateTime(timezone=True), server_default=func.now()) + + __table_args__ = ( + UniqueConstraint("slack_app_id", name="uq_slack_socket_mode_apps_slack_app_id"), + UniqueConstraint( + "agent_api_key_id", + "agent_id", + name="uq_slack_socket_mode_apps_agent_api_key", + ), + ForeignKeyConstraint( + ["agent_api_key_id", "agent_id"], + ["agent_api_keys.id", "agent_api_keys.agent_id"], + ondelete="CASCADE", + name="fk_slack_socket_mode_apps_agent_api_key", + ), + ) + + class AgentRunScheduleORM(BaseORM): __tablename__ = "agent_run_schedules" id = Column(String, primary_key=True, default=orm_id) diff --git a/agentex/src/api/routes/agent_api_keys.py b/agentex/src/api/routes/agent_api_keys.py index 660bd4a6..5c900da7 100644 --- a/agentex/src/api/routes/agent_api_keys.py +++ b/agentex/src/api/routes/agent_api_keys.py @@ -4,22 +4,26 @@ from fastapi import APIRouter, HTTPException, Query -from src.adapters.crud_store.exceptions import ItemDoesNotExist +from src.adapters.crud_store.exceptions import DuplicateItemError, ItemDoesNotExist from src.api.schemas.agent_api_keys import ( AgentAPIKey, CreateAPIKeyRequest, CreateAPIKeyResponse, CreateWebhookTriggerRequest, CreateWebhookTriggerResponse, + SetSlackSocketModeRequest, + SlackSocketMode, ) from src.api.schemas.authorization_types import ( AgentexResourceType, AuthorizedOperationType, ) -from src.domain.entities.agent_api_keys import AgentAPIKeyType +from src.domain.entities.agent_api_keys import AgentAPIKeyEntity, AgentAPIKeyType +from src.domain.services import slack_socket_mode_bridge from src.domain.services.authorization_service import DAuthorizationService from src.domain.use_cases.agent_api_keys_use_case import DAgentAPIKeysUseCase from src.domain.use_cases.agents_use_case import DAgentsUseCase +from src.utils import credential_encryption from src.utils.agent_api_key_authorization import ( API_KEY_NOT_FOUND_MESSAGE, _check_api_key_or_collapse_to_404, @@ -101,6 +105,83 @@ async def create_api_key( ) +async def _check_app_token_belongs_to(app_token: str, app_id: str) -> None: + try: + token_app_id = await slack_socket_mode_bridge.read_slack_app_id(app_token) + except slack_socket_mode_bridge.AppTokenRejected as exc: + raise HTTPException( + status_code=400, detail=f"Slack rejected app_token: {exc}." + ) from exc + except Exception as exc: + logger.warning( + "Reading the Slack app id for app_token failed (%s)", type(exc).__name__ + ) + raise HTTPException( + status_code=502, + detail="Could not confirm with Slack which app app_token belongs to; " + "try again.", + ) from exc + if token_app_id != app_id: + raise HTTPException( + status_code=400, + detail=f"app_token belongs to Slack app '{token_app_id}', not '{app_id}'.", + ) + + +def _slack_app_already_served(app_id: str) -> HTTPException: + return HTTPException( + status_code=409, + detail=f"Slack app '{app_id}' is already served over Socket Mode by another " + "trigger; delete that trigger first.", + ) + + +def _clean_forward_path(forward_path: str) -> str: + cleaned = forward_path.lstrip("/") + if _has_control_chars(cleaned): + raise HTTPException( + status_code=400, + detail="forward_path must not contain control characters.", + ) + return cleaned + + +async def _encrypt_checked_app_token( + app_token: str, + app_id: str, + agent_api_key_use_case: DAgentAPIKeysUseCase, + *, + except_key_id: str | None = None, +) -> str: + """Check an app token for the Slack app ``app_id`` and return it encrypted. + + ``except_key_id`` is the trigger being updated, which may already serve the app. + """ + if not app_token.startswith("xapp-"): + raise HTTPException( + status_code=400, + detail="app_token must be a Slack app-level token (xapp-...).", + ) + if not credential_encryption.is_configured(): + raise HTTPException( + status_code=503, + detail="This deployment cannot store app tokens: credential " + "encryption is not configured.", + ) + # The app id is the trigger's name and is unique across agents, so an + # unchecked one would let any caller reserve someone else's app. + await _check_app_token_belongs_to(app_token, app_id) + # Slack gives each event to one of an app's connections, so a second Socket + # Mode trigger for the same app would take part of the first one's events. The + # table's unique constraint enforces this; checking first keeps create()'s auth + # registration from running for a request that is bound to fail. + if await agent_api_key_use_case.has_slack_socket_mode_trigger( + app_id, except_key_id=except_key_id + ): + raise _slack_app_already_served(app_id) + return credential_encryption.encrypt(app_token) + + @router.post( "/webhook-trigger", response_model=CreateWebhookTriggerResponse, @@ -176,20 +257,35 @@ async def create_webhook_trigger( ), ) - forward_path = request.forward_path.lstrip("/") - if _has_control_chars(forward_path): - raise HTTPException( - status_code=400, - detail="forward_path must not contain control characters.", + forward_path = _clean_forward_path(request.forward_path) + + app_token_encrypted = None + if request.app_token is not None: + if request.source != AgentAPIKeyType.SLACK: + raise HTTPException( + status_code=400, + detail="app_token is only supported for Slack triggers.", + ) + app_token_encrypted = await _encrypt_checked_app_token( + request.app_token, request.name, agent_api_key_use_case ) secret = request.secret if request.secret is not None else secrets.token_hex(32) - agent_api_key_entity = await agent_api_key_use_case.create( - agent_id=agent.id, - api_key=str(secret), - name=request.name, - api_key_type=request.source, - ) + try: + agent_api_key_entity = await agent_api_key_use_case.create( + agent_id=agent.id, + api_key=str(secret), + name=request.name, + api_key_type=request.source, + slack_socket_mode_app_token_encrypted=app_token_encrypted, + slack_socket_mode_forward_path=forward_path, + ) + except DuplicateItemError: + # Only the Socket Mode insert has a unique key a client can collide on: a + # concurrent registration for the same app got there first. + if app_token_encrypted is None: + raise + raise _slack_app_already_served(request.name) from None encoded_agent_name = quote(request.agent_name, safe="") encoded_forward_path = quote(forward_path, safe="/") @@ -210,6 +306,91 @@ async def create_webhook_trigger( ) +async def _slack_trigger_for_update( + key_id: str, + agent_api_key_use_case: DAgentAPIKeysUseCase, + authorization_service: DAuthorizationService, +) -> AgentAPIKeyEntity: + # Check before loading: a missing key and one the caller cannot read must both + # return the same 404, or the response reveals whether another account's key exists. + await _check_api_key_or_collapse_to_404( + authorization_service, key_id, AuthorizedOperationType.read + ) + try: + trigger = await agent_api_key_use_case.get(id=key_id) + except ItemDoesNotExist: + raise ItemDoesNotExist(API_KEY_NOT_FOUND_MESSAGE) from None + # The same permission registering the trigger needed. + await _check_agent_or_collapse_to_404( + authorization_service, trigger.agent_id, AuthorizedOperationType.update + ) + if not await agent_api_key_use_case.get_agent(agent_id=trigger.agent_id): + raise ItemDoesNotExist(API_KEY_NOT_FOUND_MESSAGE) + if trigger.api_key_type != AgentAPIKeyType.SLACK: + raise HTTPException( + status_code=400, detail="Socket Mode applies only to Slack triggers." + ) + return trigger + + +@router.put( + "/{id}/slack_socket_mode", + response_model=SlackSocketMode, + summary="Serve a Slack trigger over Socket Mode", + description="Turn Socket Mode on for an existing Slack trigger, or replace its " + "app token and forward path. The bridge picks the change up within a minute.", +) +async def set_slack_socket_mode( + id: str, + request: SetSlackSocketModeRequest, + agent_api_key_use_case: DAgentAPIKeysUseCase, + authorization_service: DAuthorizationService, +) -> SlackSocketMode: + trigger = await _slack_trigger_for_update( + id, agent_api_key_use_case, authorization_service + ) + forward_path = _clean_forward_path(request.forward_path) + app_token_encrypted = await _encrypt_checked_app_token( + request.app_token, + trigger.name, + agent_api_key_use_case, + except_key_id=trigger.id, + ) + try: + app = await agent_api_key_use_case.set_slack_socket_mode( + trigger=trigger, + app_token_encrypted=app_token_encrypted, + forward_path=forward_path, + ) + except DuplicateItemError: + raise _slack_app_already_served(trigger.name) from None + return SlackSocketMode( + key_id=trigger.id, slack_app_id=app.slack_app_id, forward_path=app.forward_path + ) + + +@router.delete( + "/{id}/slack_socket_mode", + response_model=str, + summary="Stop serving a Slack trigger over Socket Mode", + description="Remove the trigger's app token. The trigger itself stays, and the " + "bridge closes its connection within a minute.", +) +async def delete_slack_socket_mode( + id: str, + agent_api_key_use_case: DAgentAPIKeysUseCase, + authorization_service: DAuthorizationService, +) -> str: + trigger = await _slack_trigger_for_update( + id, agent_api_key_use_case, authorization_service + ) + if not await agent_api_key_use_case.delete_slack_socket_mode(trigger.id): + raise HTTPException( + status_code=404, detail="This trigger is not served over Socket Mode." + ) + return f"Socket Mode turned off for agent API key {trigger.id}" + + @router.get( "", response_model=list[AgentAPIKey], diff --git a/agentex/src/api/schemas/agent_api_keys.py b/agentex/src/api/schemas/agent_api_keys.py index d9cf4224..c2089f63 100644 --- a/agentex/src/api/schemas/agent_api_keys.py +++ b/agentex/src/api/schemas/agent_api_keys.py @@ -84,6 +84,15 @@ class CreateWebhookTriggerRequest(BaseModel): "app's webhook signing secret." ), ) + app_token: str | None = Field( + None, + description=( + "Slack only. The app's app-level token (xapp-..., scope connections:write). " + "When set, agentex receives the app's events over Socket Mode and forwards " + "them to forward_path, so the app needs no public Request URL. Stored " + "encrypted and never returned." + ), + ) base_url: str | None = Field( None, description="Optional public agentex base URL for the returned webhook_url; " @@ -109,3 +118,26 @@ class CreateWebhookTriggerResponse(BaseModel): None, description="Full webhook URL to paste into the source (None if no base URL configured).", ) + + +class SetSlackSocketModeRequest(BaseModel): + """Turn Socket Mode on for an existing Slack trigger, or replace its settings.""" + + app_token: str = Field( + ..., + description="The Slack app's app-level token (xapp-..., scope " + "connections:write). It must belong to the app the trigger is named for. " + "Stored encrypted and never returned.", + ) + forward_path: str = Field( + ..., + description="Subpath of the agent each event is POSTed to, e.g. 'slack/events'.", + ) + + +class SlackSocketMode(BaseModel): + key_id: str = Field(..., description="The Slack trigger's agent API key id.") + slack_app_id: str = Field(..., description="The Slack app served over Socket Mode.") + forward_path: str = Field( + ..., description="Subpath of the agent each event is POSTed to." + ) diff --git a/agentex/src/domain/entities/agent_api_keys.py b/agentex/src/domain/entities/agent_api_keys.py index cc4c839b..4fb97b36 100644 --- a/agentex/src/domain/entities/agent_api_keys.py +++ b/agentex/src/domain/entities/agent_api_keys.py @@ -26,3 +26,27 @@ class AgentAPIKeyEntity(BaseModel): description="The type of the API key (either internal or external)", ) api_key: str = Field(..., description="The API key") + + +class SlackSocketModeAppEntity(BaseModel): + """A Slack app whose events agentex receives over Socket Mode. + + Attached to the app's Slack webhook trigger (an ``AgentAPIKeyEntity`` of type + ``slack``), which still holds the signing secret. + """ + + id: str = Field(..., description="The unique identifier of the row.") + agent_api_key_id: str = Field( + ..., description="The Slack webhook trigger this app's events are served for." + ) + agent_id: str = Field(..., description="The agent that owns the trigger.") + slack_app_id: str = Field( + ..., description="The Slack app id; at most one row per app." + ) + app_token_encrypted: str = Field( + ..., description="The app-level token (xapp-...), encrypted." + ) + forward_path: str = Field( + ..., description="The agent subpath each event is POSTed to." + ) + created_at: datetime | None = Field(None, description="When the row was created.") diff --git a/agentex/src/domain/repositories/agent_api_key_repository.py b/agentex/src/domain/repositories/agent_api_key_repository.py index 9ffd1a27..57803572 100644 --- a/agentex/src/domain/repositories/agent_api_key_repository.py +++ b/agentex/src/domain/repositories/agent_api_key_repository.py @@ -1,22 +1,48 @@ +import builtins from typing import Annotated from fastapi import Depends -from sqlalchemy import select +from sqlalchemy import delete, insert, select +from sqlalchemy.dialects.postgresql import insert as pg_insert +from sqlalchemy.ext.asyncio import AsyncSession from src.adapters.crud_store.adapter_postgres import ( PostgresCRUDRepository, + async_sql_exception_handler, ) from src.adapters.crud_store.exceptions import ItemDoesNotExist -from src.adapters.orm import AgentAPIKeyORM, AgentORM +from src.adapters.orm import AgentAPIKeyORM, AgentORM, SlackSocketModeAppORM from src.config.dependencies import ( DDatabaseAsyncReadOnlySessionMaker, DDatabaseAsyncReadWriteSessionMaker, ) -from src.domain.entities.agent_api_keys import AgentAPIKeyEntity, AgentAPIKeyType +from src.domain.entities.agent_api_keys import ( + AgentAPIKeyEntity, + AgentAPIKeyType, + SlackSocketModeAppEntity, +) +from src.domain.entities.agents import AgentStatus from src.utils.logging import make_logger logger = make_logger(__name__) +async def _drop_deleted_agents_slack_app( + session: AsyncSession, slack_app_id: str +) -> None: + """Remove a Socket Mode row a soft-deleted agent left for this Slack app. + + Deleting an agent keeps its keys, and the app must stay registrable on another + agent despite the unique constraint on the app id. + """ + deleted_agents = select(AgentORM.id).where(AgentORM.status == AgentStatus.DELETED) + await session.execute( + delete(SlackSocketModeAppORM).where( + SlackSocketModeAppORM.slack_app_id == slack_app_id, + SlackSocketModeAppORM.agent_id.in_(deleted_agents), + ) + ) + + class AgentAPIKeyRepository(PostgresCRUDRepository[AgentAPIKeyORM, AgentAPIKeyEntity]): def __init__( self, @@ -170,6 +196,108 @@ async def get_external_by_agent_id_and_key( row = result.scalars().first() return AgentAPIKeyEntity.model_validate(row) if row else None + async def create_with_slack_socket_mode_app( + self, item: AgentAPIKeyEntity, app: SlackSocketModeAppEntity + ) -> AgentAPIKeyEntity: + """Create a Slack trigger and its Socket Mode app row in one transaction. + + Raises: + DuplicateItemError: A live agent already serves this Slack app. + """ + async with ( + self.start_async_db_session(True) as session, + async_sql_exception_handler(), + ): + await _drop_deleted_agents_slack_app(session, app.slack_app_id) + values = {k: v for k, v in item.to_dict().items() if v is not None} + row = ( + await session.execute( + insert(AgentAPIKeyORM) + .values(**values) + .returning(*AgentAPIKeyORM.__table__.columns) + ) + ).one() + await session.execute( + insert(SlackSocketModeAppORM).values( + **{k: v for k, v in app.to_dict().items() if v is not None} + ) + ) + await session.commit() + return AgentAPIKeyEntity.model_validate(dict(row._mapping)) + + async def upsert_slack_socket_mode_app( + self, app: SlackSocketModeAppEntity + ) -> SlackSocketModeAppEntity: + """Serve an existing trigger over Socket Mode, or replace its token and path. + + Raises: + DuplicateItemError: A live agent's other trigger serves this Slack app. + """ + async with ( + self.start_async_db_session(True) as session, + async_sql_exception_handler(), + ): + await _drop_deleted_agents_slack_app(session, app.slack_app_id) + values = {k: v for k, v in app.to_dict().items() if v is not None} + row = ( + await session.execute( + pg_insert(SlackSocketModeAppORM) + .values(**values) + .on_conflict_do_update( + constraint="uq_slack_socket_mode_apps_agent_api_key", + set_={ + "app_token_encrypted": app.app_token_encrypted, + "forward_path": app.forward_path, + }, + ) + .returning(*SlackSocketModeAppORM.__table__.columns) + ) + ).one() + await session.commit() + return SlackSocketModeAppEntity.model_validate(dict(row._mapping)) + + async def delete_slack_socket_mode_app(self, agent_api_key_id: str) -> bool: + """Remove a trigger's Socket Mode row; False if it had none.""" + async with self.start_async_db_session(True) as session: + result = await session.execute( + delete(SlackSocketModeAppORM) + .where(SlackSocketModeAppORM.agent_api_key_id == agent_api_key_id) + .returning(SlackSocketModeAppORM.id) + ) + deleted = result.first() is not None + await session.commit() + return deleted + + async def list_slack_socket_mode_apps( + self, slack_app_id: str | None = None + ) -> builtins.list[tuple[AgentAPIKeyEntity, SlackSocketModeAppEntity]]: + """Socket Mode apps on agents that are not deleted, each with its trigger. + + Args: + slack_app_id: Only this Slack app, if given. + """ + async with self.start_async_db_session(allow_writes=False) as session: + query = ( + select(AgentAPIKeyORM, SlackSocketModeAppORM) + .join( + SlackSocketModeAppORM, + (SlackSocketModeAppORM.agent_api_key_id == AgentAPIKeyORM.id) + & (SlackSocketModeAppORM.agent_id == AgentAPIKeyORM.agent_id), + ) + .join(AgentORM, AgentORM.id == AgentAPIKeyORM.agent_id) + .where(AgentORM.status != AgentStatus.DELETED) + ) + if slack_app_id is not None: + query = query.where(SlackSocketModeAppORM.slack_app_id == slack_app_id) + result = await session.execute(query) + return [ + ( + AgentAPIKeyEntity.model_validate(trigger), + SlackSocketModeAppEntity.model_validate(app), + ) + for trigger, app in result.all() + ] + async def delete_by_agent_name_and_key_name( self, agent_name: str, key_name: str, api_key_type: AgentAPIKeyType ) -> None: diff --git a/agentex/src/domain/services/slack_socket_mode_bridge.py b/agentex/src/domain/services/slack_socket_mode_bridge.py new file mode 100644 index 00000000..2e7abd14 --- /dev/null +++ b/agentex/src/domain/services/slack_socket_mode_bridge.py @@ -0,0 +1,446 @@ +"""Receive Slack webhook-trigger events over Socket Mode instead of HTTP. + +A Slack trigger registered with an app-level token gets one Socket Mode connection +per bridge process (``src/run_slack_socket_mode_bridge.py``), never per API worker: +Slack caps an app at 10 open connections. Slack delivers each envelope to one of the +app's connections, so several bridge replicas don't duplicate work, and when one +closes its socket the others keep receiving. Each ``events_api`` envelope is forwarded to +the agent exactly as ``/agents/forward`` would forward the HTTP delivery, signed with the +trigger's signing secret as Slack signs one, and acked +only once the agent has accepted it: an unacked envelope is redelivered by Slack, +which is the retry path when an agent is slow or down. + +A Slack app must be owned by exactly one Socket Mode client. If an agent (or another +agentex environment) also holds a socket for the same app, Slack splits the events +between them. +""" + +from __future__ import annotations + +import asyncio +import hashlib +import hmac +import json +import time +from dataclasses import dataclass, field +from functools import partial +from typing import Any + +import aiohttp +import httpx +from slack_sdk.errors import SlackApiError +from slack_sdk.socket_mode.aiohttp import SocketModeClient +from slack_sdk.socket_mode.request import SocketModeRequest +from slack_sdk.socket_mode.response import SocketModeResponse +from slack_sdk.web.async_client import AsyncWebClient + +from src.adapters.crud_store.exceptions import ItemDoesNotExist +from src.domain.entities.agent_api_keys import ( + AgentAPIKeyEntity, + SlackSocketModeAppEntity, +) +from src.domain.entities.agents import AgentStatus +from src.domain.repositories.agent_api_key_repository import AgentAPIKeyRepository +from src.domain.repositories.agent_repository import AgentRepository +from src.utils import credential_encryption +from src.utils.acp_url import resolve_acp_url +from src.utils.logging import make_logger + +logger = make_logger(__name__) + +# Slack expects an ack within 3s; leave headroom for the ack frame itself. +ACK_DEADLINE_SECONDS = 2.5 +REFRESH_INTERVAL_SECONDS = 60.0 +HELLO_TIMEOUT_SECONDS = 10.0 + +# apps.connections.open errors that no retry can fix. +REJECTED_TOKEN_ERRORS = frozenset( + { + "invalid_auth", + "token_revoked", + "account_inactive", + "not_allowed_token_type", + "not_authed", + "token_expired", + } +) + + +class AppTokenRejected(Exception): + """Slack refused the app token.""" + + +class AppIdUnavailable(Exception): + """Slack's hello message did not name the app.""" + + +def _hello_app_id(message: dict) -> str | None: + return (message.get("connection_info") or {}).get("app_id") + + +async def read_slack_app_id(app_token: str) -> str: + """The id of the Slack app an app-level token belongs to. + + Slack names the app in the hello message that starts every Socket Mode + connection, so this opens one and closes it after that message. An event Slack + hands this connection in the meantime goes unacked, so Slack redelivers it. + + Raises: + AppTokenRejected: Slack refused the token. + AppIdUnavailable: The hello message did not name the app. + SlackApiError, aiohttp.ClientError, TimeoutError: Slack could not be + reached or answered unexpectedly; a retry may succeed. + """ + try: + response = await AsyncWebClient().apps_connections_open(app_token=app_token) + except SlackApiError as exc: + error = exc.response.get("error") + if error in REJECTED_TOKEN_ERRORS: + raise AppTokenRejected(error) from exc + raise + async with aiohttp.ClientSession() as session: + async with session.ws_connect(response["url"]) as ws: + hello = await ws.receive_json(timeout=HELLO_TIMEOUT_SECONDS) + app_id = _hello_app_id(hello) + if not app_id: + raise AppIdUnavailable(f"Slack sent {hello.get('type')!r} without an app id") + return app_id + + +class _TriggerSocketModeClient(SocketModeClient): + def __init__(self, trigger: AgentAPIKeyEntity, **kwargs: Any) -> None: + super().__init__(**kwargs) + self.trigger = trigger + self.rejected = False + # When the last WebSocket URL arrived. None while the first fetch is still + # under way, which may mean waiting out Slack's Retry-After. + self.url_fetched_at: float | None = None + + async def issue_new_wss_url(self) -> str: + # slack_sdk also calls this on every reconnect, and on a revoked token its + # connect/monitor loops would retry (and log a traceback) every few seconds + # forever. The base method still handles rate limiting (it waits out + # Retry-After); only the errors no retry can fix stop the connection. + try: + url = await super().issue_new_wss_url() + except SlackApiError as exc: + error = exc.response.get("error") + if error in REJECTED_TOKEN_ERRORS: + # slack_sdk's loops all run `while not self.closed`. + self.closed = True + self.auto_reconnect_enabled = False + self.rejected = True + logger.error( + "Slack rejected the app token for Socket Mode trigger %s " + "(app %s, agent %s): %s. Not reconnecting until the trigger is " + "re-registered with a new token.", + self.trigger.id, + self.trigger.name, + self.trigger.agent_id, + error, + ) + raise AppTokenRejected(error) from exc + raise + self.url_fetched_at = time.monotonic() + return url + + +def _slack_signature_headers( + signing_secret: str, body: bytes, timestamp: int +) -> dict[str, str]: + """The headers Slack sets on an HTTP delivery, for the same body. + + An agent that checks Slack's v0 signature itself then accepts a socket delivery + exactly as it would an HTTP one. + """ + basis = f"v0:{timestamp}:".encode() + body + digest = hmac.new(signing_secret.encode(), basis, hashlib.sha256).hexdigest() + return { + "x-slack-request-timestamp": str(timestamp), + "x-slack-signature": f"v0={digest}", + } + + +@dataclass +class _Connection: + # The row the connection was opened from; its listeners hold this copy. + app: SlackSocketModeAppEntity + client: _TriggerSocketModeClient + # Held so the task isn't garbage-collected while connect() is still retrying. + connect_task: asyncio.Task + last_connected: float = field(default_factory=time.monotonic) + + +class SlackSocketModeBridge: + def __init__( + self, + agent_api_key_repository: AgentAPIKeyRepository, + agent_repository: AgentRepository, + http_client: httpx.AsyncClient, + ): + self._agent_api_key_repo = agent_api_key_repository + self._agent_repo = agent_repository + self._http_client = http_client + self._connections: dict[str, _Connection] = {} + # (trigger id, ciphertext) pairs whose token is known bad. Keyed on the + # ciphertext so a re-registered token is tried again. + self._rejected: set[tuple[str, str]] = set() + self._task: asyncio.Task | None = None + # Set once the trigger list has loaded. Deliberately not tied to sockets + # being connected: one revoked token must not take the bridge out. + self.ready = False + + async def start(self) -> None: + if self._task is None: + self._task = asyncio.create_task(self._run()) + + async def stop(self) -> None: + if self._task is not None: + self._task.cancel() + try: + await self._task + except asyncio.CancelledError: + pass + self._task = None + for trigger_id in list(self._connections): + await self._close(trigger_id) + + async def _run(self) -> None: + while True: + try: + await self.refresh() + except Exception: + logger.exception("Refreshing Slack Socket Mode triggers failed") + await asyncio.sleep(REFRESH_INTERVAL_SECONDS) + + async def refresh(self) -> None: + """Open connections for new triggers, close them for removed ones, and + reopen any that has not connected for a whole refresh interval.""" + served = { + trigger.id: (trigger, app) + for trigger, app in await self._agent_api_key_repo.list_slack_socket_mode_apps() + } + self.ready = True + for trigger_id, connection in list(self._connections.items()): + current = served.get(trigger_id) + # A changed row (new token or forward path) reopens the connection, so + # its listeners pick the change up. + if ( + current is None + or current[1] != connection.app + or connection.client.closed + ): + if connection.client.rejected: + self._rejected.add((trigger_id, connection.app.app_token_encrypted)) + await self._close(trigger_id) + elif await connection.client.is_connected(): + connection.last_connected = time.monotonic() + elif connection.client.url_fetched_at is not None and ( + time.monotonic() + - max(connection.last_connected, connection.client.url_fetched_at) + >= REFRESH_INTERVAL_SECONDS + ): + # slack_sdk's connect() retries a failed first connection with the + # same WebSocket URL forever, and Slack issues those URLs as + # temporary. Reopening fetches a new one. The clock starts when a + # URL arrives, so waiting out Retry-After never counts against it. + logger.warning( + "Slack Socket Mode for trigger %s has not connected within %ss " + "of getting its URL; reopening it", + trigger_id, + REFRESH_INTERVAL_SECONDS, + ) + await self._close(trigger_id) + for trigger, app in served.values(): + if trigger.id in self._connections: + continue + if (trigger.id, app.app_token_encrypted) in self._rejected: + continue + await self._open(trigger, app) + + async def _open( + self, trigger: AgentAPIKeyEntity, app: SlackSocketModeAppEntity + ) -> None: + try: + app_token = credential_encryption.decrypt(app.app_token_encrypted) + except credential_encryption.CredentialEncryptionError as exc: + logger.error( + "Cannot read the app token for Slack Socket Mode trigger %s: %s", + trigger.id, + exc, + ) + self._rejected.add((trigger.id, app.app_token_encrypted)) + return + + client = _TriggerSocketModeClient(trigger=trigger, app_token=app_token) + client.message_listeners.append(partial(self._check_hello, trigger, app)) + client.socket_mode_request_listeners.append( + partial(self._on_request, trigger, app) + ) + self._connections[trigger.id] = _Connection( + app=app, + client=client, + connect_task=asyncio.create_task(self._connect(trigger, client)), + ) + logger.info( + "Slack Socket Mode connecting for trigger %s (app %s, agent %s)", + trigger.id, + trigger.name, + trigger.agent_id, + ) + + async def _connect( + self, trigger: AgentAPIKeyEntity, client: _TriggerSocketModeClient + ) -> None: + # Runs in the app's own task: fetching the URL can wait out Slack's + # Retry-After, which must not hold up refresh() or the other apps. + try: + # Fetched before connect() so a rejected token stops here instead of + # inside connect()'s retry loop; connect() reuses the URL. The next + # refresh() finds the client closed and records the rejection. + client.wss_uri = await client.issue_new_wss_url() + except AppTokenRejected: + await client.close() + return + except Exception as exc: + # Transient (network): connect() fetches a URL and retries. + logger.warning( + "Opening Slack Socket Mode for trigger %s failed (%s); retrying", + trigger.id, + type(exc).__name__, + ) + await client.connect() + + async def _check_hello( + self, + trigger: AgentAPIKeyEntity, + app: SlackSocketModeAppEntity, + client: _TriggerSocketModeClient, + message: dict, + raw_message: str | None, + ) -> None: + """Close a connection whose token turns out to belong to a different app. + + Registration checks this too; checking on every connect keeps a socket + from serving another app's events to this trigger's agent. + """ + if message.get("type") != "hello": + return + app_id = _hello_app_id(message) + if app_id == app.slack_app_id: + return + logger.error( + "The app token for Slack Socket Mode trigger %s belongs to app %s, not " + "%s; closing the connection until the trigger is re-registered.", + trigger.id, + app_id, + app.slack_app_id, + ) + client.rejected = True + await client.close() + + async def _close(self, trigger_id: str) -> None: + connection = self._connections.pop(trigger_id) + connection.connect_task.cancel() + try: + await connection.client.close() + except Exception: + logger.exception( + "Closing Slack Socket Mode connection for trigger %s failed", + trigger_id, + ) + + async def _on_request( + self, + trigger: AgentAPIKeyEntity, + app: SlackSocketModeAppEntity, + client: SocketModeClient, + request: SocketModeRequest, + ) -> None: + if request.type != "events_api": + # Interactivity and slash commands have no HTTP forward equivalent on + # a webhook trigger; leaving them unacked surfaces the gap to the user. + logger.warning( + "Ignoring Slack Socket Mode %s envelope for trigger %s", + request.type, + trigger.id, + ) + return + if await self.forward_event( + trigger, + app, + request.payload, + retry_attempt=request.retry_attempt, + retry_reason=request.retry_reason, + ): + await client.send_socket_mode_response( + SocketModeResponse(envelope_id=request.envelope_id) + ) + + async def forward_event( + self, + trigger: AgentAPIKeyEntity, + app: SlackSocketModeAppEntity, + payload: dict, + retry_attempt: int | None, + retry_reason: str | None, + ) -> bool: + """POST an Events API payload to the trigger's agent route. + + Returns whether the agent accepted it (2xx) within the ack deadline, or + declined a redelivery with ``X-Slack-No-Retry: 1`` as it can over HTTP; the + caller acks only then, so anything else is redelivered by Slack. + """ + body = json.dumps(payload).encode() + headers = { + "content-type": "application/json", + **_slack_signature_headers(trigger.api_key, body, int(time.time())), + } + # Over HTTP Slack sends these only on redeliveries; the first delivery + # over a socket has retry_attempt 0. + if retry_attempt: + headers["x-slack-retry-num"] = str(retry_attempt) + if retry_reason: + headers["x-slack-retry-reason"] = retry_reason + try: + async with asyncio.timeout(ACK_DEADLINE_SECONDS): + agent = await self._agent_repo.get(id=trigger.agent_id) + if agent.status == AgentStatus.DELETED or not agent.acp_url: + logger.warning( + "Slack Socket Mode trigger %s: agent %s is deleted or has " + "no ACP URL", + trigger.id, + trigger.agent_id, + ) + return False + url = f"{resolve_acp_url(agent.acp_url)}/{app.forward_path.lstrip('/')}" + response = await self._http_client.post( + url, content=body, headers=headers + ) + except (TimeoutError, httpx.HTTPError, ItemDoesNotExist) as exc: + logger.warning( + "Forwarding Slack Socket Mode event for trigger %s failed (%s); " + "leaving it unacked for redelivery", + trigger.id, + type(exc).__name__, + ) + return False + if response.is_success: + return True + if response.headers.get("x-slack-no-retry") == "1": + logger.info( + "Agent %s answered %s with X-Slack-No-Retry to a Slack Socket Mode " + "event for trigger %s; acking so Slack does not redeliver it", + trigger.agent_id, + response.status_code, + trigger.id, + ) + return True + logger.warning( + "Agent %s answered %s to a Slack Socket Mode event for trigger %s; " + "leaving it unacked for redelivery", + trigger.agent_id, + response.status_code, + trigger.id, + ) + return False diff --git a/agentex/src/domain/use_cases/agent_api_keys_use_case.py b/agentex/src/domain/use_cases/agent_api_keys_use_case.py index ccea009d..92460481 100644 --- a/agentex/src/domain/use_cases/agent_api_keys_use_case.py +++ b/agentex/src/domain/use_cases/agent_api_keys_use_case.py @@ -22,6 +22,7 @@ from src.domain.entities.agent_api_keys import ( AgentAPIKeyEntity, AgentAPIKeyType, + SlackSocketModeAppEntity, ) from src.domain.entities.agents import AgentEntity, AgentStatus from src.domain.repositories.agent_api_key_repository import ( @@ -107,6 +108,8 @@ async def create( agent_id: str, api_key_type: AgentAPIKeyType, api_key: str, + slack_socket_mode_app_token_encrypted: str | None = None, + slack_socket_mode_forward_path: str = "", ) -> AgentAPIKeyEntity: agent = await self.get_agent(agent_id=agent_id) if not agent: @@ -131,7 +134,26 @@ async def create( api_key_type=api_key_type, api_key=api_key, ) - return await self.agent_api_key_repo.create(item=agent_api_key) + try: + if slack_socket_mode_app_token_encrypted is None: + return await self.agent_api_key_repo.create(item=agent_api_key) + return await self.agent_api_key_repo.create_with_slack_socket_mode_app( + item=agent_api_key, + app=SlackSocketModeAppEntity( + id=orm_id(), + agent_api_key_id=api_key_id, + agent_id=agent.id, + slack_app_id=name, + app_token_encrypted=slack_socket_mode_app_token_encrypted, + forward_path=slack_socket_mode_forward_path, + ), + ) + except Exception: + # The key was registered for authorization before the insert, and a + # failed insert leaves no row or id anyone could delete it by. A + # concurrent registration for the same Slack app ends here. + await self._deregister_api_key_from_auth(api_key_id=api_key_id) + raise async def _register_api_key_in_auth( self, @@ -222,6 +244,46 @@ async def get_by_agent_id_and_name( agent_id=agent_id, name=name, api_key_type=api_key_type ) + async def has_slack_socket_mode_trigger( + self, app_id: str, except_key_id: str | None = None + ) -> bool: + """Whether a live agent already serves this Slack app over Socket Mode. + + Args: + app_id: The Slack app id. + except_key_id: A trigger to ignore, such as the one being updated. + """ + served = await self.agent_api_key_repo.list_slack_socket_mode_apps( + slack_app_id=app_id + ) + return any(trigger.id != except_key_id for trigger, _ in served) + + async def set_slack_socket_mode( + self, + trigger: AgentAPIKeyEntity, + app_token_encrypted: str, + forward_path: str, + ) -> SlackSocketModeAppEntity: + """Serve a Slack trigger over Socket Mode, or replace its token and path. + + Raises: + DuplicateItemError: Another live trigger serves the same Slack app. + """ + return await self.agent_api_key_repo.upsert_slack_socket_mode_app( + SlackSocketModeAppEntity( + id=orm_id(), + agent_api_key_id=trigger.id, + agent_id=trigger.agent_id, + slack_app_id=trigger.name, + app_token_encrypted=app_token_encrypted, + forward_path=forward_path, + ) + ) + + async def delete_slack_socket_mode(self, key_id: str) -> bool: + """Stop serving a trigger over Socket Mode; False if it was not.""" + return await self.agent_api_key_repo.delete_slack_socket_mode_app(key_id) + async def get_external_by_agent_id_and_key( self, agent_id: str, api_key: str ) -> AgentAPIKeyEntity | None: diff --git a/agentex/src/run_slack_socket_mode_bridge.py b/agentex/src/run_slack_socket_mode_bridge.py new file mode 100644 index 00000000..2ccaac3a --- /dev/null +++ b/agentex/src/run_slack_socket_mode_bridge.py @@ -0,0 +1,149 @@ +"""Slack Socket Mode bridge entry point. + +Runs the bridge as its own process so the number of Socket Mode connections per +Slack app equals the number of bridge replicas, independent of how many API pods +and uvicorn workers there are. Slack caps an app at 10 connections. + +Serves ``/healthz`` (liveness) and ``/readyz`` (trigger list loaded) on +``PROBE_PORT``. On SIGTERM the sockets are closed, so Slack moves delivery to the +remaining replicas. +""" + +# ruff: noqa: E402 +# Instrument libraries before dependency modules bind their constructors. +from src.utils import observability + +if __name__ == "__main__": + observability.initialize_worker() + +import asyncio +import signal +from contextlib import AsyncExitStack + +import httpx +from aiohttp import web +from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine + +from src.config.dependencies import database_async_read_write_session_maker +from src.config.environment_variables import EnvironmentVariables +from src.domain.repositories.agent_api_key_repository import AgentAPIKeyRepository +from src.domain.repositories.agent_repository import AgentRepository +from src.domain.services.slack_socket_mode_bridge import SlackSocketModeBridge +from src.utils import credential_encryption +from src.utils.database import async_db_engine_creator +from src.utils.logging import make_logger +from src.utils.otel_metrics import shutdown_otel_metrics + +logger = make_logger(__name__) + +PROBE_PORT = 5004 +# The bridge reads triggers once a minute and one agent per forwarded event. +DB_POOL_SIZE = 2 +DB_MAX_OVERFLOW = 3 +DB_POOL_RECYCLE_SECONDS = 3600 + + +def create_engine(database_url: str) -> AsyncEngine: + """The bridge's only database connection: a small pool for trigger and agent reads. + + The bridge does not load the API's global dependencies (Temporal, MongoDB, + Redis, Kubernetes config); it needs none of them, and waiting on them would + delay the probe server. + """ + return create_async_engine( + "postgresql+asyncpg://", + async_creator=async_db_engine_creator(database_url), + pool_size=DB_POOL_SIZE, + max_overflow=DB_MAX_OVERFLOW, + pool_pre_ping=True, + pool_recycle=DB_POOL_RECYCLE_SECONDS, + ) + + +def create_slack_socket_mode_bridge( + engine: AsyncEngine, http_client: httpx.AsyncClient +) -> SlackSocketModeBridge: + """Build the bridge on one database engine and HTTP client. + + The bridge only reads triggers and agents, so every session uses ``engine``. + """ + session_maker = database_async_read_write_session_maker(engine) + return SlackSocketModeBridge( + agent_api_key_repository=AgentAPIKeyRepository(session_maker, session_maker), + agent_repository=AgentRepository(session_maker, session_maker), + http_client=http_client, + ) + + +def build_probe_app(bridge: SlackSocketModeBridge) -> web.Application: + async def healthz(_: web.Request) -> web.Response: + return web.Response(text="ok") + + async def readyz(_: web.Request) -> web.Response: + if bridge.ready: + return web.Response(text="ok") + return web.Response(status=503, text="triggers not loaded") + + app = web.Application() + app.router.add_get("/healthz", healthz) + app.router.add_get("/readyz", readyz) + return app + + +async def main(probe_port: int = PROBE_PORT) -> None: + async with AsyncExitStack() as cleanup: + if observability.uses_observability_adapter(): + cleanup.push_async_callback(asyncio.to_thread, observability.shutdown) + else: + cleanup.callback(shutdown_otel_metrics) + + # Loads agentex/.env in development, which may be where the key is. + env = EnvironmentVariables.refresh() + # App tokens are stored encrypted, so without the key no trigger can be + # served; refuse once here rather than failing per trigger. + if not credential_encryption.is_configured(): + logger.error( + "%s is not configured, so stored Slack app tokens cannot be read; " + "the Slack Socket Mode bridge will not start.", + credential_encryption.ENV_KEY, + ) + raise SystemExit(1) + + engine = create_engine(env.DATABASE_URL) + cleanup.push_async_callback(engine.dispose) + http_client = httpx.AsyncClient() + cleanup.push_async_callback(http_client.aclose) + bridge = create_slack_socket_mode_bridge(engine, http_client) + + runner = web.AppRunner(build_probe_app(bridge)) + await runner.setup() + cleanup.push_async_callback(runner.cleanup) + await web.TCPSite(runner, port=probe_port).start() + + # Last pushed, so on shutdown the sockets close before anything else. + cleanup.push_async_callback(bridge.stop) + await bridge.start() + logger.info("Slack Socket Mode bridge started (probes on :%s)", probe_port) + await asyncio.Event().wait() + + +async def _run_cli() -> None: + """Run cleanup on SIGTERM as well as keyboard interruption.""" + loop = asyncio.get_running_loop() + main_task = asyncio.create_task(main()) + + def request_shutdown() -> None: + if not main_task.cancelling(): + main_task.cancel() + + loop.add_signal_handler(signal.SIGTERM, request_shutdown) + try: + await main_task + except asyncio.CancelledError: + logger.info("Received shutdown signal, Slack Socket Mode bridge stopped") + finally: + loop.remove_signal_handler(signal.SIGTERM) + + +if __name__ == "__main__": + asyncio.run(_run_cli()) diff --git a/agentex/tests/integration/api/agent_api_keys/test_slack_socket_mode_apps.py b/agentex/tests/integration/api/agent_api_keys/test_slack_socket_mode_apps.py new file mode 100644 index 00000000..22b05bcc --- /dev/null +++ b/agentex/tests/integration/api/agent_api_keys/test_slack_socket_mode_apps.py @@ -0,0 +1,185 @@ +"""The slack_socket_mode_apps table and its endpoints, against a real Postgres.""" + +from unittest.mock import AsyncMock + +import pytest +import pytest_asyncio +from cryptography.fernet import Fernet +from src.adapters.crud_store.exceptions import DuplicateItemError +from src.domain.entities.agent_api_keys import ( + AgentAPIKeyEntity, + AgentAPIKeyType, + SlackSocketModeAppEntity, +) +from src.domain.entities.agents import ACPType, AgentEntity, AgentStatus +from src.domain.services import slack_socket_mode_bridge +from src.utils import credential_encryption +from src.utils.ids import orm_id + +SLACK_APP_ID = "A123" + + +async def _agent(repos, name: str) -> AgentEntity: + return await repos["agent_repository"].create( + AgentEntity( + id=orm_id(), + name=name, + description="Socket Mode test agent", + acp_url="http://test-acp:8000", + acp_type=ACPType.SYNC, + ) + ) + + +async def _register(repos, agent: AgentEntity) -> AgentAPIKeyEntity: + trigger = AgentAPIKeyEntity( + id=orm_id(), + name=SLACK_APP_ID, + agent_id=agent.id, + api_key_type=AgentAPIKeyType.SLACK, + api_key="signing-secret", + ) + return await repos["agent_api_key_repository"].create_with_slack_socket_mode_app( + item=trigger, + app=SlackSocketModeAppEntity( + id=orm_id(), + agent_api_key_id=trigger.id, + agent_id=agent.id, + slack_app_id=SLACK_APP_ID, + app_token_encrypted="ciphertext", + forward_path="slack/events", + ), + ) + + +@pytest.mark.asyncio +@pytest.mark.integration +class TestSlackSocketModeApps: + async def test_one_live_agent_per_slack_app(self, isolated_repositories): + repos = isolated_repositories + key_repo = repos["agent_api_key_repository"] + first = await _agent(repos, "first-agent") + second = await _agent(repos, "second-agent") + await _register(repos, first) + + with pytest.raises(DuplicateItemError): + await _register(repos, second) + # The failed registration must not leave its trigger row behind. + assert not await key_repo.get_by_agent_id_and_name( + agent_id=second.id, name=SLACK_APP_ID, api_key_type=AgentAPIKeyType.SLACK + ) + + # Deleting an agent keeps its keys, so its stale row must not hold the app. + await repos["agent_repository"].update( + first.model_copy(update={"status": AgentStatus.DELETED}) + ) + trigger = await _register(repos, second) + + served = await key_repo.list_slack_socket_mode_apps() + assert [(t.id, app.agent_id) for t, app in served] == [(trigger.id, second.id)] + + async def test_deleting_the_trigger_removes_the_app(self, isolated_repositories): + repos = isolated_repositories + key_repo = repos["agent_api_key_repository"] + trigger = await _register(repos, await _agent(repos, "socket-agent")) + + await key_repo.delete(trigger.id) + + assert await key_repo.list_slack_socket_mode_apps() == [] + + +@pytest_asyncio.fixture +async def socket_mode_api(isolated_client, monkeypatch): + """The HTTP API, with an encryption key and Slack's app-id check answered locally.""" + credential_encryption.reset_cache() + monkeypatch.setenv(credential_encryption.ENV_KEY, Fernet.generate_key().decode()) + monkeypatch.setattr( + slack_socket_mode_bridge, + "read_slack_app_id", + AsyncMock(return_value=SLACK_APP_ID), + ) + yield isolated_client + credential_encryption.reset_cache() + + +async def _http_trigger(repos, agent: AgentEntity, source=AgentAPIKeyType.SLACK): + return await repos["agent_api_key_repository"].create( + AgentAPIKeyEntity( + id=orm_id(), + name=SLACK_APP_ID, + agent_id=agent.id, + api_key_type=source, + api_key="signing-secret", + ) + ) + + +@pytest.mark.asyncio +@pytest.mark.integration +class TestSlackSocketModeEndpoints: + async def test_put_turns_socket_mode_on_then_replaces_it( + self, socket_mode_api, isolated_repositories + ): + repos = isolated_repositories + trigger = await _http_trigger(repos, await _agent(repos, "socket-agent")) + url = f"/agent_api_keys/{trigger.id}/slack_socket_mode" + + first = await socket_mode_api.put( + url, json={"app_token": "xapp-1", "forward_path": "slack/events"} + ) + # The trigger already serving the app must not conflict with itself. + second = await socket_mode_api.put( + url, json={"app_token": "xapp-2", "forward_path": "/slack/v2"} + ) + + assert first.status_code == 200, first.text + assert second.status_code == 200, second.text + served = await repos["agent_api_key_repository"].list_slack_socket_mode_apps() + assert [(t.id, app.forward_path) for t, app in served] == [ + (trigger.id, "slack/v2") + ] + + async def test_put_conflicts_with_another_trigger_for_the_app( + self, socket_mode_api, isolated_repositories + ): + repos = isolated_repositories + await _register(repos, await _agent(repos, "first-agent")) + other = await _http_trigger(repos, await _agent(repos, "second-agent")) + + response = await socket_mode_api.put( + f"/agent_api_keys/{other.id}/slack_socket_mode", + json={"app_token": "xapp-1", "forward_path": "slack/events"}, + ) + + assert response.status_code == 409, response.text + + async def test_put_refuses_a_trigger_that_is_not_slack( + self, socket_mode_api, isolated_repositories + ): + repos = isolated_repositories + trigger = await _http_trigger( + repos, await _agent(repos, "github-agent"), AgentAPIKeyType.GITHUB + ) + + response = await socket_mode_api.put( + f"/agent_api_keys/{trigger.id}/slack_socket_mode", + json={"app_token": "xapp-1", "forward_path": "slack/events"}, + ) + + assert response.status_code == 400, response.text + + async def test_delete_turns_socket_mode_off_and_keeps_the_trigger( + self, socket_mode_api, isolated_repositories + ): + repos = isolated_repositories + trigger = await _register(repos, await _agent(repos, "socket-agent")) + url = f"/agent_api_keys/{trigger.id}/slack_socket_mode" + + assert (await socket_mode_api.delete(url)).status_code == 200 + assert (await socket_mode_api.delete(url)).status_code == 404 + + key_repo = repos["agent_api_key_repository"] + assert await key_repo.list_slack_socket_mode_apps() == [] + assert ( + await socket_mode_api.get(f"/agent_api_keys/{trigger.id}") + ).status_code == 200 diff --git a/agentex/tests/integration/services/test_slack_socket_mode_bridge_e2e.py b/agentex/tests/integration/services/test_slack_socket_mode_bridge_e2e.py new file mode 100644 index 00000000..4c46636c --- /dev/null +++ b/agentex/tests/integration/services/test_slack_socket_mode_bridge_e2e.py @@ -0,0 +1,336 @@ +"""The Socket Mode bridge end to end, with fakes for Slack and the agent. + +Registration goes through the real route, the trigger through real Postgres, and the +socket through the real slack_sdk client. Only Slack's servers and the agent are fake: +``FakeSlack`` serves ``apps.connections.open`` and a Socket Mode WebSocket that sends +``hello`` and then whatever envelopes the test pushes; ``FakeAgent`` records each +forwarded request. +""" + +import asyncio +import json +from collections.abc import AsyncIterator +from dataclasses import dataclass, field + +import httpx +import pytest +import pytest_asyncio +from aiohttp import WSMsgType, web +from cryptography.fernet import Fernet +from multidict import CIMultiDict +from slack_sdk.web.async_client import AsyncWebClient +from src.domain.entities.agent_api_keys import AgentAPIKeyType +from src.domain.entities.agents import ACPType, AgentEntity +from src.domain.services import slack_socket_mode_bridge as mod +from src.domain.services.slack_socket_mode_bridge import SlackSocketModeBridge +from src.domain.use_cases.slack_gateway_use_case import verify_signature +from src.utils import credential_encryption +from src.utils.ids import orm_id + +SLACK_APP_ID = "A123" +SIGNING_SECRET = "signing-secret" +WAIT_SECONDS = 5.0 + + +async def _serve(app: web.Application) -> tuple[web.AppRunner, str]: + runner = web.AppRunner(app) + await runner.setup() + site = web.TCPSite(runner, "127.0.0.1", 0) + await site.start() + port = site._server.sockets[0].getsockname()[1] # type: ignore[union-attr] + return runner, f"http://127.0.0.1:{port}" + + +@dataclass +class FakeSlack: + base_url: str = "" + # The app Slack names in hello, i.e. the app the token belongs to. + app_id: str = SLACK_APP_ID + connections_opened: int = 0 + # Each URL is good for one connection attempt; set to fail the first one, as a + # network blip would. + fail_first_attempt: bool = False + tried_urls: list[str] = field(default_factory=list) + sockets: list[web.WebSocketResponse] = field(default_factory=list) + acks: asyncio.Queue[str] = field(default_factory=asyncio.Queue) + connected: asyncio.Event = field(default_factory=asyncio.Event) + closed: asyncio.Event = field(default_factory=asyncio.Event) + + def app(self) -> web.Application: + app = web.Application() + app.router.add_post("/api/apps.connections.open", self._open) + app.router.add_get("/link", self._link) + return app + + async def _open(self, request: web.Request) -> web.Response: + self.connections_opened += 1 + ws_url = self.base_url.replace("http://", "ws://") + ws_url += f"/link?ticket={self.connections_opened}" + return web.json_response({"ok": True, "url": ws_url}) + + async def _link(self, request: web.Request) -> web.StreamResponse: + ticket = request.query["ticket"] + first_attempt = not self.tried_urls + if ticket in self.tried_urls: + self.tried_urls.append(ticket) + return web.Response(status=401) + self.tried_urls.append(ticket) + if first_attempt and self.fail_first_attempt: + return web.Response(status=503) + ws = web.WebSocketResponse(autoping=True) + await ws.prepare(request) + self.sockets.append(ws) + await ws.send_json( + { + "type": "hello", + "num_connections": len(self.sockets), + "connection_info": {"app_id": self.app_id}, + } + ) + self.connected.set() + async for message in ws: + if message.type == WSMsgType.TEXT: + await self.acks.put(json.loads(message.data)["envelope_id"]) + self.closed.set() + return ws + + def forget_connections(self) -> None: + """Clear what registration's own app-id check left behind.""" + self.connections_opened = 0 + self.tried_urls.clear() + self.sockets.clear() + self.connected.clear() + self.closed.clear() + + async def deliver(self, envelope_id: str, retry_attempt: int = 0) -> dict: + payload = {"type": "event_callback", "api_app_id": SLACK_APP_ID} + await self.sockets[-1].send_json( + { + "type": "events_api", + "envelope_id": envelope_id, + "payload": payload, + "accepts_response_payload": False, + "retry_attempt": retry_attempt, + "retry_reason": "timeout" if retry_attempt else "", + } + ) + return payload + + +@dataclass +class FakeAgent: + status: int = 200 + requests: asyncio.Queue[tuple[str, CIMultiDict[str], bytes]] = field( + default_factory=asyncio.Queue + ) + + def app(self) -> web.Application: + app = web.Application() + app.router.add_post("/{tail:.*}", self._receive) + return app + + async def _receive(self, request: web.Request) -> web.Response: + body = await request.read() + await self.requests.put((request.path, CIMultiDict(request.headers), body)) + return web.Response(status=self.status) + + +@pytest_asyncio.fixture +async def fakes(monkeypatch) -> AsyncIterator[tuple[FakeSlack, FakeAgent]]: + slack, agent = FakeSlack(), FakeAgent() + slack_runner, slack.base_url = await _serve(slack.app()) + agent_runner, agent_url = await _serve(agent.app()) + agent.url = agent_url # type: ignore[attr-defined] + + class ClientAgainstFakeSlack(mod._TriggerSocketModeClient): + def __init__(self, **kwargs): + super().__init__( + web_client=AsyncWebClient( + token=kwargs["app_token"], base_url=f"{slack.base_url}/api/" + ), + ping_interval=0.5, + **kwargs, + ) + + monkeypatch.setattr(mod, "_TriggerSocketModeClient", ClientAgainstFakeSlack) + # Registration's app-id check builds its own client. + monkeypatch.setattr( + mod, + "AsyncWebClient", + lambda **kwargs: AsyncWebClient(base_url=f"{slack.base_url}/api/", **kwargs), + ) + credential_encryption.reset_cache() + monkeypatch.setenv(credential_encryption.ENV_KEY, Fernet.generate_key().decode()) + yield slack, agent + credential_encryption.reset_cache() + await slack_runner.cleanup() + await agent_runner.cleanup() + + +async def _register(isolated_client, isolated_repositories, agent_url: str): + await isolated_repositories["agent_repository"].create( + AgentEntity( + id=orm_id(), + name="socket-agent", + description="Socket Mode end-to-end agent", + acp_url=agent_url, + acp_type=ACPType.SYNC, + ) + ) + return await isolated_client.post( + "/agent_api_keys/webhook-trigger", + json={ + "agent_name": "socket-agent", + "source": AgentAPIKeyType.SLACK.value, + "name": SLACK_APP_ID, + "secret": SIGNING_SECRET, + "forward_path": "slack/events", + "app_token": "xapp-1-A123-fake", + }, + ) + + +@pytest.mark.asyncio +@pytest.mark.integration +class TestSlackSocketModeBridgeEndToEnd: + @pytest_asyncio.fixture + async def bridge( + self, isolated_client, isolated_repositories, fakes + ) -> AsyncIterator[SlackSocketModeBridge]: + slack, agent = fakes + response = await _register(isolated_client, isolated_repositories, agent.url) + assert response.status_code == 200, response.text + self.key_id = response.json()["key_id"] + slack.forget_connections() + + async with httpx.AsyncClient() as http_client: + bridge = SlackSocketModeBridge( + agent_api_key_repository=isolated_repositories[ + "agent_api_key_repository" + ], + agent_repository=isolated_repositories["agent_repository"], + http_client=http_client, + ) + yield bridge + await bridge.stop() + + async def test_event_reaches_the_agent_signed_and_is_acked(self, bridge, fakes): + slack, agent = fakes + await bridge.refresh() + await asyncio.wait_for(slack.connected.wait(), WAIT_SECONDS) + + payload = await slack.deliver("env-1") + path, headers, body = await asyncio.wait_for(agent.requests.get(), WAIT_SECONDS) + + assert path == "/slack/events" + assert json.loads(body) == payload + assert verify_signature( + SIGNING_SECRET, + headers["X-Slack-Request-Timestamp"], + headers["X-Slack-Signature"], + body, + ) + assert "X-Slack-Retry-Num" not in headers + assert await asyncio.wait_for(slack.acks.get(), WAIT_SECONDS) == "env-1" + + async def test_unaccepted_event_is_acked_only_on_a_redelivery_the_agent_takes( + self, bridge, fakes + ): + slack, agent = fakes + await bridge.refresh() + await asyncio.wait_for(slack.connected.wait(), WAIT_SECONDS) + agent.status = 503 + + await slack.deliver("env-1") + await asyncio.wait_for(agent.requests.get(), WAIT_SECONDS) + with pytest.raises(TimeoutError): + await asyncio.wait_for(slack.acks.get(), mod.ACK_DEADLINE_SECONDS) + + agent.status = 200 + await slack.deliver("env-1", retry_attempt=1) + _, headers, _ = await asyncio.wait_for(agent.requests.get(), WAIT_SECONDS) + + assert headers["X-Slack-Retry-Num"] == "1" + assert headers["X-Slack-Retry-Reason"] == "timeout" + assert await asyncio.wait_for(slack.acks.get(), WAIT_SECONDS) == "env-1" + + async def test_deleting_the_trigger_closes_the_socket( + self, bridge, fakes, isolated_client + ): + slack, _ = fakes + await bridge.refresh() + await asyncio.wait_for(slack.connected.wait(), WAIT_SECONDS) + + response = await isolated_client.delete(f"/agent_api_keys/{self.key_id}") + assert response.status_code == 200, response.text + await bridge.refresh() + + await asyncio.wait_for(slack.closed.wait(), WAIT_SECONDS) + assert bridge._connections == {} + assert slack.connections_opened == 1 + + async def test_a_connection_stuck_on_a_dead_url_is_reopened( + self, bridge, fakes, monkeypatch + ): + slack, _ = fakes + slack.fail_first_attempt = True + + await bridge.refresh() + while len(slack.tried_urls) < 3: + await asyncio.sleep(0.1) + # slack_sdk keeps retrying the URL it was given, which is now dead. + assert set(slack.tried_urls) == {"1"} + assert not slack.connected.is_set() + + monkeypatch.setattr(mod, "REFRESH_INTERVAL_SECONDS", 0) + await bridge.refresh() + + await asyncio.wait_for(slack.connected.wait(), WAIT_SECONDS) + assert slack.connections_opened == 2 + + async def test_registration_refuses_a_token_for_another_app( + self, isolated_client, isolated_repositories, fakes + ): + slack, agent = fakes + slack.app_id = "B999" + + response = await _register(isolated_client, isolated_repositories, agent.url) + + assert response.status_code == 400, response.text + assert "B999" in response.text + key_repo = isolated_repositories["agent_api_key_repository"] + assert await key_repo.list_slack_socket_mode_apps() == [] + + async def test_bridge_drops_a_token_that_names_another_app(self, bridge, fakes): + slack, agent = fakes + slack.app_id = "B999" + + await bridge.refresh() + await asyncio.wait_for(slack.closed.wait(), WAIT_SECONDS) + await bridge.refresh() + + assert bridge._connections == {} + assert slack.connections_opened == 1 + assert agent.requests.empty() + + async def test_a_new_forward_path_takes_effect_after_refresh( + self, bridge, fakes, isolated_client + ): + slack, agent = fakes + await bridge.refresh() + await asyncio.wait_for(slack.connected.wait(), WAIT_SECONDS) + + response = await isolated_client.put( + f"/agent_api_keys/{self.key_id}/slack_socket_mode", + json={"app_token": "xapp-1-A123-fake", "forward_path": "slack/v2"}, + ) + assert response.status_code == 200, response.text + slack.forget_connections() + await bridge.refresh() + await asyncio.wait_for(slack.connected.wait(), WAIT_SECONDS) + + await slack.deliver("env-1") + path, _, _ = await asyncio.wait_for(agent.requests.get(), WAIT_SECONDS) + + assert path == "/slack/v2" + assert await asyncio.wait_for(slack.acks.get(), WAIT_SECONDS) == "env-1" diff --git a/agentex/tests/unit/api/test_observability_lifespan.py b/agentex/tests/unit/api/test_observability_lifespan.py index 9d6a6ad8..520f29c8 100644 --- a/agentex/tests/unit/api/test_observability_lifespan.py +++ b/agentex/tests/unit/api/test_observability_lifespan.py @@ -51,8 +51,15 @@ def close_adapter(): "GlobalDependencies", lambda: SimpleNamespace(postgres_metrics_collector=None), ) + from src.domain.services.slack_socket_mode_bridge import SlackSocketModeBridge from src.utils import observability + async def start_bridge(self): + record("slack-socket-mode") + + # Sockets belong to the dedicated bridge process; per-API-worker sockets + # would exceed Slack's 10-connection cap per app. + monkeypatch.setattr(SlackSocketModeBridge, "start", start_bridge) monkeypatch.setattr(observability, "shutdown", close_adapter) monkeypatch.setattr(observability, "uses_observability_adapter", lambda: managed) @@ -70,3 +77,4 @@ async def run(): assert calls[-4:] == expected assert ("metrics-init" in calls) is not managed assert ("serve" in calls) is (failure != "startup") + assert "slack-socket-mode" not in calls diff --git a/agentex/tests/unit/api/test_slack_socket_mode_routes.py b/agentex/tests/unit/api/test_slack_socket_mode_routes.py new file mode 100644 index 00000000..6a5a6c3f --- /dev/null +++ b/agentex/tests/unit/api/test_slack_socket_mode_routes.py @@ -0,0 +1,61 @@ +"""Access checks on the Slack Socket Mode settings routes.""" + +from unittest.mock import AsyncMock, MagicMock + +import pytest +import src.api.routes.agent_api_keys as mod +from src.adapters.authorization.exceptions import AuthorizationError +from src.adapters.crud_store.exceptions import ItemDoesNotExist +from src.api.schemas.agent_api_keys import SetSlackSocketModeRequest +from src.utils.agent_api_key_authorization import API_KEY_NOT_FOUND_MESSAGE + +MISSING = ItemDoesNotExist("Item with id 'key-1' does not exist.") + + +def _set(use_case, authorization): + return mod.set_slack_socket_mode( + id="key-1", + request=SetSlackSocketModeRequest(app_token="xapp-1", forward_path="slack"), + agent_api_key_use_case=use_case, + authorization_service=authorization, + ) + + +def _delete(use_case, authorization): + return mod.delete_slack_socket_mode( + id="key-1", + agent_api_key_use_case=use_case, + authorization_service=authorization, + ) + + +@pytest.mark.unit +@pytest.mark.asyncio +@pytest.mark.parametrize("route", [_set, _delete], ids=["put", "delete"]) +@pytest.mark.parametrize( + ("readable", "stored"), + [ + pytest.param(False, MagicMock(id="key-1"), id="another-accounts-key"), + pytest.param(False, MISSING, id="no-such-key"), + # An access grant left behind for a key that is gone. + pytest.param(True, MISSING, id="stale-grant"), + ], +) +async def test_a_key_the_caller_cannot_see_looks_the_same_as_a_missing_one( + route, readable, stored +): + # Different 404s would tell a caller whether another account's key exists. + authorization = MagicMock() + authorization.check = AsyncMock( + side_effect=None if readable else AuthorizationError("denied") + ) + use_case = MagicMock() + use_case.get = AsyncMock( + side_effect=stored if isinstance(stored, Exception) else None, + return_value=stored, + ) + + with pytest.raises(ItemDoesNotExist) as exc: + await route(use_case, authorization) + + assert str(exc.value.message) == API_KEY_NOT_FOUND_MESSAGE diff --git a/agentex/tests/unit/api/test_webhook_trigger.py b/agentex/tests/unit/api/test_webhook_trigger.py index ca9fb3a3..c6515aa6 100644 --- a/agentex/tests/unit/api/test_webhook_trigger.py +++ b/agentex/tests/unit/api/test_webhook_trigger.py @@ -7,17 +7,37 @@ import pytest import src.api.routes.agent_api_keys as mod from fastapi import HTTPException +from src.adapters.crud_store.exceptions import DuplicateItemError from src.api.routes.agent_api_keys import create_webhook_trigger from src.api.schemas.agent_api_keys import CreateWebhookTriggerRequest from src.domain.entities.agent_api_keys import AgentAPIKeyType +from src.domain.services.slack_socket_mode_bridge import AppTokenRejected @pytest.mark.unit @pytest.mark.asyncio class TestCreateWebhookTrigger: - async def _call(self, monkeypatch, request, *, existing=None, base_env=None): + async def _call( + self, + monkeypatch, + request, + *, + existing=None, + base_env=None, + app_served_over_socket=False, + create_error=None, + token_app_id="A123", + ): # The agent-authorization helper does real authz work; stub it to a no-op. monkeypatch.setattr(mod, "_check_agent_or_collapse_to_404", AsyncMock()) + read_app_id = ( + AsyncMock(side_effect=token_app_id) + if isinstance(token_app_id, Exception) + else AsyncMock(return_value=token_app_id) + ) + monkeypatch.setattr( + mod.slack_socket_mode_bridge, "read_slack_app_id", read_app_id + ) if base_env is not None: monkeypatch.setenv("AGENTEX_PUBLIC_URL", base_env) else: @@ -28,8 +48,12 @@ async def _call(self, monkeypatch, request, *, existing=None, base_env=None): akuc = MagicMock() akuc.get_by_agent_id_and_name = AsyncMock(return_value=existing) + akuc.has_slack_socket_mode_trigger = AsyncMock( + return_value=app_served_over_socket + ) akuc.create = AsyncMock( - return_value=MagicMock(id="key-1", api_key_type=request.source) + return_value=MagicMock(id="key-1", api_key_type=request.source), + side_effect=create_error, ) resp = await create_webhook_trigger( @@ -95,7 +119,9 @@ async def test_forward_path_reserved_chars_are_url_encoded(self, monkeypatch): name="o/r", forward_path="github-pr/cfg-9?mode=review#frag ment", ) - resp, _ = await self._call(monkeypatch, req, base_env="https://sgp.example.com/") + resp, _ = await self._call( + monkeypatch, req, base_env="https://sgp.example.com/" + ) assert ( resp.webhook_path @@ -154,7 +180,10 @@ async def test_slack_without_secret_rejected(self, monkeypatch): # Slack signs with the app's existing Signing Secret — we can't generate one, # so omitting it must 400 rather than store a random value that never matches. req = CreateWebhookTriggerRequest( - agent_name="a", source=AgentAPIKeyType.SLACK, name="my-app", forward_path="slack" + agent_name="a", + source=AgentAPIKeyType.SLACK, + name="my-app", + forward_path="slack", ) with pytest.raises(HTTPException) as exc: await self._call(monkeypatch, req) @@ -172,10 +201,73 @@ async def test_slack_with_provided_secret_ok(self, monkeypatch): assert resp.secret == "slack-signing-secret" assert akuc.create.await_args.kwargs["api_key"] == "slack-signing-secret" + @pytest.mark.parametrize( + ("served", "create_error"), + [ + pytest.param(True, None, id="already-registered"), + # A concurrent registration passed the same check and inserted first; + # the table's unique constraint is what catches it. + pytest.param(False, DuplicateItemError("dup"), id="concurrent-insert"), + ], + ) + async def test_second_socket_trigger_for_a_slack_app_conflicts( + self, monkeypatch, served, create_error + ): + # Slack splits an app's events across its connections, so a second + # Socket Mode trigger would silently take part of the first one's events. + monkeypatch.setattr(mod.credential_encryption, "is_configured", lambda: True) + monkeypatch.setattr(mod.credential_encryption, "encrypt", lambda _: "ct") + req = CreateWebhookTriggerRequest( + agent_name="b", + source=AgentAPIKeyType.SLACK, + name="A123", + forward_path="slack/events", + secret="slack-signing-secret", + app_token="xapp-1-A123-example", + ) + with pytest.raises(HTTPException) as exc: + await self._call( + monkeypatch, + req, + app_served_over_socket=served, + create_error=create_error, + ) + assert exc.value.status_code == 409 + + @pytest.mark.parametrize( + ("token_app_id", "status"), + [ + # Without this check any caller could reserve another team's app id. + pytest.param("B999", 400, id="token-for-another-app"), + pytest.param( + AppTokenRejected("invalid_auth"), 400, id="token-rejected-by-slack" + ), + pytest.param(TimeoutError(), 502, id="slack-unreachable"), + ], + ) + async def test_app_token_must_belong_to_the_named_app( + self, monkeypatch, token_app_id, status + ): + monkeypatch.setattr(mod.credential_encryption, "is_configured", lambda: True) + req = CreateWebhookTriggerRequest( + agent_name="b", + source=AgentAPIKeyType.SLACK, + name="A123", + forward_path="slack/events", + secret="slack-signing-secret", + app_token="xapp-1-A123-example", + ) + with pytest.raises(HTTPException) as exc: + await self._call(monkeypatch, req, token_app_id=token_app_id) + assert exc.value.status_code == status + async def test_linear_without_secret_rejected(self, monkeypatch): # Linear signs with the OAuth app's webhook signing secret, like Slack. req = CreateWebhookTriggerRequest( - agent_name="a", source=AgentAPIKeyType.LINEAR, name="client-id", forward_path="linear/webhook" + agent_name="a", + source=AgentAPIKeyType.LINEAR, + name="client-id", + forward_path="linear/webhook", ) with pytest.raises(HTTPException) as exc: await self._call(monkeypatch, req) diff --git a/agentex/tests/unit/services/test_slack_socket_mode_bridge.py b/agentex/tests/unit/services/test_slack_socket_mode_bridge.py new file mode 100644 index 00000000..93fd1e6a --- /dev/null +++ b/agentex/tests/unit/services/test_slack_socket_mode_bridge.py @@ -0,0 +1,373 @@ +"""Ack and reconnect behaviour of the Slack Socket Mode bridge.""" + +import asyncio +from unittest.mock import AsyncMock, MagicMock + +import httpx +import pytest +import slack_sdk.socket_mode.async_client as sdk_async_client +import src.run_slack_socket_mode_bridge as entrypoint +from cryptography.fernet import Fernet +from slack_sdk.errors import SlackApiError +from slack_sdk.socket_mode.request import SocketModeRequest +from slack_sdk.web.async_client import AsyncWebClient +from slack_sdk.web.slack_response import SlackResponse +from src.domain.entities.agent_api_keys import ( + AgentAPIKeyEntity, + AgentAPIKeyType, + SlackSocketModeAppEntity, +) +from src.domain.entities.agents import AgentStatus +from src.domain.services import slack_socket_mode_bridge as mod +from src.domain.services.slack_socket_mode_bridge import SlackSocketModeBridge +from src.domain.use_cases.slack_gateway_use_case import verify_signature + +TRIGGER = AgentAPIKeyEntity( + id="key-1", + agent_id="agent-1", + name="A123", + api_key_type=AgentAPIKeyType.SLACK, + api_key="signing-secret", +) +APP = SlackSocketModeAppEntity( + id="app-1", + agent_api_key_id=TRIGGER.id, + agent_id=TRIGGER.agent_id, + slack_app_id="A123", + app_token_encrypted="ciphertext", + forward_path="slack/events", +) + + +def _bridge( + handler, served=((TRIGGER, APP),) +) -> tuple[SlackSocketModeBridge, MagicMock]: + agent_repo = MagicMock() + agent_repo.get = AsyncMock( + return_value=MagicMock(status=AgentStatus.READY, acp_url="http://agent:8000") + ) + key_repo = MagicMock() + key_repo.list_slack_socket_mode_apps = AsyncMock(return_value=list(served)) + bridge = SlackSocketModeBridge( + agent_api_key_repository=key_repo, + agent_repository=agent_repo, + http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)), + ) + return bridge, key_repo + + +def _envelope(retry_attempt: int = 0, retry_reason: str = "") -> SocketModeRequest: + return SocketModeRequest( + type="events_api", + envelope_id="env-1", + payload={"type": "event_callback", "api_app_id": "A123"}, + retry_attempt=retry_attempt, + retry_reason=retry_reason, + ) + + +@pytest.mark.unit +class TestEnvelopeAck: + async def test_acks_after_agent_accepts(self): + seen: list[httpx.Request] = [] + + def handler(request: httpx.Request) -> httpx.Response: + seen.append(request) + return httpx.Response(200) + + bridge, _ = _bridge(handler) + client = MagicMock(send_socket_mode_response=AsyncMock()) + + await bridge._on_request(TRIGGER, APP, client, _envelope()) + + assert str(seen[0].url) == "http://agent:8000/slack/events" + assert "x-slack-retry-num" not in seen[0].headers + client.send_socket_mode_response.assert_awaited_once() + assert client.send_socket_mode_response.await_args.args[0].envelope_id == ( + "env-1" + ) + + async def test_no_ack_when_agent_rejects(self): + bridge, _ = _bridge(lambda request: httpx.Response(503)) + client = MagicMock(send_socket_mode_response=AsyncMock()) + + await bridge._on_request(TRIGGER, APP, client, _envelope()) + + client.send_socket_mode_response.assert_not_awaited() + + async def test_no_ack_when_agent_misses_deadline(self, monkeypatch): + monkeypatch.setattr(mod, "ACK_DEADLINE_SECONDS", 0.05) + + async def slow(request: httpx.Request) -> httpx.Response: + await asyncio.sleep(1) + return httpx.Response(200) + + bridge, _ = _bridge(slow) + client = MagicMock(send_socket_mode_response=AsyncMock()) + + await bridge._on_request(TRIGGER, APP, client, _envelope()) + + client.send_socket_mode_response.assert_not_awaited() + + async def test_retry_attempt_becomes_retry_headers(self): + seen: list[httpx.Request] = [] + + def handler(request: httpx.Request) -> httpx.Response: + seen.append(request) + return httpx.Response(200) + + bridge, _ = _bridge(handler) + client = MagicMock(send_socket_mode_response=AsyncMock()) + + await bridge._on_request( + TRIGGER, APP, client, _envelope(retry_attempt=2, retry_reason="timeout") + ) + + assert seen[0].headers["x-slack-retry-num"] == "2" + assert seen[0].headers["x-slack-retry-reason"] == "timeout" + + async def test_forward_passes_slacks_own_signature_check(self): + seen: list[httpx.Request] = [] + + def handler(request: httpx.Request) -> httpx.Response: + seen.append(request) + return httpx.Response(200) + + bridge, _ = _bridge(handler) + client = MagicMock(send_socket_mode_response=AsyncMock()) + + await bridge._on_request(TRIGGER, APP, client, _envelope()) + + forwarded = seen[0] + assert verify_signature( + TRIGGER.api_key, + forwarded.headers["x-slack-request-timestamp"], + forwarded.headers["x-slack-signature"], + forwarded.content, + ) + assert not verify_signature( + "another-secret", + forwarded.headers["x-slack-request-timestamp"], + forwarded.headers["x-slack-signature"], + forwarded.content, + ) + + async def test_acks_when_agent_declines_redelivery(self): + bridge, _ = _bridge( + lambda request: httpx.Response(400, headers={"X-Slack-No-Retry": "1"}) + ) + client = MagicMock(send_socket_mode_response=AsyncMock()) + + await bridge._on_request(TRIGGER, APP, client, _envelope()) + + client.send_socket_mode_response.assert_awaited_once() + + +@pytest.mark.unit +class TestRateLimited: + async def test_rate_limit_waits_and_retries_instead_of_rejecting(self, monkeypatch): + rate_limited = SlackApiError( + "ratelimited", + SlackResponse( + client=None, + http_verb="POST", + api_url="https://slack.com/api/apps.connections.open", + req_args={}, + data={"ok": False, "error": "ratelimited"}, + headers={"Retry-After": "7"}, + status_code=429, + ), + ) + monkeypatch.setattr( + AsyncWebClient, + "apps_connections_open", + AsyncMock(side_effect=[rate_limited, {"url": "wss://example.invalid"}]), + ) + slept: list[float] = [] + + async def fake_sleep(delay: float) -> None: + slept.append(delay) + + monkeypatch.setattr(sdk_async_client.asyncio, "sleep", fake_sleep) + client = mod._TriggerSocketModeClient(trigger=TRIGGER, app_token="xapp-1") + + assert await client.issue_new_wss_url() == "wss://example.invalid" + assert slept == [7] + assert not client.rejected + await client.close() + + +@pytest.mark.unit +class TestOneAppCannotStallTheOthers: + async def test_a_rate_limited_app_does_not_hold_up_refresh(self, monkeypatch): + other_trigger = TRIGGER.model_copy(update={"id": "key-2", "name": "B456"}) + other_app = APP.model_copy( + update={ + "id": "app-2", + "agent_api_key_id": "key-2", + "slack_app_id": "B456", + "app_token_encrypted": "ciphertext-2", + } + ) + monkeypatch.setattr( + mod.credential_encryption, + "decrypt", + {"ciphertext": "xapp-waiting", "ciphertext-2": "xapp-ready"}.__getitem__, + ) + + async def connections_open(self, **kwargs): + if kwargs["app_token"] == "xapp-waiting": + # Stands in for waiting out a long Retry-After. + await asyncio.Event().wait() + return {"url": "wss://example.invalid"} + + monkeypatch.setattr(AsyncWebClient, "apps_connections_open", connections_open) + connected = asyncio.Event() + monkeypatch.setattr( + mod._TriggerSocketModeClient, + "connect", + AsyncMock(side_effect=lambda: connected.set()), + ) + bridge, _ = _bridge( + lambda request: httpx.Response(200), + [(TRIGGER, APP), (other_trigger, other_app)], + ) + + await asyncio.wait_for(bridge.refresh(), 1) + await asyncio.wait_for(connected.wait(), 1) + + await bridge.stop() + + +@pytest.mark.unit +class TestRateLimitWaitIsNotCutShort: + async def test_refresh_leaves_a_url_fetch_that_is_still_waiting(self, monkeypatch): + monkeypatch.setattr(mod.credential_encryption, "decrypt", lambda _: "xapp-1") + fetches = 0 + + async def connections_open(self, **kwargs): + nonlocal fetches + fetches += 1 + # Stands in for waiting out a Retry-After longer than a refresh interval. + await asyncio.Event().wait() + + monkeypatch.setattr(AsyncWebClient, "apps_connections_open", connections_open) + monkeypatch.setattr(mod._TriggerSocketModeClient, "connect", AsyncMock()) + bridge, _ = _bridge(lambda request: httpx.Response(200)) + await bridge.refresh() + while not fetches: + await asyncio.sleep(0) + waiting = bridge._connections[TRIGGER.id] + + monkeypatch.setattr(mod, "REFRESH_INTERVAL_SECONDS", 0) + await bridge.refresh() + + assert bridge._connections[TRIGGER.id] is waiting + assert fetches == 1 + await bridge.stop() + + +@pytest.mark.unit +class TestRejectedToken: + async def test_rejected_token_stops_without_retrying(self, monkeypatch): + monkeypatch.setattr(mod.credential_encryption, "decrypt", lambda _: "xapp-1") + connections_open = AsyncMock( + side_effect=SlackApiError( + "rejected", {"ok": False, "error": "invalid_auth"} + ) + ) + monkeypatch.setattr(AsyncWebClient, "apps_connections_open", connections_open) + connect = AsyncMock() + monkeypatch.setattr(mod._TriggerSocketModeClient, "connect", connect) + bridge, _ = _bridge(lambda request: httpx.Response(200)) + + await bridge.refresh() + await bridge._connections[TRIGGER.id].connect_task + # A later refresh with the same stored token must not try it again. + await bridge.refresh() + + connections_open.assert_awaited_once() + connect.assert_not_awaited() + assert bridge._connections == {} + # A dead token must not hold the bridge out of readiness. + assert bridge.ready + + +@pytest.mark.unit +class TestShutdown: + async def test_stop_closes_open_sockets(self, monkeypatch): + monkeypatch.setattr(mod.credential_encryption, "decrypt", lambda _: "xapp-1") + monkeypatch.setattr( + AsyncWebClient, + "apps_connections_open", + AsyncMock(return_value={"url": "wss://example.invalid"}), + ) + monkeypatch.setattr(mod._TriggerSocketModeClient, "connect", AsyncMock()) + bridge, _ = _bridge(lambda request: httpx.Response(200)) + await bridge.refresh() + client = bridge._connections[TRIGGER.id].client + + await bridge.stop() + + assert client.closed + assert client.aiohttp_client_session.closed + assert bridge._connections == {} + + async def test_cancelling_main_stops_bridge_and_disposes_engine(self, monkeypatch): + fake = MagicMock(start=AsyncMock(), stop=AsyncMock(), ready=True) + engine = MagicMock(dispose=AsyncMock()) + monkeypatch.setattr( + entrypoint.credential_encryption, "is_configured", lambda: True + ) + monkeypatch.setattr(entrypoint, "create_engine", lambda url: engine) + monkeypatch.setattr( + entrypoint, "create_slack_socket_mode_bridge", lambda engine, client: fake + ) + + task = asyncio.create_task(entrypoint.main(probe_port=0)) + while not fake.start.await_count: + await asyncio.sleep(0) + # _run_cli turns SIGTERM into this cancellation. + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + + fake.stop.assert_awaited_once() + engine.dispose.assert_awaited_once() + + async def test_reads_the_key_from_the_environment_file(self, monkeypatch): + # In development the key may exist only in agentex/.env, which + # EnvironmentVariables.refresh() loads into the environment. + class Started(Exception): + pass + + def refresh_loading_env_file(): + monkeypatch.setenv( + entrypoint.credential_encryption.ENV_KEY, + Fernet.generate_key().decode(), + ) + return MagicMock(DATABASE_URL="postgresql://example.invalid/agentex") + + monkeypatch.delenv(entrypoint.credential_encryption.ENV_KEY, raising=False) + entrypoint.credential_encryption.reset_cache() + monkeypatch.setattr( + entrypoint.EnvironmentVariables, "refresh", refresh_loading_env_file + ) + monkeypatch.setattr(entrypoint, "create_engine", MagicMock(side_effect=Started)) + + try: + with pytest.raises(Started): + await entrypoint.main(probe_port=0) + finally: + entrypoint.credential_encryption.reset_cache() + + async def test_refuses_to_start_without_encryption_key(self, monkeypatch): + create_engine = MagicMock() + monkeypatch.setattr(entrypoint, "create_engine", create_engine) + monkeypatch.setattr( + entrypoint.credential_encryption, "is_configured", lambda: False + ) + + with pytest.raises(SystemExit): + await entrypoint.main(probe_port=0) + create_engine.assert_not_called() diff --git a/agentex/tests/unit/use_cases/test_agents_api_keys_use_case.py b/agentex/tests/unit/use_cases/test_agents_api_keys_use_case.py index 4bee562a..8efdf6af 100644 --- a/agentex/tests/unit/use_cases/test_agents_api_keys_use_case.py +++ b/agentex/tests/unit/use_cases/test_agents_api_keys_use_case.py @@ -3,7 +3,7 @@ import pytest from fastapi import HTTPException -from src.adapters.crud_store.exceptions import ItemDoesNotExist +from src.adapters.crud_store.exceptions import DuplicateItemError, ItemDoesNotExist from src.domain.entities.agent_api_keys import AgentAPIKeyType from src.domain.entities.agents import ACPType, AgentEntity, AgentStatus from src.domain.repositories.agent_api_key_repository import AgentAPIKeyRepository @@ -161,6 +161,35 @@ async def test_delete_by_agent_id( api_key_type=AgentAPIKeyType.EXTERNAL, ) + async def test_failed_insert_removes_the_auth_registration( + self, agent_api_keys_use_case, agent_repository, sample_agent + ): + # Two registrations for one Slack app can both pass the route's duplicate + # check; the loser's insert fails after its key was registered for auth. + auth = agent_api_keys_use_case.authorization_service + auth.principal_context = {"user_id": "user-1"} + first = await create_or_get_agent(agent_repository, sample_agent) + second = await agent_repository.create( + sample_agent.model_copy(update={"id": str(uuid4()), "name": "second"}) + ) + for agent in (first, second): + create = agent_api_keys_use_case.create( + name="A123", + agent_id=agent.id, + api_key_type=AgentAPIKeyType.SLACK, + api_key="signing-secret", + slack_socket_mode_app_token_encrypted="ciphertext", + slack_socket_mode_forward_path="slack/events", + ) + if agent is first: + await create + else: + with pytest.raises(DuplicateItemError): + await create + + losing_key = auth.register_resource.await_args_list[-1].kwargs["resource"] + auth.deregister_resource.assert_awaited_once_with(resource=losing_key) + async def test_create_external_api_key( self, agent_api_keys_use_case, agent_repository, sample_agent ): @@ -268,9 +297,7 @@ def test_returns_none_for_empty_credentials(self): assert extract_agent_key_from_authorization("AgentKey ") is None def test_strips_surrounding_whitespace(self): - assert ( - extract_agent_key_from_authorization(" AgentKey abc123 ") == "abc123" - ) + assert extract_agent_key_from_authorization(" AgentKey abc123 ") == "abc123" @pytest.mark.asyncio diff --git a/uv.lock b/uv.lock index c9be1692..ced36825 100644 --- a/uv.lock +++ b/uv.lock @@ -81,6 +81,7 @@ dependencies = [ { name = "python-multipart" }, { name = "pyyaml" }, { name = "redis" }, + { name = "slack-sdk" }, { name = "sqlalchemy" }, { name = "temporalio" }, { name = "tzdata" }, @@ -141,6 +142,7 @@ requires-dist = [ { name = "python-multipart", specifier = ">=0.0.32" }, { name = "pyyaml", specifier = ">=6.0,<7" }, { name = "redis", specifier = ">=5.1.0,<6" }, + { name = "slack-sdk", specifier = ">=3.44.1,<4" }, { name = "sqlalchemy", specifier = ">=2.0.35,<3" }, { name = "temporalio", specifier = ">=1.18.0,<2" }, { name = "tzdata", specifier = ">=2025.2" }, @@ -2475,6 +2477,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] +[[package]] +name = "slack-sdk" +version = "3.46.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7a/43/9eb4f5172ec64d8c25f9fa397d3ca283782d356a60809e4b68ade81fde1a/slack_sdk-3.46.0.tar.gz", hash = "sha256:25215ca293d2954ed759b87573b4c833cb3f82ebff371355936515c688411dbb", size = 266040, upload-time = "2026-10-30T05:08:27.384Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/5c/0be529c9a48ccd7b452c6ca47ad1ab5e5e2f7f2cf53d8f34970aebffd0e8/slack_sdk-3.46.0-py2.py3-none-any.whl", hash = "sha256:6286d89da97ea193c853609131515e6f1b3edf86866d6e5aad0dba9dcf1cb72d", size = 325190, upload-time = "2026-10-30T05:08:25.985Z" }, +] + [[package]] name = "sniffio" version = "1.3.1"