a3s-use-core 0.2.6

Shared typed contracts for A3S Use domains
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use a3s_use_core::{
    PlanScopeKind, PluginManagerApplyPlanInput, PluginManagerInspectInput,
    PluginManagerInstallPlanInput, PluginManagerListInstalledInput, PluginManagerPackageScopeInput,
    PluginManagerSearchInput, PluginManagerUpgradePlanInput, PluginSurfaceKind,
};

#[test]
fn manager_inputs_accept_the_frozen_tool_shapes() {
    let search: PluginManagerSearchInput = serde_json::from_value(serde_json::json!({
        "query": "cognitive",
        "kind": "okf",
        "channel": "stable",
        "cursor": "page:2",
        "limit": 20
    }))
    .unwrap();
    search.validate().unwrap();
    assert_eq!(search.kind, Some(PluginSurfaceKind::Okf));
    assert_eq!(search.page_limit(), 20);

    let inspect: PluginManagerInspectInput = serde_json::from_value(serde_json::json!({
        "packageId": "acme/cognitive",
        "version": "1.2.3",
        "channel": "stable"
    }))
    .unwrap();
    inspect.validate().unwrap();

    let list: PluginManagerListInstalledInput = serde_json::from_value(serde_json::json!({
        "scopeKind": "workspace",
        "scopeId": "workspace:alpha"
    }))
    .unwrap();
    list.validate().unwrap();
    assert_eq!(list.scope().kind, PlanScopeKind::Workspace);
    assert_eq!(list.page_limit(), 50);

    let scoped: PluginManagerPackageScopeInput = serde_json::from_value(serde_json::json!({
        "packageId": "acme/cognitive",
        "scopeKind": "user",
        "scopeId": "user:current"
    }))
    .unwrap();
    scoped.validate().unwrap();

    let install: PluginManagerInstallPlanInput = serde_json::from_value(serde_json::json!({
        "packageId": "acme/cognitive",
        "registryName": "packages",
        "versionRequirement": "^1.2",
        "channel": "stable",
        "surfaces": [
            {"kind": "tool", "id": "run"},
            {"kind": "okf", "id": "knowledge"}
        ],
        "scopeKind": "workspace",
        "scopeId": "workspace:alpha"
    }))
    .unwrap();
    install.validate().unwrap();
    assert_eq!(
        install.canonical_version_requirement().as_deref(),
        Some("^1.2")
    );
    let canonical = install.canonical_surfaces();
    assert_eq!(canonical[0].kind, PluginSurfaceKind::Okf);
    assert_eq!(canonical[1].kind, PluginSurfaceKind::Tool);

    let upgrade: PluginManagerUpgradePlanInput = serde_json::from_value(serde_json::json!({
        "packageId": "acme/cognitive",
        "versionRequirement": ">=1.2, <2",
        "scopeKind": "workspace",
        "scopeId": "workspace:alpha"
    }))
    .unwrap();
    upgrade.validate().unwrap();

    let exact: PluginManagerUpgradePlanInput = serde_json::from_value(serde_json::json!({
        "packageId": "acme/cognitive",
        "versionRequirement": "1.2.3",
        "scopeKind": "workspace",
        "scopeId": "workspace:alpha"
    }))
    .unwrap();
    exact.validate().unwrap();
    assert_eq!(
        exact.canonical_version_requirement().as_deref(),
        Some("1.2.3")
    );

    let apply: PluginManagerApplyPlanInput = serde_json::from_value(serde_json::json!({
        "operationId": "operation:install:01",
        "planDigest": format!("sha256:{}", "a".repeat(64))
    }))
    .unwrap();
    apply.validate().unwrap();
}

#[test]
fn manager_inputs_reject_ambiguous_or_unbounded_authority() {
    let duplicate_surfaces: PluginManagerInstallPlanInput =
        serde_json::from_value(serde_json::json!({
            "packageId": "acme/cognitive",
            "surfaces": [
                {"kind": "tool", "id": "run"},
                {"kind": "tool", "id": "run"}
            ],
            "scopeKind": "user",
            "scopeId": "user:current"
        }))
        .unwrap();
    assert_eq!(
        duplicate_surfaces.validate().unwrap_err().code,
        "use.plugin.manager_input_invalid"
    );

    let invalid_requirement: PluginManagerUpgradePlanInput =
        serde_json::from_value(serde_json::json!({
            "packageId": "acme/cognitive",
            "versionRequirement": "latest",
            "scopeKind": "user",
            "scopeId": "user:current"
        }))
        .unwrap();
    assert_eq!(
        invalid_requirement.validate().unwrap_err().code,
        "use.plugin.manager_input_invalid"
    );

    let empty_surfaces: PluginManagerInstallPlanInput = serde_json::from_value(serde_json::json!({
        "packageId": "acme/cognitive",
        "surfaces": [],
        "scopeKind": "user",
        "scopeId": "user:current"
    }))
    .unwrap();
    assert_eq!(
        empty_surfaces.validate().unwrap_err().code,
        "use.plugin.manager_input_invalid"
    );

    assert!(
        serde_json::from_value::<PluginManagerPackageScopeInput>(serde_json::json!({
            "packageId": "acme/cognitive",
            "scopeKind": "user",
            "scopeId": "user:current",
            "path": "/tmp/escape"
        }))
        .is_err()
    );

    let invalid_apply: PluginManagerApplyPlanInput = serde_json::from_value(serde_json::json!({
        "operationId": "../escape",
        "planDigest": format!("sha256:{}", "a".repeat(64))
    }))
    .unwrap();
    assert_eq!(
        invalid_apply.validate().unwrap_err().code,
        "use.plugin.manager_input_invalid"
    );
}