yosh_plugin_manager/

install.rs

use std::path::Path;

use toml_edit::{DocumentMut, Item, Table, value};

use crate::config::{self, PluginSource};
use crate::github::GitHubClient;

#[derive(Debug)]
pub struct InstallTarget {
    pub name: String,
    pub source: PluginSource,
    pub version: Option<String>,
}

const GITHUB_PREFIX: &str = "https://github.com/";

fn source_string(source: &PluginSource) -> String {
    match source {
        PluginSource::GitHub { owner, repo } => format!("github:{}/{}", owner, repo),
        PluginSource::Local { path } => format!("local:{}", path),
    }
}

pub fn write_plugin_entry(
    config_path: &Path,
    target: &InstallTarget,
    force: bool,
) -> Result<(), String> {
    let content = std::fs::read_to_string(config_path).unwrap_or_default();

    let mut doc: DocumentMut = content
        .parse()
        .map_err(|e| format!("failed to parse {}: {}", config_path.display(), e))?;

    // Ensure [[plugin]] array of tables exists
    if !doc.contains_key("plugin") {
        doc["plugin"] = Item::ArrayOfTables(toml_edit::ArrayOfTables::new());
    }

    let plugins = doc["plugin"]
        .as_array_of_tables_mut()
        .ok_or_else(|| "config 'plugin' key is not an array of tables".to_string())?;

    // Check for duplicates
    let existing_idx = plugins
        .iter()
        .position(|t| t.get("name").and_then(|v| v.as_str()) == Some(&target.name));

    if let Some(idx) = existing_idx {
        if !force {
            return Err(format!(
                "plugin '{}' is already installed. Use --force to overwrite.",
                target.name
            ));
        }
        plugins.remove(idx);
    }

    // Build new entry
    let mut entry = Table::new();
    entry.insert("name", value(&target.name));
    entry.insert("source", value(source_string(&target.source)));
    if let Some(ver) = &target.version {
        entry.insert("version", value(ver.as_str()));
    }
    entry.insert("enabled", value(true));

    plugins.push(entry);

    std::fs::write(config_path, doc.to_string())
        .map_err(|e| format!("failed to write {}: {}", config_path.display(), e))?;

    Ok(())
}

pub fn parse_install_arg(arg: &str) -> Result<InstallTarget, String> {
    if let Some(rest) = arg.strip_prefix(GITHUB_PREFIX) {
        parse_github(rest)
    } else if arg.starts_with('/')
        || arg.starts_with("./")
        || arg.starts_with("../")
        || arg.starts_with("~/")
    {
        parse_local(arg)
    } else {
        Err(format!(
            "unrecognized install argument '{}': expected a GitHub URL (https://github.com/owner/repo) or a local path",
            arg
        ))
    }
}

/// Parse the portion of a GitHub URL after `https://github.com/`.
fn parse_github(rest: &str) -> Result<InstallTarget, String> {
    // Split off version at `@` — but only after the github.com/ prefix has been stripped.
    let (url_part, version) = if let Some(at_pos) = rest.find('@') {
        let v = rest[at_pos + 1..].to_string();
        if v.is_empty() {
            return Err(format!(
                "empty version after '@' in 'https://github.com/{}'",
                rest
            ));
        }
        (&rest[..at_pos], Some(v))
    } else {
        (rest, None)
    };

    // Strip trailing `/` and `.git` suffix.
    let url_part = url_part.trim_end_matches('/');
    let url_part = url_part.strip_suffix(".git").unwrap_or(url_part);
    // Strip again in case there was a trailing slash before `.git`
    let url_part = url_part.trim_end_matches('/');

    // Split into owner/repo — exactly two non-empty segments, no extra path components.
    let parts: Vec<&str> = url_part.splitn(3, '/').collect();
    if parts.len() < 2 || parts[0].is_empty() || parts[1].is_empty() {
        return Err(format!(
            "invalid GitHub URL 'https://github.com/{}': expected 'https://github.com/owner/repo'",
            url_part
        ));
    }
    if parts.len() > 2 {
        return Err(format!(
            "invalid GitHub URL 'https://github.com/{}': unexpected path after repo name",
            url_part
        ));
    }
    let owner = parts[0].to_string();
    let repo = parts[1].to_string();
    let name = repo.clone();

    Ok(InstallTarget {
        name,
        source: PluginSource::GitHub { owner, repo },
        version,
    })
}

