Extensions system

crates/flowstate-extension/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "flowstate-extension"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+bytes = "1.12.1"
+hex = "0.4.3"
+parking_lot = "0.12.5"
+serde = { workspace = true, features = ["derive"] }
+sha2 = "0.11.0"
+thiserror = "2.0.18"
+toml.workspace = true
+wasmtime = { version = "38", features = ["component-model", "cranelift", "runtime"] }
+wasmtime-wasi = "38"
+wasmtime-wasi-http = "38"
+
+[lints]
+workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true

crates/flowstate-extension/src/discovery.rs

@@ -0,0 +1,56 @@
+use std::collections::HashSet;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use crate::ExtensionManifest;
+
+#[derive(Clone, Debug)]
+pub struct InstalledExtension {
+    pub manifest: ExtensionManifest,
+    pub root: PathBuf,
+    pub component_path: PathBuf,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DiscoveryIssue {
+    pub path: PathBuf,
+    pub message: String,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct DiscoveryResult {
+    pub extensions: Vec<InstalledExtension>,
+    pub issues: Vec<DiscoveryIssue>,
+}
+
+pub fn discover_extensions(root: &Path) -> DiscoveryResult {
+    let mut result = DiscoveryResult::default();
+    let Ok(entries) = fs::read_dir(root) else { return result };
+    let mut manifests: Vec<_> = entries.flatten().map(|entry| entry.path().join("extension.toml")).filter(|path| path.is_file()).collect();
+    manifests.sort();
+    let mut ids = HashSet::new();
+    for path in manifests {
+        match load_extension(&path) {
+            Ok(extension) if ids.insert(extension.manifest.id.clone()) => result.extensions.push(extension),
+            Ok(extension) => result.issues.push(DiscoveryIssue { path, message: format!("duplicate extension id: {}", extension.manifest.id) }),
+            Err(message) => result.issues.push(DiscoveryIssue { path, message }),
+        }
+    }
+    result
+}
+
+fn load_extension(path: &Path) -> Result<InstalledExtension, String> {
+    let source = fs::read_to_string(path).map_err(|error| error.to_string())?;
+    let manifest = ExtensionManifest::parse(&source).map_err(|error| error.to_string())?;
+    let root = path.parent().ok_or("manifest has no parent directory")?.to_path_buf();
+    let component_path = root.join(&manifest.component);
+    if !component_path.is_file() {
+        return Err(format!("component does not exist: {}", component_path.display()));
+    }
+    let canonical_root = root.canonicalize().map_err(|error| error.to_string())?;
+    let canonical_component = component_path.canonicalize().map_err(|error| error.to_string())?;
+    if !canonical_component.starts_with(&canonical_root) {
+        return Err("component resolves outside the extension directory".to_owned());
+    }
+    Ok(InstalledExtension { manifest, root, component_path: canonical_component })
+}

crates/flowstate-extension/src/lib.rs

@@ -0,0 +1,9 @@
+mod discovery;
+mod manifest;
+mod runtime;
+mod trust;
+
+pub use discovery::{DiscoveryIssue, DiscoveryResult, InstalledExtension, discover_extensions};
+pub use manifest::{ActionManifest, ExtensionManifest, ManifestError};
+pub use runtime::{CancellationHandle, DirectoryAccess, DirectoryGrant, DirectoryGrantResponse, ExtensionHost, HostError, Invocation, InvocationOutput, Runtime, RuntimeConfig, RuntimeError};
+pub use trust::{ComponentDigest, TrustDecision, TrustStore};

crates/flowstate-extension/src/manifest.rs

@@ -0,0 +1,86 @@
+use std::collections::HashSet;
+use std::path::{Component, Path};
+
+use serde::Deserialize;
+use thiserror::Error;
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct ExtensionManifest {
+    pub manifest_version: u32,
+    pub id: String,
+    pub name: String,
+    pub version: String,
+    pub component: String,
+    #[serde(default)]
+    pub actions: Vec<ActionManifest>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct ActionManifest {
+    pub id: String,
+    pub label: String,
+    #[serde(default)]
+    pub requires_document: bool,
+}
+
+#[derive(Debug, Error, Eq, PartialEq)]
+pub enum ManifestError {
+    #[error("manifest TOML is invalid: {0}")]
+    Toml(String),
+    #[error("unsupported manifest version {0}")]
+    UnsupportedVersion(u32),
+    #[error("{field} must be a dot-separated identifier")]
+    InvalidId { field: &'static str },
+    #[error("{field} must not be empty")]
+    Empty { field: &'static str },
+    #[error("component must be a relative path without parent traversal")]
+    InvalidComponentPath,
+    #[error("duplicate action id: {0}")]
+    DuplicateAction(String),
+    #[error("at least one action is required")]
+    NoActions,
+}
+
+impl ExtensionManifest {
+    pub fn parse(source: &str) -> Result<Self, ManifestError> {
+        let manifest: Self = toml::from_str(source).map_err(|error| ManifestError::Toml(error.to_string()))?;
+        manifest.validate()?;
+        Ok(manifest)
+    }
+
+    pub fn validate(&self) -> Result<(), ManifestError> {
+        if self.manifest_version != 1 {
+            return Err(ManifestError::UnsupportedVersion(self.manifest_version));
+        }
+        validate_id(&self.id, "id")?;
+        require_text(&self.name, "name")?;
+        require_text(&self.version, "version")?;
+        let path = Path::new(&self.component);
+        if path.is_absolute() || path.as_os_str().is_empty() || path.components().any(|part| matches!(part, Component::ParentDir | Component::RootDir | Component::Prefix(_))) {
+            return Err(ManifestError::InvalidComponentPath);
+        }
+        if self.actions.is_empty() {
+            return Err(ManifestError::NoActions);
+        }
+        let mut ids = HashSet::new();
+        for action in &self.actions {
+            validate_id(&action.id, "action id")?;
+            require_text(&action.label, "action label")?;
+            if !ids.insert(&action.id) {
+                return Err(ManifestError::DuplicateAction(action.id.clone()));
+            }
+        }
+        Ok(())
+    }
+}
+
+fn require_text(value: &str, field: &'static str) -> Result<(), ManifestError> {
+    if value.trim().is_empty() { Err(ManifestError::Empty { field }) } else { Ok(()) }
+}
+
+fn validate_id(value: &str, field: &'static str) -> Result<(), ManifestError> {
+    let valid = !value.is_empty() && value.split('.').all(|part| !part.is_empty() && part.bytes().all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_')));
+    if valid { Ok(()) } else { Err(ManifestError::InvalidId { field }) }
+}