fix: Fix npm package

kosz78 · kosz78 · commit dc94aa0d0ea3 · 2025-06-16T13:40:47.000+07:00
chore: add run parameters to provide data directory and config
diff --git a/npm/huly-coder/src/index.ts b/npm/huly-coder/src/index.ts
@@ -21,7 +21,7 @@ function getExePath() {
 
     try {
         // Since the binary will be located inside `node_modules`, we can simply call `require.resolve`
-        return require.resolve(`app-${os}-${arch}/bin/app${extension}`);
+        return require.resolve(`huly-coder-${os}-${arch}/bin/huly-coder${extension}`);
     } catch (e) {
         throw new Error(
             `Couldn't find application binary inside node_modules for ${os}-${arch}`
@@ -34,7 +34,10 @@ function getExePath() {
  */
 function run() {
     const args = process.argv.slice(2);
-    const processResult = spawnSync(getExePath(), args, { stdio: "inherit" });
+    const path = getExePath();
+    const pathSeparator = ["win32", "cygwin"].includes(process.platform) ? "\\" : "/";
+    const parentDir = path.split(pathSeparator).slice(0, -2).join(pathSeparator);
+    const processResult = spawnSync(path, args, { cwd: parentDir, stdio: "inherit" });
     process.exit(processResult.status ?? 0);
 }
 
diff --git a/src/agent/mod.rs b/src/agent/mod.rs
@@ -2,6 +2,7 @@ use std::collections::HashSet;
 use std::fmt::Display;
 use std::fs;
 use std::path::Path;
+use std::path::PathBuf;
 // Copyright © 2025 Huly Labs. Use of this source code is governed by the MIT license.
 use std::sync::Arc;
 
@@ -87,12 +88,11 @@ struct AgentConfigState {
 }
 
 impl AgentConfigState {
-    pub fn new() -> Self {
-        if Path::new(CONFIG_STATE_FILE_PATH).exists() {
-            serde_yaml::from_str(
-                &std::fs::read_to_string(CONFIG_STATE_FILE_PATH).unwrap_or_default(),
-            )
-            .unwrap_or_default()
+    pub fn new(data_dir: &str) -> Self {
+        let path = Path::new(data_dir).join(CONFIG_STATE_FILE_PATH);
+        if path.exists() {
+            serde_yaml::from_str(&std::fs::read_to_string(path).unwrap_or_default())
+                .unwrap_or_default()
         } else {
             Self {
                 approved_tools: HashSet::default(),
@@ -132,6 +132,7 @@ fn pending_tool_id<'a>(messages: RwLockReadGuard<'a, Vec<Message>>) -> Option<St
 
 struct AgentContext {
     config: Config,
+    data_dir: PathBuf,
     config_state: Arc<RwLock<AgentConfigState>>,
     messages: Arc<RwLock<Vec<Message>>>,
     state: Arc<RwLock<AgentState>>,
@@ -144,11 +145,15 @@ struct AgentContext {
 }
 
 impl Agent {
-    pub fn new(config: Config, sender: mpsc::UnboundedSender<AgentOutputEvent>) -> Self {
+    pub fn new(
+        data_dir: &str,
+        config: Config,
+        sender: mpsc::UnboundedSender<AgentOutputEvent>,
+    ) -> Self {
         Self {
             config,
             sender,
-            memory: Arc::new(RwLock::new(MemoryManager::new(false))),
+            memory: Arc::new(RwLock::new(MemoryManager::new(data_dir, false))),
             process_registry: Arc::new(RwLock::new(ProcessRegistry::default())),
         }
     }
@@ -407,6 +412,7 @@ impl Agent {
 
     pub async fn run(
         &mut self,
+        data_dir: &str,
         receiver: mpsc::UnboundedReceiver<AgentControlEvent>,
         messages: Vec<Message>,
         memory_index: InMemoryVectorIndex<rig_fastembed::EmbeddingModel, Entity>,
@@ -463,10 +469,11 @@ impl Agent {
         let memory_index = Arc::new(RwLock::new(memory_index));
         let sender = self.sender.clone();
         let state = Arc::new(RwLock::new(state));
-        let config_state = Arc::new(RwLock::new(AgentConfigState::new()));
+        let config_state = Arc::new(RwLock::new(AgentConfigState::new(data_dir)));
 
         let events_context = AgentContext {
             config: self.config.clone(),
+            data_dir: PathBuf::from(data_dir),
             config_state: config_state.clone(),
             messages: messages.clone(),
             state: state.clone(),
@@ -480,6 +487,7 @@ impl Agent {
 
         let process_context = AgentContext {
             config: self.config.clone(),
+            data_dir: PathBuf::from(data_dir),
             config_state: config_state.clone(),
             messages: messages.clone(),
             state: state.clone(),
@@ -584,14 +592,14 @@ impl AgentContext {
     async fn persist_history(&self) {
         tracing::debug!("persist_history");
         let messages = self.messages.read().await;
-        persist_history(&messages);
+        persist_history(&self.data_dir, &messages);
     }
 
     async fn persist_config_state(&self) {
         tracing::debug!("persist_config_state");
         let state = self.config_state.read().await;
         fs::write(
-            CONFIG_STATE_FILE_PATH,
+            self.data_dir.join(CONFIG_STATE_FILE_PATH),
             serde_yaml::to_string(&*state).unwrap(),
         )
         .unwrap();
diff --git a/src/agent/utils.rs b/src/agent/utils.rs
@@ -132,9 +132,9 @@ pub async fn add_env_message<'a>(
     }
 }
 
-pub fn persist_history(messages: &[Message]) {
+pub fn persist_history(data_dir: &Path, messages: &[Message]) {
     fs::write(
-        HISTORY_PATH,
+        data_dir.join(HISTORY_PATH),
         serde_json::to_string_pretty(messages).unwrap(),
     )
     .unwrap();
diff --git a/src/config.rs b/src/config.rs
@@ -8,7 +8,6 @@ use serde::Deserialize;
 
 const CONFIG_FILE: &str = "huly-coder.yaml";
 const LOCAL_CONFIG_FILE: &str = "huly-coder-local.yaml";
-const DOCKER_LOCAL_CONFIG_FILE: &str = "data/huly-coder-local.yaml";
 
 #[derive(Debug, Deserialize, Clone)]
 pub enum ProviderKind {
@@ -98,7 +97,7 @@ pub struct Config {
 }
 
 impl Config {
-    pub fn new() -> color_eyre::Result<Self> {
+    pub fn new(custom_config: &str) -> color_eyre::Result<Self> {
         let mut builder = config::Config::builder()
             .add_source(config::File::with_name(CONFIG_FILE))
             .add_source(config::Environment::with_prefix("HULY_CODER"));
@@ -108,12 +107,6 @@ impl Config {
             builder = builder.add_source(config::File::with_name(LOCAL_CONFIG_FILE));
         }
 
-        // Docker related local config file that stored in /data directory
-        if Path::new(DOCKER_LOCAL_CONFIG_FILE).exists() {
-            tracing::info!("Found local config at {}", DOCKER_LOCAL_CONFIG_FILE);
-            builder = builder.add_source(config::File::with_name(DOCKER_LOCAL_CONFIG_FILE));
-        }
-
         let user_config = format!(
             "{}/{}",
             dirs::home_dir().unwrap().to_str().unwrap(),
@@ -123,6 +116,10 @@ impl Config {
             tracing::info!("Found user config at {}", user_config);
             builder = builder.add_source(config::File::with_name(&user_config));
         }
+        if Path::new(custom_config).exists() {
+            tracing::info!("Found custom config at {}", custom_config);
+            builder = builder.add_source(config::File::with_name(custom_config));
+        }
         if env::var("DOCKER_RUN").is_ok() {
             builder = builder.set_override("permission_mode", "full_autonomous")?;
         }
diff --git a/src/main.rs b/src/main.rs
@@ -1,8 +1,10 @@
+use std::fs;
 // Copyright © 2025 Huly Labs. Use of this source code is governed by the MIT license.
 use std::io;
 use std::io::stdout;
 use std::panic::set_hook;
 use std::panic::take_hook;
+use std::path::Path;
 
 use crossterm::execute;
 use crossterm::terminal::disable_raw_mode;
@@ -29,19 +31,26 @@ pub mod templates;
 pub mod tools;
 mod tui;
 
-const HISTORY_PATH: &str = "data/history.json";
-const CONFIG_STATE_FILE_PATH: &str = "data/config_state.yaml";
+const HISTORY_PATH: &str = "history.json";
+const CONFIG_STATE_FILE_PATH: &str = "config_state.yaml";
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
 struct Args {
     /// Skip loading previous session from history.json file
     #[arg(short, long)]
     skip_load_messages: bool,
+    /// Path to data directory
+    #[arg(short, long, default_value = "data")]
+    data: String,
+    /// Path to config file
+    #[arg(short, long, default_value = "huly-coder-local.yaml")]
+    config: String,
 }
 
-fn init_logger() {
-    let writer = tracing_appender::rolling::daily("data/logs", "huly-coder.log");
+fn init_logger(data_dir: &str) {
+    let log_dir = Path::new(data_dir).join("logs");
+    let writer = tracing_appender::rolling::daily(log_dir, "huly-coder.log");
     tracing_subscriber::registry()
         .with(
             tracing_subscriber::fmt::layer()
@@ -96,31 +105,46 @@ pub fn restore_tui() -> io::Result<()> {
 async fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
     init_panic_hook();
-    init_logger();
     let args = Args::parse();
 
+    init_logger(&args.data);
+
     tracing::info!("Start");
-    let config = Config::new()?;
+    let config = match Config::new(&args.config) {
+        Ok(config) => config,
+        Err(e) => {
+            ratatui::restore();
+            println!("Error: Failed to load config");
+            return Err(e);
+        }
+    };
+    let data_dir = Path::new(&args.data);
+    if !data_dir.exists() {
+        fs::create_dir_all(data_dir)?;
+    }
+    let history_path = data_dir.join(HISTORY_PATH);
     // start agent
     let (output_sender, output_receiver) =
         tokio::sync::mpsc::unbounded_channel::<AgentOutputEvent>();
     let (control_sender, control_receiver) =
         tokio::sync::mpsc::unbounded_channel::<AgentControlEvent>();
-    let history = if !args.skip_load_messages && std::path::Path::new(HISTORY_PATH).exists() {
-        serde_json::from_str(&std::fs::read_to_string(HISTORY_PATH).unwrap()).unwrap()
+    let history = if !args.skip_load_messages && history_path.exists() {
+        serde_json::from_str(&std::fs::read_to_string(history_path).unwrap()).unwrap()
     } else {
         Vec::new()
     };
 
-    let model_info = model_info(&config).await?;
+    let model_info = model_info(&args.data, &config).await?;
     tracing::info!("Model info: {:?}", model_info);
 
-    let mut agent = agent::Agent::new(config.clone(), output_sender);
+    let mut agent = agent::Agent::new(&args.data, config.clone(), output_sender);
     let memory_index = agent.init_memory_index().await;
 
     let messages = history.clone();
     let agent_handler = tokio::spawn(async move {
-        agent.run(control_receiver, messages, memory_index).await;
+        agent
+            .run(&args.data, control_receiver, messages, memory_index)
+            .await;
     });
 
     let terminal = init_tui().unwrap();
diff --git a/src/providers/model_info.rs b/src/providers/model_info.rs
@@ -6,7 +6,7 @@ use serde::Deserialize;
 
 use crate::config::Config;
 
-const OPENROUTER_MODELS_FILE: &str = "data/openrouter_models.json";
+const OPENROUTER_MODELS_FILE: &str = "openrouter_models.json";
 const ANTHROPIC_MODELS: &str = include_str!("anthropic_models.json");
 const OPENAI_MODELS: &str = include_str!("openai_models.json");
 
@@ -53,7 +53,8 @@ struct OpenAIModelInfo {
     pub max_context_tokens: u32,
 }
 
-pub async fn model_info(config: &Config) -> color_eyre::Result<ModelInfo> {
+pub async fn model_info(data_dir: &str, config: &Config) -> color_eyre::Result<ModelInfo> {
+    let openrouter_models_file = Path::new(data_dir).join(OPENROUTER_MODELS_FILE);
     match config.provider {
         crate::config::ProviderKind::OpenAI => {
             let models: Vec<OpenAIModelInfo> = serde_json::from_str(OPENAI_MODELS)?;
@@ -69,16 +70,16 @@ pub async fn model_info(config: &Config) -> color_eyre::Result<ModelInfo> {
         }
         crate::config::ProviderKind::OpenRouter => {
             let models: Vec<OpenRouterModelInfo> =
-                serde_json::from_value(if Path::new(OPENROUTER_MODELS_FILE).exists() {
-                    let data = fs::read_to_string(OPENROUTER_MODELS_FILE)?;
+                serde_json::from_value(if openrouter_models_file.exists() {
+                    let data = fs::read_to_string(openrouter_models_file)?;
                     serde_json::from_str(&data)?
                 } else {
                     let mut data = reqwest::get("https://openrouter.ai/api/v1/models")
                         .await?
                         .json::<serde_json::Value>()
                         .await?;
                     let data = data["data"].take();
-                    fs::write(OPENROUTER_MODELS_FILE, data.to_string())?;
+                    fs::write(openrouter_models_file, data.to_string())?;
                     data
                 })?;
             models
diff --git a/src/tools/memory/mod.rs b/src/tools/memory/mod.rs
@@ -4,6 +4,7 @@
 // Copyright © 2025 Huly Labs. Use of this source code is governed by the MIT license.
 use std::collections::HashSet;
 use std::fs;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use indicium::simple::{Indexable, SearchIndex};
@@ -19,7 +20,7 @@ use super::AgentToolError;
 mod tests;
 
 const TOOLS_STR: &str = include_str!("tools.json");
-const MEMORY_PATH: &str = "data/memory.yaml";
+const MEMORY_PATH: &str = "memory.yaml";
 
 #[derive(Clone, Deserialize)]
 struct JsonToolDefinition {
@@ -115,6 +116,7 @@ pub struct MemoryManager {
     memory_only: bool,
     knowledge_graph: KnowledgeGraph,
     search_index: SearchIndex<usize>,
+    data_dir: PathBuf,
 }
 
 impl Embed for Entity {
@@ -139,14 +141,15 @@ impl Indexable for Entity {
 }
 
 impl MemoryManager {
-    pub fn new(memory_only: bool) -> Self {
+    pub fn new(data_dir: &str, memory_only: bool) -> Self {
         let knowledge_graph = if !memory_only {
-            serde_yaml::from_str(&fs::read_to_string(MEMORY_PATH).unwrap_or_default()).unwrap_or(
-                KnowledgeGraph {
-                    entities: Vec::new(),
-                    relations: Vec::new(),
-                },
+            serde_yaml::from_str(
+                &fs::read_to_string(Path::new(data_dir).join(MEMORY_PATH)).unwrap_or_default(),
             )
+            .unwrap_or(KnowledgeGraph {
+                entities: Vec::new(),
+                relations: Vec::new(),
+            })
         } else {
             KnowledgeGraph {
                 entities: Vec::new(),
@@ -167,6 +170,7 @@ impl MemoryManager {
             memory_only,
             knowledge_graph,
             search_index,
+            data_dir: PathBuf::from(data_dir),
         }
     }
 
@@ -357,7 +361,7 @@ impl MemoryManager {
             });
         if !self.memory_only {
             fs::write(
-                MEMORY_PATH,
+                self.data_dir.join(MEMORY_PATH),
                 serde_yaml::to_string(&self.knowledge_graph).unwrap(),
             )
             .unwrap();

Original file line number	Diff line number	Diff line change
`@@ -132,9 +132,9 @@ pub async fn add_env_message<'a>(`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`135`		`-pub fn persist_history(messages: &[Message]) {`
	`135`	`+pub fn persist_history(data_dir: &Path, messages: &[Message]) {`
`136`	`136`	`fs::write(`
`137`		`- HISTORY_PATH,`
	`137`	`+ data_dir.join(HISTORY_PATH),`
`138`	`138`	`serde_json::to_string_pretty(messages).unwrap(),`
`139`	`139`	`)`
`140`	`140`	`.unwrap();`