/// Parse a local filesystem path (absolute or relative).
///
/// v0.2.0+ requires `.wasm` Component Model plugins; we reject any other
/// extension at install time so the user sees the migration error
/// immediately rather than at sync time.
fn parse_local(arg: &str) -> Result<InstallTarget, String> {
    // `Path::canonicalize` doesn't expand `~`, so `yosh-plugin install
    // ~/my-plugin.wasm` would otherwise fail with ENOENT. Pre-expand
    // tildes via the same helper sync/lockfile uses.
    let expanded = config::expand_tilde_path(arg);
    let path = expanded.as_path();
    let canonical = path
        .canonicalize()
        .map_err(|e| format!("cannot resolve local path '{}': {}", arg, e))?;

    // Require `.wasm` for local plugin installs. Directories are allowed
    // (the file_stem-based fallback below handled them historically) so
    // we only enforce the extension when one is present.
    if canonical.is_file() {
        let valid_ext = canonical
            .extension()
            .and_then(|e| e.to_str())
            .map(|e| e.eq_ignore_ascii_case("wasm"))
            .unwrap_or(false);
        if !valid_ext {
            return Err(format!(
                "{}: not a .wasm file (yosh v0.2.0 requires WebAssembly Component plugins)",
                canonical.display()
            ));
        }
    }

    let name = canonical
        .file_stem()
        .and_then(|s| s.to_str())
        .ok_or_else(|| {
            format!(
                "cannot determine plugin name from path '{}'",
                canonical.display()
            )
        })?
        .to_string();

    let path_str = canonical
        .to_str()
        .ok_or_else(|| {
            format!(
                "path '{}' contains non-UTF-8 characters",
                canonical.display()
            )
        })?
        .to_string();

    Ok(InstallTarget {
        name,
        source: PluginSource::Local { path: path_str },
        version: None,
    })
}

