* Add user-owned IM channel connections
* Fix dev startup and channel connect popup
* Use async channel connect flow
* Harden dev service daemon startup
* Support local IM channel connections
* Align IM connections with local channels
* Fix safe user id digest algorithm
* Address Copilot IM channel feedback
* Address IM channel review comments
* Support all integrated IM channel connections
* Format additional channel connection tests
* Keep unavailable channel connect buttons clickable
* Fix IM channel provider icons
* Add runtime setup for enabled IM channels
* Guard global shortcut key handling
* Keep configured IM channels editable
* Avoid password autofill for channel secrets
* Make channel threads visible to connection owners
* Persist IM runtime config locally
* Allow disconnecting runtime IM channels
* Route no-auth channel sessions to local user
* Use default user for auth-disabled local mode
* Show IM channel source on threads
* Prefill IM channel runtime config
* Reflect IM channel runtime health
* Ignore Feishu message read events
* Ignore Feishu non-content message events
* Let setup wizard enable IM channels
* Fix frontend formatting after merge
* Stabilize backend tests without local config
* Isolate channel runtime config tests
* Address channel connection review comments
* Use sha256 user buckets with legacy migration
* Ensure runtime IM channels are ready after restart
* Persist disconnected IM channel state
* Address channel connection review comments
* Address channel connection review findings
Frontend connect flow:
- Open the runtime-config dialog only when a provider still needs
credentials; configured providers go straight to the connect flow, so
the binding-code/deep-link path is reachable from the UI again.
- After saving credentials, continue into the connect flow when a user
binding is still required (multi-user mode) instead of stopping at a
"Connected" toast.
- Extract shared provider-state helpers to core/channels/provider-state
and add unit + e2e coverage for the direct-connect and
configure-then-connect paths.
Provider status semantics:
- Report connection_status from the user's newest connection row;
with no binding it is not_connected, except in auth-disabled local
mode where a configured running channel is effectively connected.
Concurrency and event-loop correctness:
- Offload ChannelRuntimeConfigStore construction and writes, channel
service construction, and Slack connection replies to threads; add a
tests/blocking_io/ anchor for the runtime-config handlers.
- Consume binding codes with a conditional UPDATE so a code can only be
used once under concurrent workers; retry upsert_connection as an
update when a concurrent insert wins the unique constraint.
- Serialize ensure_channel_ready per channel so concurrent provider
polls cannot double-start a channel worker.
Config and migration hardening:
- Stop mutating the get_app_config()-cached Telegram provider config;
the runtime store now owns the UI-entered bot username.
- Register channel_connections in STARTUP_ONLY_FIELDS with the
standardized startup-only Field description.
- Match the legacy unsafe-id bucket by recomputing its exact SHA-1 name
so another user's same-prefix bucket can never be migrated.
- Remove the unused Telegram process_webhook_update path and document
src/core/channels in the frontend docs.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* Address PR review comments on authz scoping and channel runtime
Security (review feedback from ShenAC-SAC):
- Scope internal-token callers to the connection owner carried in
X-DeerFlow-Owner-User-Id instead of bypassing owner checks outright,
in both require_permission(owner_check=True) and the stateless run
endpoints. Internal callers keep access to their own and
shared/legacy threads, and may claim a default-owned channel thread
for its real owner, but a leaked internal token no longer grants
cross-user thread access.
- Require admin privileges for POST/DELETE /api/channels/{provider}/
runtime-config: runtime credentials and channel workers are
instance-wide shared state (same model as the MCP config API).
Read-only provider listing stays available to all users.
Performance (review feedback from willem-bd):
- Skip the redundant thread channel-metadata PATCH after the first
successful backfill per thread.
- Reuse the per-connection Slack WebClient until its token changes
instead of constructing one per outbound message.
- Reconcile channel readiness for all providers concurrently in
GET /api/channels/providers.
Also resolve the code-quality unused-import flag in the blocking-io
anchor by pre-importing the channel service via importlib.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* Fix prettier formatting in provider-state test
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* Reconcile UI runtime channel config with config reload on restart
Main now reloads a channel's config.yaml entry on restart_channel()
(#3514, issue #3497). Adapt the user-owned connection flow to coexist:
- configure_channel() restarts with reload_config=False — the caller
just supplied the authoritative config (browser-entered credentials
that are never written to config.yaml), so a file reload must not
clobber it with the stale on-disk entry.
- _load_channel_config() re-applies the UI runtime-store overlay used
at startup, so an operator-triggered restart keeps browser-entered
credentials for channels without a config.yaml entry and does not
resurrect a channel disconnected from the UI.
- Offload the reload's disk IO (config.yaml + runtime store) with
asyncio.to_thread, matching the blocking-IO policy on this branch.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
112 lines
5.3 KiB
Python
112 lines
5.3 KiB
Python
"""ORM models for user-owned IM channel connections."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from datetime import UTC, datetime
|
|
|
|
from sqlalchemy import JSON, DateTime, ForeignKey, Index, Integer, String, Text, UniqueConstraint
|
|
from sqlalchemy.orm import Mapped, mapped_column
|
|
|
|
from deerflow.persistence.base import Base
|
|
|
|
|
|
def _utc_now() -> datetime:
|
|
return datetime.now(UTC)
|
|
|
|
|
|
class ChannelConnectionRow(Base):
|
|
__tablename__ = "channel_connections"
|
|
|
|
id: Mapped[str] = mapped_column(String(64), primary_key=True)
|
|
owner_user_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
|
|
provider: Mapped[str] = mapped_column(String(32), nullable=False, index=True)
|
|
status: Mapped[str] = mapped_column(String(32), nullable=False, default="connected")
|
|
|
|
external_account_id: Mapped[str] = mapped_column(String(128), nullable=False, default="")
|
|
external_account_name: Mapped[str | None] = mapped_column(String(256), nullable=True)
|
|
workspace_id: Mapped[str] = mapped_column(String(128), nullable=False, default="")
|
|
workspace_name: Mapped[str | None] = mapped_column(String(256), nullable=True)
|
|
bot_user_id: Mapped[str | None] = mapped_column(String(128), nullable=True)
|
|
|
|
scopes_json: Mapped[list] = mapped_column(JSON, default=list)
|
|
capabilities_json: Mapped[dict] = mapped_column(JSON, default=dict)
|
|
metadata_json: Mapped[dict] = mapped_column(JSON, default=dict)
|
|
|
|
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=_utc_now)
|
|
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=_utc_now, onupdate=_utc_now)
|
|
last_seen_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
|
last_error_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
|
|
|
__table_args__ = (
|
|
UniqueConstraint(
|
|
"owner_user_id",
|
|
"provider",
|
|
"external_account_id",
|
|
"workspace_id",
|
|
name="uq_channel_connection_owner_provider_identity",
|
|
),
|
|
Index("idx_channel_connections_event_lookup", "provider", "workspace_id", "bot_user_id"),
|
|
)
|
|
|
|
|
|
class ChannelCredentialRow(Base):
|
|
__tablename__ = "channel_credentials"
|
|
|
|
connection_id: Mapped[str] = mapped_column(
|
|
String(64),
|
|
ForeignKey("channel_connections.id", ondelete="CASCADE"),
|
|
primary_key=True,
|
|
)
|
|
encrypted_access_token: Mapped[str | None] = mapped_column(Text, nullable=True)
|
|
encrypted_refresh_token: Mapped[str | None] = mapped_column(Text, nullable=True)
|
|
token_type: Mapped[str | None] = mapped_column(String(32), nullable=True)
|
|
expires_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
|
refresh_expires_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
|
encrypted_extra_json: Mapped[str | None] = mapped_column(Text, nullable=True)
|
|
version: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
|
|
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=_utc_now, onupdate=_utc_now)
|
|
|
|
|
|
class ChannelOAuthStateRow(Base):
|
|
__tablename__ = "channel_oauth_states"
|
|
|
|
state_hash: Mapped[str] = mapped_column(String(128), primary_key=True)
|
|
owner_user_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
|
|
provider: Mapped[str] = mapped_column(String(32), nullable=False, index=True)
|
|
code_verifier_encrypted: Mapped[str | None] = mapped_column(Text, nullable=True)
|
|
nonce_hash: Mapped[str | None] = mapped_column(String(128), nullable=True)
|
|
redirect_after: Mapped[str | None] = mapped_column(Text, nullable=True)
|
|
requested_scopes_json: Mapped[list] = mapped_column(JSON, default=list)
|
|
metadata_json: Mapped[dict] = mapped_column(JSON, default=dict)
|
|
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
|
consumed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
|
|
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=_utc_now)
|
|
|
|
|
|
class ChannelConversationRow(Base):
|
|
__tablename__ = "channel_conversations"
|
|
|
|
id: Mapped[str] = mapped_column(String(64), primary_key=True)
|
|
connection_id: Mapped[str] = mapped_column(
|
|
String(64),
|
|
ForeignKey("channel_connections.id", ondelete="CASCADE"),
|
|
nullable=False,
|
|
index=True,
|
|
)
|
|
owner_user_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
|
|
provider: Mapped[str] = mapped_column(String(32), nullable=False, index=True)
|
|
external_conversation_id: Mapped[str] = mapped_column(String(128), nullable=False)
|
|
external_topic_id: Mapped[str] = mapped_column(String(128), nullable=False, default="")
|
|
thread_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
|
|
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=_utc_now)
|
|
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=_utc_now, onupdate=_utc_now)
|
|
|
|
__table_args__ = (
|
|
UniqueConstraint(
|
|
"connection_id",
|
|
"external_conversation_id",
|
|
"external_topic_id",
|
|
name="uq_channel_conversation_connection_external",
|
|
),
|
|
)
|