Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

14.4 KB
Raw Blame
use super::staged::{STAGED_COLLECTION, STAGED_DOMAIN};
use super::*;

fn image(media: MediaReference) -> ContentPart {
    ContentPart::Image {
        media,
        caption: None,
        alt_text: None,
    }
}

#[test]
fn persisted_refs_require_unique_opaque_ids_without_source_authority() {
    let valid = image(MediaReference {
        opaque_id: Some("opaque-1".into()),
        content_type: Some("image/png".into()),
        ..Default::default()
    });
    assert!(validate_opaque_parts(std::slice::from_ref(&valid)).is_ok());

    for media in [
        MediaReference {
            opaque_id: Some("opaque-1".into()),
            path: Some("../../etc/passwd".into()),
            ..Default::default()
        },
        MediaReference {
            opaque_id: Some("opaque-1".into()),
            url: Some("data:image/png;base64,AAAA".into()),
            ..Default::default()
        },
        MediaReference::default(),
    ] {
        assert!(validate_opaque_parts(&[image(media)]).is_err());
    }
    assert!(validate_opaque_parts(&[valid.clone(), valid]).is_err());
}

#[test]
fn public_projection_hides_paths_but_keeps_opaque_attachment_refs() {
    let part = image(MediaReference {
        opaque_id: Some("opaque-2".into()),
        content_type: Some("image/png".into()),
        ..Default::default()
    });
    let mut metadata = json!({"keep": true});
    let public = save(
        &mut metadata,
        vec![(part.clone(), "uploads/thread/a.png".into())],
    );
    assert_eq!(public, vec![part]);
    assert!(metadata[STORAGE_KEY][0]["path"]
        .as_str()
        .unwrap()
        .contains("uploads/"));

    let projected = public_refs(&metadata);
    assert_eq!(projected, public);
    strip_private_metadata(&mut metadata);
    assert_eq!(metadata, json!({"keep": true}));
}

#[test]
fn staged_image_reference_preserves_uploaded_file_name() {
    let part = image(MediaReference {
        file_name: Some("queued-roundtrip.png".into()),
        content_type: Some("image/png".into()),
        ..Default::default()
    });
    let staged = Attachment {
        path: "uploads/thread/attachment".into(),
        name: "attachment".into(),
        mime: "image/png".into(),
        size_bytes: 68,
    };

    let result = from_staged_parts(&[part], &[staged]).unwrap();
    let ContentPart::Image { media, .. } = &result[0].0 else {
        panic!("staged image changed kind");
    };
    assert_eq!(media.file_name.as_deref(), Some("queued-roundtrip.png"));
}

fn claim(message_id: &str, part: ContentPart, canceled: bool) -> StagedAttachmentClaim {
    StagedAttachmentClaim {
        tenant: crate::core::runtime::Tenant::default(),
        thread_id: "thread".into(),
        message_id: message_id.into(),
        part,
        canceled,
    }
}

fn test_repo(workspace: &std::path::Path) -> Repo {
    let backend = crate::storage::local::backend_for(workspace).unwrap();
    Repo::on(
        &backend,
        &crate::storage::Scope::local(),
        STAGED_DOMAIN,
        staged_collections,
    )
    .unwrap()
}

fn staged_record(part: ContentPart, path: &str) -> StagedAttachment {
    StagedAttachment {
        tenant: crate::core::runtime::Tenant::default(),
        thread_id: "thread".into(),
        attachment: StoredAttachment {
            part,
            path: path.into(),
        },
        expires_at: chrono::Utc::now().timestamp() + 60,
        claim: None,
    }
}

fn insert_record(repo: &Repo, record: &StagedAttachment) {
    let id = staged_doc_id(
        opaque_media(&record.attachment.part)
            .and_then(|media| media.opaque_id.as_deref())
            .unwrap(),
    )
    .unwrap();
    let body = serde_json::to_value(record).unwrap();
    repo.run(|docs| async move {
        docs.put(STAGED_COLLECTION, &id, body, Precondition::Absent)
            .await?;
        Ok(())
    })
    .unwrap();
}

