1use clap::{Args, Subcommand};
2use serde::{Deserialize, Serialize};
3use std::fs;
4use std::path::PathBuf;
5use std::process::{Command, Stdio};
6use std::time::Duration;
7use sysinfo::{Pid, Signal, System};
8
9pub const DEFAULT_DAEMON_PORT: u16 = 4242;
10const PID_FILE_NAME: &str = "daemon-service.json";
11const LOG_FILE_NAME: &str = "daemon-service.log";
12const ERR_LOG_FILE_NAME: &str = "daemon-service.err.log";
13
14#[derive(Args, Debug, Clone)]
15pub struct DaemonOpts {
16 #[arg(long, global = true)]
18 pub dev: bool,
19 #[arg(long, default_value_t = DEFAULT_DAEMON_PORT, global = true)]
21 pub port: u16,
22 #[arg(long, default_value = "unmetered", global = true)]
24 pub net_mode: String,
25 #[arg(long, default_value = "unlimited", global = true)]
27 pub energy_mode: String,
28 #[arg(long, default_value = "1", global = true)]
30 pub workers: u16,
31 #[arg(long, global = true)]
33 pub compute_swarm: bool,
34 #[arg(long, global = true)]
36 pub empty_graph: bool,
37}
38
39#[derive(Subcommand, Debug, Clone)]
40pub enum DaemonAction {
41 Serve {
43 #[arg(long, hide = true)]
45 service_child: bool,
46 },
47 Start {
49 #[arg(long)]
51 force: bool,
52 },
53 Stop,
55 Status,
57 Doctor,
59}
60
61#[derive(Debug, Serialize, Deserialize)]
62struct DaemonServiceRecord {
63 pid: u32,
64 port: u16,
65 dev: bool,
66 started_at: String,
67 log_path: String,
68 workers: u16,
69 compute_swarm: bool,
70}
71
72pub async fn handle(action: &DaemonAction, opts: &DaemonOpts) {
74 match action {
75 DaemonAction::Serve { service_child } => {
76 if *service_child {
77 let _ = write_service_record(DaemonServiceRecord {
78 pid: std::process::id(),
79 port: opts.port,
80 dev: opts.dev,
81 started_at: chrono::Utc::now().to_rfc3339(),
82 log_path: log_file_path().display().to_string(),
83 workers: opts.workers,
84 compute_swarm: opts.compute_swarm,
85 });
86 }
87 serve_foreground(opts, !*service_child).await;
88 }
89 DaemonAction::Start { force } => {
90 if let Err(err) = start_service(opts, *force) {
91 eprintln!("Failed to start daemon service: {err}");
92 std::process::exit(1);
93 }
94 }
95 DaemonAction::Stop => {
96 if let Err(err) = stop_service() {
97 eprintln!("Failed to stop daemon service: {err}");
98 std::process::exit(1);
99 }
100 }
101 DaemonAction::Status => {
102 if let Err(err) = print_status() {
103 eprintln!("Failed to inspect daemon service: {err}");
104 std::process::exit(1);
105 }
106 }
107 DaemonAction::Doctor => {
108 if let Err(err) = print_doctor(opts.port) {
109 eprintln!("Daemon doctor failed: {err}");
110 std::process::exit(1);
111 }
112 }
113 }
114}
115
116pub async fn serve_foreground(opts: &DaemonOpts, wait_for_ctrl_c: bool) {
118 let is_dev = opts.dev;
119 println!(
120 "Starting Qualia Native Loopback Server on 127.0.0.1:{}",
121 opts.port
122 );
123
124 println!("============================================================");
125 println!("Qualia-DB Zero-Allocation Native Local Daemon Booting...");
126 println!("============================================================");
127 println!("Network Mode: {}", opts.net_mode.to_uppercase());
128 println!("Energy Mode: {}", opts.energy_mode.to_uppercase());
129 println!("Fractal Shards: {} independent 512MB cells", opts.workers);
130 if opts.compute_swarm {
131 println!("Sleep-Cycle Swarm: ENABLED (Waiting for idle state...)");
132 }
133
134 if wait_for_ctrl_c {
135 tokio::spawn(async {
136 if let Ok(client) = reqwest::Client::builder()
137 .user_agent("qualia-cli-update-checker")
138 .build()
139 {
140 if let Ok(res) = client
141 .get("https://crates.io/api/v1/crates/qualia-cli")
142 .send()
143 .await
144 {
145 if let Ok(json) = res.json::<serde_json::Value>().await {
146 if let Some(version) = json["crate"]["max_version"].as_str() {
147 let current_version = env!("CARGO_PKG_VERSION");
148 if version != current_version {
149 println!("\n========================================");
150 println!(
151 "A new version of qualia-cli (v{}) is available!",
152 version
153 );
154 println!(" You are currently running v{}", current_version);
155 println!(" Run `cargo install qualia-cli --force` to update.");
156 println!("========================================\n");
157 }
158 }
159 }
160 }
161 }
162 });
163 }
164
165 if is_dev {
166 println!("WARNING: Running in DEV MODE. Trusting localhost origins.");
167 } else {
168 println!(
169 "Strict Origin Enforcement enabled: Trusting webizen.au and mediaprophet.github.io"
170 );
171 }
172
173 let storage_dir = std::env::var("QUALIA_DATA_DIR").unwrap_or_else(|_| ".".to_string());
174 let vault = qualia_core_db::key_vault::KeyVault::load_or_generate(&storage_dir)
175 .expect("Failed to load KeyVault");
176 let signing_key_bytes = vault.get_master_key_bytes();
177 let vault_arc = std::sync::Arc::new(std::sync::Mutex::new(vault));
178 if let Err(error) = webizen_render::poet_preview::register_poet_render_provider() {
179 eprintln!("POET renderer provider was not replaced: {error}");
180 }
181 let library_root = std::env::var("QUALIA_STORAGE_PATH")
182 .map(PathBuf::from)
183 .unwrap_or_else(|_| {
184 PathBuf::from(qualia_client_core::state::load_config_from_disk().storage_path)
185 });
186 if let Err(error) =
187 qualia_client_core::poet_library_provider::register_semantic_library_provider(
188 library_root,
189 signing_key_bytes,
190 )
191 {
192 eprintln!("POET Semantic Library provider was not replaced: {error}");
193 }
194 qualia_core_db::daemon::configure_daemon_topology(qualia_core_db::daemon::DaemonTopology {
195 worker_cells_configured: opts.workers,
196 compute_swarm_enabled: opts.compute_swarm,
197 });
198 qualia_core_db::daemon::start_local_daemon_with_options(
199 opts.port,
200 is_dev,
201 vault_arc,
202 opts.empty_graph,
203 )
204 .await;
205
206 if wait_for_ctrl_c {
207 println!("[Qualia Daemon] All subsystems active. Press Ctrl-C to shut down.");
208 tokio::signal::ctrl_c()
209 .await
210 .expect("Failed to install Ctrl-C handler");
211 println!("[Qualia Daemon] Shutdown signal received. Goodbye.");
212 } else {
213 println!(
214 "[Qualia Daemon] Background service active on 127.0.0.1:{}.",
215 opts.port
216 );
217 std::future::pending::<()>().await;
218 }
219}
220
221pub fn start_service(opts: &DaemonOpts, force: bool) -> Result<(), String> {
223 ensure_runtime_dir()?;
224
225 if let Some(record) = read_service_record()? {
226 if pid_is_running(record.pid) {
227 return Err(format!(
228 "daemon already running (pid {}, port {}). Use `qualia-cli daemon stop` first.",
229 record.pid, record.port
230 ));
231 }
232 if !force {
233 eprintln!(
234 "Removing stale daemon service record for pid {} on port {}.",
235 record.pid, record.port
236 );
237 }
238 let _ = clear_service_record();
239 }
240
241 let launched_pid = spawn_detached_service(opts)?;
242
243 for _ in 0..40 {
244 std::thread::sleep(Duration::from_millis(250));
245 if let Some(record) = read_service_record()? {
246 if record.port == opts.port && ping_daemon(opts.port).is_ok() {
247 println!(
248 "Daemon service started on http://127.0.0.1:{} (pid {}).",
249 record.port, record.pid
250 );
251 return Ok(());
252 }
253 }
254 }
255
256 let pid_hint = read_service_record()?
257 .map(|record| record.pid.to_string())
258 .or_else(|| launched_pid.map(|pid| pid.to_string()))
259 .unwrap_or_else(|| "unknown".to_string());
260 match ping_daemon(opts.port) {
261 Ok(_) => {
262 println!(
263 "Daemon service started on http://127.0.0.1:{} (pid {}).",
264 opts.port, pid_hint
265 );
266 Ok(())
267 }
268 Err(err) => Err(format!(
269 "spawned pid {pid_hint}, but health probe failed: {err}. Check {}",
270 err_log_file_path().display()
271 )),
272 }
273}
274
275pub fn stop_service() -> Result<(), String> {
277 let Some(record) = read_service_record()? else {
278 println!("Daemon service is not running.");
279 return Ok(());
280 };
281
282 if !pid_is_running(record.pid) {
283 clear_service_record()?;
284 println!(
285 "Removed stale daemon service record for pid {}.",
286 record.pid
287 );
288 return Ok(());
289 }
290
291 let mut system = System::new_all();
292 system.refresh_all();
293 let pid = Pid::from_u32(record.pid);
294 let Some(process) = system.process(pid) else {
295 clear_service_record()?;
296 println!(
297 "Removed stale daemon service record for pid {}.",
298 record.pid
299 );
300 return Ok(());
301 };
302
303 let terminated = process.kill_with(Signal::Term).unwrap_or(false) || process.kill();
304 if !terminated {
305 return Err(format!("unable to terminate pid {}", record.pid));
306 }
307
308 for _ in 0..15 {
309 if !pid_is_running(record.pid) {
310 clear_service_record()?;
311 println!("Stopped daemon service pid {}.", record.pid);
312 return Ok(());
313 }
314 std::thread::sleep(Duration::from_millis(200));
315 }
316
317 clear_service_record()?;
318 println!(
319 "Sent termination to pid {} and cleared the daemon service record.",
320 record.pid
321 );
322 Ok(())
323}
324
325pub fn print_status() -> Result<(), String> {
327 let Some(record) = read_service_record()? else {
328 println!("stopped");
329 return Ok(());
330 };
331
332 let running = pid_is_running(record.pid);
333 let health = ping_daemon(record.port).ok();
334 let health_label = if health.is_some() {
335 "healthy"
336 } else {
337 "unreachable"
338 };
339
340 if running {
341 println!(
342 "running pid={} port={} dev={} health={}",
343 record.pid, record.port, record.dev, health_label
344 );
345 } else {
346 println!(
347 "stale pid={} port={} dev={} health={}",
348 record.pid, record.port, record.dev, health_label
349 );
350 }
351 Ok(())
352}
353
354pub fn print_doctor(default_port: u16) -> Result<(), String> {
356 println!("Daemon doctor");
357 println!(" foreground : qualia-cli daemon --dev");
358 println!(
359 " background : qualia-cli daemon start --dev --port {}",
360 default_port
361 );
362
363 match read_service_record()? {
364 Some(record) => {
365 println!(
366 " service record : pid={} port={} dev={}",
367 record.pid, record.port, record.dev
368 );
369 println!(" pid alive : {}", pid_is_running(record.pid));
370 println!(" log file : {}", record.log_path);
371
372 match ping_daemon(record.port) {
373 Ok(body) => {
374 println!(" health : ok");
375 if let Some(version) = body.get("engine_version").and_then(|v| v.as_str()) {
376 println!(" engine_version : {version}");
377 }
378 }
379 Err(err) => {
380 println!(" health : failed ({err})");
381 }
382 }
383 }
384 None => {
385 println!(" service record : none");
386 match ping_daemon(default_port) {
387 Ok(_) => println!(
388 " health : foreground daemon responding on port {default_port}"
389 ),
390 Err(_) => println!(" health : service not running"),
391 }
392 }
393 }
394
395 Ok(())
396}
397
398pub fn ping_daemon(port: u16) -> Result<serde_json::Value, String> {
400 use std::io::{Read, Write};
401 use std::net::{SocketAddr, TcpStream};
402
403 let url = format!("http://127.0.0.1:{port}/health");
404 let addr: SocketAddr = format!("127.0.0.1:{port}")
405 .parse()
406 .map_err(|e| format!("parse {url}: {e}"))?;
407 let mut stream = TcpStream::connect_timeout(&addr, Duration::from_secs(3))
408 .map_err(|e| format!("connect {url}: {e}"))?;
409 stream
410 .set_read_timeout(Some(Duration::from_secs(3)))
411 .map_err(|e| e.to_string())?;
412 let request =
413 format!("GET /health HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n");
414 stream
415 .write_all(request.as_bytes())
416 .map_err(|e| format!("write {url}: {e}"))?;
417
418 let mut body = String::new();
419 stream
420 .read_to_string(&mut body)
421 .map_err(|e| format!("read {url}: {e}"))?;
422 let json_start = body
423 .find('{')
424 .ok_or_else(|| format!("no JSON body in {url} response"))?;
425 serde_json::from_str(&body[json_start..]).map_err(|e| format!("decode {url}: {e}"))
426}
427
428fn spawn_detached_service(opts: &DaemonOpts) -> Result<Option<u32>, String> {
429 #[cfg(windows)]
430 {
431 spawn_detached_service_windows(opts)
432 }
433
434 #[cfg(not(windows))]
435 {
436 spawn_detached_service_portable(opts)
437 }
438}
439
440#[cfg(windows)]
441fn spawn_detached_service_windows(opts: &DaemonOpts) -> Result<Option<u32>, String> {
442 let current_exe = std::env::current_exe().map_err(|e| e.to_string())?;
443 let log = log_file_path();
444 let err = err_log_file_path();
445 let batch = runtime_dir().join("daemon-start.cmd");
446 let mut line = format!(
447 "@echo off\r\n\"{}\" daemon serve --port {} --net-mode {} --energy-mode {} --workers {} --service-child",
448 current_exe.display(),
449 opts.port,
450 opts.net_mode,
451 opts.energy_mode,
452 opts.workers
453 );
454 if opts.dev {
455 line.push_str(" --dev");
456 }
457 if opts.compute_swarm {
458 line.push_str(" --compute-swarm");
459 }
460 if opts.empty_graph {
461 line.push_str(" --empty-graph");
462 }
463 line.push_str(&format!(
464 " 1>> \"{}\" 2>> \"{}\"\r\n",
465 log.display(),
466 err.display()
467 ));
468 fs::write(&batch, line).map_err(|e| format!("write {}: {e}", batch.display()))?;
469
470 let mut command = Command::new("cmd");
471 command
472 .arg("/C")
473 .arg("start")
474 .arg("/B")
475 .arg("")
476 .arg(&batch)
477 .stdin(Stdio::null());
478
479 use std::os::windows::process::CommandExt;
480 const CREATE_NO_WINDOW: u32 = 0x08000000;
481 const CREATE_NEW_PROCESS_GROUP: u32 = 0x00000200;
482 command.creation_flags(CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP);
483
484 let child = command.spawn().map_err(|e| format!("spawn failed: {e}"))?;
485 Ok(Some(child.id()))
486}
487
488#[cfg(not(windows))]
489fn spawn_detached_service_portable(opts: &DaemonOpts) -> Result<Option<u32>, String> {
490 let current_exe = std::env::current_exe().map_err(|e| e.to_string())?;
491 let log = log_file_path();
492 let err = err_log_file_path();
493 let mut inner = format!(
494 "exec \"{}\" daemon serve --port {} --net-mode {} --energy-mode {} --workers {} --service-child",
495 current_exe.display(),
496 opts.port,
497 opts.net_mode,
498 opts.energy_mode,
499 opts.workers
500 );
501 if opts.dev {
502 inner.push_str(" --dev");
503 }
504 if opts.compute_swarm {
505 inner.push_str(" --compute-swarm");
506 }
507 if opts.empty_graph {
508 inner.push_str(" --empty-graph");
509 }
510 inner.push_str(&format!(
511 " >>\"{}\" 2>>\"{}\"",
512 log.display(),
513 err.display()
514 ));
515
516 let child = Command::new("sh")
517 .arg("-c")
518 .arg(&inner)
519 .stdin(Stdio::null())
520 .spawn()
521 .map_err(|e| format!("spawn failed: {e}"))?;
522 Ok(Some(child.id()))
523}
524
525fn ensure_runtime_dir() -> Result<(), String> {
526 fs::create_dir_all(runtime_dir()).map_err(|e| e.to_string())
527}
528
529fn runtime_dir() -> PathBuf {
530 state_dir().join("run")
531}
532
533fn state_dir() -> PathBuf {
534 if let Ok(dir) = std::env::var("QUALIA_DATA_DIR") {
535 return PathBuf::from(dir);
536 }
537 if let Ok(dir) = std::env::var("QUALIA_STORAGE_PATH") {
538 return PathBuf::from(dir);
539 }
540 if let Ok(dir) = std::env::current_dir() {
541 return dir.join(".qualia");
542 }
543 if let Ok(home) = std::env::var("HOME") {
544 return PathBuf::from(home).join(".qualia");
545 }
546 if let Ok(home) = std::env::var("USERPROFILE") {
547 return PathBuf::from(home).join(".qualia");
548 }
549 PathBuf::from(".qualia")
550}
551
552fn pid_file_path() -> PathBuf {
553 runtime_dir().join(PID_FILE_NAME)
554}
555
556fn log_file_path() -> PathBuf {
557 runtime_dir().join(LOG_FILE_NAME)
558}
559
560fn err_log_file_path() -> PathBuf {
561 runtime_dir().join(ERR_LOG_FILE_NAME)
562}
563
564fn read_service_record() -> Result<Option<DaemonServiceRecord>, String> {
565 let path = pid_file_path();
566 if !path.exists() {
567 return Ok(None);
568 }
569 let raw = fs::read_to_string(&path).map_err(|e| format!("read {}: {e}", path.display()))?;
570 let record =
571 serde_json::from_str(&raw).map_err(|e| format!("decode {}: {e}", path.display()))?;
572 Ok(Some(record))
573}
574
575fn write_service_record(record: DaemonServiceRecord) -> Result<(), String> {
576 ensure_runtime_dir()?;
577 let path = pid_file_path();
578 let raw = serde_json::to_string_pretty(&record).map_err(|e| e.to_string())?;
579 fs::write(&path, raw).map_err(|e| format!("write {}: {e}", path.display()))
580}
581
582fn clear_service_record() -> Result<(), String> {
583 let path = pid_file_path();
584 if path.exists() {
585 fs::remove_file(&path).map_err(|e| format!("remove {}: {e}", path.display()))?;
586 }
587 Ok(())
588}
589
590fn pid_is_running(pid: u32) -> bool {
591 let mut system = System::new_all();
592 system.refresh_all();
593 system.process(Pid::from_u32(pid)).is_some()
594}