Enterprise agent platform for building, deploying, and operating AI teammates.
"""Tests for the workforce widget deployment channel (#948).
Covers: owner-side widget management endpoints (get / update / rotate, gated
on ``status == "active"`` for enable/rotate), widget auth resolving a
workforce deployment key (direct visit and embed ticket), the embedding
allowed-domains check, guest task creation entering through
``create_workforce_run(source="widget")``, widget-context task scoping, and
rotate/disable invalidating already-issued guest tokens.
Builds on the share-link channel patterns (#947).
"""
from __future__ import annotations
import io
from pathlib import Path
from typing import Any, cast
import pytest
from xagent.core.execution_scope import EXECUTION_SCOPE_AGENT_CONFIG_KEY
from xagent.core.tools.core.workspace_file_tool import WorkspaceFileOperations
from xagent.core.workspace import TaskWorkspace
from xagent.web.models.agent import Agent, AgentStatus
from xagent.web.models.deployment import Deployment, DeploymentOwnerType
from xagent.web.models.task import Task
from xagent.web.models.uploaded_file import UploadedFile
from xagent.web.models.user import User
from xagent.web.models.workforce import WorkforceRun
from xagent.web.services.task_runtime import SELECTED_FILE_IDS_AGENT_CONFIG_KEY
from .conftest import (
_admin_headers,
_direct_db_session,
_register_second_user,
client,
patch_schedule_bg,
)
pytestmark = pytest.mark.usefixtures("_test_db")
def _user_id(username: str = "admin") -> int:
db = _direct_db_session()
try:
user = db.query(User).filter(User.username == username).one()
return int(user.id)
finally:
db.close()
def _create_published_agent(user_id: int, name: str) -> int:
db = _direct_db_session()
try:
agent = Agent(
user_id=user_id,
name=name,
description=f"{name} description",
instructions=f"{name} instructions",
execution_mode="balanced",
status=AgentStatus.PUBLISHED,
)
db.add(agent)
db.commit()
db.refresh(agent)
return int(agent.id)
finally:
db.close()
def _create_workforce(name: str, *, publish: bool = True) -> int:
headers = _admin_headers()
owner_id = _user_id()
manager_agent_id = _create_published_agent(owner_id, f"{name} Manager")
worker_agent_id = _create_published_agent(owner_id, f"{name} Worker")
response = client.post(
"/api/workforces",
headers=headers,
json={
"name": name,
"description": "Coordinates widget tests",
"manager_agent_id": manager_agent_id,
"workers": [
{
"source_type": "existing",
"agent_id": worker_agent_id,
"alias": "worker-1",
"assignment_instructions": "Handle everything",
"enabled": True,
"sort_order": 1,
}
],
},
)
assert response.status_code == 200, response.text
workforce_id = int(response.json()["id"])
if publish:
published = client.post(
f"/api/workforces/{workforce_id}/publish", headers=headers
)
assert published.status_code == 200, published.text
return workforce_id
def _enable_widget(
workforce_id: int, *, allowed_domains: list[str] | None = None
) -> str:
"""Enable the widget and return its (freshly minted) widget key."""
response = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=_admin_headers(),
json={
"widget_enabled": True,
"allowed_domains": allowed_domains
if allowed_domains is not None
else ["*"],
},
)
assert response.status_code == 200, response.text
body = response.json()
assert body["widget_enabled"] is True
key = body["widget_key"]
assert isinstance(key, str) and key
return str(key)
def _set_workforce_allowed_domains_raw(
workforce_id: int, allowed_domains: object
) -> None:
db = _direct_db_session()
try:
deployment = (
db.query(Deployment)
.filter(
Deployment.owner_type == DeploymentOwnerType.WORKFORCE.value,
Deployment.owner_id == workforce_id,
)
.one()
)
cast(Any, deployment).allowed_domains = allowed_domains
db.commit()
finally:
db.close()
def _authenticate_widget_guest_by_key(
widget_key: str, guest_id: str = "guest_test"
) -> dict[str, str]:
response = client.post(
"/api/widget/auth",
json={"guest_id": guest_id, "widget_key": widget_key},
)
assert response.status_code == 200, response.text
return {"Authorization": f"Bearer {response.json()['access_token']}"}
# ===== Widget management endpoints =====
def test_widget_enable_requires_active_workforce() -> None:
workforce_id = _create_workforce("Draft Widget Workforce", publish=False)
enabled = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=_admin_headers(),
json={"widget_enabled": True},
)
assert enabled.status_code == 400, enabled.text
rotated = client.post(
f"/api/workforces/{workforce_id}/widget-key/rotate", headers=_admin_headers()
)
assert rotated.status_code == 400, rotated.text
def test_widget_enable_rotate_disable_lifecycle() -> None:
workforce_id = _create_workforce("Lifecycle Widget Workforce")
headers = _admin_headers()
# Default state: widget is opt-in and starts disabled with no key.
initial = client.get(f"/api/workforces/{workforce_id}/widget-key", headers=headers)
assert initial.status_code == 200, initial.text
assert initial.json() == {
"workforce_id": workforce_id,
"widget_enabled": False,
"widget_key": None,
"allowed_domains": [],
}
key = _enable_widget(workforce_id, allowed_domains=["example.com"])
db = _direct_db_session()
try:
deployment = (
db.query(Deployment)
.filter(
Deployment.owner_type == DeploymentOwnerType.WORKFORCE.value,
Deployment.owner_id == workforce_id,
)
.one()
)
assert deployment.widget_enabled is True
assert deployment.widget_key == key
assert list(deployment.allowed_domains or []) == ["example.com"]
finally:
db.close()
fetched = client.get(f"/api/workforces/{workforce_id}/widget-key", headers=headers)
assert fetched.status_code == 200, fetched.text
assert fetched.json()["widget_key"] == key
assert fetched.json()["allowed_domains"] == ["example.com"]
# Re-enabling keeps the existing key stable.
assert _enable_widget(workforce_id, allowed_domains=["example.com"]) == key
rotated = client.post(
f"/api/workforces/{workforce_id}/widget-key/rotate", headers=headers
)
assert rotated.status_code == 200, rotated.text
rotated_key = rotated.json()["widget_key"]
assert rotated_key and rotated_key != key
assert rotated.json()["widget_enabled"] is True
disabled = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=headers,
json={"widget_enabled": False},
)
assert disabled.status_code == 200, disabled.text
assert disabled.json()["widget_enabled"] is False
# Disabling preserves the key (like agent widget); only the flag flips.
assert disabled.json()["widget_key"] == rotated_key
def test_widget_allowed_domains_update_independent_of_enable() -> None:
workforce_id = _create_workforce("Domains Widget Workforce")
_enable_widget(workforce_id, allowed_domains=["a.com"])
updated = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=_admin_headers(),
json={"allowed_domains": ["a.com", "b.com"]},
)
assert updated.status_code == 200, updated.text
assert updated.json()["allowed_domains"] == ["a.com", "b.com"]
# widget_enabled untouched when only domains are sent.
assert updated.json()["widget_enabled"] is True
@pytest.mark.parametrize(
"blank_domain",
["", " ", "\u001c"],
ids=["empty", "spaces", "unicode-control-separator"],
)
def test_workforce_widget_update_rejects_blank_allowed_domain(
blank_domain: str,
) -> None:
workforce_id = _create_workforce("Validated Domains Widget Workforce")
_enable_widget(workforce_id, allowed_domains=["existing.example"])
response = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=_admin_headers(),
json={"allowed_domains": [blank_domain]},
)
assert response.status_code == 422, response.text
fetched = client.get(
f"/api/workforces/{workforce_id}/widget-key", headers=_admin_headers()
)
assert fetched.status_code == 200, fetched.text
assert fetched.json()["allowed_domains"] == ["existing.example"]
def test_widget_requires_workforce_owner() -> None:
workforce_id = _create_workforce("Owner Only Widget Workforce")
other_headers = _register_second_user()
for method, url, kwargs in (
("get", f"/api/workforces/{workforce_id}/widget-key", {}),
(
"put",
f"/api/workforces/{workforce_id}/widget",
{"json": {"widget_enabled": True}},
),
("post", f"/api/workforces/{workforce_id}/widget-key/rotate", {}),
):
response = getattr(client, method)(url, headers=other_headers, **kwargs)
assert response.status_code == 403, response.text
def test_widget_enable_rotate_rejected_for_archived_workforce() -> None:
workforce_id = _create_workforce("Archived Widget Workforce")
headers = _admin_headers()
_enable_widget(workforce_id)
archived = client.delete(f"/api/workforces/{workforce_id}", headers=headers)
assert archived.status_code == 200, archived.text
# Re-enabling re-exposes the workforce, so it stays blocked on archive
# (400 from _ensure_active_workforce; the PUT itself uses the archived-safe
# can_edit gate so disabling still works — see the disable test below).
enabled = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=headers,
json={"widget_enabled": True},
)
assert enabled.status_code == 400, enabled.text
# Rotate keeps the stricter edit gate, so it 409s on an archived workforce.
rotated = client.post(
f"/api/workforces/{workforce_id}/widget-key/rotate", headers=headers
)
assert rotated.status_code == 409, rotated.text
def test_widget_disable_allowed_for_archived_workforce() -> None:
"""Mirrors the share-link disable path: turning the widget off only removes
access, so it stays available on an archived workforce (archived-safe
``can_edit_workforce`` gate)."""
workforce_id = _create_workforce("Archived Disable Widget Workforce")
headers = _admin_headers()
_enable_widget(workforce_id)
archived = client.delete(f"/api/workforces/{workforce_id}", headers=headers)
assert archived.status_code == 200, archived.text
disabled = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=headers,
json={"widget_enabled": False},
)
assert disabled.status_code == 200, disabled.text
assert disabled.json()["widget_enabled"] is False
def test_widget_rotate_preserves_disabled_state() -> None:
workforce_id = _create_workforce("Rotate Preserve Widget Workforce")
headers = _admin_headers()
_enable_widget(workforce_id)
disabled = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=headers,
json={"widget_enabled": False},
)
assert disabled.status_code == 200, disabled.text
rotated = client.post(
f"/api/workforces/{workforce_id}/widget-key/rotate", headers=headers
)
assert rotated.status_code == 200, rotated.text
body = rotated.json()
assert body["widget_enabled"] is False # preserved, not force-enabled
assert body["widget_key"] # key still rotated
# ===== Widget auth resolution =====
def test_widget_direct_visit_auth_resolves_workforce() -> None:
workforce_id = _create_workforce("Auth Widget Workforce")
key = _enable_widget(workforce_id)
response = client.post(
"/api/widget/auth",
json={"guest_id": "guest_test", "widget_key": key},
)
assert response.status_code == 200, response.text
body = response.json()
assert body["workforce_id"] == workforce_id
assert body["agent_id"] is None
assert body["agent_name"] == "Auth Widget Workforce"
assert body["access_token"]
def test_widget_embed_ticket_and_auth_workforce() -> None:
workforce_id = _create_workforce("Ticket Widget Workforce")
key = _enable_widget(workforce_id, allowed_domains=["example.com"])
ticket_resp = client.post(
"/api/widget/embed-ticket",
json={"widget_key": key},
headers={"origin": "https://example.com"},
)
assert ticket_resp.status_code == 200, ticket_resp.text
ticket_body = ticket_resp.json()
assert ticket_body["workforce_id"] == workforce_id
assert ticket_body["agent_id"] is None
ticket = ticket_body["ticket"]
assert ticket
auth = client.post(
"/api/widget/auth",
json={"guest_id": "guest_test", "embed_ticket": ticket},
)
assert auth.status_code == 200, auth.text
assert auth.json()["workforce_id"] == workforce_id
def test_widget_embed_ticket_enforces_allowed_domains() -> None:
workforce_id = _create_workforce("Domain Gate Widget Workforce")
key = _enable_widget(workforce_id, allowed_domains=["example.com"])
blocked = client.post(
"/api/widget/embed-ticket",
json={"widget_key": key},
headers={"origin": "https://evil.com"},
)
assert blocked.status_code == 403, blocked.text
allowed = client.post(
"/api/widget/embed-ticket",
json={"widget_key": key},
headers={"origin": "https://example.com"},
)
assert allowed.status_code == 200, allowed.text
def test_widget_embed_ticket_rejects_malformed_workforce_allowlist(
caplog: pytest.LogCaptureFixture,
) -> None:
caplog.set_level("WARNING", logger="xagent.web.services.widget_domains")
workforce_id = _create_workforce("Malformed Domain Gate Widget Workforce")
key = _enable_widget(workforce_id, allowed_domains=["example.com"])
_set_workforce_allowed_domains_raw(
workforce_id, "do-not-log-this-policy-value.example"
)
response = client.post(
"/api/widget/embed-ticket",
json={"widget_key": key},
headers={"origin": "https://example.com"},
)
assert response.status_code == 403
assert response.json()["detail"] == "Domain not allowed: example.com"
assert (
"Rejected malformed widget allowed-domains policy: "
f"owner_type=workforce owner_id={workforce_id} reason=not_list"
) in caplog.text
assert "do-not-log-this-policy-value.example" not in caplog.text
def test_widget_auth_rejects_ticket_when_workforce_allowlist_becomes_malformed(
caplog: pytest.LogCaptureFixture,
) -> None:
caplog.set_level("WARNING", logger="xagent.web.services.widget_domains")
workforce_id = _create_workforce("Malformed Live Allowlist Widget Workforce")
key = _enable_widget(workforce_id, allowed_domains=["example.com"])
ticket_response = client.post(
"/api/widget/embed-ticket",
json={"widget_key": key},
headers={"origin": "https://example.com"},
)
assert ticket_response.status_code == 200, ticket_response.text
_set_workforce_allowed_domains_raw(
workforce_id, [None, "do-not-log-this-policy-value.example"]
)
response = client.post(
"/api/widget/auth",
json={
"guest_id": "guest_test",
"embed_ticket": ticket_response.json()["ticket"],
},
)
assert response.status_code == 403
assert response.json()["detail"] == "Domain not allowed: example.com"
assert (
"Rejected malformed widget allowed-domains policy: "
f"owner_type=workforce owner_id={workforce_id} reason=non_string_entry"
) in caplog.text
assert "do-not-log-this-policy-value.example" not in caplog.text
def test_widget_auth_rejects_unknown_key() -> None:
response = client.post(
"/api/widget/auth",
json={"guest_id": "guest_test", "widget_key": "no-such-key"},
)
assert response.status_code == 403, response.text
def test_widget_auth_rejects_disabled_widget() -> None:
workforce_id = _create_workforce("Disabled Widget Workforce")
key = _enable_widget(workforce_id)
disabled = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=_admin_headers(),
json={"widget_enabled": False},
)
assert disabled.status_code == 200, disabled.text
response = client.post(
"/api/widget/auth",
json={"guest_id": "guest_test", "widget_key": key},
)
assert response.status_code == 403, response.text
def test_widget_auth_rejects_inactive_workforce() -> None:
workforce_id = _create_workforce("Inactive Widget Workforce")
key = _enable_widget(workforce_id)
unpublished = client.post(
f"/api/workforces/{workforce_id}/unpublish", headers=_admin_headers()
)
assert unpublished.status_code == 200, unpublished.text
response = client.post(
"/api/widget/auth",
json={"guest_id": "guest_test", "widget_key": key},
)
assert response.status_code == 403, response.text
def test_rotated_widget_key_invalidates_existing_guest_tokens() -> None:
workforce_id = _create_workforce("Rotate Auth Widget Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
rotated = client.post(
f"/api/workforces/{workforce_id}/widget-key/rotate", headers=_admin_headers()
)
assert rotated.status_code == 200, rotated.text
# Previously issued guest JWTs are invalidated by the key mismatch.
response = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={"title": "hello", "description": "hello"},
)
assert response.status_code == 403, response.text
def test_disabled_widget_invalidates_existing_guest_tokens() -> None:
workforce_id = _create_workforce("Disable Invalidate Widget Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
disabled = client.put(
f"/api/workforces/{workforce_id}/widget",
headers=_admin_headers(),
json={"widget_enabled": False},
)
assert disabled.status_code == 200, disabled.text
response = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={"title": "hello", "description": "hello"},
)
assert response.status_code == 403, response.text
# ===== Guest task creation → create_workforce_run =====
def test_widget_task_create_forwards_timezone_to_the_opening_turn(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""The widget opening turn starts inside this request and never reaches the
websocket chat frame, so the zone has to travel on the create body."""
workforce_id = _create_workforce("Widget Timezone Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
scheduled = patch_schedule_bg(monkeypatch)
response = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={
"title": "how many shifts do we have on tomorrow?",
"description": "how many shifts do we have on tomorrow?",
"timezone": "Australia/Melbourne",
},
)
assert response.status_code == 200, response.text
assert scheduled["context"] == {"timezone": "Australia/Melbourne"}
def test_widget_task_create_without_timezone_sends_no_context(
monkeypatch: pytest.MonkeyPatch,
) -> None:
workforce_id = _create_workforce("Widget No Timezone Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
scheduled = patch_schedule_bg(monkeypatch)
response = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={"title": "hello", "description": "hello"},
)
assert response.status_code == 200, response.text
assert scheduled["context"] is None
def test_widget_task_create_starts_workforce_run(
monkeypatch: pytest.MonkeyPatch,
) -> None:
workforce_id = _create_workforce("Guest Run Widget Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
patch_schedule_bg(monkeypatch)
response = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={"title": "hello workforce", "description": "hello workforce"},
)
assert response.status_code == 200, response.text
task_id = int(response.json()["task_id"])
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
assert task.source == "widget"
assert bool(task.is_visible) is False
assert int(task.user_id) == _user_id()
assert task.channel_id is None
assert task.agent_config.get("auth_mode") == "widget"
assert task.agent_config.get("__xagent_file_operation_access_version") == 1
assert int(task.agent_config.get("widget_workforce_id")) == workforce_id
assert task.agent_config.get("guest_id") == "guest_test"
# The server-observed creator IP is stamped on the workforce path too
# (#1108): it is the widget run quota's per-abuser key, and a future
# snapshot key collision in _merge_agent_config would silently drop it,
# degrading the sub-quota to entity-only. Regression-lock it here.
assert task.agent_config.get("widget_client_ip") == "testclient"
run = db.query(WorkforceRun).filter(WorkforceRun.task_id == task_id).one()
assert int(run.workforce_id) == workforce_id
assert bool(run.is_preview) is False
finally:
db.close()
# The run shows up in the owner's runs history with source=widget.
listed = client.get(
f"/api/workforces/{workforce_id}/runs", headers=_admin_headers()
)
assert listed.status_code == 200, listed.text
items = listed.json()["items"]
assert items and items[0]["source"] == "widget"
def test_widget_task_create_rejects_foreign_agent_id(
monkeypatch: pytest.MonkeyPatch,
) -> None:
workforce_id = _create_workforce("Foreign Agent Widget Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
patch_schedule_bg(monkeypatch)
foreign_agent_id = _create_published_agent(_user_id(), "Foreign Agent")
response = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={
"title": "hello",
"description": "hello",
"agent_id": foreign_agent_id,
},
)
assert response.status_code == 403, response.text
def test_widget_task_create_discards_forged_agent_config(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""``_create_workforce_widget_chat_task`` never reads
``TaskCreateRequest.agent_config`` -- ``create_workforce_run`` only sees
the handler's own ``extra_agent_config`` (``auth_mode``,
``widget_workforce_id``, ``guest_id``). A forged reserved key in the
request body must not survive into the persisted config, and neither
should an ordinary client key."""
workforce_id = _create_workforce("Forged Config Widget Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
patch_schedule_bg(monkeypatch)
response = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={
"title": "forged",
"description": "forged",
"agent_config": {
EXECUTION_SCOPE_AGENT_CONFIG_KEY: {
"sandbox_key_suffix": "victim",
"workspace_segments": ["victim"],
"memory_dimensions": {"tenant": "victim"},
},
SELECTED_FILE_IDS_AGENT_CONFIG_KEY: ["victim-file-id"],
"keep_me": "client value",
},
},
)
assert response.status_code == 200, response.text
task_id = int(response.json()["task_id"])
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
assert EXECUTION_SCOPE_AGENT_CONFIG_KEY not in task.agent_config
assert SELECTED_FILE_IDS_AGENT_CONFIG_KEY not in task.agent_config
assert "keep_me" not in task.agent_config
assert task.agent_config.get("auth_mode") == "widget"
assert int(task.agent_config.get("widget_workforce_id")) == workforce_id
finally:
db.close()
# ===== Task-less opening-message upload =====
def test_workforce_widget_first_turn_attachments_reach_run(
monkeypatch: pytest.MonkeyPatch,
tmp_path,
) -> None:
workforce_id = _create_workforce("First Turn Widget File Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
patch_schedule_bg(monkeypatch)
upload = client.post(
"/api/widget/files/upload",
headers=guest_headers,
data={"task_type": "task"},
files={"file": ("brief.txt", io.BytesIO(b"widget brief"), "text/plain")},
)
assert upload.status_code == 200, upload.text
file_id = upload.json()["file_id"]
created = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={
"title": "summarize",
"description": "summarize this",
"files": [file_id],
},
)
assert created.status_code == 200, created.text
task_id = int(created.json()["task_id"])
db = _direct_db_session()
try:
bound = db.query(UploadedFile).filter(UploadedFile.file_id == file_id).one()
task = db.query(Task).filter(Task.id == task_id).one()
assert bound.task_id == task_id
assert task.agent_config.get("__xagent_file_operation_access_version") == 1
workspace = TaskWorkspace(
id="agent_1_widget_first_turn",
base_dir=str(tmp_path / "workspaces"),
allowed_external_dirs=[str(Path(bound.storage_path).parent)],
db_task_id=task_id,
)
workspace.owner_user_id = int(task.user_id)
workspace.file_operation_access_version = 1
monkeypatch.setattr(
"xagent.core.storage.manager.create_db_session",
_direct_db_session,
)
assert WorkspaceFileOperations(workspace).read_file(file_id) == "widget brief"
finally:
db.close()
def test_taskless_widget_upload_enforces_file_count_cap() -> None:
"""The task-less workforce-widget upload path is reachable by any widget
guest before a task/owner exists, so it caps files per request to blunt
the worst storage-abuse case (mirrors the share path)."""
from xagent.web.api.public_chat_access import MAX_TASKLESS_SHARE_UPLOAD_FILES
workforce_id = _create_workforce("Widget Upload Cap Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
over_cap = [
("files", (f"f{i}.txt", io.BytesIO(b"x"), "text/plain"))
for i in range(MAX_TASKLESS_SHARE_UPLOAD_FILES + 1)
]
rejected = client.post(
"/api/widget/files/upload",
headers=guest_headers,
data={"task_type": "task"},
files=over_cap,
)
assert rejected.status_code == 422, rejected.text
assert str(MAX_TASKLESS_SHARE_UPLOAD_FILES) in rejected.json()["detail"]
def test_taskless_widget_upload_rate_limited(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""The widget upload path carries its own throttle (#973): keyed per
widget entity + caller IP — NOT the client-supplied widget guest_id, so
rotating the guest must not reset the budget."""
from xagent.web.services.share_rate_limit import reset_share_rate_limiter
workforce_id = _create_workforce("Widget Upload RL Workforce")
key = _enable_widget(workforce_id)
monkeypatch.setenv("XAGENT_WIDGET_UPLOAD_IP_RATE_LIMIT", "1/minute")
reset_share_rate_limiter()
def _upload(headers: dict[str, str]) -> Any:
return client.post(
"/api/widget/files/upload",
headers=headers,
data={"task_type": "task"},
files=[("files", ("f.txt", io.BytesIO(b"x"), "text/plain"))],
)
first = _upload(_authenticate_widget_guest_by_key(key, guest_id="g-one"))
assert first.status_code == 200, first.text
# Rotating the (client-supplied) guest_id must not escape the budget.
second = _upload(_authenticate_widget_guest_by_key(key, guest_id="g-two"))
assert second.status_code == 429, second.text
def test_agent_widget_taskless_upload_still_requires_task_id() -> None:
"""The task-less upload relaxation is workforce-only; the agent widget
path keeps its task_id-required contract (files ride the first WS turn)."""
_admin_headers() # ensure the admin owner exists before _user_id()
owner_id = _user_id()
agent_id = _create_published_agent(owner_id, "Agent Widget Upload")
db = _direct_db_session()
try:
agent = db.query(Agent).filter(Agent.id == agent_id).one()
agent.widget_enabled = True
agent.widget_key = "agent-widget-key-upload-test"
agent.allowed_domains = ["*"]
db.commit()
finally:
db.close()
auth = client.post(
"/api/widget/auth",
json={"guest_id": "guest_test", "widget_key": "agent-widget-key-upload-test"},
)
assert auth.status_code == 200, auth.text
guest_headers = {"Authorization": f"Bearer {auth.json()['access_token']}"}
rejected = client.post(
"/api/widget/files/upload",
headers=guest_headers,
data={"task_type": "task"},
files=[("files", ("f.txt", io.BytesIO(b"x"), "text/plain"))],
)
assert rejected.status_code == 400, rejected.text
assert "task_id" in rejected.json()["detail"]
# ===== Widget task-access scoping =====
def test_widget_task_access_scoped_to_guest_and_workforce(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""A widget guest may only reach its OWN task on ITS workforce: another
guest of the same workforce, or any guest of a different workforce, is
rejected (guest_id + widget_workforce_id scoping in
``_get_task_for_workforce_widget_context``)."""
patch_schedule_bg(monkeypatch)
wf_a = _create_workforce("Scope Widget A")
key_a = _enable_widget(wf_a)
wf_b = _create_workforce("Scope Widget B")
key_b = _enable_widget(wf_b)
owner = _authenticate_widget_guest_by_key(key_a, guest_id="guest-owner")
created = client.post(
"/api/widget/chat/task/create",
headers=owner,
json={"title": "hi", "description": "hi"},
)
assert created.status_code == 200, created.text
task_id = int(created.json()["task_id"])
upload = [("files", ("f.txt", io.BytesIO(b"x"), "text/plain"))]
# Same workforce, a different guest -> rejected.
intruder = _authenticate_widget_guest_by_key(key_a, guest_id="guest-intruder")
r1 = client.post(
"/api/widget/files/upload",
headers=intruder,
data={"task_type": "task", "task_id": str(task_id)},
files=upload,
)
assert r1.status_code == 403, r1.text
# A guest of a different workforce (even reusing the guest id) -> rejected.
cross_wf = _authenticate_widget_guest_by_key(key_b, guest_id="guest-owner")
r2 = client.post(
"/api/widget/files/upload",
headers=cross_wf,
data={"task_type": "task", "task_id": str(task_id)},
files=upload,
)
assert r2.status_code == 403, r2.text
def test_widget_auth_accepts_legacy_agent_ticket_without_owner_type() -> None:
"""Backward-compat: agent embed tickets minted before workforce support
carried no ``owner_type`` claim; ``_owner_from_embed_ticket`` must still
resolve them as agent tickets."""
from datetime import datetime, timedelta, timezone
from xagent.web import jwt_codec as jwt
from xagent.web.api.widget import EMBED_TICKET_TYPE
from xagent.web.auth_config import JWT_ALGORITHM, JWT_SECRET_KEY
_admin_headers()
owner_id = _user_id()
agent_id = _create_published_agent(owner_id, "Legacy Ticket Agent")
db = _direct_db_session()
try:
agent = db.query(Agent).filter(Agent.id == agent_id).one()
agent.widget_enabled = True
agent.widget_key = "legacy-agent-widget-key"
agent.allowed_domains = ["example.com"]
db.commit()
finally:
db.close()
legacy_ticket = jwt.encode(
{
"type": EMBED_TICKET_TYPE,
"agent_id": agent_id,
"embed_origin": "example.com",
# No "owner_type" -- exactly how pre-workforce tickets looked.
"exp": datetime.now(timezone.utc) + timedelta(seconds=60),
},
JWT_SECRET_KEY,
algorithm=JWT_ALGORITHM,
)
auth = client.post(
"/api/widget/auth",
json={"guest_id": "guest_test", "embed_ticket": legacy_ticket},
)
assert auth.status_code == 200, auth.text
body = auth.json()
assert body["agent_id"] == agent_id
assert body.get("workforce_id") is None
# ===== Public file tickets on workforce widgets =====
def test_workforce_widget_file_ticket_resolves_and_dies_with_the_deployment_key(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""A workforce widget guest's file ticket restores the live key from the
workforce deployment (not an agent row), so key rotation revokes it."""
workforce_id = _create_workforce("Ticket Widget Workforce")
key = _enable_widget(workforce_id)
guest_headers = _authenticate_widget_guest_by_key(key)
patch_schedule_bg(monkeypatch)
created = client.post(
"/api/widget/chat/task/create",
headers=guest_headers,
json={"title": "hello", "description": "hello"},
)
assert created.status_code == 200, created.text
uploaded = client.post(
"/api/widget/files/upload",
headers=guest_headers,
data={"task_type": "task", "task_id": str(created.json()["task_id"])},
files={"file": ("wf-ticket.txt", io.BytesIO(b"workforce"), "text/plain")},
)
assert uploaded.status_code == 200, uploaded.text
file_id = uploaded.json()["file_id"]
minted = client.post(f"/api/files/public/tickets/{file_id}", headers=guest_headers)
assert minted.status_code == 200, minted.text
ticket = minted.json()["ticket"]
url = f"/api/files/public/preview/{file_id}"
allowed = client.get(url, params={"ticket": ticket})
assert allowed.status_code == 200, allowed.text
assert allowed.content == b"workforce"
rotated = client.post(
f"/api/workforces/{workforce_id}/widget-key/rotate", headers=_admin_headers()
)
assert rotated.status_code == 200, rotated.text
revoked = client.get(url, params={"ticket": ticket})
assert revoked.status_code == 403, revoked.text
assert revoked.json()["detail"] == "Widget is unavailable"
def test_deployment_secret_lookup_prefers_the_workforce_deployment() -> None:
"""Same precedence as the guest validators: a workforce id wins over an
agent id, so the ticket digest is checked against the workforce key."""
from xagent.web.api.public_chat_access import _current_deployment_secret
workforce_id = _create_workforce("Ticket Secret Precedence Workforce")
key = _enable_widget(workforce_id)
agent_id = _create_published_agent(_user_id(), "Ticket Secret Agent")
db = _direct_db_session()
try:
guest = {
"auth_mode": "widget",
"widget_workforce_id": workforce_id,
"widget_agent_id": agent_id,
}
assert _current_deployment_secret(db, guest) == key
# The share secret of the same workforce is not set: no secret.
share_guest = {"auth_mode": "share", "share_workforce_id": workforce_id}
assert _current_deployment_secret(db, share_guest) is None
finally:
db.close()