#[tokio::test]
async fn staged_claim_and_cancellation_have_one_atomic_document_winner() {
    let dir = tempfile::tempdir().unwrap();
    let repo = test_repo(dir.path());
    let part = image(MediaReference {
        opaque_id: Some(uuid::Uuid::new_v4().simple().to_string()),
        ..Default::default()
    });
    let record = staged_record(part.clone(), "media.png");
    insert_record(&repo, &record);
    let id = staged_doc_id(opaque_media(&part).unwrap().opaque_id.as_deref().unwrap()).unwrap();
    let bound = claim("user:req", part.clone(), false);
    let canceled = claim("", part.clone(), true);
    let barrier = std::sync::Arc::new(tokio::sync::Barrier::new(3));
    let claim_task = {
        let barrier = barrier.clone();
        let repo = repo.clone();
        let bound = bound.clone();
        let part = part.clone();
        let id = id.clone();
        tokio::spawn(async move {
            barrier.wait().await;
            claim_staged_record(&repo, &bound.tenant, "thread", &id, &part, &bound)
        })
    };
    let cancel_task = {
        let barrier = barrier.clone();
        let repo = repo.clone();
        let canceled = canceled.clone();
        let part = part.clone();
        let id = id.clone();
        tokio::spawn(async move {
            barrier.wait().await;
            cancel_staged_record(&repo, &canceled.tenant, "thread", &id, &part, &canceled)
        })
    };
    barrier.wait().await;
    let claim_result = claim_task.await.unwrap();
    let cancel_result = cancel_task.await.unwrap();
    assert_ne!(claim_result.is_ok(), cancel_result.is_ok());
    let stored = get_staged_record(&repo, &id).unwrap().unwrap();
    let winner = stored.claim.unwrap();
    if winner.canceled {
        assert!(claim_staged_record(&repo, &bound.tenant, "thread", &id, &part, &bound).is_err());
    } else {
        assert!(
            !cancel_staged_record(&repo, &canceled.tenant, "thread", &id, &part, &canceled)
                .unwrap()
        );
        assert!(!claim_staged_record(&repo, &bound.tenant, "thread", &id, &part, &bound).unwrap());
    }
}

#[tokio::test]
async fn native_attachment_refs_are_bound_to_profile_agent_account_and_turn() {
    use crate::core::runtime::{ContextOverlay, CoreContext, DispatchCtx, DomainSet};

    let temp = tempfile::tempdir().unwrap();
    let workspace = temp.path().join("workspace");
    let config = crate::config::Config {
        workspace_dir: workspace.clone(),
        action_dir: workspace.clone(),
        ..Default::default()
    };
    let make_dispatch = |profile: &str, agent: &str| {
        let root = CoreContext::for_test(DomainSet::none(), Some(workspace.clone()));
        let scoped = root.derive_with(
            ContextOverlay::new(config.clone(), DomainSet::full(), Default::default())
                .profile(profile)
                .session_agent(agent),
        );
        DispatchCtx::new(scoped)
    };
    let alice = make_dispatch("profile-a", "agent-a");
    let other_profile = make_dispatch("profile-b", "agent-a");
    let other_agent = make_dispatch("profile-a", "agent-b");
    let part = image(MediaReference {
        opaque_id: Some(uuid::Uuid::new_v4().simple().to_string()),
        content_type: Some("image/png".into()),
        size_bytes: Some(4),
        ..Default::default()
    });
    let thread = "telegram:account-a:conversation-42";
    let record = StagedAttachment {
        tenant: crate::core::runtime::Tenant {
            profile: Some("profile-a".into()),
            agent: Some("agent-a".into()),
        },
        thread_id: thread.into(),
        attachment: StoredAttachment {
            part: part.clone(),
            path: "media.png".into(),
        },
        expires_at: chrono::Utc::now().timestamp() + 60,
        claim: None,
    };
    let repo = staged_repo(&alice, &workspace).unwrap();
    insert_record(&repo, &record);
    let opaque_id = opaque_media(&part)
        .unwrap()
        .opaque_id
        .as_deref()
        .unwrap()
        .to_owned();

    for dispatch in [&other_profile, &other_agent] {
        assert!(read_authorized_native_attachment(
            dispatch,
            &config,
            thread,
            &opaque_id,
            std::slice::from_ref(&part),
            false,
        )
        .await
        .is_err());
    }
    assert!(
        read_authorized_native_attachment(
            &alice,
            &config,
            "telegram:account-b:conversation-42",
            &opaque_id,
            std::slice::from_ref(&part),
            false,
        )
        .await
        .is_err(),
        "the same conversation under another configured account is isolated"
    );

    let forged_part = match part.clone() {
        ContentPart::Image {
            media, alt_text, ..
        } => ContentPart::Image {
            media,
            caption: Some("forged turn".into()),
            alt_text,
        },
        _ => unreachable!(),
    };
    assert!(
        read_authorized_native_attachment(
            &alice,
            &config,
            thread,
            &opaque_id,
            &[forged_part],
            false,
        )
        .await
        .is_err(),
        "opaque IDs alone do not authorize a modified part"
    );
    assert!(
        read_authorized_native_attachment(&alice, &config, thread, &opaque_id, &[], false)
            .await
            .is_err(),
        "an unclaimed reference from another turn is not authorized"
    );
    assert!(
        read_authorized_native_attachment(&alice, &config, thread, &opaque_id, &[], true)
            .await
            .is_err(),
        "history access still requires a committed host claim"
    );
}

