235 lines
8.4 KiB
Rust
235 lines
8.4 KiB
Rust
//! Preference schemas contain portable values only; no paths, permissions, providers or secrets.
|
|
use crate::workspace::{HostError, Result};
|
|
use serde::Deserialize;
|
|
use serde_json::Value;
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct DialoguePair {
|
|
user: String,
|
|
assistant: String,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct Persona {
|
|
version: u64,
|
|
name: String,
|
|
system_prompt: String,
|
|
dialogue_pairs: Vec<DialoguePair>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
struct Layout {
|
|
primary_expanded: bool,
|
|
workspace_width: f64,
|
|
chat_width: f64,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
struct Level {
|
|
size: f64,
|
|
weight: u16,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
struct Headings {
|
|
custom: bool,
|
|
family: String,
|
|
levels: Vec<Level>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
struct Theme {
|
|
theme_id: String,
|
|
font_editor_size: f64,
|
|
font_editor_family: String,
|
|
line_height: f64,
|
|
code_block_theme: String,
|
|
headings: Headings,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
struct Markdown {
|
|
heading: String,
|
|
bullet: String,
|
|
increment_list: bool,
|
|
fence: String,
|
|
math: bool,
|
|
callouts: bool,
|
|
diagrams: bool,
|
|
auto_links: bool,
|
|
line_numbers: bool,
|
|
wrap_code: bool,
|
|
indent: u8,
|
|
default_language: String,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
struct Preset {
|
|
name: String,
|
|
preferences: Markdown,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
struct Preferences {
|
|
restore_last_vault: bool,
|
|
auto_save_interval: u32,
|
|
language: String,
|
|
default_editor_mode: String,
|
|
editor_line_width: u16,
|
|
spell_check: bool,
|
|
markdown: Markdown,
|
|
presets: Vec<Preset>,
|
|
}
|
|
fn decode<T: serde::de::DeserializeOwned>(value: &Value) -> Result<T> {
|
|
serde_json::from_value(value.clone()).map_err(|_| HostError::new("RECORD_SCHEMA_INVALID"))
|
|
}
|
|
fn markdown(value: &Markdown) -> bool {
|
|
let _ = (
|
|
value.increment_list,
|
|
value.math,
|
|
value.callouts,
|
|
value.diagrams,
|
|
value.auto_links,
|
|
value.line_numbers,
|
|
value.wrap_code,
|
|
);
|
|
matches!(value.heading.as_str(), "atx" | "setext")
|
|
&& matches!(value.bullet.as_str(), "-" | "*" | "+")
|
|
&& matches!(value.fence.as_str(), "`" | "~")
|
|
&& [2, 4, 8].contains(&value.indent)
|
|
&& value.default_language.len() <= 40
|
|
&& value
|
|
.default_language
|
|
.bytes()
|
|
.all(|b| b.is_ascii_alphanumeric() || b"_+-".contains(&b))
|
|
}
|
|
pub fn validate(kind: &str, value: &Value) -> Result<()> {
|
|
let valid = match kind {
|
|
"persona" => {
|
|
let value: Persona = decode(value)?;
|
|
value.version <= 9007199254740991
|
|
&& value.name.chars().count() <= 128
|
|
&& value.system_prompt.chars().count() <= 16000
|
|
&& value.dialogue_pairs.len() <= 20
|
|
&& value.dialogue_pairs.iter().all(|pair| {
|
|
pair.user.chars().count() <= 8000 && pair.assistant.chars().count() <= 8000
|
|
})
|
|
}
|
|
"layout" => {
|
|
let value: Layout = decode(value)?;
|
|
let _ = value.primary_expanded;
|
|
(200.0..=520.0).contains(&value.workspace_width)
|
|
&& (200.0..=520.0).contains(&value.chat_width)
|
|
}
|
|
"theme_settings" => {
|
|
let value: Theme = decode(value)?;
|
|
let _ = value.headings.custom;
|
|
!value.theme_id.is_empty()
|
|
&& value.theme_id.len() <= 128
|
|
&& value
|
|
.theme_id
|
|
.bytes()
|
|
.all(|b| b.is_ascii_alphanumeric() || b"._-".contains(&b))
|
|
&& (6.0..=72.0).contains(&value.font_editor_size)
|
|
&& (1.0..=3.0).contains(&value.line_height)
|
|
&& !value.font_editor_family.is_empty()
|
|
&& value.font_editor_family.len() <= 256
|
|
&& !value
|
|
.font_editor_family
|
|
.chars()
|
|
.any(|v| v.is_control() || ";{}\\".contains(v))
|
|
&& matches!(
|
|
value.code_block_theme.as_str(),
|
|
"auto" | "github-light" | "github-dark"
|
|
)
|
|
&& matches!(
|
|
value.headings.family.as_str(),
|
|
"inherit" | "serif" | "sans-serif" | "monospace"
|
|
)
|
|
&& value.headings.levels.len() == 6
|
|
&& value.headings.levels.iter().all(|level| {
|
|
(12.0..=72.0).contains(&level.size)
|
|
&& [400, 500, 600, 700, 800].contains(&level.weight)
|
|
})
|
|
}
|
|
"preferences" => {
|
|
let value: Preferences = decode(value)?;
|
|
let _ = (value.restore_last_vault, value.spell_check);
|
|
(50..=60000).contains(&value.auto_save_interval)
|
|
&& matches!(value.language.as_str(), "zh-CN" | "en")
|
|
&& matches!(value.default_editor_mode.as_str(), "source" | "wysiwyg")
|
|
&& (40..=200).contains(&value.editor_line_width)
|
|
&& markdown(&value.markdown)
|
|
&& value.presets.len() <= 20
|
|
&& value.presets.iter().all(|p| {
|
|
!p.name.trim().is_empty()
|
|
&& p.name.chars().count() <= 40
|
|
&& markdown(&p.preferences)
|
|
})
|
|
}
|
|
_ => return Err(HostError::new("RECORD_SCHEMA_UNSUPPORTED")),
|
|
};
|
|
if valid {
|
|
Ok(())
|
|
} else {
|
|
Err(HostError::new("RECORD_DATA_INVALID"))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use serde_json::json;
|
|
#[test]
|
|
fn layout_schema_limits_widths_and_rejects_device_fields() {
|
|
let good = json!({"primaryExpanded":true,"workspaceWidth":400.5,"chatWidth":320});
|
|
let path = crate::records::path_for("layout", "sidebars").unwrap();
|
|
assert!(crate::records::allowed(&path));
|
|
let record = json!({"schema":1,"kind":"layout","id":"sidebars","data":good});
|
|
crate::records::validate(&path, &serde_json::to_vec(&record).unwrap()).unwrap();
|
|
for invalid in [199.0, 521.0, -1.0] {
|
|
let mut data = good.clone();
|
|
data["workspaceWidth"] = json!(invalid);
|
|
assert!(validate("layout", &data).is_err());
|
|
}
|
|
let mut bad = good;
|
|
bad["windowPath"] = json!("private-device-path");
|
|
assert!(validate("layout", &bad).is_err());
|
|
assert!(crate::records::path_for("layout", "other").is_err());
|
|
}
|
|
#[test]
|
|
fn portable_preferences_reject_unowned_nested_fields_and_invalid_values() {
|
|
let theme = json!({"themeId":"dark","fontEditorSize":18,"fontEditorFamily":"system-ui","lineHeight":1.7,"codeBlockTheme":"auto","headings":{"custom":false,"family":"inherit","levels":([32,28,24,21,18,16].map(|size|json!({"size":size,"weight":700})))}});
|
|
validate("theme_settings", &theme).unwrap();
|
|
let markdown = json!({"heading":"atx","bullet":"-","incrementList":true,"fence":"`","math":true,"callouts":true,"diagrams":true,"autoLinks":true,"lineNumbers":true,"wrapCode":false,"indent":4,"defaultLanguage":""});
|
|
let preferences = json!({"restoreLastVault":true,"autoSaveInterval":1500,"language":"zh-CN","defaultEditorMode":"wysiwyg","editorLineWidth":80,"spellCheck":false,"markdown":markdown,"presets":[]});
|
|
validate("preferences", &preferences).unwrap();
|
|
for field in [
|
|
"apiKey",
|
|
"permissions",
|
|
"environment",
|
|
"vaultPath",
|
|
"provider",
|
|
] {
|
|
let mut bad = preferences.clone();
|
|
bad[field] = json!("planted-secret");
|
|
assert_eq!(
|
|
validate("preferences", &bad).unwrap_err().code,
|
|
"RECORD_SCHEMA_INVALID"
|
|
);
|
|
}
|
|
let mut bad = preferences.clone();
|
|
bad["markdown"]["apiKey"] = json!("planted-secret");
|
|
assert_eq!(
|
|
validate("preferences", &bad).unwrap_err().code,
|
|
"RECORD_SCHEMA_INVALID"
|
|
);
|
|
let mut bad = theme;
|
|
bad["fontEditorFamily"] = json!("x;url(secret)");
|
|
assert_eq!(
|
|
validate("theme_settings", &bad).unwrap_err().code,
|
|
"RECORD_DATA_INVALID"
|
|
);
|
|
}
|
|
}
|