pointbreak 0.5.0

Durable terminal code review for changes humans and coding agents collaborate on together
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

mod cosignature;
mod enroll;
mod ingest;
mod policy;
#[cfg(test)]
pub(crate) mod test_support;
mod trust;
mod verify;
mod write;

pub use cosignature::{
    COSIGNATURE_BINDING_MISMATCH_CODE, COSIGNATURE_INVALID_CODE, COSIGNATURE_TARGET_PENDING_CODE,
    COSIGNATURE_UNTRUSTED_SIGNER_CODE, CosignatureGateDecision, CosignatureVerification,
    gate_cosignature_for_store, verify_cosignature,
};
pub use enroll::{
    ALLOWED_SIGNERS_REL_PATH, EnrollmentDiff, enroll_signer, stage_enrollment, trust_set_to_value,
};
pub use ingest::IngestEventVerification;
pub(crate) use ingest::verify_events_for_ingest;
pub use policy::{
    ArtifactAvailability, EventVerificationPolicy, EventVerificationView, PrincipalPolicy,
    RemovalPolicy, principal_sufficient, verification_view,
};
pub use trust::{TrustSet, event_signature_trust_set};
pub use verify::verify_event_signature;
pub(crate) use write::sign_event_if_requested;
pub use write::{BestEffortSkipSink, EventSigningOptions};

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::{
        ArtifactAvailability, EventVerificationPolicy, TrustSet, event_signature_trust_set,
        verification_view,
    };
    use crate::crypto::{EventVerificationStatus, SignerId};
    use crate::model::ActorId;

    const FRIENDLY_ACTOR: &str = "actor:git-email:alice@example.com";
    const FRIENDLY_SIGNER: &str = "did:key:z6MkehRgf7yJbgaGfYsdoAsKdBPE3dj2CYhowQdcjqSJgvVd";

    #[test]
    fn status_values_serialize_as_contract_snake_case() {
        assert_eq!(
            serde_json::to_value(EventVerificationStatus::Valid).unwrap(),
            "valid"
        );
        assert_eq!(
            serde_json::to_value(EventVerificationStatus::Invalid).unwrap(),
            "invalid"
        );
        assert_eq!(
            serde_json::to_value(EventVerificationStatus::UntrustedKey).unwrap(),
            "untrusted_key"
        );
        assert_eq!(
            serde_json::to_value(EventVerificationStatus::Unsigned).unwrap(),
            "unsigned"
        );
    }

    #[test]
    fn policy_presets_reject_the_contract_statuses() {
        let advisory = EventVerificationPolicy::advisory();
        assert!(!advisory.rejects(EventVerificationStatus::Valid));
        assert!(!advisory.rejects(EventVerificationStatus::Invalid));
        assert!(!advisory.rejects(EventVerificationStatus::UntrustedKey));
        assert!(!advisory.rejects(EventVerificationStatus::Unsigned));

        let integrity = EventVerificationPolicy::integrity_strict();
        assert!(integrity.rejects(EventVerificationStatus::Invalid));
        assert!(!integrity.rejects(EventVerificationStatus::UntrustedKey));
        assert!(!integrity.rejects(EventVerificationStatus::Unsigned));

        let trusted = EventVerificationPolicy::trusted_strict();
        assert!(trusted.rejects(EventVerificationStatus::Invalid));
        assert!(trusted.rejects(EventVerificationStatus::UntrustedKey));
        assert!(trusted.rejects(EventVerificationStatus::Unsigned));
        assert!(
            !trusted
                .with_allow_unsigned(true)
                .rejects(EventVerificationStatus::Unsigned)
        );
    }

    #[test]
    fn verification_status_is_not_artifact_availability() {
        let view = verification_view(
            EventVerificationStatus::Valid,
            ArtifactAvailability::Unavailable,
        );

        assert_eq!(view.verification_status, EventVerificationStatus::Valid);
        assert_eq!(
            view.artifact_availability,
            ArtifactAvailability::Unavailable
        );
    }

    #[test]
    fn trust_set_authorizes_self_certifying_and_friendly_actors() {
        let trust = event_signature_trust_set(json!({
            "allowedSigners": {
                FRIENDLY_ACTOR: [FRIENDLY_SIGNER]
            }
        }))
        .unwrap();
        let signer = SignerId::parse(FRIENDLY_SIGNER).unwrap();

        assert!(trust.authorizes(
            &ActorId::new(FRIENDLY_SIGNER),
            &signer,
            "2026-06-03T00:00:00Z"
        ));
        assert!(trust.authorizes(
            &ActorId::new(FRIENDLY_ACTOR),
            &signer,
            "2026-06-03T00:00:00Z"
        ));
        assert!(!TrustSet::default().authorizes(
            &ActorId::new(FRIENDLY_ACTOR),
            &signer,
            "2026-06-03T00:00:00Z"
        ));
    }

    #[test]
    fn checked_in_allowed_signers_file_authorizes_friendly_actor() {
        let trust = TrustSet::from_allowed_signers_file(
            std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
                .join("tests/fixtures/event_signatures/.shore/allowed-signers.json"),
        )
        .unwrap();
        let signer = SignerId::parse(FRIENDLY_SIGNER).unwrap();

        assert!(trust.authorizes(
            &ActorId::new(FRIENDLY_ACTOR),
            &signer,
            "2026-06-03T00:00:00Z"
        ));
    }
}