feat: SIGKILL when SIGTERM don't to the job

src/lib.rs

@@ -2,6 +2,8 @@ pub mod config;
 pub mod container;
 pub mod db;
 pub mod known_ports;
+pub mod ports;
+pub mod process;
 pub mod scanner;
 pub mod template;
 
@@ -65,7 +67,7 @@ pub fn create_router(state: AppState) -> Router {
             get(get_app).put(update_app).delete(delete_app),
         )
         .route("/events", get(sse_handler))
-        .route("/api/kill/{port}", post(kill_port))
+        .route("/api/kill/{port}", post(kill_port_handler))
         .route("/api/refresh", post(trigger_refresh))
         .route("/api/tag-colors", get(list_tag_colors))
         .route(
@@ -122,14 +124,8 @@ async fn publish_scan(state: &AppState, alive: &[u16]) {
     let tag_colors = db::list_tag_colors(&state.db).await.unwrap_or_default();
     let container_ports = container::discover().await;
 
-    // Merge container ports into alive list
     let mut merged_alive = alive.to_vec();
-    for cp in &container_ports {
-        if !merged_alive.contains(&cp.port) && cp.port != state.dashboard_port {
-            merged_alive.push(cp.port);
-        }
-    }
-    merged_alive.sort_unstable();
+    ports::merge_alive(&mut merged_alive, &container_ports, state.dashboard_port);
 
     let rows = template::build_rows(&merged_alive, &apps, &container_ports);
     let total = rows.len();
@@ -220,13 +216,7 @@ pub async fn scanner_loop(
         if is_full_scan {
             cached_container_ports = container::discover().await;
         }
-        // Add container ports that the TCP scan might have missed
-        for cp in &cached_container_ports {
-            if !alive.contains(&cp.port) && cp.port != dashboard_port {
-                alive.push(cp.port);
-            }
-        }
-        alive.sort_unstable();
+        ports::merge_alive(&mut alive, &cached_container_ports, dashboard_port);
 
         let rows = template::build_rows(&alive, &apps, &cached_container_ports);
         let total = rows.len();
@@ -454,31 +444,20 @@ async fn trigger_refresh(State(state): State<AppState>) -> StatusCode {
     StatusCode::NO_CONTENT
 }
 
-async fn kill_port(State(state): State<AppState>, Path(port): Path<u16>) -> StatusCode {
-    let output = std::process::Command::new("lsof")
-        .args(["-ti", &format!(":{port}"), "-sTCP:LISTEN"])
-        .output();
-
-    let Ok(output) = output else {
-        return StatusCode::INTERNAL_SERVER_ERROR;
-    };
-
-    let pids: Vec<&str> = std::str::from_utf8(&output.stdout)
-        .unwrap_or("")
-        .lines()
-        .filter(|l| !l.is_empty())
-        .collect();
-
-    if pids.is_empty() {
-        return StatusCode::NOT_FOUND;
-    }
-
-    for pid in &pids {
-        let _ = std::process::Command::new("kill").arg(pid).status();
+async fn kill_port_handler(
+    State(state): State<AppState>,
+    Path(port): Path<u16>,
+) -> Result<StatusCode, (StatusCode, String)> {
+    match process::kill_port(port).await {
+        process::KillResult::NotFound => {
+            Err((StatusCode::NOT_FOUND, "Nothing running".to_string()))
+        }
+        process::KillResult::Error(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e)),
+        process::KillResult::Killed | process::KillResult::ForceKilled => {
+            state.scan_notify.notify_one();
+            Ok(StatusCode::NO_CONTENT)
+        }
     }
-
-    state.scan_notify.notify_one();
-    StatusCode::NO_CONTENT
 }
 
 // -- SSE live updates --
@@ -588,13 +567,7 @@ async fn dashboard(State(state): State<AppState>, headers: HeaderMap) -> Respons
         state.dashboard_port,
     )
     .await;
-    // Add container ports
-    for cp in &container_ports {
-        if !alive.contains(&cp.port) && cp.port != state.dashboard_port {
-            alive.push(cp.port);
-        }
-    }
-    alive.sort_unstable();
+    ports::merge_alive(&mut alive, &container_ports, state.dashboard_port);
     let tag_colors = db::list_tag_colors(&state.db).await.unwrap_or_default();
     let html = template::render(
         &alive,

src/main.rs

@@ -200,13 +200,7 @@ async fn cmd_list(db_path: &str, dashboard_port: u16) {
     let mut alive = portmap::scanner::scan_ports(1000, 9999, 0).await;
     let container_ports = portmap::container::discover().await;
 
-    // Add container ports that TCP scan might have missed
-    for cp in &container_ports {
-        if !alive.contains(&cp.port) {
-            alive.push(cp.port);
-        }
-    }
-    alive.sort_unstable();
+    portmap::ports::merge_alive(&mut alive, &container_ports, 0);
 
     if apps.is_empty() && alive.is_empty() {
         println!("No ports found.");
@@ -391,8 +385,6 @@ async fn cmd_update(
 }
 
 async fn cmd_kill(db_path: &str, target: &str) {
-    use std::process::Command as Cmd;
-
     let db = portmap::db::init(db_path)
         .await
         .expect("Failed to open database");
@@ -403,27 +395,6 @@ async fn cmd_kill(db_path: &str, target: &str) {
         return;
     };
 
-    // Find PIDs *listening* on this port (not clients connected to it)
-    let output = Cmd::new("lsof")
-        .args(["-ti", &format!(":{port}"), "-sTCP:LISTEN"])
-        .output();
-
-    let Ok(output) = output else {
-        eprintln!("Failed to run lsof");
-        return;
-    };
-
-    let pids: Vec<&str> = std::str::from_utf8(&output.stdout)
-        .unwrap_or("")
-        .lines()
-        .filter(|l| !l.is_empty())
-        .collect();
-
-    if pids.is_empty() {
-        println!("Nothing running on :{port}");
-        return;
-    }
-
     let display = app.as_ref().map_or(format!(":{port}"), |a| {
         if a.name.is_empty() {
             format!(":{port}")
@@ -432,10 +403,14 @@ async fn cmd_kill(db_path: &str, target: &str) {
         }
     });
 
-    for pid in &pids {
-        let _ = Cmd::new("kill").arg(pid).status();
+    match portmap::process::kill_port(port).await {
+        portmap::process::KillResult::NotFound => println!("Nothing running on :{port}"),
+        portmap::process::KillResult::Killed => println!("Killed {display} (port {port})"),
+        portmap::process::KillResult::ForceKilled => {
+            println!("Force killed {display} (port {port})");
+        }
+        portmap::process::KillResult::Error(e) => eprintln!("Error: {e}"),
     }
-    println!("Killed {display} (port {port})");
 }
 
 fn is_homebrew_install() -> bool {

src/ports.rs

@@ -0,0 +1,109 @@
+use crate::container::ContainerPort;
+use crate::db::App;
+
+/// Merge TCP scan results with container ports into a single alive list.
+/// Container ports outside the scan range are added automatically.
+pub fn merge_alive(alive: &mut Vec<u16>, container_ports: &[ContainerPort], exclude_port: u16) {
+    for cp in container_ports {
+        if !alive.contains(&cp.port) && cp.port != exclude_port {
+            alive.push(cp.port);
+        }
+    }
+    alive.sort_unstable();
+}
+
+/// A unified port entry used by both CLI and API.
+#[derive(Clone)]
+pub struct PortEntry {
+    pub port: u16,
+    pub name: String,
+    pub category: String,
+    pub source: String,
+    pub registered: bool,
+    pub alive: bool,
+}
+
+/// Build a merged list of port entries from apps, alive ports, and container data.
+/// This is the single source of truth for how ports are presented.
+pub fn build_port_entries(
+    alive: &[u16],
+    apps: &[App],
+    container_ports: &[ContainerPort],
+) -> Vec<PortEntry> {
+    let container_map: std::collections::HashMap<u16, &ContainerPort> =
+        container_ports.iter().map(|cp| (cp.port, cp)).collect();
+    let mut entries = Vec::new();
+    let mut seen_ports = std::collections::HashSet::new();
+
+    // Alive ports first
+    for &port in alive {
+        seen_ports.insert(port);
+        let app = apps.iter().find(|a| a.port == i64::from(port));
+        let cp = container_map.get(&port);
+        let source = cp.map_or(String::new(), |c| c.source.clone());
+
+        if let Some(a) = app {
+            entries.push(PortEntry {
+                port,
+                name: if a.name.is_empty() {
+                    String::new()
+                } else {
+                    a.name.clone()
+                },
+                category: a.category.clone(),
+                source,
+                registered: true,
+                alive: true,
+            });
+        } else if let Some(c) = cp {
+            entries.push(PortEntry {
+                port,
+                name: c.container_name.clone(),
+                category: String::new(),
+                source: c.source.clone(),
+                registered: false,
+                alive: true,
+            });
+        } else if let Some(k) = crate::known_ports::lookup(port) {
+            entries.push(PortEntry {
+                port,
+                name: k.name.to_string(),
+                category: "macos".to_string(),
+                source: String::new(),
+                registered: false,
+                alive: true,
+            });
+        } else {
+            entries.push(PortEntry {
+                port,
+                name: String::new(),
+                category: String::new(),
+                source: String::new(),
+                registered: false,
+                alive: true,
+            });
+        }
+    }
+
+    // Offline registered apps
+    for app in apps {
+        let port = u16::try_from(app.port).unwrap_or(0);
+        if seen_ports.contains(&port) {
+            continue;
+        }
+        entries.push(PortEntry {
+            port,
+            name: if app.name.is_empty() {
+                String::new()
+            } else {
+                app.name.clone()
+            },
+            category: app.category.clone(),
+            source: String::new(),
+            registered: true,
+            alive: false,
+        });
+    }
+
+    entries
+}