@pheem49/mint 1.15.0 → 1.17.0

package/crates/mint-core/src/mods/operations.rs

@@ -0,0 +1,204 @@
+use super::*;
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+use std::path::Path;
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Operation {
+    pub workspace_path: String,
+    pub chat_id: String,
+    pub action: String,
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub scope: String,
+    #[serde(default)]
+    pub grant_permissions: bool,
+    #[serde(default)]
+    pub expected_hash: Option<String>,
+    #[serde(default)]
+    pub hash: String,
+    #[serde(default)]
+    pub instance_id: String,
+    #[serde(default)]
+    pub command: String,
+    #[serde(default)]
+    pub value: Value,
+    #[serde(default)]
+    pub source: Option<Source>,
+    #[serde(default)]
+    pub package: String,
+    #[serde(default)]
+    pub viewport: Option<Viewport>,
+}
+pub fn operate(op: &Operation) -> Result<Value, String> {
+    if op.chat_id.trim().is_empty() || op.chat_id.len() > 512 {
+        return Err("An explicit chat ID is required".into());
+    }
+    let root = Path::new(&op.workspace_path);
+    let config = crate::load_config().map_err(|e| e.to_string())?;
+    crate::assert_path_capability(root, crate::Capability::Read, &config)
+        .map_err(|e| e.to_string())?;
+    let chat = crate::scoped_chat_id(&op.chat_id, Some(&op.workspace_path));
+    match op.action.as_str() {
+        "list" => {
+            return Ok(
+                json!({"mods":list(root,&chat)?,"toolRequests":pending_requests(root,&chat)?,"session":session_snapshot(root,&chat)?}),
+            );
+        }
+        "validate" => {
+            return validate(
+                root,
+                &match &op.source {
+                    Some(s) => s.clone(),
+                    None => shareable_source(root, &op.id)?,
+                },
+            );
+        }
+        "hot_reload" => set_hot_reload(
+            root,
+            &chat,
+            op.value
+                .as_bool()
+                .ok_or("Hot reload requires true or false")?,
+        )?,
+        "viewport" => {
+            update_viewport(root, &chat, op.viewport.clone().ok_or("Viewport required")?)?
+        }
+        "usage" => return Ok(json!({"usage":current_usage(root,&chat)})),
+        "test" => return Ok(json!({"testReport":test_mod(root,&op.id)?})),
+        "enable" => {
+            if op.grant_permissions && op.expected_hash.is_none() {
+                return Err("Review the source hash before granting mod permissions".into());
+            }
+            enable_reviewed(
+                root,
+                &chat,
+                &op.id,
+                if op.scope.is_empty() {
+                    "chat"
+                } else {
+                    &op.scope
+                },
+                op.grant_permissions,
+                op.expected_hash.as_deref(),
+            )?;
+        }
+        "disable" => disable(root, &chat, &op.id)?,
+        "action" => {
+            return action(
+                root,
+                &chat,
+                &op.id,
+                &op.instance_id,
+                &op.command,
+                op.value.clone(),
+            );
+        }
+        "command" => {
+            return command(
+                root,
+                &chat,
+                &op.id,
+                &op.command,
+                op.value.as_str().unwrap_or(""),
+            );
+        }
+        "close" => {
+            close_chat(root, &chat);
+            return Ok(json!({"mods":[],"session":session_snapshot(root,&chat)?}));
+        }
+        "rollback" => {
+            crate::assert_path_capability(
+                &source_path(root, &op.id)?,
+                crate::Capability::Write,
+                &config,
+            )
+            .map_err(|e| e.to_string())?;
+            rollback(
+                root,
+                &op.id,
+                &op.hash,
+                op.expected_hash
+                    .as_deref()
+                    .ok_or("Expected source hash required")?,
+            )?;
+        }
+        "inspect_package" => {
+            if op.package.len() > 2 * 1024 * 1024 {
+                return Err("Package is too large".into());
+            }
+            let bytes = STANDARD.decode(&op.package).map_err(|e| e.to_string())?;
+            let source: Source = serde_json::from_value(mint_mod_runtime::unpack(&bytes)?)
+                .map_err(|e| e.to_string())?;
+            validate(root, &source)?;
+            let expected = load_source(root, &source.manifest.id)
+                .ok()
+                .map(|s| s.hash());
+            return Ok(json!({"id":source.manifest.id,"expectedHash":expected}));
+        }
+        "export" => {
+            let source = shareable_source(root, &op.id)?;
+            let bytes = mint_mod_runtime::pack(
+                &serde_json::to_value(&source.manifest).unwrap(),
+                &source.source,
+                &source.readme,
+            )?;
+            return Ok(
+                json!({"filename":format!("{}.mintmod",op.id),"package":STANDARD.encode(bytes)}),
+            );
+        }
+        "import" => {
+            if op.package.len() > 2 * 1024 * 1024 {
+                return Err("Package is too large".into());
+            }
+            let bytes = STANDARD.decode(&op.package).map_err(|e| e.to_string())?;
+            let source: Source = serde_json::from_value(mint_mod_runtime::unpack(&bytes)?)
+                .map_err(|e| e.to_string())?;
+            crate::assert_path_capability(
+                &source_path(root, &source.manifest.id)?,
+                crate::Capability::Write,
+                &config,
+            )
+            .map_err(|e| e.to_string())?;
+            publish(root, &source, op.expected_hash.as_deref())?;
+        }
+        _ => return Err("Unknown mod operation".into()),
+    }
+    Ok(json!({"mods":list(root,&chat)?,"session":session_snapshot(root,&chat)?}))
+}
+
+pub async fn operate_async(op: Operation) -> Result<Value, String> {
+    if op.action == "run_request" {
+        let config = crate::load_config().map_err(|e| e.to_string())?;
+        let root = crate::assert_path_capability(
+            Path::new(&op.workspace_path),
+            crate::Capability::Read,
+            &config,
+        )
+        .map_err(|e| e.to_string())?;
+        if op.chat_id.is_empty() || !op.grant_permissions {
+            return Err("Review and approve the concrete tool request first".into());
+        }
+        let chat = crate::scoped_chat_id(&op.chat_id, Some(&op.workspace_path));
+        let ids = vec![op.command.clone()];
+        crate::orchestration::execute_mod_requests(
+            &root,
+            &chat,
+            &config,
+            false,
+            &mut |_| Ok(crate::ApprovalOutcome::Approved),
+            &mut |_| {},
+            Some(&ids),
+        )
+        .await?;
+        return Ok(
+            json!({"mods":list(&root,&chat)?,"toolRequests":pending_requests(&root,&chat)?}),
+        );
+    }
+    tokio::task::spawn_blocking(move || operate(&op))
+        .await
+        .map_err(|e| e.to_string())?
+}

