ai-agent 0.88.0

Idiomatic agent sdk inspired by the claude code source leak
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

// Source: ~/claudecode/openclaudecode/src/utils/plugins/pluginBlocklist.ts
#![allow(dead_code)]

use super::installed_plugins_manager::load_installed_plugins_v2;
use super::marketplace_manager::{get_marketplace, load_known_marketplaces_config_safe};
use super::plugin_flagging::{add_flagged_plugin, get_flagged_plugins, load_flagged_plugins};

/// Detect plugins installed from a marketplace that are no longer listed there.
pub fn detect_delisted_plugins(
    installed_plugins: &super::installed_plugins_manager::InstalledPluginsFileV2,
    marketplace: &super::types::PluginMarketplace,
    marketplace_name: &str,
) -> Vec<String> {
    let marketplace_plugin_names: std::collections::HashSet<_> = marketplace
        .plugins
        .iter()
        .map(|p| p.name.as_str())
        .collect();

    let suffix = format!("@{}", marketplace_name);
    let mut delisted = Vec::new();

    for plugin_id in installed_plugins.plugins.keys() {
        if !plugin_id.ends_with(&suffix) {
            continue;
        }

        let plugin_name = &plugin_id[..plugin_id.len() - suffix.len()];
        if !marketplace_plugin_names.contains(plugin_name) {
            delisted.push(plugin_id.clone());
        }
    }

    delisted
}

/// Detect delisted plugins across all marketplaces, auto-uninstall them,
/// and record them as flagged.
pub async fn detect_and_uninstall_delisted_plugins()
-> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
    load_flagged_plugins().await?;

    let installed_plugins = load_installed_plugins_v2()?;
    let already_flagged = get_flagged_plugins();
    let known_marketplaces = load_known_marketplaces_config_safe().await?;
    let mut newly_flagged = Vec::new();

    for marketplace_name in known_marketplaces.keys() {
        let marketplace = match get_marketplace(marketplace_name).await {
            Ok(m) => m,
            Err(e) => {
                log::debug!(
                    "Failed to check for delisted plugins in \"{}\": {}",
                    marketplace_name,
                    e
                );
                continue;
            }
        };

        if !marketplace.force_remove_deleted_plugins.unwrap_or(false) {
            continue;
        }

        let delisted = detect_delisted_plugins(&installed_plugins, &marketplace, marketplace_name);

        for plugin_id in delisted {
            if already_flagged.contains_key(&plugin_id) {
                continue;
            }

            let installations = installed_plugins
                .plugins
                .get(&plugin_id)
                .cloned()
                .unwrap_or_default();

            let has_user_install = installations.iter().any(|i| {
                matches!(
                    i.scope,
                    super::schemas::PluginScope::User
                        | super::schemas::PluginScope::Project
                        | super::schemas::PluginScope::Local
                )
            });

            if !has_user_install {
                continue;
            }

            add_flagged_plugin(&plugin_id).await?;
            newly_flagged.push(plugin_id);
        }
    }

    Ok(newly_flagged)
}