codewhale-tui 0.9.10

Terminal UI for open-source and open-weight coding models
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

//! Runtime adapters for reviewed, content-addressed plugin components.
//!
//! This module is the only place that translates mutable discovery paths into
//! immutable staged component paths. Consumers still revalidate the attached
//! [`PluginAuthority`] at their execution boundary so disable, revoke, and
//! uninstall transitions in another process fail closed immediately.

use std::path::{Path, PathBuf};

use super::PluginRegistry;
use super::activation::PluginActivationCapability;
use super::registry::verify_plugin_component_authority;
use super::types::{LoadedPlugin, PluginAuthority, PluginScope};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PluginComponentSource {
    pub plugin_name: String,
    pub path: PathBuf,
    pub authority: PluginAuthority,
}

fn component_paths(plugin: &LoadedPlugin, capability: PluginActivationCapability) -> &[PathBuf] {
    match capability {
        PluginActivationCapability::Commands => &plugin.components.commands,
        PluginActivationCapability::Agents => &plugin.components.agents,
        PluginActivationCapability::Hooks => &plugin.components.hooks,
        PluginActivationCapability::Skills
        | PluginActivationCapability::McpStdio
        | PluginActivationCapability::McpRemote
        | PluginActivationCapability::Lsp
        | PluginActivationCapability::Native
        | PluginActivationCapability::FilesystemRoots
        | PluginActivationCapability::LifecycleMutation => &[],
    }
}

fn scope_precedence(scope: PluginScope) -> u8 {
    match scope {
        PluginScope::Workspace => 0,
        PluginScope::User => 1,
        PluginScope::Builtin => 2,
    }
}

/// Resolve one active component kind into immutable staged paths.
///
/// Workspace bundles win same-name collisions over user and built-in bundles;
/// consumers retain their existing non-plugin precedence above this list.
pub fn active_component_sources(
    registry: &PluginRegistry,
    capability: PluginActivationCapability,
) -> (Vec<PluginComponentSource>, Vec<String>) {
    let mut plugins = registry
        .active_plugins()
        .into_iter()
        .filter(|plugin| plugin.component_active(capability))
        .collect::<Vec<_>>();
    plugins.sort_by(|left, right| {
        scope_precedence(left.scope)
            .cmp(&scope_precedence(right.scope))
            .then_with(|| left.name().cmp(right.name()))
            .then_with(|| left.id.cmp(&right.id))
    });

    let mut sources = Vec::new();
    let mut errors = Vec::new();
    for plugin in plugins {
        let Some(authority) = registry.authority_for(plugin.id.as_str()) else {
            errors.push(format!(
                "Plugin `{}` has no persisted runtime authority",
                plugin.name()
            ));
            continue;
        };
        if let Err(reason) = verify_plugin_component_authority(&authority, capability) {
            errors.push(format!(
                "Plugin `{}` {} adapter was denied: {reason}",
                plugin.name(),
                capability.as_str()
            ));
            continue;
        }
        let Some(staged_root) = plugin.staged_root.as_deref() else {
            errors.push(format!(
                "Plugin `{}` has no immutable runtime snapshot",
                plugin.name()
            ));
            continue;
        };
        for source_path in component_paths(plugin, capability) {
            match staged_component_path(&plugin.canonical_root, staged_root, source_path) {
                Ok(path) => sources.push(PluginComponentSource {
                    plugin_name: plugin.name().to_string(),
                    path,
                    authority: authority.clone(),
                }),
                Err(reason) => errors.push(format!(
                    "Plugin `{}` {} component was denied: {reason}",
                    plugin.name(),
                    capability.as_str()
                )),
            }
        }
    }
    (sources, errors)
}

fn staged_component_path(
    canonical_root: &Path,
    staged_root: &Path,
    source_path: &Path,
) -> Result<PathBuf, String> {
    let relative = source_path
        .strip_prefix(canonical_root)
        .map_err(|_| "reviewed component escaped the plugin root".to_string())?;
    let staged_root = staged_root
        .canonicalize()
        .map_err(|_| "runtime snapshot is unavailable".to_string())?;
    let candidate = staged_root.join(relative);
    let candidate = candidate
        .canonicalize()
        .map_err(|_| "runtime component is unavailable".to_string())?;
    if !candidate.starts_with(&staged_root) {
        return Err("runtime component escaped the immutable snapshot".to_string());
    }
    Ok(candidate)
}