package/crates/mint-core/src/mods/session.rs

@@ -0,0 +1,146 @@
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+use std::{
+    collections::BTreeMap,
+    path::Path,
+    sync::{LazyLock, Mutex},
+};
+
+#[derive(Clone, Default)]
+struct Session {
+    hot_reload: bool,
+    usage: Option<Value>,
+    viewport: Viewport,
+    revisions: BTreeMap<String, (String, String)>,
+}
+static SESSIONS: LazyLock<Mutex<BTreeMap<String, Session>>> =
+    LazyLock::new(|| Mutex::new(BTreeMap::new()));
+
+#[derive(Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Viewport {
+    pub surface: Option<String>,
+    pub columns: Option<u16>,
+    pub rows: Option<u16>,
+    pub width_px: Option<u32>,
+    pub height_px: Option<u32>,
+    #[serde(default)]
+    pub side_panel_open: bool,
+}
+pub fn set_hot_reload(root: &Path, chat: &str, enabled: bool) -> Result<(), String> {
+    SESSIONS
+        .lock()
+        .unwrap()
+        .entry(super::manager::key(root, chat, "")?)
+        .or_default()
+        .hot_reload = enabled;
+    Ok(())
+}
+pub fn session_snapshot(root: &Path, chat: &str) -> Result<Value, String> {
+    let sessions = SESSIONS.lock().unwrap();
+    let current = sessions
+        .get(&super::manager::key(root, chat, "")?)
+        .cloned()
+        .unwrap_or_default();
+    Ok(json!({"hotReload":current.hot_reload,"viewport":current.viewport}))
+}
+pub(super) fn hot_reload(root: &Path, chat: &str) -> bool {
+    session_snapshot(root, chat)
+        .ok()
+        .is_some_and(|v| v["hotReload"] == true)
+}
+pub(super) fn revision(root: &Path, chat: &str, id: &str, base: &str) -> Option<String> {
+    let sessions = SESSIONS.lock().unwrap();
+    let s = sessions.get(&super::manager::key(root, chat, "").ok()?)?;
+    s.revisions
+        .get(id)
+        .filter(|(b, _)| b == base)
+        .map(|(_, h)| h.clone())
+}
+pub(super) fn set_revision(
+    root: &Path,
+    chat: &str,
+    id: &str,
+    base: &str,
+    hash: &str,
+) -> Result<(), String> {
+    SESSIONS
+        .lock()
+        .unwrap()
+        .entry(super::manager::key(root, chat, "")?)
+        .or_default()
+        .revisions
+        .insert(id.into(), (base.into(), hash.into()));
+    Ok(())
+}
+pub(super) fn clear(root: &Path, chat: &str) {
+    if let Ok(k) = super::manager::key(root, chat, "") {
+        SESSIONS.lock().unwrap().remove(&k);
+    }
+}
+pub(super) fn clear_matching(marker: &str) {
+    SESSIONS
+        .lock()
+        .unwrap()
+        .retain(|key, _| !key.contains(marker));
+}
+pub fn current_usage(root: &Path, chat: &str) -> Value {
+    let current = super::manager::key(root, chat, "").ok().and_then(|k| {
+        SESSIONS
+            .lock()
+            .unwrap()
+            .get(&k)
+            .and_then(|s| s.usage.clone())
+    });
+    current
+        .or_else(|| {
+            super::manager::telemetry_path(root, chat)
+                .ok()
+                .and_then(|p| std::fs::read(p.with_extension("usage.json")).ok())
+                .and_then(|v| serde_json::from_slice(&v).ok())
+        })
+        .unwrap_or_else(|| super::telemetry::UsageTracker::new(root, chat, 0).snapshot())
+}
+pub(super) fn store_usage(root: &Path, chat: &str, value: &Value) -> Result<(), String> {
+    SESSIONS
+        .lock()
+        .unwrap()
+        .entry(super::manager::key(root, chat, "")?)
+        .or_default()
+        .usage = Some(value.clone());
+    super::manager::atomic_json(
+        &super::manager::telemetry_path(root, chat)?.with_extension("usage.json"),
+        value,
+    )
+}
+pub fn update_viewport(root: &Path, chat: &str, viewport: Viewport) -> Result<(), String> {
+    if !matches!(
+        viewport.surface.as_deref(),
+        Some("terminal" | "desktop" | "web")
+    ) || viewport.columns.is_some_and(|n| n == 0 || n > 10000)
+        || viewport.rows.is_some_and(|n| n == 0 || n > 10000)
+        || viewport.width_px.is_some_and(|n| n == 0 || n > 100000)
+        || viewport.height_px.is_some_and(|n| n == 0 || n > 100000)
+    {
+        return Err("Invalid mod viewport".into());
+    }
+    let changed = {
+        let mut sessions = SESSIONS.lock().unwrap();
+        let s = sessions
+            .entry(super::manager::key(root, chat, "")?)
+            .or_default();
+        let changed = s.viewport != viewport;
+        s.viewport = viewport.clone();
+        changed
+    };
+    if changed {
+        super::event(
+            root,
+            chat,
+            "ui_resize",
+            serde_json::to_value(viewport).map_err(|e| e.to_string())?,
+            None,
+        )?;
+    }
+    Ok(())
+}

