Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

9.4 KB
Raw Blame
//! Bounded, passive DSH public patch documents. No YAML expressions or plugins are executed.
use super::pi_sources::clear_native_value;
use super::{QoderNativeError, qoder_error};
use serde_json::{Value, json};
use zeroize::Zeroizing;

pub(super) struct Patch {
    rows: Vec<Value>,
    bytes: Zeroizing<Vec<u8>>,
    spans: Vec<std::ops::Range<usize>>,
}
impl Drop for Patch {
    fn drop(&mut self) {
        self.rows.iter_mut().for_each(clear_native_value);
    }
}
impl Patch {
    pub fn parse(bytes: Option<&[u8]>) -> Result<Self, QoderNativeError> {
        let bytes = bytes.unwrap_or(b"[]\n");
        if bytes.len() > 2 * 1024 * 1024 {
            return Err(qoder_error("DSH patch bound"));
        }
        let text = std::str::from_utf8(bytes).map_err(|_| qoder_error("DSH patch encoding"))?;
        // serde_yaml normalizes unknown secondary tags (e.g. !!js) to scalars.
        // Refuse the executable public extensions before any such normalization.
        if text
            .lines()
            .filter(|l| !l.trim_start().starts_with('#'))
            .any(|l| l.contains("!!js") || l.contains("!include"))
        {
            return Err(qoder_error("DSH static patch required"));
        }
        let value: Value = if text.trim().is_empty() {
            json!([])
        } else {
            let yaml: serde_yaml::Value =
                serde_yaml::from_str(text).map_err(|_| qoder_error("DSH static patch required"))?;
            fn static_value(value: &serde_yaml::Value, depth: usize) -> bool {
                if depth > 32 {
                    return false;
                }
                match value {
                    serde_yaml::Value::Tagged(_) => false,
                    serde_yaml::Value::Sequence(values) => {
                        values.iter().all(|v| static_value(v, depth + 1))
                    }
                    serde_yaml::Value::Mapping(values) => values.iter().all(|(k, v)| {
                        k.as_str().is_some_and(|k| k != "<<") && static_value(v, depth + 1)
                    }),
                    _ => true,
                }
            }
            if !static_value(&yaml, 0) {
                return Err(qoder_error("DSH static patch required"));
            }
            serde_json::to_value(yaml).map_err(|_| qoder_error("DSH static patch required"))?
        };
        let rows = value
            .as_array()
            .ok_or_else(|| qoder_error("DSH patch sequence"))?
            .clone();
        let mut offset = 0;
        let mut starts = Vec::new();
        for line in text.split_inclusive('\n') {
            if line.starts_with("- ") || line.trim_end() == "-" {
                starts.push(offset);
            }
            offset += line.len();
        }
        let spans = starts
            .iter()
            .enumerate()
            .map(|(i, start)| *start..starts.get(i + 1).copied().unwrap_or(bytes.len()))
            .collect();
        let mut ids = std::collections::BTreeSet::new();
        for row in &rows {
            if !row.is_object() {
                return Err(qoder_error("DSH patch row"));
            }
            if let Some(id) = row.get("id").and_then(Value::as_str)
                && !ids.insert(id)
            {
                return Err(qoder_error("DSH duplicate patch row"));
            }
        }
        Ok(Self {
            rows,
            bytes: Zeroizing::new(bytes.to_vec()),
            spans,
        })
    }
    pub fn config(&self, id: &str) -> Result<Option<&Value>, QoderNativeError> {
        let row = self.rows.iter().find(|r| r["id"] == id);
        if row.is_some_and(|r| {
            r.get("remove").is_some() || r.get("disabled").is_some_and(|v| v != false)
        }) {
            return Err(qoder_error("DSH disabled target"));
        }
        Ok(row.and_then(|r| r.get("config")))
    }
    pub fn credentials_config(&self) -> Result<Option<&Value>, QoderNativeError> {
        // Nested insert/remove operations can replace the module. Do not infer
        // the default store from a composition this passive reader cannot prove.
        if self.rows.iter().any(|r| {
            r["id"].as_str().is_none()
                || r.as_object().expect("validated row").keys().any(|k| {
                    !matches!(k.as_str(), "id" | "name" | "config" | "disabled" | "remove")
                })
        }) {
            return Err(qoder_error("DSH static credentials composition required"));
        }
        if let Some(row) = self.rows.iter().find(|r| r["id"] == "credentials")
            && row
                .get("name")
                .is_some_and(|v| v != "@deepseek-ai/dsh-credentials-local")
        {
            return Err(qoder_error("DSH standard credentials module required"));
        }
        self.config("credentials")
    }
    pub fn providers(&self) -> Result<Value, QoderNativeError> {
        let providers = self
            .config("llm-pi-ai")?
            .and_then(|c| c.get("providers"))
            .cloned()
            .unwrap_or_else(|| json!({}));
        if !providers.is_object() {
            return Err(qoder_error("DSH providers object"));
        }
        Ok(providers)
    }
    pub fn model_root(&self) -> Result<Value, QoderNativeError> {
        let mut value = json!({"providers":self.providers()?});
        if let Some(default) = self.config("agent-default-model")?
            && let (Some(provider), Some(model)) =
                (default["provider"].as_str(), default["model"].as_str())
        {
            value["model"] = json!({"name":format!("{provider}/{model}")});
        }
        Ok(value)
    }
    pub fn edit_provider(
        &self,
        id: &str,
        provider: Option<&Value>,
    ) -> Result<Zeroizing<Vec<u8>>, QoderNativeError> {
        // Static flow documents are readable, but only block sequences have safe edit spans.
        // An empty sequence has no foreign rows to preserve.
        if self.spans.len() != self.rows.len() {
            return Err(qoder_error("DSH block patch required"));
        }
        if let Some(first) = self.spans.first() {
            let prefix = std::str::from_utf8(&self.bytes[..first.start])
                .map_err(|_| qoder_error("DSH patch encoding"))?;
            if prefix.lines().any(|line| {
                let line = line.trim();
                !line.is_empty() && !line.starts_with('#') && line != "---"
            }) {
                return Err(qoder_error("DSH block patch required"));
            }
            // A dash inside a multiline string is not a top-level row. Prove each span
            // independently represents the corresponding semantic row before editing it.
            for (span, row) in self.spans.iter().zip(&self.rows) {
                let fragment = Self::parse(Some(&self.bytes[span.clone()]))?;
                if fragment.rows.as_slice() != std::slice::from_ref(row) {
                    return Err(qoder_error("DSH block patch required"));
                }
            }
        }
        let index = self.rows.iter().position(|r| r["id"] == "llm-pi-ai");
        let mut row = index
            .map(|i| self.rows[i].clone())
            .unwrap_or_else(|| json!({"id":"llm-pi-ai","config":{"providers":{}}}));
        if row.get("config").is_none() {
            row["config"] = json!({});
        }
        if !row["config"].is_object() {
            return Err(qoder_error("DSH provider config"));
        }
        let mut providers = self.providers()?;
        let map = providers.as_object_mut().expect("validated providers");
        match provider {
            Some(value) => {
                map.insert(id.into(), value.clone());
            }
            None => {
                map.remove(id);
            }
        }
        row["config"]["providers"] = providers;
        // JSON is a public YAML subset; only the affected row is reformatted.
        let rendered =
            serde_json::to_string_pretty(&row).map_err(|_| qoder_error("DSH patch encoding"))?;
        let rendered = format!("- {}\n", rendered.replace('\n', "\n  "));
        let mut output = Zeroizing::new(Vec::new());
        if let Some(index) = index {
            let span = &self.spans[index];
            output.extend_from_slice(&self.bytes[..span.start]);
            output.extend_from_slice(rendered.as_bytes());
            output.extend_from_slice(&self.bytes[span.end..]);
        } else {
            if !self.rows.is_empty() || self.bytes.contains(&b'#') {
                // Preserve leading comments, omitting the empty sequence syntax.
                for line in self.bytes.split_inclusive(|b| *b == b'\n') {
                    if line.starts_with(b"#") || line.iter().all(u8::is_ascii_whitespace) {
                        output.extend_from_slice(line);
                    }
                }
                if !self.rows.is_empty() {
                    output = Zeroizing::new(self.bytes.to_vec());
                }
            }
            if !output.is_empty() && !output.ends_with(b"\n") {
                output.push(b'\n');
            }
            output.extend_from_slice(rendered.as_bytes());
        }
        Self::parse(Some(&output))?;
        Ok(output)
    }
}

/// Native composition files are public-readable; credentials keep the private reader.
pub(super) fn read_patch_bytes(
    path: &std::path::Path,
) -> Result<Zeroizing<Vec<u8>>, super::AgentFilesystemScanError> {
    let observed = super::filesystem_config::read_system_config_bytes(path)?;
    Ok(observed.map(|(bytes, _)| bytes).unwrap_or_default())
}