Enterprise agent platform for building, deploying, and operating AI teammates.
"""Run-scoped runtime inputs remain encrypted, scoped and transactional."""
import pytest
from cryptography.fernet import Fernet, InvalidToken
from xagent.core.tools.adapters.vibe.connector_runtime import (
ERROR_CONNECTOR_RUNTIME_UNAVAILABLE,
ERROR_RUNTIME_SECRET_UNAVAILABLE,
ConnectorRef,
ConnectorRuntimeError,
)
from xagent.web.models.database import Base, get_engine, get_session_local, init_db
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.task_runtime_secret import TaskRuntimeSecret
from xagent.web.models.user import User
from xagent.web.services.task_runtime_secrets import (
bind_runtime_values_to_run,
clean_finished_runtime_values,
load_runtime_values,
stage_runtime_values,
)
VALUES = {
ConnectorRef("mcp", 1): {
"secrets": {"token": "synthetic-secret"},
"auth_selector": {"account": "synthetic-account"},
}
}
@pytest.fixture(autouse=True)
def private_encryption_key(monkeypatch):
key = Fernet.generate_key().decode()
monkeypatch.setenv("ENCRYPTION_KEY", key)
return key
@pytest.fixture
def task_id(tmp_path):
init_db(db_url=f"sqlite:///{tmp_path / 'secrets.db'}")
with get_session_local()() as db:
user = User(username="owner", password_hash="unused")
db.add(user)
db.flush()
task = Task(
user_id=user.id,
title="Inputs",
status=TaskStatus.RUNNING,
run_id="run-1",
state_version=1,
control_state="running",
)
db.add(task)
db.commit()
yield task.id
Base.metadata.drop_all(bind=get_engine())
def stage(db, task_id):
stage_runtime_values(db, task_id=task_id, turn_id="turn-1", values_by_ref=VALUES)
assert bind_runtime_values_to_run(
db, task_id=task_id, turn_id="turn-1", run_id="run-1"
)
def test_ciphertext_round_trip_in_independent_session(task_id):
with get_session_local()() as db:
stage(db, task_id)
row = db.query(TaskRuntimeSecret).one()
assert "synthetic" not in row.ciphertext
db.commit()
with get_session_local()() as db:
task = db.get(Task, task_id)
assert load_runtime_values(db, task=task, turn_id="turn-1", required=True) == {
ref.storage_key: values for ref, values in VALUES.items()
}
assert load_runtime_values(db, task=task, turn_id="turn-1", required=True)
def test_acceptance_rollback_removes_runtime_inputs(task_id):
with get_session_local()() as db:
stage(db, task_id)
db.rollback()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 0
@pytest.mark.parametrize("change", ["owner", "run", "ciphertext", "turn"])
def test_missing_or_mismatched_values_fail_closed(task_id, change):
with get_session_local()() as db:
stage(db, task_id)
row = db.query(TaskRuntimeSecret).one()
if change == "owner":
db.get(
User, db.get(Task, task_id).user_id
).actor_subject = "replacement-owner"
elif change == "run":
db.get(Task, task_id).run_id = "run-2"
elif change == "ciphertext":
row.ciphertext = "synthetic-plaintext"
db.commit()
with get_session_local()() as db:
with pytest.raises(ConnectorRuntimeError) as error:
load_runtime_values(
db,
task=db.get(Task, task_id),
turn_id="other-turn" if change == "turn" else "turn-1",
required=True,
)
assert "synthetic" not in str(error.value)
def test_compensation_preserves_queued_and_active_inputs(task_id):
with get_session_local()() as db:
stage(db, task_id)
db.commit()
clean_finished_runtime_values()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 1
db.get(Task, task_id).status = TaskStatus.COMPLETED
db.commit()
clean_finished_runtime_values()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 0
@pytest.mark.parametrize(
"resting_status", [TaskStatus.PAUSED, TaskStatus.WAITING_FOR_USER]
)
def test_resumed_execution_reuses_run_values_after_lease_release(
task_id, resting_status
):
with get_session_local()() as db:
stage(db, task_id)
task = db.get(Task, task_id)
task.status = resting_status
task.runner_id = "worker"
db.commit()
clean_finished_runtime_values()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 1
db.get(Task, task_id).runner_id = None
db.commit()
clean_finished_runtime_values()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 1
task = db.get(Task, task_id)
task.status = TaskStatus.RUNNING
task.runner_id = "resumed-worker"
assert load_runtime_values(db, task=task, required=True) == {
ref.storage_key: values for ref, values in VALUES.items()
}
def test_cleanup_cannot_observe_inputs_before_transaction_binds_run(task_id):
with get_session_local()() as acceptance:
stage_runtime_values(
acceptance, task_id=task_id, turn_id="turn-1", values_by_ref=VALUES
)
assert acceptance.query(TaskRuntimeSecret).one().run_id is None
with get_session_local()() as observer:
assert observer.query(TaskRuntimeSecret).count() == 0
# Cleanup runs through its own session while acceptance is uncommitted.
clean_finished_runtime_values()
assert bind_runtime_values_to_run(
acceptance, task_id=task_id, turn_id="turn-1", run_id="run-1"
)
acceptance.commit()
clean_finished_runtime_values()
with get_session_local()() as observer:
row = observer.query(TaskRuntimeSecret).one()
assert row.run_id == "run-1"
assert load_runtime_values(
observer, task=observer.get(Task, task_id), turn_id="turn-1", required=True
)
@pytest.mark.parametrize("key", [None, "", "invalid-key", "非密钥"])
def test_invalid_key_refuses_staging_without_writing(task_id, monkeypatch, key):
monkeypatch.delenv("ENCRYPTION_KEY", raising=False)
if key is not None:
monkeypatch.setenv("ENCRYPTION_KEY", key)
with get_session_local()() as db:
with pytest.raises(ConnectorRuntimeError) as error:
stage(db, task_id)
assert error.value.code == ERROR_CONNECTOR_RUNTIME_UNAVAILABLE
assert error.value.status_code == 503
assert "synthetic-secret" not in str(error.value)
db.commit()
with get_session_local()() as observer:
assert observer.query(TaskRuntimeSecret).count() == 0
def test_explicit_fallback_key_round_trip(task_id, monkeypatch):
from xagent.config import DEV_FALLBACK_ENCRYPTION_KEY
monkeypatch.setenv("ENCRYPTION_KEY", DEV_FALLBACK_ENCRYPTION_KEY)
with get_session_local()() as db:
stage(db, task_id)
assert load_runtime_values(
db, task=db.get(Task, task_id), turn_id="turn-1", required=True
)
def test_store_does_not_reuse_cached_development_cipher(
task_id, monkeypatch, private_encryption_key
):
from xagent.core.utils.encryption import get_cipher
get_cipher.cache_clear()
try:
monkeypatch.delenv("ENCRYPTION_KEY")
development_cipher = get_cipher()
monkeypatch.setenv("ENCRYPTION_KEY", private_encryption_key)
with get_session_local()() as db:
stage(db, task_id)
ciphertext = db.query(TaskRuntimeSecret).one().ciphertext.encode()
assert b"synthetic-secret" in Fernet(
private_encryption_key.encode()
).decrypt(ciphertext)
with pytest.raises(InvalidToken):
development_cipher.decrypt(ciphertext)
assert load_runtime_values(
db, task=db.get(Task, task_id), turn_id="turn-1", required=True
)
finally:
get_cipher.cache_clear()
@pytest.mark.parametrize("status", [TaskStatus.COMPLETED, TaskStatus.FAILED])
def test_terminal_cleanup_is_scoped_to_run(task_id, status):
with get_session_local()() as db:
stage(db, task_id)
db.get(Task, task_id).status = status
db.commit()
clean_finished_runtime_values(task_id=task_id, run_id="other-run")
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 1
clean_finished_runtime_values(task_id=task_id, run_id="run-1")
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 0
def test_new_run_never_inherits_old_values_and_old_cleanup_preserves_new(task_id):
with get_session_local()() as db:
stage(db, task_id)
task = db.get(Task, task_id)
task.run_id = "run-2"
db.flush()
assert load_runtime_values(db, task=task) is None
stage_runtime_values(
db, task_id=task_id, turn_id="turn-2", values_by_ref=VALUES
)
bind_runtime_values_to_run(
db, task_id=task_id, turn_id="turn-2", run_id="run-2"
)
db.commit()
clean_finished_runtime_values(task_id=task_id, run_id="run-1")
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).one().run_id == "run-2"
assert load_runtime_values(db, task=db.get(Task, task_id), required=True)
def test_missing_accepted_values_fail_even_when_optional(task_id):
from xagent.web.services.task_start_protocol import (
TaskStartPayload,
stage_task_start_command,
)
with get_session_local()() as db:
task = db.get(Task, task_id)
task.status = TaskStatus.PENDING
task.run_id = None
stage_task_start_command(
db,
task_id=task_id,
actor_user_id=task.user_id,
start=TaskStartPayload(
version=1,
run_id="run-1",
state_version=1,
turn_id="turn-1",
kind="create",
message="hello",
runtime_values_ref="turn-1",
),
)
task.status = TaskStatus.RUNNING
task.run_id = "run-1"
db.commit()
with get_session_local()() as db:
with pytest.raises(ConnectorRuntimeError) as error:
load_runtime_values(db, task=db.get(Task, task_id))
assert error.value.code == ERROR_RUNTIME_SECRET_UNAVAILABLE
@pytest.mark.parametrize(
"key_state", ["unset", "empty", "default", "malformed", "rotated"]
)
def test_read_distinguishes_key_configuration_from_decryption_failure(
task_id, monkeypatch, key_state
):
from xagent.config import DEV_FALLBACK_ENCRYPTION_KEY
with get_session_local()() as db:
stage(db, task_id)
db.commit()
if key_state == "unset":
monkeypatch.delenv("ENCRYPTION_KEY")
else:
monkeypatch.setenv(
"ENCRYPTION_KEY",
{
"empty": "",
"default": DEV_FALLBACK_ENCRYPTION_KEY,
"malformed": "not-a-fernet-key",
"rotated": Fernet.generate_key().decode(),
}[key_state],
)
with get_session_local()() as db:
with pytest.raises(ConnectorRuntimeError) as error:
load_runtime_values(
db, task=db.get(Task, task_id), turn_id="turn-1", required=True
)
assert error.value.code == (
ERROR_RUNTIME_SECRET_UNAVAILABLE
if key_state in {"default", "rotated"}
else ERROR_CONNECTOR_RUNTIME_UNAVAILABLE
)
assert error.value.status_code == 503
assert "synthetic-secret" not in str(error.value)
assert db.query(TaskRuntimeSecret).count() == 1
@pytest.mark.parametrize(
"status,removed",
[
(TaskStatus.COMPLETED, True),
(TaskStatus.FAILED, True),
(TaskStatus.PAUSED, False),
(TaskStatus.WAITING_FOR_USER, False),
(TaskStatus.RUNNING, False),
],
)
def test_expired_terminal_owner_does_not_leak_inputs(task_id, status, removed):
from datetime import datetime, timedelta, timezone
with get_session_local()() as db:
stage(db, task_id)
task = db.get(Task, task_id)
task.status = status
task.runner_id = "dead-worker"
task.lease_attempt_id = "dead-attempt"
task.lease_expires_at = datetime.now(timezone.utc) + timedelta(minutes=1)
db.commit()
clean_finished_runtime_values()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 1
db.get(Task, task_id).lease_expires_at = datetime.now(timezone.utc) - timedelta(
minutes=1
)
db.commit()
clean_finished_runtime_values()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == (0 if removed else 1)
def test_cleanup_pages_past_retained_inputs(task_id):
with get_session_local()() as db:
owner = db.get(Task, task_id).user_id
for i in range(5):
task = Task(
user_id=owner,
title=str(i),
run_id="run-1",
status=TaskStatus.WAITING_FOR_USER if i < 4 else TaskStatus.COMPLETED,
)
db.add(task)
db.flush()
stage(db, task.id)
db.commit()
cursor = clean_finished_runtime_values(batch_size=2)
assert cursor is not None
cursor = clean_finished_runtime_values(batch_size=2, after_id=cursor)
assert cursor is not None
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 5
assert clean_finished_runtime_values(batch_size=2, after_id=cursor) is None
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 4
@pytest.mark.parametrize(
"status", [TaskStatus.PAUSED, TaskStatus.WAITING_FOR_USER, TaskStatus.RUNNING]
)
def test_expired_values_fail_before_sweep_and_are_removed(task_id, monkeypatch, status):
from datetime import datetime, timedelta, timezone
monkeypatch.setenv("XAGENT_TASK_RUNTIME_SECRETS_TTL_SECONDS", "60")
with get_session_local()() as db:
stage(db, task_id)
db.get(Task, task_id).status = status
db.query(TaskRuntimeSecret).one().created_at = datetime.now(
timezone.utc
) - timedelta(seconds=61)
db.commit()
with get_session_local()() as db:
with pytest.raises(ConnectorRuntimeError) as error:
load_runtime_values(db, task=db.get(Task, task_id), required=True)
assert error.value.code == ERROR_RUNTIME_SECRET_UNAVAILABLE
clean_finished_runtime_values()
with get_session_local()() as db:
assert db.query(TaskRuntimeSecret).count() == 0