Skip to main content

qualia_cli/
daemon.rs

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    /// Run in Development Mode (allows localhost origin and skips strict JWT pairing)
17    #[arg(long, global = true)]
18    pub dev: bool,
19    /// Local daemon port for the native bridge
20    #[arg(long, default_value_t = DEFAULT_DAEMON_PORT, global = true)]
21    pub port: u16,
22    /// Network Connectivity Profile (offline, metered, unmetered)
23    #[arg(long, default_value = "unmetered", global = true)]
24    pub net_mode: String,
25    /// Energy Circumstance Profile (strict, opportunistic, unlimited)
26    #[arg(long, default_value = "unlimited", global = true)]
27    pub energy_mode: String,
28    /// Fractal Sharding parallelism: number of 512MB cells to spin up
29    #[arg(long, default_value = "1", global = true)]
30    pub workers: u16,
31    /// Enable Sleep-Cycle Swarm AI Compute
32    #[arg(long, global = true)]
33    pub compute_swarm: bool,
34    /// Skip default graph seeding and startup ontologies (for docs/tests parity with WASM empty buffer)
35    #[arg(long, global = true)]
36    pub empty_graph: bool,
37}
38
39#[derive(Subcommand, Debug, Clone)]
40pub enum DaemonAction {
41    /// Run the graph daemon in the foreground (default when no subcommand is given)
42    Serve {
43        /// Hidden child mode used by `daemon start`
44        #[arg(long, hide = true)]
45        service_child: bool,
46    },
47    /// Start a detached daemon service on the loopback port (default 4242)
48    Start {
49        /// Replace an existing recorded service if its PID file is stale
50        #[arg(long)]
51        force: bool,
52    },
53    /// Stop the detached daemon service
54    Stop,
55    /// Report whether the detached daemon service is running
56    Status,
57    /// Inspect daemon health, port binding, and graph readiness
58    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
72/// Handles the subcommand action.
73pub 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
116/// Serves the daemon in the foreground.
117pub 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
221/// Starts the service.
222pub 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
275/// Stops the service.
276pub 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
325/// Prints status.
326pub 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
354/// Prints diagnostics.
355pub 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
398/// Pings the daemon.
399pub 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}