use serde::{Deserialize, Serialize}; use std::path::Path; /// SQUID has its own import ledger, outside the signed package migration ledger. /// Keep this read-only: a pending base import can contain player data and must not /// be replayed or cleared merely because the normal schema contract passes. pub(crate) fn database_problems(root: &Path, mode: crate::realms::Mode, query: &impl Fn(&str) -> crate::Result) -> crate::Result> { let active = root.join("Core/configs/modules/playerbots.conf"); let config = if active.is_file() { active } else { root.join("Core/configs/modules/playerbots.conf.dist") }; let enabled = if config.is_file() { let conf = crate::config::parser::ConfFile::parse_bytes(&std::fs::read(config)?)?; !matches!(conf.get("AiPlayerbot.Enabled").unwrap_or("1").trim().trim_matches('"').to_ascii_lowercase().as_str(), "0" | "false" | "no" | "off") } else { false }; let mut problems = Vec::new(); for schema in [mode.schema("characters")?, mode.schema("world")?, "acore_playerbots"] { let tables: std::collections::BTreeSet<_> = query(&format!("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA='{schema}';"))?.lines().map(str::to_owned).collect(); if tables.contains("coa_squid_pending") { for pending in query(&format!("SELECT path FROM `{schema}`.coa_squid_pending;"))?.lines().filter(|path| !path.is_empty()) { problems.push(crate::schema_check::Problem { database: schema.into(), table: "coa_squid_pending".into(), column: String::new(), detail: format!("SQUID base import was interrupted: {pending}. File repair and package SQL updates cannot complete this import. Restore a verified database backup from before the import; do not delete the pending record or replay base SQL.") }); } } if enabled && schema == mode.schema("characters")? { for table in ["playerbots_names", "playerbots_guild_names", "playerbots_arena_team_names"] { if !tables.contains(table) { problems.push(crate::schema_check::Problem { database: schema.into(), table: table.into(), column: String::new(), detail: "Required SQUID character table is missing. A normal server start provisions it when no interrupted import is present; an interrupted import requires database recovery first.".into() }); } } } } Ok(problems) } #[derive(Debug, Serialize, PartialEq, Eq)] pub struct Release { pub tag: Option, pub commit: Option, } pub fn imported_repack(root: &Path) -> bool { root.join("CoA-Bots/release.json").is_file() } pub fn release(root: &Path) -> Option { for name in [ "Extras/SquidPlayerbots/release.json", "Core/configs/modules/playerbots.conf.settings.json", "CoA-Bots/release.json", ] { let Ok(bytes) = std::fs::read(root.join(name)) else { continue; }; if bytes.len() > 1024 * 1024 { continue; } let Ok(json) = serde_json::from_slice::(&bytes) else { continue; }; let safe = |key: &str| { json.get(key) .and_then(|value| value.as_str()) .filter(|value| { !value.is_empty() && value.len() <= 80 && value .chars() .all(|c| c.is_ascii_alphanumeric() || "._-".contains(c)) }) .map(str::to_owned) }; let tag = safe("tag").or_else(|| safe("version")); let revision = if name == "CoA-Bots/release.json" { json.get("botsModuleRevision") .and_then(|value| value.as_str()) .and_then(|value| value.split_whitespace().next()) .map(str::to_owned) .or_else(|| safe("commit")) } else if name.ends_with(".settings.json") { None } else { safe("commit") }; let commit = revision.filter(|value| { value.len() >= 7 && value.len() <= 40 && value.chars().all(|c| c.is_ascii_hexdigit()) }); if tag.is_some() || commit.is_some() { return Some(Release { tag, commit }); } } None } #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)] pub struct Field { pub key: String, #[serde(rename = "type")] pub kind: String, pub title: String, pub description: String, #[serde(default)] pub group: String, #[serde(default)] pub group_title: Option, pub default: serde_json::Value, #[serde(default)] pub default_if_missing: Option, pub min: Option, pub max: Option, /// A fixed list of allowed values with their labels (SQUID 1.9+); the editor shows it as a drop-down. #[serde(default, skip_serializing_if = "Vec::is_empty")] pub choices: Vec, } #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)] pub struct Choice { pub value: serde_json::Value, pub label: String, } #[derive(Deserialize)] struct Settings { format: u32, settings: Vec, #[serde(default)] groups: std::collections::BTreeMap, } pub fn fields(root: &Path) -> crate::Result> { let path = root.join("Core/configs/modules/playerbots.conf.settings.json"); if !path.is_file() { return Ok(Default::default()); } let Ok(bytes) = std::fs::read(path) else { return Ok(Default::default()); }; if bytes.len() > 1024 * 1024 { return Ok(Default::default()); } let Ok(settings) = serde_json::from_slice::(&bytes) else { return Ok(Default::default()); }; if settings.format != 1 { return Ok(Default::default()); } let mut fields = std::collections::BTreeMap::new(); for value in settings.settings { let Ok(mut field) = serde_json::from_value::(value) else { continue; }; field.group_title = settings.groups.get(&field.group).cloned(); if !matches!(field.kind.as_str(), "bool" | "int" | "float" | "string") || field.key.len() > 200 || field.key.is_empty() || !field .key .chars() .all(|c| c.is_ascii_alphanumeric() || "._".contains(c)) || field.min.zip(field.max).is_some_and(|(min, max)| min > max) || !default_type(&field.kind, &field.default) || field .default_if_missing .as_ref() .is_some_and(|value| !default_type(&field.kind, value)) || !valid_choices(&field) || fields.contains_key(&field.key) { continue; } fields.insert(field.key.clone(), field); } Ok(fields) } /// A list of choices must be small, labelled, free of repeats and made of values of the field's own type. fn valid_choices(field: &Field) -> bool { field.choices.len() <= 64 && field.choices.iter().all(|c| { !c.label.trim().is_empty() && c.label.len() <= 80 && default_type(&field.kind, &c.value) }) && field.choices.iter().enumerate().all(|(i, c)| { field.choices[..i] .iter() .all(|earlier| scalar(&earlier.value) != scalar(&c.value)) }) } fn default_type(kind: &str, value: &serde_json::Value) -> bool { match kind { "bool" => value.is_boolean(), "int" => value.is_i64() || value.is_u64(), "float" => value.is_number(), "string" => value.is_string(), _ => false, } } pub fn scalar(value: &serde_json::Value) -> Option { match value { serde_json::Value::Bool(value) => Some(if *value { "1" } else { "0" }.into()), serde_json::Value::String(value) => Some(value.clone()), serde_json::Value::Number(value) => Some(value.to_string()), _ => None, } } pub fn validate(field: &Field, value: &str) -> crate::Result<()> { let valid = match field.kind.as_str() { "bool" => matches!(value, "0" | "1"), "int" | "float" => value.parse::().is_ok_and(|number| { number.is_finite() && (field.kind != "int" || number.fract() == 0.0) && field.min.is_none_or(|min| number >= min) && field.max.is_none_or(|max| number <= max) }), "string" => true, _ => false, } && (field.choices.is_empty() || field .choices .iter() .any(|c| scalar(&c.value).as_deref() == Some(value))); if valid { Ok(()) } else { Err(crate::Error::Invalid(format!( "{} must match its documented SquidBots type and range.", field.key ))) } } #[cfg(test)] mod tests { use super::*; #[test] fn database_check_reports_pending_squid_imports_in_each_realm_without_writes() { let root = tempfile::tempdir().unwrap(); for mode in [crate::realms::Mode::Coa, crate::realms::Mode::Wildcard] { let problems = database_problems(root.path(), mode, &|sql| { assert!(sql.starts_with("SELECT ")); if sql.contains("information_schema.TABLES") { Ok("coa_squid_pending".into()) } else { Ok("playerbots/base/ai_playerbot_texts.sql".into()) } }).unwrap(); assert_eq!(problems.len(), 3); assert_eq!(problems[0].database, mode.schema("characters").unwrap()); assert!(problems.iter().all(|p| p.detail.contains("interrupted"))); } } #[test] fn enabled_squid_requires_character_tables_but_disabled_squid_does_not() { let root = tempfile::tempdir().unwrap(); let config = root.path().join("Core/configs/modules/playerbots.conf"); crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 1\n").unwrap(); let query = |_: &str| Ok(String::new()); assert_eq!(database_problems(root.path(), crate::realms::Mode::Wildcard, &query).unwrap().len(), 3); crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 0\n").unwrap(); assert!(database_problems(root.path(), crate::realms::Mode::Wildcard, &query).unwrap().is_empty()); crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 1\n").unwrap(); assert!(database_problems(root.path(), crate::realms::Mode::Coa, &|_| Ok("playerbots_names\nplayerbots_guild_names\nplayerbots_arena_team_names".into())).unwrap().is_empty()); } #[test] fn a_setting_with_choices_only_accepts_one_of_them() { let root = tempfile::tempdir().unwrap(); crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[ {"key":"AiPlayerbot.BotTextLocale","type":"int","group":"chat","title":"Language","description":"x","default":-1,"min":-1,"max":8, "choices":[{"value":-1,"label":"Auto"},{"value":0,"label":"English"},{"value":8,"label":"Russian"}]}, {"key":"AiPlayerbot.Broken","type":"int","group":"chat","title":"b","description":"x","default":0,"choices":[{"value":"a","label":"wrong type"}]}]}"#).unwrap(); let fields = fields(root.path()).unwrap(); let locale = &fields["AiPlayerbot.BotTextLocale"]; assert_eq!(locale.choices.len(), 3); for ok in ["-1", "0", "8"] { assert!(validate(locale, ok).is_ok(), "{ok}"); } for bad in ["1", "7", "x"] { assert!(validate(locale, bad).is_err(), "{bad}"); } assert!( !fields.contains_key("AiPlayerbot.Broken"), "a choice of the wrong type invalidates the setting" ); } #[test] fn upstream_settings_preserve_types_ranges_and_distinct_defaults() { let root = tempfile::tempdir().unwrap(); crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[{"key":"AiPlayerbot.MinRandomBots","type":"int","group":"population","title":"Minimum bots","description":"Lower bound","default":500,"default_if_missing":50,"min":0,"max":5000}]}"#).unwrap(); let fields = fields(root.path()).unwrap(); let field = &fields["AiPlayerbot.MinRandomBots"]; assert_eq!(scalar(&field.default).as_deref(), Some("500")); assert_eq!( scalar(field.default_if_missing.as_ref().unwrap()).as_deref(), Some("50") ); assert!(validate(field, "5000").is_ok()); for value in ["5001", "-1", "0.5", "NaN"] { assert!(validate(field, value).is_err()); } } #[test] fn unsupported_metadata_falls_back_and_bad_entries_do_not_hide_valid_fields() { let root = tempfile::tempdir().unwrap(); let path = root .path() .join("Core/configs/modules/playerbots.conf.settings.json"); for data in [ r#"{"format":99,"settings":[]}"#, "invalid json", r#"{"format":1,"settings":{}}"#, ] { crate::fsx::atomic_write(&path, data.as_bytes()).unwrap(); assert!(fields(root.path()).unwrap().is_empty()); } crate::fsx::atomic_write(&path, br#"{"format":1,"settings":[{"key":"Broken","type":"enum","title":"Broken","description":"Unknown type","default":1},{"key":"Malformed"},{"key":"WrongDefault","type":"int","title":"Wrong","description":"Bad default","default":"oops"},{"key":"Good","type":"bool","title":"Good","description":"Good field","default":true}]}"#).unwrap(); let parsed = fields(root.path()).unwrap(); assert_eq!(parsed.len(), 1); assert!(parsed.contains_key("Good")); } #[test] fn imported_revision_uses_its_first_word_and_empty_tags_are_hidden() { let root = tempfile::tempdir().unwrap(); crate::fsx::atomic_write(&root.path().join("CoA-Bots/release.json"), br#"{"tag":"","botsModuleRevision":"48c4786a 2026-10-01 (coa branch)","commit":"abcdef01"}"#).unwrap(); assert_eq!( release(root.path()).unwrap(), Release { tag: None, commit: Some("48c4786a".into()) } ); crate::fsx::atomic_write( &root .path() .join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"tag":"v1.8.1","commit":"11111111"}"#, ) .unwrap(); assert_eq!( release(root.path()).unwrap(), Release { tag: Some("v1.8.1".into()), commit: None } ); } #[test] fn diagnostics_only_expose_release_identifiers() { let root = tempfile::tempdir().unwrap(); crate::fsx::atomic_write( &root.path().join("CoA-Bots/release.json"), br#"{"tag":"v1.8","commit":"48c4786a","password":"secret"}"#, ) .unwrap(); assert!(imported_repack(root.path())); assert_eq!( release(root.path()).unwrap(), Release { tag: Some("v1.8".into()), commit: Some("48c4786a".into()) } ); } }