package/crates/mint-core/src/mods/slash.rs

@@ -0,0 +1,59 @@
+use super::*;
+use serde_json::json;
+use std::io::Read;
+use std::path::Path;
+
+pub fn slash(root: &Path, chat: &str, input: &str) -> Result<String, String> {
+    let chat = crate::scoped_chat_id(chat, Some(&root.to_string_lossy()));
+    if let Some(rest) = input.strip_prefix("/mods:") {
+        let (token, args) = rest.split_once(char::is_whitespace).unwrap_or((rest, ""));
+        let (id, name) = token.split_once(':').ok_or("Use /mods:<id>:<command>")?;
+        return command(root, &chat, id, name, args.trim()).map(|r| {
+            r["value"]
+                .as_str()
+                .map(str::to_owned)
+                .unwrap_or_else(|| r["value"].to_string())
+        });
+    }
+    let rest = input.trim().strip_prefix("/mods").unwrap_or(input).trim();
+    let words = shlex::split(rest).ok_or("Unclosed quote in mod command")?;
+    let mut args = words.iter().map(String::as_str);
+    let action = args.next().unwrap_or("list");
+    let id = args.next().unwrap_or("");
+    match action {
+        "hot-reload"=>{let enabled=match id {"on"=>true,"off"=>false,""=>return Ok(session_snapshot(root,&chat)?.to_string()),_=>return Err("Use /mods hot-reload on|off".into())};set_hot_reload(root,&chat,enabled)?;Ok(format!("Hot reload {} for this session",if enabled {"on"}else{"off"}))},
+        "usage"=>Ok(current_usage(root,&chat).to_string()),
+        "test"=>Ok(test_mod(root,id)?.to_string()),
+        "export" => {
+            let options: Vec<_> = args.collect();
+            let default = format!("{id}.mintmod");
+            let filename = options.first().copied().filter(|s| !s.starts_with("--")).unwrap_or(&default);
+            let path = crate::assert_path_capability(&root.join(filename), crate::Capability::Write, &crate::load_config().map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
+            if path.exists() && !options.contains(&"--replace") { return Err("Export file exists; choose another path or add --replace".into()); }
+            let source = shareable_source(root, id)?;
+            let bytes = mint_mod_runtime::pack(&serde_json::to_value(&source.manifest).map_err(|e| e.to_string())?, &source.source, &source.readme)?;
+            std::fs::write(&path, bytes).map_err(|e| e.to_string())?;
+            Ok(format!("Exported {}", path.display()))
+        },
+        "import" => {
+            let path = crate::assert_path_capability(&root.join(id), crate::Capability::Read, &crate::load_config().map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
+            let mut bytes = Vec::new();
+            std::fs::File::open(path).map_err(|e| e.to_string())?.take(1024 * 1024 + 1).read_to_end(&mut bytes).map_err(|e| e.to_string())?;
+            let source: Source = serde_json::from_value(mint_mod_runtime::unpack(&bytes)?).map_err(|e| e.to_string())?;
+            crate::assert_path_capability(&source_path(root, &source.manifest.id)?, crate::Capability::Write, &crate::load_config().map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
+            let replace = args.any(|a| a == "--replace");
+            let expected = if replace { load_source(root, &source.manifest.id).ok().map(|s| s.hash()) } else { None };
+            publish(root, &source, expected.as_deref())?;
+            Ok(format!("Imported {}; disabled until enabled", source.manifest.id))
+        },
+        "list"=>{let mods=list(root,&chat)?;if mods.is_empty(){return Ok("No mods yet. Ask Mint to create one in .mint-mods/.".into());}Ok(mods.iter().map(|m|format!("- {} · {}{}",m["id"].as_str().unwrap_or(""),if m["enabled"]==true{"active"}else{"off"},m["error"].as_str().or(m["reloadError"].as_str()).map(|e|format!(" · {e}")).unwrap_or_default())).collect::<Vec<_>>().join("\n"))},
+        "source"=>{let source=shareable_source(root,id)?;Ok(format!("```json\n{}\n```\n```typescript\n{}\n```",serde_json::to_string_pretty(&source.manifest).unwrap(),source.source))},
+        "logs"=>{let mods=list(root,&chat)?;let m=mods.iter().find(|m|m["id"].as_str()==Some(id)).ok_or("Unknown mod")?;Ok(m["snapshot"]["logs"].to_string())},
+        "validate"=>{let source=shareable_source(root,id)?;validate(root,&source).map(|s|json!({"valid":true,"preview":s}).to_string())},
+        "enable"=>{let options:Vec<_>=args.collect();let scope=options.iter().find(|a|["chat","workspace","global"].contains(a)).copied().unwrap_or("chat");enable(root,&chat,id,scope,options.contains(&"--grant-permissions"))?;Ok(format!("Enabled {id} for {scope}"))},
+        "disable"=>{disable(root,&chat,id)?;Ok(format!("Disabled {id} in this chat"))},
+        "revisions"=>Ok(serde_json::to_string_pretty(&revisions(root,id)?).unwrap()),
+        "rollback"=>{crate::assert_path_capability(&source_path(root,id)?,crate::Capability::Write,&crate::load_config().map_err(|e|e.to_string())?).map_err(|e|e.to_string())?;let hash=args.next().ok_or("Revision hash required")?;let current=load_source(root,id)?;rollback(root,id,hash,&current.hash())?;Ok(format!("Restored {id} source; review and enable the revision."))},
+        _=>Ok("/mods list | source <id> | validate <id> | test <id> | hot-reload on|off | usage | enable <id> [chat|workspace|global] [--grant-permissions] | disable <id> | logs <id> | revisions <id> | rollback <id> <hash> | export <id> [file] [--replace] | import <file> [--replace]\n/mods:<id>:<command> [value]".into())
+    }
+}