#[tokio::test]
async fn native_staged_file_reader_enforces_limit_and_rejects_symlinks() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("workspace");
    let outside = temp.path().join("outside");
    std::fs::create_dir_all(&root).unwrap();
    std::fs::write(root.join("small.txt"), b"small").unwrap();
    std::fs::write(root.join("large.txt"), b"larger than bound").unwrap();

    assert_eq!(
        super::staged::read_staged_file_bounded(&root.join("small.txt"), &root, 16)
            .await
            .unwrap(),
        b"small"
    );
    assert!(
        super::staged::read_staged_file_bounded(&root.join("large.txt"), &root, 4)
            .await
            .unwrap_err()
            .contains("configured byte limit")
    );

    #[cfg(unix)]
    {
        use std::os::unix::fs::symlink;

        std::fs::write(&outside, b"outside workspace").unwrap();
        symlink(&outside, root.join("swapped.txt")).unwrap();
        assert!(
            super::staged::read_staged_file_bounded(&root.join("swapped.txt"), &root, 128,)
                .await
                .is_err()
        );
    }
}

#[tokio::test]
async fn multipart_claim_failure_keeps_prior_claim_owned_by_retry() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = crate::config::Config::default();
    config.workspace_dir = dir.path().join("workspace");
    config.action_dir = dir.path().join("actions");
    let repo = test_repo(&config.workspace_dir);
    let first_id = uuid::Uuid::new_v4().simple().to_string();
    let second_id = uuid::Uuid::new_v4().simple().to_string();
    let first = image(MediaReference {
        opaque_id: Some(first_id.clone()),
        ..Default::default()
    });
    let second = image(MediaReference {
        opaque_id: Some(second_id.clone()),
        ..Default::default()
    });
    insert_record(&repo, &staged_record(first.clone(), "first.png"));
    insert_record(&repo, &staged_record(second.clone(), "second.png"));
    let second_claim = claim("", second.clone(), true);
    assert!(cancel_staged_record(
        &repo,
        &second_claim.tenant,
        "thread",
        &staged_doc_id(&second_id).unwrap(),
        &second,
        &second_claim,
    )
    .unwrap());
    let entries = vec![
        StoredAttachment {
            part: first.clone(),
            path: "first.png".into(),
        },
        StoredAttachment {
            part: second.clone(),
            path: "second.png".into(),
        },
    ];
    assert!(claim_staged_refs(
        &crate::core::runtime::DispatchCtx::ambient(),
        "thread",
        &config,
        "user:req",
        &entries,
    )
    .await
    .is_err());
    let first_claim = claim("user:req", first.clone(), false);
    assert!(!claim_staged_record(
        &repo,
        &first_claim.tenant,
        "thread",
        &staged_doc_id(&first_id).unwrap(),
        &first,
        &first_claim,
    )
    .unwrap());
    let other = claim("user:other", first.clone(), false);
    assert!(claim_staged_record(
        &repo,
        &other.tenant,
        "thread",
        &staged_doc_id(&first_id).unwrap(),
        &first,
        &other,
    )
    .is_err());
}

#[tokio::test]
async fn discarding_claimed_attachment_preserves_row_owned_file() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = crate::config::Config::default();
    config.workspace_dir = dir.path().join("workspace");
    config.action_dir = dir.path().join("actions");
    let opaque_id = uuid::Uuid::new_v4().simple().to_string();
    let part = image(MediaReference {
        opaque_id: Some(opaque_id.clone()),
        content_type: Some("image/png".into()),
        ..Default::default()
    });
    let repo = test_repo(&config.workspace_dir);
    insert_record(&repo, &staged_record(part.clone(), "committed.png"));
    let bound = claim("user:req", part.clone(), false);
    assert!(claim_staged_record(
        &repo,
        &bound.tenant,
        "thread",
        &staged_doc_id(&opaque_id).unwrap(),
        &part,
        &bound,
    )
    .unwrap());
    let workspace = crate::attachments::thread_action_dir(
        &crate::core::runtime::DispatchCtx::ambient(),
        &config,
        &config.workspace_dir,
        Some("thread"),
    )
    .await
    .unwrap();
    tokio::fs::create_dir_all(&workspace).await.unwrap();
    let file_path = workspace.join("committed.png");
    tokio::fs::write(&file_path, b"row-owned bytes")
        .await
        .unwrap();
    discard_staged_entries(
        &crate::core::runtime::DispatchCtx::ambient(),
        "thread",
        &config,
        vec![StoredAttachment {
            part: part.clone(),
            path: "committed.png".into(),
        }],
    )
    .await
    .unwrap();
    assert_eq!(
        tokio::fs::read(file_path).await.unwrap(),
        b"row-owned bytes"
    );
    let stored = get_staged_record(&repo, &staged_doc_id(&opaque_id).unwrap())
        .unwrap()
        .unwrap();
    assert_eq!(stored.claim, Some(bound));
}

#[path = "attachments_staged_tests.rs"]
mod staged_tests;

#[path = "attachments_native_tests.rs"]
mod native_tests;