Fix moose config reading w/ read only config

Author: LucioFranco

apps/framework-cli/src/cli/routines/mod.rs

@@ -467,11 +467,8 @@ pub async fn start_development_mode(
     settings: &Settings,
     enable_mcp: bool,
 ) -> anyhow::Result<()> {
-    // Set global flag so ensure_typescript_compiled knows to skip
-    // (tspc --watch handles compilation in dev mode)
     use crate::utilities::constants::IS_DEV_MODE;
     use std::sync::atomic::Ordering;
-    IS_DEV_MODE.store(true, Ordering::Relaxed);
 
     display::show_message_wrapper(
         MessageType::Info,
@@ -515,8 +512,29 @@ pub async fn start_development_mode(
     // For TypeScript, initial compilation is required (no ts-node fallback). Fail fast if it fails.
     let ts_compile_handle = if project.language == SupportedLanguages::Typescript {
         use crate::cli::ts_compilation_watcher::spawn_and_await_initial_compile;
+        use crate::framework::typescript::parser::ensure_typescript_compiled;
         match spawn_and_await_initial_compile(&project).await {
-            Ok(handle) => Some(handle),
+            Ok(Some(handle)) => {
+                // tspc --watch is working; set IS_DEV_MODE so ensure_typescript_compiled
+                // is a no-op (tspc --watch handles compilation going forward)
+                IS_DEV_MODE.store(true, Ordering::Relaxed);
+                Some(handle)
+            }
+            Ok(None) => {
+                // Old moose-tspc without --watch support: run single compilation,
+                // then use FileWatcher for watching changes
+                warn!("moose-tspc does not support --watch; using file watcher fallback");
+                display::show_message_wrapper(
+                    MessageType::Highlight,
+                    Message {
+                        action: "Fallback".to_string(),
+                        details: "moose-tspc does not support --watch; using file watcher"
+                            .to_string(),
+                    },
+                );
+                ensure_typescript_compiled(&project)?;
+                None
+            }
             Err(e) => {
                 error!("Initial TypeScript compilation failed: {}", e);
                 display::show_message_wrapper(
@@ -739,44 +757,38 @@ pub async fn start_development_mode(
     // Create shutdown channel for graceful watcher termination
     let (watcher_shutdown_tx, watcher_shutdown_rx) = tokio::sync::watch::channel(false);
 
-    // Use TypeScript compilation watcher for TS projects (incremental compilation)
-    // Use file watcher for Python projects
+    // Use TypeScript compilation watcher when tspc --watch is available (ts_compile_handle is Some),
+    // otherwise use file watcher (Python projects, or TypeScript with old moose-tspc)
     let state_storage = Arc::new(state_storage);
-    match project.language {
-        SupportedLanguages::Typescript => {
-            // Pass the handle from spawn_and_await_initial_compile() if we have one.
-            // This continues watching the already-running tspc process instead of
-            // spawning a new one, and ensures we don't trigger duplicate plan_changes.
-            let ts_watcher = TsCompilationWatcher::new();
-            ts_watcher.start(
-                project.clone(),
-                route_update_channel,
-                webapp_update_channel,
-                infra_map,
-                process_registry.clone(),
-                metrics.clone(),
-                state_storage,
-                settings.clone(),
-                processing_coordinator.clone(),
-                watcher_shutdown_rx,
-                ts_compile_handle,
-            )?;
-        }
-        SupportedLanguages::Python => {
-            let file_watcher = FileWatcher::new();
-            file_watcher.start(
-                project.clone(),
-                route_update_channel,
-                webapp_update_channel,
-                infra_map,
-                process_registry.clone(),
-                metrics.clone(),
-                state_storage,
-                settings.clone(),
-                processing_coordinator.clone(),
-                watcher_shutdown_rx,
-            )?;
-        }
+    if let Some(handle) = ts_compile_handle {
+        let ts_watcher = TsCompilationWatcher::new();
+        ts_watcher.start(
+            project.clone(),
+            route_update_channel,
+            webapp_update_channel,
+            infra_map,
+            process_registry.clone(),
+            metrics.clone(),
+            state_storage,
+            settings.clone(),
+            processing_coordinator.clone(),
+            watcher_shutdown_rx,
+            Some(handle),
+        )?;
+    } else {
+        let file_watcher = FileWatcher::new();
+        file_watcher.start(
+            project.clone(),
+            route_update_channel,
+            webapp_update_channel,
+            infra_map,
+            process_registry.clone(),
+            metrics.clone(),
+            state_storage,
+            settings.clone(),
+            processing_coordinator.clone(),
+            watcher_shutdown_rx,
+        )?;
     }
 
     // Log MCP server status

apps/framework-cli/src/cli/settings.rs

@@ -290,10 +290,28 @@ is_moose_developer=false
                     }
                 };
 
-                table.entry("enabled").or_insert(value(true));
-                table.entry("is_moose_developer").or_insert(value(false));
-
-                std::fs::write(path, toml.to_string())?;
+                let mut changed = false;
+                if let Entry::Vacant(e) = table.entry("enabled") {
+                    e.insert(value(true));
+                    changed = true;
+                }
+                if let Entry::Vacant(e) = table.entry("is_moose_developer") {
+                    e.insert(value(false));
+                    changed = true;
+                }
+
+                if changed {
+                    if let Err(e) = std::fs::write(&path, toml.to_string()) {
+                        if e.kind() == std::io::ErrorKind::PermissionDenied {
+                            warn!(
+                                "Config file {} is read-only (externally managed); skipping write",
+                                path.display()
+                            );
+                            return Ok(());
+                        }
+                        return Err(e);
+                    }
+                }
             }
             Err(e) => {
                 show_message!(
@@ -426,7 +444,17 @@ pub fn set_suppress_dev_setup_prompt(value_to_set: bool) -> Result<(), std::io::
         }
     }
 
-    std::fs::write(path, doc.to_string())
+    if let Err(e) = std::fs::write(&path, doc.to_string()) {
+        if e.kind() == std::io::ErrorKind::PermissionDenied {
+            warn!(
+                "Config file {} is read-only (externally managed); skipping write",
+                path.display()
+            );
+            return Ok(());
+        }
+        return Err(e);
+    }
+    Ok(())
 }
 
 /// Updates the global CLI config (~/.moose/config.toml) to set the
@@ -457,7 +485,17 @@ pub fn set_docs_default_language(language: &str) -> Result<(), std::io::Error> {
         }
     }
 
-    std::fs::write(path, doc.to_string())
+    if let Err(e) = std::fs::write(&path, doc.to_string()) {
+        if e.kind() == std::io::ErrorKind::PermissionDenied {
+            warn!(
+                "Config file {} is read-only (externally managed); skipping write",
+                path.display()
+            );
+            return Ok(());
+        }
+        return Err(e);
+    }
+    Ok(())
 }
 
 #[cfg(test)]

apps/framework-cli/src/cli/ts_compilation_watcher.rs

@@ -128,7 +128,7 @@ fn spawn_tspc_watch(project: &Project) -> Result<Child, TsCompilationWatcherErro
 /// then call `start()` to begin background watching.
 pub async fn spawn_and_await_initial_compile(
     project: &Project,
-) -> Result<InitialCompileHandle, TsCompilationWatcherError> {
+) -> Result<Option<InitialCompileHandle>, TsCompilationWatcherError> {
     debug!(
         "Spawning moose-tspc --watch for initial compilation: {:?}",
         project.app_dir().display()
@@ -210,7 +210,7 @@ pub async fn spawn_and_await_initial_compile(
                         } else if event.is_compile_complete() {
                             display_compilation_success(&event);
                             // Initial compilation done! Return handle for continued watching.
-                            return Ok(InitialCompileHandle { child, line_rx });
+                            return Ok(Some(InitialCompileHandle { child, line_rx }));
                         }
                     }
                     Err(_) => {
@@ -220,12 +220,14 @@ pub async fn spawn_and_await_initial_compile(
                 }
             }
             None => {
-                // Kill the child process to avoid resource leak
+                // moose-tspc exited without producing any JSON events.
+                // This means the installed version doesn't support --watch
+                // (it interpreted --watch as an outDir argument, ran a single
+                // compilation, and exited). Fall back to FileWatcher.
+                warn!("moose-tspc exited without JSON events, --watch not supported; falling back to single compilation");
                 let _ = child.kill();
                 let _ = child.wait();
-                return Err(TsCompilationWatcherError::ReadError(
-                    "tspc process closed stdout before initial compilation completed".into(),
-                ));
+                return Ok(None);
             }
         }
     }