smallcloudai · olegklimov · Feb 25, 2025 · Feb 25, 2025 · Feb 25, 2025 · Feb 25, 2025
diff --git a/.refact/integrations.d/cmdline_cargo_check.yaml b/.refact/integrations.d/cmdline_cargo_check.yaml
@@ -5,7 +5,7 @@ parameters:
   - name: "additional_params"
     description: "Additional parameters for cargo check, such as --workspace or --all-features"
   - name: "project_path"
-    description: "absolute path to the project"
+    description: "Absolute path to the project, the rust stuff is at refact/refact-agent/engine/Cargo.toml for the Refact project, so use ../refact/refact-agent/engine"
 timeout: "60"
 output_filter:
   limit_lines: 100

diff --git a/refact-agent/engine/Cargo.toml b/refact-agent/engine/Cargo.toml
@@ -96,7 +96,6 @@ uuid = { version = "1", features = ["v4", "serde"] }
 walkdir = "2.3"
 which = "7.0.1"
 zerocopy = "0.8.14"
-jsonschema = "0.28.3"
 
 # There you can use a local copy:
 mcp_client_rs = { git = "https://github.com/smallcloudai/mcp_client_rust.git" }

diff --git a/refact-agent/engine/src/files_blocklist.rs b/refact-agent/engine/src/files_blocklist.rs
@@ -198,7 +198,7 @@ pub async fn reload_indexing_everywhere_if_needed(gcx: Arc<ARwLock<GlobalContext
 
 pub fn is_blocklisted(indexing_settings: &IndexingSettings, path: &PathBuf) -> bool {
     let block = any_glob_matches_path(&indexing_settings.blocklist, &path);
-    tracing::info!("is_blocklisted {:?} {:?} block={}", indexing_settings, path, block);
+    // tracing::info!("is_blocklisted {:?} {:?} block={}", indexing_settings, path, block);
     block
 }
 

diff --git a/refact-agent/engine/src/http/routers/v1.rs b/refact-agent/engine/src/http/routers/v1.rs
@@ -43,7 +43,7 @@ use crate::http::routers::v1::system_prompt::handle_v1_prepend_system_prompt_and
 use crate::http::routers::v1::vecdb::{handle_v1_vecdb_search, handle_v1_vecdb_status};
 #[cfg(feature="vecdb")]
 use crate::http::routers::v1::handlers_memdb::{handle_mem_add, handle_mem_erase, handle_mem_update_used, handle_mem_block_until_vectorized};
-use crate::http::routers::v1::v1_integrations::{handle_v1_integration_get, handle_v1_integration_icon, handle_v1_integration_save, handle_v1_integration_delete, handle_v1_integrations, handle_v1_integrations_filtered, handle_v1_integration_json_schema};
+use crate::http::routers::v1::v1_integrations::{handle_v1_integration_get, handle_v1_integration_icon, handle_v1_integration_save, handle_v1_integration_delete, handle_v1_integrations, handle_v1_integrations_filtered};
 use crate::agent_db::db_cthread::{handle_db_v1_cthread_update, handle_db_v1_cthreads_sub};
 use crate::agent_db::db_cmessage::{handle_db_v1_cmessages_update, handle_db_v1_cmessages_sub};
 use crate::agent_db::db_chore::{handle_db_v1_chore_update, handle_db_v1_chore_event_update, handle_db_v1_chores_sub};
@@ -137,7 +137,6 @@ pub fn make_v1_router() -> Router {
         .route("/integration-save", telemetry_post!(handle_v1_integration_save))
         .route("/integration-delete", delete(handle_v1_integration_delete))
         .route("/integration-icon/:icon_name", get(handle_v1_integration_icon))
-        .route("/integration-json-schema", get(handle_v1_integration_json_schema))
 
         .route("/docker-container-list", telemetry_post!(handle_v1_docker_container_list))
         .route("/docker-container-action", telemetry_post!(handle_v1_docker_container_action))

diff --git a/refact-agent/engine/src/http/routers/v1/v1_integrations.rs b/refact-agent/engine/src/http/routers/v1/v1_integrations.rs
@@ -11,7 +11,6 @@ use axum::extract::Query;
 use rust_embed::RustEmbed;
 use crate::custom_error::ScratchError;
 use crate::global_context::GlobalContext;
-use crate::integrations::json_schema::INTEGRATION_JSON_SCHEMA;
 use crate::integrations::setting_up_integrations::split_path_into_project_and_integration;
 
 
@@ -189,14 +188,3 @@ pub async fn handle_v1_integration_delete(
         .body(Body::from("{}"))
         .unwrap())
 }
-
-pub async fn handle_v1_integration_json_schema() -> axum::response::Result<Response<Body>, ScratchError> {
-    let schema_string = serde_json::to_string_pretty(&*INTEGRATION_JSON_SCHEMA).map_err(|e| {
-        ScratchError::new(StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to serialize JSON schema: {}", e))
-    })?;
-
-    Ok(Response::builder()
-        .header("Content-Type", "application/json")
-        .body(Body::from(schema_string))
-        .unwrap())
-}
diff --git a/refact-agent/engine/src/integrations/docker/integr_docker.rs b/refact-agent/engine/src/integrations/docker/integr_docker.rs
@@ -54,24 +54,9 @@ pub struct ToolDocker {
 impl IntegrationTrait for ToolDocker {
     fn as_any(&self) -> &dyn std::any::Any { self }
 
-    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), String> {
-        match serde_json::from_value::<SettingsDocker>(value.clone()) {
-            Ok(settings_docker) => {
-                tracing::info!("Docker settings applied: {:?}", settings_docker);
-                self.settings_docker = settings_docker
-            },
-            Err(e) => {
-                tracing::error!("Failed to apply settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
-        match serde_json::from_value::<IntegrationCommon>(value.clone()) {
-            Ok(x) => self.common = x,
-            Err(e) => {
-                tracing::error!("Failed to apply common settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
+    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error> {
+        self.settings_docker = serde_json::from_value(value.clone())?;
+        self.common = serde_json::from_value(value.clone())?;
         self.config_path = config_path;
         Ok(())
     }

diff --git a/refact-agent/engine/src/integrations/docker/integr_isolation.rs b/refact-agent/engine/src/integrations/docker/integr_isolation.rs
@@ -31,26 +31,11 @@ pub struct IntegrationIsolation {
 impl IntegrationTrait for IntegrationIsolation {
     fn as_any(&self) -> &dyn std::any::Any { self }
 
-    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, _config_path: String, value: &serde_json::Value) -> Result<(), String> {
-        match serde_json::from_value::<SettingsIsolation>(value.clone()) {
-            Ok(settings_isolation) => {
-                tracing::info!("Isolation settings applied: {:?}", settings_isolation);
-                self.settings_isolation = settings_isolation
-            },
-            Err(e) => {
-                tracing::error!("Failed to apply settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
-        match serde_json::from_value::<IntegrationCommon>(value.clone()) {
-            Ok(x) => self.common = x,
-            Err(e) => {
-                tracing::error!("Failed to apply common settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
-        Ok(())
-    }
+    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, _config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error> {
+      self.settings_isolation = serde_json::from_value(value.clone())?;
+      self.common = serde_json::from_value(value.clone())?;
+      Ok(())
+  }
 
     fn integr_settings_as_json(&self) -> Value {
         serde_json::to_value(&self.settings_isolation).unwrap()

diff --git a/refact-agent/engine/src/integrations/integr_abstract.rs b/refact-agent/engine/src/integrations/integr_abstract.rs
@@ -11,7 +11,7 @@ use crate::global_context::GlobalContext;
 pub trait IntegrationTrait: Send + Sync {
     fn as_any(&self) -> &dyn std::any::Any;
     fn integr_schema(&self) -> &str;
-    async fn integr_settings_apply(&mut self, gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), String>;
+    async fn integr_settings_apply(&mut self, gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error>;
     fn integr_settings_as_json(&self) -> serde_json::Value;
     fn integr_common(&self) -> IntegrationCommon;
     async fn integr_tools(&self, integr_name: &str) -> Vec<Box<dyn crate::tools::tools_description::Tool + Send>>;  // integr_name is sometimes different, "cmdline_compile_my_project" != "cmdline"

diff --git a/refact-agent/engine/src/integrations/integr_chrome.rs b/refact-agent/engine/src/integrations/integr_chrome.rs
@@ -152,21 +152,9 @@ impl IntegrationSession for ChromeSession
 impl IntegrationTrait for ToolChrome {
     fn as_any(&self) -> &dyn std::any::Any { self }
 
-    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), String> {
-        match serde_json::from_value::<SettingsChrome>(value.clone()) {
-            Ok(settings_chrome) => self.settings_chrome = settings_chrome,
-            Err(e) => {
-                tracing::error!("Failed to apply settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
-        match serde_json::from_value::<IntegrationCommon>(value.clone()) {
-            Ok(x) => self.common = x,
-            Err(e) => {
-                tracing::error!("Failed to apply common settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
+    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error> {
+        self.settings_chrome = serde_json::from_value(value.clone())?;
+        self.common = serde_json::from_value(value.clone())?;
         self.config_path = config_path;
         Ok(())
     }

diff --git a/refact-agent/engine/src/integrations/integr_cmdline.rs b/refact-agent/engine/src/integrations/integr_cmdline.rs
@@ -66,21 +66,9 @@ pub struct ToolCmdline {
 impl IntegrationTrait for ToolCmdline {
     fn as_any(&self) -> &dyn std::any::Any { self }
 
-    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), String> {
-        match serde_json::from_value::<CmdlineToolConfig>(value.clone()) {
-            Ok(x) => self.cfg = x,
-            Err(e) => {
-                tracing::error!("Failed to apply settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
-        match serde_json::from_value::<IntegrationCommon>(value.clone()) {
-            Ok(x) => self.common = x,
-            Err(e) => {
-                tracing::error!("Failed to apply common settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
+    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error> {
+        self.cfg = serde_json::from_value(value.clone())?;
+        self.common = serde_json::from_value(value.clone())?;
         self.config_path = config_path;
         Ok(())
     }
@@ -148,10 +136,16 @@ fn powershell_escape(s: &str) -> String {
 pub fn replace_args(x: &str, args_str: &HashMap<String, String>) -> String {
     let mut result = x.to_string();
     for (key, value) in args_str {
-        #[cfg(target_os = "windows")]
-        let escaped_value = powershell_escape(value);
-        #[cfg(not(target_os = "windows"))]
-        let escaped_value = escape(Cow::from(value.as_str())).to_string();
+        let escaped_value = if value == "" {
+            // special case for an empty paramter, we want it empty as replacement, rather than escaped empty string ""
+            "".to_string()
+        } else {
+            #[cfg(target_os = "windows")]
+            let x = powershell_escape(value);
+            #[cfg(not(target_os = "windows"))]
+            let x = escape(Cow::from(value.as_str())).to_string();
+            x
+        };
         result = result.replace(&format!("%{}%", key), &escaped_value);
     }
     result
@@ -257,7 +251,7 @@ pub async fn execute_blocking_command(
     }
 }
 
-fn parse_command_args(args: &HashMap<String, serde_json::Value>, cfg: &CmdlineToolConfig) -> Result<(String, String), String>
+fn _parse_command_args(args: &HashMap<String, serde_json::Value>, cfg: &CmdlineToolConfig) -> Result<(String, String), String>
 {
     let mut args_str: HashMap<String, String> = HashMap::new();
     let valid_params: Vec<String> = cfg.parameters.iter().map(|p| p.name.clone()).collect();
@@ -293,7 +287,7 @@ impl Tool for ToolCmdline {
         tool_call_id: &String,
         args: &HashMap<String, serde_json::Value>,
     ) -> Result<(bool, Vec<ContextEnum>), String> {
-        let (command, workdir) = parse_command_args(args, &self.cfg)?;
+        let (command, workdir) = _parse_command_args(args, &self.cfg)?;
 
         let gcx = ccx.lock().await.global_context.clone();
         let mut error_log = Vec::<YamlError>::new();
@@ -335,7 +329,7 @@ impl Tool for ToolCmdline {
         &self,
         args: &HashMap<String, serde_json::Value>,
     ) -> Result<String, String> {
-        let (command, _workdir) = parse_command_args(args, &self.cfg)?;
+        let (command, _workdir) = _parse_command_args(args, &self.cfg)?;
         return Ok(command);
     }
 

diff --git a/refact-agent/engine/src/integrations/integr_cmdline_service.rs b/refact-agent/engine/src/integrations/integr_cmdline_service.rs
@@ -34,21 +34,9 @@ pub struct ToolService {
 impl IntegrationTrait for ToolService {
     fn as_any(&self) -> &dyn std::any::Any { self }
 
-    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), String> {
-        match serde_json::from_value::<CmdlineToolConfig>(value.clone()) {
-            Ok(x) => self.cfg = x,
-            Err(e) => {
-                tracing::error!("Failed to apply settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
-        match serde_json::from_value::<IntegrationCommon>(value.clone()) {
-            Ok(x) => self.common = x,
-            Err(e) => {
-                tracing::error!("Failed to apply common settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        }
+    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error> {
+        self.cfg = serde_json::from_value(value.clone())?;
+        self.common = serde_json::from_value(value.clone())?;
         self.config_path = config_path;
         Ok(())
     }

diff --git a/refact-agent/engine/src/integrations/integr_github.rs b/refact-agent/engine/src/integrations/integr_github.rs
@@ -1,7 +1,6 @@
 use std::sync::Arc;
 use std::collections::HashMap;
 use async_trait::async_trait;
-use tracing::{error, info};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex as AMutex;
 use tokio::sync::RwLock as ARwLock;
@@ -35,23 +34,9 @@ pub struct ToolGithub {
 impl IntegrationTrait for ToolGithub {
     fn as_any(&self) -> &dyn std::any::Any { self }
 
-    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), String> {
-        match serde_json::from_value::<SettingsGitHub>(value.clone()) {
-            Ok(settings_github) => {
-                self.settings_github = settings_github;
-            },
-            Err(e) => {
-                error!("Failed to apply settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        };
-        match serde_json::from_value::<IntegrationCommon>(value.clone()) {
-            Ok(x) => self.common = x,
-            Err(e) => {
-                error!("Failed to apply common settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        };
+    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error> {
+        self.settings_github = serde_json::from_value(value.clone())?;
+        self.common = serde_json::from_value(value.clone())?;
         self.config_path = config_path;
         Ok(())
     }
@@ -185,7 +170,7 @@ fn parse_command_args(args: &HashMap<String, Value>) -> Result<Vec<String>, Stri
         return Err("Parsed command is empty".to_string());
     }
     for (i, arg) in parsed_args.iter().enumerate() {
-        info!("argument[{}]: {}", i, arg);
+        tracing::info!("argument[{}]: {}", i, arg);
     }
     if parsed_args[0] == "gh" {
         parsed_args.remove(0);

diff --git a/refact-agent/engine/src/integrations/integr_gitlab.rs b/refact-agent/engine/src/integrations/integr_gitlab.rs
@@ -1,7 +1,6 @@
 use std::sync::Arc;
 use std::collections::HashMap;
 use async_trait::async_trait;
-use tracing::{error, info};
 use tokio::sync::Mutex as AMutex;
 use tokio::sync::RwLock as ARwLock;
 use tokio::process::Command;
@@ -34,24 +33,9 @@ pub struct ToolGitlab {
 impl IntegrationTrait for ToolGitlab {
     fn as_any(&self) -> &dyn std::any::Any { self }
 
-    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), String> {
-        match serde_json::from_value::<SettingsGitLab>(value.clone()) {
-            Ok(settings_gitlab) => {
-                info!("GitLab settings applied: {:?}", settings_gitlab);
-                self.settings_gitlab = settings_gitlab;
-            },
-            Err(e) => {
-                error!("Failed to apply settings: {}\n{:?}", e, value);
-                return Err(e.to_string())
-            }
-        };
-        match serde_json::from_value::<IntegrationCommon>(value.clone()) {
-            Ok(x) => self.common = x,
-            Err(e) => {
-                error!("Failed to apply common settings: {}\n{:?}", e, value);
-                return Err(e.to_string());
-            }
-        };
+    async fn integr_settings_apply(&mut self, _gcx: Arc<ARwLock<GlobalContext>>, config_path: String, value: &serde_json::Value) -> Result<(), serde_json::Error> {
+        self.settings_gitlab = serde_json::from_value(value.clone())?;
+        self.common = serde_json::from_value(value.clone())?;
         self.config_path = config_path;
         Ok(())
     }
@@ -184,7 +168,7 @@ fn parse_command_args(args: &HashMap<String, Value>) -> Result<Vec<String>, Stri
         return Err("Parsed command is empty".to_string());
     }
     for (i, arg) in parsed_args.iter().enumerate() {
-        info!("argument[{}]: {}", i, arg);
+        tracing::info!("argument[{}]: {}", i, arg);
     }
     if parsed_args[0] == "glab" {
         parsed_args.remove(0);