Function install_from_dir

atomic-agent/src/integrations/install.rs:96–213

Install an integration package from a local directory (a synced cache clone or a `--from` checkout).

(pkg_dir: &Path, opts: &InstallOptions)

/// Install an integration package from a local directory (a synced cache
/// clone or a `--from` checkout).
pub fn install_from_dir(pkg_dir: &Path, opts: &InstallOptions) -> AgentResult<InstallOutcome> {
    let manifest = IntegrationManifest::load(pkg_dir)?;

    if let Some(expect) = &opts.expect_agent {
        if &manifest.agent != expect {
            return Err(AgentError::Integration {
                agent: expect.clone(),
                reason: format!(
                    "package at {} is for agent '{}'",
                    pkg_dir.display(),
                    manifest.agent
                ),
            });
        }
    }

    manifest.check_cli_version(&opts.cli_version)?;

    let previous = Receipt::load(&manifest.agent)?;

    let mut installed = Vec::new();
    let mut refreshed = Vec::new();
    let mut skipped = Vec::new();
    let mut receipt_files = Vec::new();

    for entry in &manifest.files {
        reject_parent_traversal(&manifest.agent, &entry.src)?;
        let src = pkg_dir.join(&entry.src);
        if !src.is_file() {
            return Err(AgentError::Integration {
                agent: manifest.agent.clone(),
                reason: format!("manifest file source missing: {}", src.display()),
            });
        }
        let dst = expand_dst(&entry.dst)?;

        match install_decision(&dst, previous.as_ref(), opts.force)? {
            Decision::Install => installed.push(dst.clone()),
            Decision::Refresh => refreshed.push(dst.clone()),
            Decision::Skip(reason) => {
                skipped.push(SkippedFile {
                    dst: dst.clone(),
                    reason,
                });
                // Keep protecting this file: preserve any prior receipt entry
                // so a later --force still knows whether it was ours.
                if let Some(old) = previous
                    .as_ref()
                    .and_then(|r| r.files.iter().find(|f| f.dst == dst))
                {
                    receipt_files.push(old.clone());
                }
                continue;
            }
        }

        if let Some(parent) = dst.parent() {
            std::fs::create_dir_all(parent)?;