aa015462a7
* 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>
255 lines
10 KiB
Python
255 lines
10 KiB
Python
"""Tests for user-scoped path resolution in Paths."""
|
|
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from deerflow.config.paths import Paths
|
|
|
|
|
|
@pytest.fixture
|
|
def paths(tmp_path: Path) -> Paths:
|
|
return Paths(tmp_path)
|
|
|
|
|
|
class TestValidateUserId:
|
|
def test_valid_user_id(self, paths: Paths):
|
|
d = paths.user_dir("u-abc-123")
|
|
assert d == paths.base_dir / "users" / "u-abc-123"
|
|
|
|
def test_rejects_path_traversal(self, paths: Paths):
|
|
with pytest.raises(ValueError, match="Invalid user_id"):
|
|
paths.user_dir("../escape")
|
|
|
|
def test_rejects_slash(self, paths: Paths):
|
|
with pytest.raises(ValueError, match="Invalid user_id"):
|
|
paths.user_dir("foo/bar")
|
|
|
|
def test_rejects_empty(self, paths: Paths):
|
|
with pytest.raises(ValueError, match="Invalid user_id"):
|
|
paths.user_dir("")
|
|
|
|
|
|
class TestMakeSafeUserId:
|
|
def test_already_safe_id_is_unchanged(self):
|
|
from deerflow.config.paths import make_safe_user_id
|
|
|
|
assert make_safe_user_id("ou_abc-123") == "ou_abc-123"
|
|
assert make_safe_user_id("123456") == "123456"
|
|
|
|
def test_unsafe_chars_are_sanitized_with_stable_suffix(self):
|
|
from deerflow.config.paths import make_safe_user_id
|
|
|
|
result = make_safe_user_id("user@example.com")
|
|
# Sanitized prefix plus a stable digest of the original.
|
|
assert result.startswith("user-example-com-")
|
|
assert len(result.rsplit("-", 1)[1]) == 16
|
|
assert result == "user-example-com-b4c9a289323b21a0"
|
|
assert make_safe_user_id("user@example.com") == result
|
|
|
|
def test_sanitized_id_passes_validation(self, paths: Paths):
|
|
from deerflow.config.paths import make_safe_user_id
|
|
|
|
safe = make_safe_user_id("用户/../etc")
|
|
# Must be usable as a filesystem-scoped bucket without raising.
|
|
assert paths.user_dir(safe) == paths.base_dir / "users" / safe
|
|
|
|
def test_distinct_unsafe_ids_do_not_collide(self):
|
|
from deerflow.config.paths import make_safe_user_id
|
|
|
|
assert make_safe_user_id("a.b") != make_safe_user_id("a/b")
|
|
|
|
def test_empty_id_rejected(self):
|
|
from deerflow.config.paths import make_safe_user_id
|
|
|
|
with pytest.raises(ValueError, match="non-empty"):
|
|
make_safe_user_id("")
|
|
|
|
|
|
class TestUserDir:
|
|
def test_user_dir(self, paths: Paths):
|
|
assert paths.user_dir("alice") == paths.base_dir / "users" / "alice"
|
|
|
|
def test_prepare_user_dir_migrates_unique_legacy_unsafe_bucket(self, paths: Paths):
|
|
from deerflow.config.paths import make_safe_user_id
|
|
|
|
raw = "user@example.com"
|
|
safe = make_safe_user_id(raw)
|
|
legacy_dir = paths.base_dir / "users" / "user-example-com-63a710569261a24b"
|
|
legacy_dir.mkdir(parents=True)
|
|
(legacy_dir / "memory.json").write_text('{"legacy": true}\n', encoding="utf-8")
|
|
|
|
assert paths.prepare_user_dir_for_raw_id(raw) == safe
|
|
|
|
current_dir = paths.user_dir(safe)
|
|
assert current_dir.exists()
|
|
assert not legacy_dir.exists()
|
|
assert (current_dir / "memory.json").read_text(encoding="utf-8") == '{"legacy": true}\n'
|
|
|
|
def test_prepare_user_dir_never_migrates_another_users_bucket(self, paths: Paths):
|
|
"""A different raw ID with the same sanitized prefix has a different legacy digest."""
|
|
import hashlib
|
|
|
|
from deerflow.config.paths import make_safe_user_id
|
|
|
|
users_dir = paths.base_dir / "users"
|
|
other_legacy = users_dir / f"a-b-{hashlib.sha1(b'a/b').hexdigest()[:16]}"
|
|
other_legacy.mkdir(parents=True)
|
|
arbitrary_16_hex = users_dir / "a-b-1111111111111111"
|
|
arbitrary_16_hex.mkdir(parents=True)
|
|
|
|
assert paths.prepare_user_dir_for_raw_id("a.b") == make_safe_user_id("a.b")
|
|
|
|
assert not paths.user_dir(make_safe_user_id("a.b")).exists()
|
|
assert other_legacy.exists()
|
|
assert arbitrary_16_hex.exists()
|
|
|
|
|
|
class TestUserMemoryFile:
|
|
def test_user_memory_file(self, paths: Paths):
|
|
assert paths.user_memory_file("bob") == paths.base_dir / "users" / "bob" / "memory.json"
|
|
|
|
|
|
class TestUserAgentMemoryFile:
|
|
def test_user_agent_memory_file(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "bob" / "agents" / "myagent" / "memory.json"
|
|
assert paths.user_agent_memory_file("bob", "myagent") == expected
|
|
|
|
def test_user_agent_memory_file_lowercases_name(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "bob" / "agents" / "myagent" / "memory.json"
|
|
assert paths.user_agent_memory_file("bob", "MyAgent") == expected
|
|
|
|
|
|
class TestUserAgentDir:
|
|
def test_user_agents_dir(self, paths: Paths):
|
|
assert paths.user_agents_dir("alice") == paths.base_dir / "users" / "alice" / "agents"
|
|
|
|
def test_user_agent_dir(self, paths: Paths):
|
|
assert paths.user_agent_dir("alice", "code-reviewer") == paths.base_dir / "users" / "alice" / "agents" / "code-reviewer"
|
|
|
|
def test_user_agent_dir_lowercases_name(self, paths: Paths):
|
|
assert paths.user_agent_dir("alice", "CodeReviewer") == paths.base_dir / "users" / "alice" / "agents" / "codereviewer"
|
|
|
|
def test_user_agent_dir_validates_user_id(self, paths: Paths):
|
|
with pytest.raises(ValueError, match="Invalid user_id"):
|
|
paths.user_agent_dir("../escape", "myagent")
|
|
|
|
|
|
class TestUserThreadDir:
|
|
def test_user_thread_dir(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "u1" / "threads" / "t1"
|
|
assert paths.thread_dir("t1", user_id="u1") == expected
|
|
|
|
def test_thread_dir_no_user_id_falls_back_to_legacy(self, paths: Paths):
|
|
expected = paths.base_dir / "threads" / "t1"
|
|
assert paths.thread_dir("t1") == expected
|
|
|
|
|
|
class TestUserSandboxDirs:
|
|
def test_sandbox_work_dir(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "u1" / "threads" / "t1" / "user-data" / "workspace"
|
|
assert paths.sandbox_work_dir("t1", user_id="u1") == expected
|
|
|
|
def test_sandbox_uploads_dir(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "u1" / "threads" / "t1" / "user-data" / "uploads"
|
|
assert paths.sandbox_uploads_dir("t1", user_id="u1") == expected
|
|
|
|
def test_sandbox_outputs_dir(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "u1" / "threads" / "t1" / "user-data" / "outputs"
|
|
assert paths.sandbox_outputs_dir("t1", user_id="u1") == expected
|
|
|
|
def test_sandbox_user_data_dir(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "u1" / "threads" / "t1" / "user-data"
|
|
assert paths.sandbox_user_data_dir("t1", user_id="u1") == expected
|
|
|
|
def test_acp_workspace_dir(self, paths: Paths):
|
|
expected = paths.base_dir / "users" / "u1" / "threads" / "t1" / "acp-workspace"
|
|
assert paths.acp_workspace_dir("t1", user_id="u1") == expected
|
|
|
|
def test_legacy_sandbox_work_dir(self, paths: Paths):
|
|
expected = paths.base_dir / "threads" / "t1" / "user-data" / "workspace"
|
|
assert paths.sandbox_work_dir("t1") == expected
|
|
|
|
|
|
class TestHostPathsWithUserId:
|
|
def test_host_thread_dir_with_user_id(self, paths: Paths):
|
|
result = paths.host_thread_dir("t1", user_id="u1")
|
|
assert "users" in result
|
|
assert "u1" in result
|
|
assert "threads" in result
|
|
assert "t1" in result
|
|
|
|
def test_host_thread_dir_legacy(self, paths: Paths):
|
|
result = paths.host_thread_dir("t1")
|
|
assert "threads" in result
|
|
assert "t1" in result
|
|
assert "users" not in result
|
|
|
|
def test_host_sandbox_user_data_dir_with_user_id(self, paths: Paths):
|
|
result = paths.host_sandbox_user_data_dir("t1", user_id="u1")
|
|
assert "users" in result
|
|
assert "user-data" in result
|
|
|
|
def test_host_sandbox_work_dir_with_user_id(self, paths: Paths):
|
|
result = paths.host_sandbox_work_dir("t1", user_id="u1")
|
|
assert "workspace" in result
|
|
|
|
def test_host_sandbox_uploads_dir_with_user_id(self, paths: Paths):
|
|
result = paths.host_sandbox_uploads_dir("t1", user_id="u1")
|
|
assert "uploads" in result
|
|
|
|
def test_host_sandbox_outputs_dir_with_user_id(self, paths: Paths):
|
|
result = paths.host_sandbox_outputs_dir("t1", user_id="u1")
|
|
assert "outputs" in result
|
|
|
|
def test_host_acp_workspace_dir_with_user_id(self, paths: Paths):
|
|
result = paths.host_acp_workspace_dir("t1", user_id="u1")
|
|
assert "acp-workspace" in result
|
|
|
|
|
|
class TestEnsureAndDeleteWithUserId:
|
|
def test_ensure_thread_dirs_creates_user_scoped(self, paths: Paths):
|
|
paths.ensure_thread_dirs("t1", user_id="u1")
|
|
assert paths.sandbox_work_dir("t1", user_id="u1").is_dir()
|
|
assert paths.sandbox_uploads_dir("t1", user_id="u1").is_dir()
|
|
assert paths.sandbox_outputs_dir("t1", user_id="u1").is_dir()
|
|
assert paths.acp_workspace_dir("t1", user_id="u1").is_dir()
|
|
|
|
def test_delete_thread_dir_removes_user_scoped(self, paths: Paths):
|
|
paths.ensure_thread_dirs("t1", user_id="u1")
|
|
assert paths.thread_dir("t1", user_id="u1").exists()
|
|
paths.delete_thread_dir("t1", user_id="u1")
|
|
assert not paths.thread_dir("t1", user_id="u1").exists()
|
|
|
|
def test_delete_thread_dir_idempotent(self, paths: Paths):
|
|
paths.delete_thread_dir("nonexistent", user_id="u1") # should not raise
|
|
|
|
def test_ensure_thread_dirs_legacy_still_works(self, paths: Paths):
|
|
paths.ensure_thread_dirs("t1")
|
|
assert paths.sandbox_work_dir("t1").is_dir()
|
|
|
|
def test_user_scoped_and_legacy_are_independent(self, paths: Paths):
|
|
paths.ensure_thread_dirs("t1", user_id="u1")
|
|
paths.ensure_thread_dirs("t1")
|
|
# Both exist independently
|
|
assert paths.thread_dir("t1", user_id="u1").exists()
|
|
assert paths.thread_dir("t1").exists()
|
|
# Delete one doesn't affect the other
|
|
paths.delete_thread_dir("t1", user_id="u1")
|
|
assert not paths.thread_dir("t1", user_id="u1").exists()
|
|
assert paths.thread_dir("t1").exists()
|
|
|
|
|
|
class TestResolveVirtualPathWithUserId:
|
|
def test_resolve_virtual_path_with_user_id(self, paths: Paths):
|
|
paths.ensure_thread_dirs("t1", user_id="u1")
|
|
result = paths.resolve_virtual_path("t1", "/mnt/user-data/workspace/file.txt", user_id="u1")
|
|
expected_base = paths.sandbox_user_data_dir("t1", user_id="u1").resolve()
|
|
assert str(result).startswith(str(expected_base))
|
|
|
|
def test_resolve_virtual_path_legacy(self, paths: Paths):
|
|
paths.ensure_thread_dirs("t1")
|
|
result = paths.resolve_virtual_path("t1", "/mnt/user-data/workspace/file.txt")
|
|
expected_base = paths.sandbox_user_data_dir("t1").resolve()
|
|
assert str(result).startswith(str(expected_base))
|