forklaunch 1.33.0

Launch faster with forklaunch
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Preserve the scaffold's portable Bun install policy when moving installation.
use std::{fs, path::Path};

use anyhow::{Context, Result};
use toml_edit::{DocumentMut, Item, Table};

use crate::core::application_output::output_path;

pub(super) fn include_packages(
    package: &mut serde_json::Map<String, serde_json::Value>,
    additions: &[String],
    absent_generated_members: &[String],
) -> Result<()> {
    let workspaces = package
        .entry("workspaces")
        .or_insert_with(|| serde_json::json!([]))
        .as_array_mut()
        .context("Bun workspaces must be a list")?;
    // Bun rejects absent literal package members. Only these known optional
    // generated packages may be removed; authored members and globs stay.
    workspaces.retain(|member| {
        !member.as_str().is_some_and(|path| {
            absent_generated_members
                .iter()
                .any(|missing| missing == path)
        })
    });
    for addition in additions {
        if absent_generated_members.contains(addition) {
            continue;
        }
        let value = serde_json::json!(addition);
        if !workspaces.contains(&value) {
            workspaces.push(value);
        }
    }
    Ok(())
}

pub(super) fn install_policy(root: &Path, modules: &Path) -> Result<Option<String>> {
    let source = output_path(root, &modules.join("bunfig.toml"))?;
    if !source.is_file() {
        return Ok(None);
    }
    let source: DocumentMut = fs::read_to_string(source)?.parse()?;
    let Some(install) = source.get("install") else {
        return Ok(None);
    };
    let install = install
        .as_table_like()
        .context("Module Bun install settings must be a table")?;
    // These generated settings are portable. Other Bun options may reference
    // files relative to the modules directory and must not be copied blindly.
    let defaults: Vec<_> = ["minimumReleaseAge", "minimumReleaseAgeExcludes"]
        .into_iter()
        .filter_map(|name| install.get(name).map(|value| (name, value.clone())))
        .collect();
    if defaults.is_empty() {
        return Ok(None);
    }
    let destination = output_path(root, Path::new("bunfig.toml"))?;
    let mut document: DocumentMut = if destination.exists() {
        fs::read_to_string(destination)?.parse()?
    } else {
        DocumentMut::new()
    };
    let root_install = document
        .entry("install")
        .or_insert(Item::Table(Table::new()))
        .as_table_like_mut()
        .context("Root Bun install settings must be a table")?;
    for (name, value) in defaults {
        if !root_install.contains_key(name) {
            root_install.insert(name, value);
        }
    }
    Ok(Some(document.to_string()))
}

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

    #[test]
    fn plans_portable_policy_without_writes_and_preserves_root_overrides() {
        let root = tempfile::tempdir().unwrap();
        fs::create_dir(root.path().join("modules")).unwrap();
        fs::write(root.path().join("modules/bunfig.toml"), "[install]\nminimumReleaseAge = 86400\nminimumReleaseAgeExcludes = ['@forklaunch/core']\ncafile = './module-ca.pem'\n").unwrap();
        let generated = install_policy(root.path(), Path::new("modules"))
            .unwrap()
            .unwrap();
        let policy: toml::Value = toml::from_str(&generated).unwrap();
        assert_eq!(
            policy["install"]["minimumReleaseAge"].as_integer(),
            Some(86400)
        );
        assert!(policy["install"].get("cafile").is_none());
        assert!(!root.path().join("bunfig.toml").exists());
        let original =
            "# application owned\n[install]\nminimumReleaseAge = 172800\n[run]\nshell = 'system'\n";
        fs::write(root.path().join("bunfig.toml"), original).unwrap();
        let merged = install_policy(root.path(), Path::new("modules"))
            .unwrap()
            .unwrap();
        assert!(merged.starts_with("# application owned\n"));
        let policy: toml::Value = toml::from_str(&merged).unwrap();
        assert_eq!(
            policy["install"]["minimumReleaseAge"].as_integer(),
            Some(172800)
        );
        assert_eq!(
            policy["install"]["minimumReleaseAgeExcludes"][0].as_str(),
            Some("@forklaunch/core")
        );
        assert_eq!(policy["run"]["shell"].as_str(), Some("system"));
        assert_eq!(
            fs::read_to_string(root.path().join("bunfig.toml")).unwrap(),
            original
        );
    }

    #[test]
    fn missing_policy_is_optional_and_external_destinations_reject() {
        let root = tempfile::tempdir().unwrap();
        fs::create_dir(root.path().join("modules")).unwrap();
        assert!(
            install_policy(root.path(), Path::new("modules"))
                .unwrap()
                .is_none()
        );
        fs::write(
            root.path().join("modules/bunfig.toml"),
            "[install]\nminimumReleaseAge = 86400\n",
        )
        .unwrap();
        fs::write(root.path().join("bunfig.toml"), "install = false\n").unwrap();
        assert!(install_policy(root.path(), Path::new("modules")).is_err());
        #[cfg(unix)]
        {
            let external = tempfile::NamedTempFile::new().unwrap();
            fs::remove_file(root.path().join("bunfig.toml")).unwrap();
            std::os::unix::fs::symlink(external.path(), root.path().join("bunfig.toml")).unwrap();
            assert!(install_policy(root.path(), Path::new("modules")).is_err());
        }
    }
}