Fix several morloc-manager bugs

- unfreeze hangs forever during validation because the serve image
  ENTRYPOINT causes --help to run as router args instead of a direct
  command. Fixed by adding --entrypoint "" override.

- stop <env> silently kills a different running container when the named
  one isn't serving. Removed the fallback; now returns error.

- freeze produces base_image "unknown" when active env comes from system
  config fallback. Now checks system config like resolve_active_env_name
  does.

- daemon logs spurious "read error" on first /call/ because the router's
  readiness probe connects then closes without sending data. Added
  MSG_PEEK to silently ignore EOF probe connections.

- start hint leaked raw docker/podman command instead of morloc-manager logs.

- ls output now shows "Local environments:" header with indentation,
  matching the system environments section.

Author: arendsee

data/rust/morloc-manager/src/freeze.rs

@@ -67,17 +67,26 @@ pub fn freeze_from_dir(
     eprintln!("Created {tar_path}");
     let now = Utc::now();
 
-    // Get base image from the active environment config
-    let m_cfg = config::read_active_config();
-    let active_env_name = m_cfg.as_ref().and_then(|c| c.active_env.as_deref());
-
-    let (base_img, env_layer) = if let Some(env_name) = active_env_name {
-        match config::read_env_config(scope, env_name) {
+    // Get base image from the active environment config.
+    // Check local config first, then system config for the active env name
+    // (mirrors resolve_active_env_name in environment.rs).
+    let active_env_name: Option<String> = config::read_active_config()
+        .and_then(|c| c.active_env)
+        .or_else(|| {
+            let sys_path = config::config_path(Scope::System);
+            config::read_config::<Config>(&sys_path)
+                .ok()
+                .and_then(|c| c.active_env)
+        });
+
+    let (base_img, env_layer) = if let Some(ref env_name) = active_env_name {
+        let env_scope = config::find_env_scope(env_name).unwrap_or(scope);
+        match config::read_env_config(env_scope, env_name) {
             Ok(ec) => {
                 let base = ec.base_image.clone();
                 // Capture env layer info if there's a Dockerfile
                 let layer = if ec.dockerfile.is_some() {
-                    let df_path = config::env_dockerfile_path(scope, env_name);
+                    let df_path = config::env_dockerfile_path(env_scope, env_name);
                     if df_path.exists() {
                         let df_contents = fs::read_to_string(&df_path).unwrap_or_default();
                         let content_hash = ec.content_hash.unwrap_or_default();

data/rust/morloc-manager/src/main.rs

@@ -1055,12 +1055,15 @@ fn dispatch(verbose: bool, cmd: Cmd) -> Result<()> {
                 let local_active = if active_in_local { active_str } else { None };
                 let envs = environment::list_environments(Scope::Local, local_active);
                 total += envs.len();
-                for e in envs {
-                    let active_mark = if e.active { " (active)" } else { "" };
-                    let ver_mark = e.morloc_version
-                        .map(|v| format!(" [{}]", v.show()))
-                        .unwrap_or_default();
-                    println!("{}{}{}", e.name, ver_mark, active_mark);
+                if !envs.is_empty() {
+                    println!("Local environments:");
+                    for e in envs {
+                        let active_mark = if e.active { " (active)" } else { "" };
+                        let ver_mark = e.morloc_version
+                            .map(|v| format!(" [{}]", v.show()))
+                            .unwrap_or_default();
+                        println!("  {}{}{}", e.name, ver_mark, active_mark);
+                    }
                 }
             }
             if show_system {
@@ -1071,7 +1074,7 @@ fn dispatch(verbose: bool, cmd: Cmd) -> Result<()> {
                     if show_local {
                         println!();
                     }
-                    println!("System:");
+                    println!("System environments:");
                     for e in envs {
                         let active_mark = if e.active { " (active)" } else { "" };
                         let ver_mark = e.morloc_version
@@ -1472,10 +1475,9 @@ fn dispatch(verbose: bool, cmd: Cmd) -> Result<()> {
                 serve::stop_serve_container(ec.engine, verbose, &container_name)?;
                 eprintln!("Stopped serving environment: {env_name}");
             } else {
-                // Fallback: scan for running serve containers
-                let (found_name, found_engine) = find_running_serve_container()?;
-                serve::stop_serve_container(found_engine, verbose, &found_name)?;
-                eprintln!("Stopped {found_name} (active env '{env_name}' was not serving)");
+                return Err(ManagerError::EnvError(
+                    format!("No serve container running for environment '{env_name}'")
+                ));
             }
             Ok(())
         }

data/rust/morloc-manager/src/serve.rs

@@ -247,7 +247,7 @@ pub fn run_serve_container(
             if state == "running" {
                 eprintln!("Container {name} started");
                 eprintln!("  Stop:   morloc-manager stop {name}");
-                eprintln!("  Logs:   {exe} logs -f {name}");
+                eprintln!("  Logs:   morloc-manager logs");
                 eprintln!("  Status: morloc-manager status");
                 Ok(())
             } else {
@@ -357,7 +357,7 @@ pub fn serve_environment(
             if state == "running" {
                 eprintln!("Container {container_name} started");
                 eprintln!("  Stop:   morloc-manager stop");
-                eprintln!("  Logs:   {exe} logs -f {container_name}");
+                eprintln!("  Logs:   morloc-manager logs");
                 eprintln!("  Status: morloc-manager status");
                 Ok(())
             } else {
@@ -489,14 +489,17 @@ pub fn validate_programs(
         let exe_path = format!("{}/bin/{}", CONTAINER_MORLOC_HOME, prog.name);
         if verbose {
             let exe = engine_executable(engine);
-            eprintln!("[morloc-manager] {exe} run --rm {image} {exe_path} --help");
+            eprintln!("[morloc-manager] {exe} run --rm --entrypoint '' {image} {exe_path} --help");
         }
         let cfg = RunConfig {
             bind_mounts: bind_mounts.clone(),
             command: Some(vec![exe_path, "--help".to_string()]),
             env: vec![
                 ("MORLOC_HOME".to_string(), CONTAINER_MORLOC_HOME.to_string()),
             ],
+            // Override the image ENTRYPOINT so the command runs directly
+            // instead of being appended to the router entrypoint.
+            extra_flags: vec!["--entrypoint".to_string(), "".to_string()],
             ..RunConfig::new(image)
         };
         let (status, _stdout, stderr) = container_run_quiet(engine, &cfg);

data/rust/morloc-runtime/src/daemon_ffi.rs

@@ -1333,6 +1333,17 @@ unsafe fn handle_lp_connection(
     let mut errmsg: *mut c_char = ptr::null_mut();
     let mut msg_len: usize = 0;
 
+    // Peek to distinguish a probe connection (immediate EOF) from a real
+    // client.  The router's readiness check connects then closes without
+    // sending data; silently ignore those.
+    let mut peek_buf = [0u8; 1];
+    let peek_n = libc::recv(client_fd, peek_buf.as_mut_ptr() as *mut c_void, 1, libc::MSG_PEEK);
+    if peek_n == 0 {
+        // Clean EOF — probe connection, silently close.
+        libc::close(client_fd);
+        return;
+    }
+
     let msg = read_lp_message(client_fd, &mut msg_len, &mut errmsg);
     if !errmsg.is_null() {
         let err_str = CStr::from_ptr(errmsg).to_string_lossy();