Edit photos by describing the change, on your own GPU. A free, open-source alternative to Nano Banana and ChatGPT image editing: photos stay on your computer, no daily limit. One installer for Windows, Mac and Linux sets up the best open model (Qwen-Image 2.1). MCP server for AI agents.
TypeScript ai-photo-editorcomfyui-alternativegenerative-fillimage-editingimage-generationinpaintinglinuxlocal-aimacosmcpmcp-servernano-banana-alternativeofflinephoto-editorprivacyqwen-imageqwen-image-2-1stable-diffusion-cppvulkanwindows
fix: start on a free port when Windows reserves Kokon's ports
Gabriele Lozuponea2703eb94e59
diff --git a/crates/qls-core/src/engine.rs b/crates/qls-core/src/engine.rsindex c4929fa..b1cb58b 100644--- a/crates/qls-core/src/engine.rs+++ b/crates/qls-core/src/engine.rs@@ -827,7 +827,7 @@ impl Engine {// Whether the running server can use the upscaler (an engine older than MoSR lists the// file but cannot run it; an external server may lack --hires-upscalers-dir):// enlargements fall back to Lanczos. Fresh, because the server rescans the folder.- let client = SdcppClient::new(cfg.server_port);+ let client = SdcppClient::new(self.server.port());let caps = client.capabilities(Duration::from_secs(5)).await.ok().or_else(|| self.server.capabilities()).unwrap_or_default();let esrgan = plan.upscaler.clone().filter(|n| caps.has_upscaler(n, true));let needs_esrgan = plan.upscale.is_some() || plan.output.area() as f64 > plan.content.area() as f64 * 1.21;diff --git a/crates/qls-core/src/process.rs b/crates/qls-core/src/process.rsindex d500afb..61d4716 100644--- a/crates/qls-core/src/process.rs+++ b/crates/qls-core/src/process.rs@@ -418,10 +418,13 @@ impl ServerManager {pub async fn ensure_ready(&self, cfg: &AppConfig) -> Result<Capabilities, AppError> {let _guard = self.start_lock.lock().await;let profile = cfg.profile().clone();- let client = SdcppClient::new(cfg.server_port);+ // Our server may run on a fallback port (see `launch_port`); otherwise the configured one.+ let rec = self.read_record().filter(|r| process_alive(r.pid));+ let port = rec.as_ref().map(|r| r.port).unwrap_or(cfg.server_port);+ let client = SdcppClient::new(port);if let Ok(caps) = client.capabilities(Duration::from_secs(3)).await {- let rec = self.read_record().filter(|r| r.port == cfg.server_port && process_alive(r.pid));+ let rec = rec.filter(|r| r.port == port);if caps.model_matches(&profile.diffusion_model) && caps.supports_img_gen() {let owned = rec.is_some();if let Some(r) = &rec@@ -433,7 +436,7 @@ impl ServerManager {g.state = ServerState::Ready;g.owned = owned;g.pid = rec.as_ref().map(|r| r.pid);- g.port = cfg.server_port;+ g.port = port;g.model = Some(caps.model.name.clone());g.error = None;g.caps = Some(caps.clone());@@ -443,30 +446,21 @@ impl ServerManager {});return Ok(caps);}- // Wrong model on our port.if let Some(r) = rec {tracing::info!("restarting owned sd-server (pid {}) for a different model", r.pid);kill_pid(r.pid);let _ = std::fs::remove_file(self.record_path());wait_port_free(&client, Duration::from_secs(15)).await;} else {- let e = AppError::new(- ErrorCode::ServerStartFailed,- format!("Port {} is used by another stable-diffusion.cpp server with a different model ({}).", cfg.server_port, caps.model.name),- )- .suggest("Stop that server or choose another port in Settings.");- self.set_state(|g| {- g.state = ServerState::Error;- g.error = Some(e.clone());- });- return Err(e);+ // Someone else's server with another model: ours starts on a free port.+ tracing::info!("port {port} is used by another stable-diffusion.cpp server ({}); starting ours on another port", caps.model.name);}}- self.spawn_and_wait(cfg, &profile, &client).await+ self.spawn_and_wait(cfg, &profile).await}- async fn spawn_and_wait(&self, cfg: &AppConfig, profile: &ModelProfile, client: &SdcppClient) -> Result<Capabilities, AppError> {+ async fn spawn_and_wait(&self, cfg: &AppConfig, profile: &ModelProfile) -> Result<Capabilities, AppError> {let fail = |e: AppError| {self.set_state(|g| {g.state = ServerState::Error;@@ -483,14 +477,34 @@ impl ServerManager {if let Some(d) = log_path.parent() {std::fs::create_dir_all(d).map_err(|e| fail(AppError::io("create the log folder", d, e)))?;}+ let mut port = launch_port(cfg.server_port).ok_or_else(|| fail(port_unavailable_error(cfg.server_port)))?;+ // sd-server exits with code 0 and no log line when it cannot listen (a port reserved+ // between our check and its bind): one more try on another free port.+ for attempt in 0..2 {+ match self.launch(cfg, profile, &exe, &log_path, port).await {+ Ok(caps) => return Ok(caps),+ Err(Launch::Failed(e)) => return Err(fail(e)),+ Err(Launch::NotListening) if attempt == 0 => {+ tracing::warn!("sd-server exited without listening on port {port}; retrying on another port");+ port = free_port().ok_or_else(|| fail(port_unavailable_error(port)))?;+ }+ Err(Launch::NotListening) => break,+ }+ }+ Err(fail(port_unavailable_error(port)))+ }++ async fn launch(&self, cfg: &AppConfig, profile: &ModelProfile, exe: &Path, log_path: &Path, port: u16) -> Result<Capabilities, Launch> {+ let fail = Launch::Failed;if log_path.exists() {- let _ = std::fs::rename(&log_path, log_path.with_extension("prev.log"));+ let _ = std::fs::rename(log_path, log_path.with_extension("prev.log"));}- let file = std::fs::File::create(&log_path).map_err(|e| fail(AppError::io("create the server log", &log_path, e)))?;- let args = build_server_args(cfg, profile);+ let file = std::fs::File::create(log_path).map_err(|e| fail(AppError::io("create the server log", log_path, e)))?;+ let run_cfg = AppConfig { server_port: port, ..cfg.clone() };+ let args = build_server_args(&run_cfg, profile);tracing::info!("starting {} {}", exe.display(), args.join(" "));- let mut cmd = std::process::Command::new(&exe);+ let mut cmd = std::process::Command::new(exe);cmd.args(&args).current_dir(&cfg.sdcpp_dir).stdin(std::process::Stdio::null())@@ -505,25 +519,30 @@ impl ServerManager {fail(AppError::new(ErrorCode::ServerStartFailed, "Could not launch sd-server.exe.").detail(e.to_string()))})?;let pid = child.id();- let rec = OwnedRecord { pid, port: cfg.server_port, model: profile.model_name(), log: log_path.clone() };+ let rec = OwnedRecord { pid, port, model: profile.model_name(), log: log_path.to_path_buf() };let _ = std::fs::write(self.record_path(), serde_json::to_string(&rec).unwrap_or_default());self.set_state(|g| {g.state = ServerState::Starting;g.owned = true;g.pid = Some(pid);- g.port = cfg.server_port;+ g.port = port;g.error = None;g.caps = None;g.started_at = Some(chrono::Utc::now());});- self.start_tail(&log_path, false);+ self.start_tail(log_path, false);+ let client = SdcppClient::new(port);let started = Instant::now();loop {if let Ok(Some(status)) = child.try_wait() {tokio::time::sleep(Duration::from_millis(300)).await;let tail = self.log.tail(40).join("\n");let _ = std::fs::remove_file(self.record_path());+ // Code 0 before answering = `svr.listen` failed (it logs "listening on" first).+ if status.success() {+ return Err(Launch::NotListening);+ }return Err(fail(translate_startup_failure(&format!("{tail}\n(exit status {status})"))));}if let Ok(caps) = client.capabilities(Duration::from_secs(2)).await {@@ -545,6 +564,11 @@ impl ServerManager {}}+ /// The port of the server in use; it can differ from the configured one (`launch_port`).+ pub fn port(&self) -> u16 {+ self.inner.lock().unwrap().port+ }+/// Stops the server if this app owns it. Never touches servers it did not start.pub async fn stop(&self) -> bool {let _guard = self.start_lock.lock().await;@@ -647,6 +671,36 @@ async fn wait_port_free(client: &SdcppClient, timeout: Duration) {}}+enum Launch {+ Failed(AppError),+ /// Exited with code 0 before answering: the port could not be opened.+ NotListening,+}++/// The configured port when it can be opened, otherwise a free one. Windows reserves port+/// ranges for Hyper-V, WSL and Docker (`netsh interface ipv4 show excludedportrange+/// protocol=tcp`), different at every boot; binding a reserved port fails with "access denied".+fn launch_port(configured: u16) -> Option<u16> {+ match std::net::TcpListener::bind(("127.0.0.1", configured)) {+ Ok(_) => Some(configured),+ Err(e) => {+ let p = free_port();+ tracing::warn!("port {configured} cannot be opened ({e}); using {p:?}");+ p+ }+ }+}++/// A port the system reports free right now.+pub fn free_port() -> Option<u16> {+ std::net::TcpListener::bind(("127.0.0.1", 0)).and_then(|l| l.local_addr()).map(|a| a.port()).ok()+}++fn port_unavailable_error(port: u16) -> AppError {+ AppError::new(ErrorCode::ServerStartFailed, format!("The inference server could not open a network port on this computer (last tried: {port})."))+ .suggest("Windows can reserve ports for Hyper-V, WSL or Docker. Restart the computer, or set another port in Settings → Performance.")+}+pub fn process_alive(pid: u32) -> bool {use sysinfo::{Pid, ProcessRefreshKind, ProcessesToUpdate, System};let mut sys = System::new();@@ -924,6 +978,17 @@ mod tests {assert_eq!(u.step, Some((20, 20)));}+ #[test]+ fn launch_port_falls_back_when_the_port_cannot_be_opened() {+ let taken = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();+ let busy = taken.local_addr().unwrap().port();+ let p = launch_port(busy).unwrap();+ assert_ne!(p, busy);+ assert!(std::net::TcpListener::bind(("127.0.0.1", p)).is_ok(), "the fallback is free");+ let free = free_port().unwrap();+ assert_eq!(launch_port(free), Some(free), "a free configured port is kept");+ }+#[test]fn parser_ignores_lines_before_a_job() {let mut p = ProgressParser::default();diff --git a/crates/qls-service/src/api.rs b/crates/qls-service/src/api.rsindex 71caa1e..466bda0 100644--- a/crates/qls-service/src/api.rs+++ b/crates/qls-service/src/api.rs@@ -203,7 +203,7 @@ async fn status(State(s): St) -> Json<Value> {Json(json!({"service": { "version": APP_VERSION, "pid": std::process::id(), "uptime_s": s.started.elapsed().as_secs() },"server": {- "state": srv.state, "owned": srv.owned, "pid": srv.pid, "port": cfg.server_port,+ "state": srv.state, "owned": srv.owned, "pid": srv.pid, "port": if srv.port > 0 { srv.port } else { cfg.server_port },"model": srv.model, "model_loaded": srv.state == qls_core::process::ServerState::Ready,"error": srv.error,"cancel_generating": srv.capabilities.as_ref().map(|c| c.img_feature("cancel_generating")),@@ -543,7 +543,7 @@ async fn diagnostics_json(State(s): St) -> ApiResult<Json<Value>> {.map(|d| d.installed_tag(&cfg.sdcpp_dir).unwrap_or_else(|| "none".into())).collect();let _ = writeln!(text, "Engine release: {} (expected {})", tags.join(", "), catalog::engine_tag());- let _ = writeln!(text, "State: {:?}, owned: {}, pid: {:?}, port: {}", srv.state, srv.owned, srv.pid, cfg.server_port);+ let _ = writeln!(text, "State: {:?}, owned: {}, pid: {:?}, port: {}", srv.state, srv.owned, srv.pid, srv.port);if let Some(e) = &srv.error {let _ = writeln!(text, "Last error: {} {}", e.message, e.detail.clone().unwrap_or_default());}diff --git a/crates/qls-service/src/main.rs b/crates/qls-service/src/main.rsindex 19075e3..dfba8ae 100644--- a/crates/qls-service/src/main.rs+++ b/crates/qls-service/src/main.rs@@ -77,6 +77,21 @@ fn load_or_create_token(dir: &std::path::Path) -> String {t}+/// The port of a kokon-service that answers its ping at the port recorded in service.json.+async fn running_service() -> Option<u16> {+ use tokio::io::{AsyncReadExt, AsyncWriteExt};+ let info: ServiceInfo = serde_json::from_str(&std::fs::read_to_string(service_info_path()).ok()?).ok()?;+ let ping = async {+ let mut s = tokio::net::TcpStream::connect(("127.0.0.1", info.port)).await.ok()?;+ s.write_all(b"GET /api/v1/ping HTTP/1.0\r\nHost: 127.0.0.1\r\n\r\n").await.ok()?;+ let mut buf = vec![0u8; 256];+ let n = s.read(&mut buf).await.ok()?;+ let head = String::from_utf8_lossy(&buf[..n]);+ (head.starts_with("HTTP/1.") && head.split(' ').nth(1) == Some("200")).then_some(info.port)+ };+ tokio::time::timeout(Duration::from_secs(2), ping).await.ok().flatten()+}+pub fn service_info_path() -> PathBuf {data_dir().join("service.json")}@@ -115,15 +130,30 @@ async fn main() {.and_then(|p| p.parse().ok()).unwrap_or(cfg.service_port);- // Single instance: binding the port is the lock. Loopback only.- let addr = SocketAddr::from(([127, 0, 0, 1], port));- let listener = match tokio::net::TcpListener::bind(addr).await {+ // Single instance: a kokon-service answering at the port in service.json. Loopback only.+ let listener = match tokio::net::TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], port))).await {Ok(l) => l,Err(e) => {- tracing::info!("port {port} busy ({e}); another kokon-service is probably running — exiting");- return;+ if let Some(other) = running_service().await {+ tracing::info!("port {port} busy ({e}); kokon-service is already running on port {other} — exiting");+ return;+ }+ // Reserved by Windows (Hyper-V/WSL/Docker excluded ranges, "access denied") or taken+ // by another program: any free port. Clients find it in service.json.+ match tokio::net::TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).await {+ Ok(l) => {+ tracing::warn!("port {port} cannot be opened ({e}); using {}", l.local_addr().map(|a| a.port()).unwrap_or(0));+ l+ }+ Err(e2) => {+ tracing::error!("port {port} cannot be opened ({e}) and no free port either ({e2}) — exiting");+ return;+ }+ }}};+ let addr = listener.local_addr().unwrap_or_else(|_| SocketAddr::from(([127, 0, 0, 1], port)));+ let port = addr.port();let engine = match Engine::new(cfg, &dir) {Ok(e) => e,