/// Main install entry point.
/// `github_client` is optional — if None and a GitHub latest version is needed, a default client is created.
pub fn install(
    arg: &str,
    force: bool,
    config_path: &Path,
    github_client: Option<&GitHubClient>,
) -> Result<String, String> {
    let mut target = parse_install_arg(arg)?;

    // Resolve latest version for GitHub sources when not specified
    if matches!(&target.source, PluginSource::GitHub { .. }) && target.version.is_none() {
        let default_client;
        let client = match github_client {
            Some(c) => c,
            None => {
                default_client = GitHubClient::new();
                &default_client
            }
        };
        if let PluginSource::GitHub { owner, repo } = &target.source {
            let version = client.latest_version(owner, repo)?;
            target.version = Some(version);
        }
    }

    // Ensure config file exists
    if !config_path.exists() {
        if let Some(parent) = config_path.parent() {
            std::fs::create_dir_all(parent)
                .map_err(|e| format!("failed to create {}: {}", parent.display(), e))?;
        }
        std::fs::write(config_path, "")
            .map_err(|e| format!("failed to create {}: {}", config_path.display(), e))?;
    }

    write_plugin_entry(config_path, &target, force)?;

    // Build result message
    let source_str = source_string(&target.source);
    let msg = match &target.version {
        Some(v) => format!("Installed plugin '{}' ({}@{})", target.name, source_str, v),
        None => format!("Installed plugin '{}' ({})", target.name, source_str),
    };

    Ok(msg)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn write_github_entry_to_empty_file() {
        let f = tempfile::NamedTempFile::new().unwrap();
        std::fs::write(f.path(), "").unwrap();
        let target = InstallTarget {
            name: "foo".into(),
            source: PluginSource::GitHub {
                owner: "example".into(),
                repo: "foo".into(),
            },
            version: Some("1.0.0".into()),
        };
        write_plugin_entry(f.path(), &target, false).unwrap();
        let content = std::fs::read_to_string(f.path()).unwrap();
        assert!(content.contains("name = \"foo\""));
        assert!(content.contains("source = \"github:example/foo\""));
        assert!(content.contains("version = \"1.0.0\""));
        assert!(content.contains("enabled = true"));
    }

    #[test]
    fn write_local_entry_appends() {
        let f = tempfile::NamedTempFile::new().unwrap();
        std::fs::write(
            f.path(),
            "[[plugin]]\nname = \"existing\"\nsource = \"local:/tmp/lib.dylib\"\nenabled = true\n",
        )
        .unwrap();
        let target = InstallTarget {
            name: "new-plugin".into(),
            source: PluginSource::Local {
                path: "/usr/lib/new.dylib".into(),
            },
            version: None,
        };
        write_plugin_entry(f.path(), &target, false).unwrap();
        let content = std::fs::read_to_string(f.path()).unwrap();
        assert!(content.contains("name = \"existing\""));
        assert!(content.contains("name = \"new-plugin\""));
        assert!(content.contains("source = \"local:/usr/lib/new.dylib\""));
        assert!(!content.contains("version"));
    }

    #[test]
    fn write_duplicate_without_force_errors() {
        let f = tempfile::NamedTempFile::new().unwrap();
        std::fs::write(
            f.path(),
            "[[plugin]]\nname = \"foo\"\nsource = \"local:/tmp/lib.dylib\"\nenabled = true\n",
        )
        .unwrap();
        let target = InstallTarget {
            name: "foo".into(),
            source: PluginSource::Local {
                path: "/tmp/new.dylib".into(),
            },
            version: None,
        };
        let result = write_plugin_entry(f.path(), &target, false);
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("already installed"));
    }

    #[test]
    fn write_duplicate_with_force_replaces() {
        let f = tempfile::NamedTempFile::new().unwrap();
        std::fs::write(
            f.path(),
            "[[plugin]]\nname = \"foo\"\nsource = \"local:/tmp/old.dylib\"\nenabled = true\n",
        )
        .unwrap();
        let target = InstallTarget {
            name: "foo".into(),
            source: PluginSource::GitHub {
                owner: "example".into(),
                repo: "foo".into(),
            },
            version: Some("2.0.0".into()),
        };
        write_plugin_entry(f.path(), &target, true).unwrap();
        let content = std::fs::read_to_string(f.path()).unwrap();
        assert!(!content.contains("local:/tmp/old.dylib"));
        assert!(content.contains("github:example/foo"));
        assert!(content.contains("version = \"2.0.0\""));
    }

    #[test]
    fn write_preserves_comments() {
        let f = tempfile::NamedTempFile::new().unwrap();
        std::fs::write(
            f.path(),
            "# My plugins config\n\n[[plugin]]\nname = \"bar\"\nsource = \"local:/tmp/bar.dylib\"\nenabled = true\n",
        )
        .unwrap();
        let target = InstallTarget {
            name: "baz".into(),
            source: PluginSource::Local {
                path: "/tmp/baz.dylib".into(),
            },
            version: None,
        };
        write_plugin_entry(f.path(), &target, false).unwrap();
        let content = std::fs::read_to_string(f.path()).unwrap();
        assert!(content.contains("# My plugins config"));
        assert!(content.contains("name = \"bar\""));
        assert!(content.contains("name = \"baz\""));
    }

    #[test]
    fn parse_github_url_no_version() {
        let t = parse_install_arg("https://github.com/example/yosh-plugin-foo").unwrap();
        assert_eq!(t.name, "yosh-plugin-foo");
        assert_eq!(
            t.source,
            PluginSource::GitHub {
                owner: "example".into(),
                repo: "yosh-plugin-foo".into()
            }
        );
        assert_eq!(t.version, None);
    }

    #[test]
    fn parse_github_url_with_version() {
        let t = parse_install_arg("https://github.com/example/plugin@1.0.0").unwrap();
        assert_eq!(t.name, "plugin");
        assert_eq!(
            t.source,
            PluginSource::GitHub {
                owner: "example".into(),
                repo: "plugin".into()
            }
        );
        assert_eq!(t.version, Some("1.0.0".into()));
    }

    #[test]
    fn parse_github_url_trailing_slash_stripped() {
        let t = parse_install_arg("https://github.com/owner/repo/").unwrap();
        assert_eq!(t.name, "repo");
        assert_eq!(
            t.source,
            PluginSource::GitHub {
                owner: "owner".into(),
                repo: "repo".into()
            }
        );
    }

    #[test]
    fn parse_github_url_with_dot_git_suffix() {
        let t = parse_install_arg("https://github.com/owner/repo.git").unwrap();
        assert_eq!(t.name, "repo");
        assert_eq!(
            t.source,
            PluginSource::GitHub {
                owner: "owner".into(),
                repo: "repo".into()
            }
        );
    }

    #[test]
    fn parse_github_invalid_url_missing_repo() {
        let result = parse_install_arg("https://github.com/owneronly");
        assert!(result.is_err());
    }

    #[test]
    fn parse_github_invalid_url_empty_repo() {
        let result = parse_install_arg("https://github.com/owner/");
        assert!(result.is_err());
    }

    #[test]
    fn parse_github_empty_version_error() {
        let result = parse_install_arg("https://github.com/owner/repo@");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("empty version"));
    }

    #[test]
    fn parse_github_extra_path_segments_error() {
        let result = parse_install_arg("https://github.com/owner/repo/tree/main");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("unexpected path"));
    }

    #[test]
    fn parse_local_absolute_path() {
        let t = parse_install_arg("/tmp").unwrap();
        assert_eq!(t.name, "tmp");
        assert!(matches!(t.source, PluginSource::Local { .. }));
        assert_eq!(t.version, None);
    }

    #[test]
    fn parse_local_nonexistent_path_error() {
        let result = parse_install_arg("/nonexistent/path/to/lib.dylib");
        assert!(result.is_err());
    }

    /// `~` in a local install path is expanded via $HOME so users can
    /// run `yosh-plugin install ~/my-plugin.wasm` without first
    /// resolving the tilde themselves. Before this fix `canonicalize`
    /// took the literal `~/...` string and failed with ENOENT.
    #[test]
    fn parse_local_path_with_tilde_is_expanded() {
        let dir = tempfile::tempdir().unwrap();
        // Stage a .wasm under tmp_dir so canonicalize succeeds after expansion.
        let plugin = dir.path().join("tilde_test_plugin.wasm");
        std::fs::write(&plugin, b"\0asm\x01\0\0\0").unwrap();
        // Build a tilde path by overriding HOME for the duration of this
        // call. The helper's `~/...` strip-prefix logic + HOME concat then
        // resolves to `dir.path()/tilde_test_plugin.wasm`.
        let prev_home = std::env::var_os("HOME");
        // SAFETY: this test holds no other threads' references to HOME.
        unsafe {
            std::env::set_var("HOME", dir.path());
        }
        let result = parse_install_arg("~/tilde_test_plugin.wasm");
        if let Some(h) = prev_home {
            unsafe {
                std::env::set_var("HOME", h);
            }
        } else {
            unsafe {
                std::env::remove_var("HOME");
            }
        }
        let t = result.expect("tilde-prefixed local path should parse");
        assert_eq!(t.name, "tilde_test_plugin");
        assert!(matches!(t.source, PluginSource::Local { .. }));
    }

    #[test]
    fn install_github_with_explicit_version() {
        let dir = tempfile::tempdir().unwrap();
        let config_path = dir.path().join("plugins.toml");
        std::fs::write(&config_path, "").unwrap();

        install(
            "https://github.com/example/my-plugin@1.0.0",
            false,
            &config_path,
            None, // skip GitHub API when version is explicit
        )
        .unwrap();

        let content = std::fs::read_to_string(&config_path).unwrap();
        assert!(content.contains("name = \"my-plugin\""));
        assert!(content.contains("source = \"github:example/my-plugin\""));
        assert!(content.contains("version = \"1.0.0\""));
        assert!(content.contains("enabled = true"));
    }

    #[test]
    fn install_local_path() {
        let dir = tempfile::tempdir().unwrap();
        let config_path = dir.path().join("plugins.toml");
        std::fs::write(&config_path, "").unwrap();

        // Create a temp file to act as the local plugin binary.
        // v0.2.0+ requires `.wasm` component plugins.
        let lib_file = dir.path().join("test.wasm");
        std::fs::write(&lib_file, b"fake").unwrap();
        let lib_path = lib_file.to_string_lossy().to_string();
        // canonicalize resolves symlinks (e.g. /var -> /private/var on macOS)
        let canonical_lib_path = lib_file
            .canonicalize()
            .unwrap()
            .to_string_lossy()
            .to_string();

        install(&lib_path, false, &config_path, None).unwrap();

        let content = std::fs::read_to_string(&config_path).unwrap();
        assert!(content.contains("name = \"test\""));
        assert!(content.contains(&format!("source = \"local:{}\"", canonical_lib_path)));
        assert!(!content.contains("version"));
    }

    #[test]
    fn install_rejects_non_wasm_local_file() {
        let dir = tempfile::tempdir().unwrap();
        let config_path = dir.path().join("plugins.toml");
        std::fs::write(&config_path, "").unwrap();

        let lib_file = dir.path().join("libtest.dylib");
        std::fs::write(&lib_file, b"fake").unwrap();
        let lib_path = lib_file.to_string_lossy().to_string();

        let err = install(&lib_path, false, &config_path, None).unwrap_err();
        assert!(
            err.contains("not a .wasm file") || err.contains("v0.2.0"),
            "expected wasm-only error, got: {}",
            err
        );
    }

    #[test]
    fn install_duplicate_without_force() {
        let dir = tempfile::tempdir().unwrap();
        let config_path = dir.path().join("plugins.toml");
        std::fs::write(
            &config_path,
            "[[plugin]]\nname = \"my-plugin\"\nsource = \"local:/tmp/x.dylib\"\nenabled = true\n",
        )
        .unwrap();

        let result = install(
            "https://github.com/example/my-plugin@1.0.0",
            false,
            &config_path,
            None,
        );
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("already installed"));
    }

    #[test]
    fn install_duplicate_with_force() {
        let dir = tempfile::tempdir().unwrap();
        let config_path = dir.path().join("plugins.toml");
        std::fs::write(
            &config_path,
            "[[plugin]]\nname = \"my-plugin\"\nsource = \"local:/tmp/old.dylib\"\nenabled = true\n",
        )
        .unwrap();

        install(
            "https://github.com/example/my-plugin@2.0.0",
            true,
            &config_path,
            None,
        )
        .unwrap();

        let content = std::fs::read_to_string(&config_path).unwrap();
        assert!(!content.contains("local:/tmp/old.dylib"));
        assert!(content.contains("github:example/my-plugin"));
        assert!(content.contains("version = \"2.0.0\""));
    }
}