Skip to main content

aios_daemon/
lib.rs

1//! # dipecsd - DiPECS system daemon
2//!
3//! Deployment path: `/system/bin/dipecsd`
4//! Startup: `dipecsd [--no-daemon] [--verbose]`
5//!
6//! ## Runtime Modes
7//!
8//! - daemon mode: fork to the background and keep collecting system events
9//! - `--no-daemon`: foreground mode for debugging and development
10//!
11//! ## Data Flow
12//!
13//! ```text
14//! Task 1 (collection): BinderProbe + ProcReader + SysCollector -> bus.raw_events_tx
15//! Task 2 (processing): bus.raw_events_rx -> PrivacyAirGap -> WindowAggregator
16//!                      -> DecisionRouter -> PolicyEngine -> ActionExecutor
17//! ```
18//!
19//! ## Current Implementation Status
20//!
21//! - ProcReader: available on Linux/Android
22//! - SystemStateCollector: available with battery/network fallback
23//! - BinderProbe/FanotifyMonitor: interfaces complete; real fd/eBPF attach requires privileged deployment
24//! - Decision routing: RuleBased, LocalEvaluator, CloudLlm, and FallbackNoOp
25//! - Action execution: Android bridge plus local fallback behavior
26use std::time::Duration;
27
28use aios_action::{AndroidAdapter, AndroidBridgeConfig, DefaultActionExecutor};
29use aios_agent::{DecisionRouter, ProfileSummarizer};
30use aios_core::action_bus::ActionBus;
31use aios_core::action_lifecycle::ActionLifecycle;
32use aios_core::context_builder::WindowAggregator;
33use aios_core::context_memory::{ModelMemoryConfig, ModelMemoryStore};
34use aios_core::governance::ActionAdapter;
35use aios_core::policy_engine::PolicyEngine;
36use aios_core::privacy_airgap::DefaultPrivacyAirGap;
37
38mod collection;
39mod daemon;
40pub mod pipeline;
41
42use collection::{run_collection_loop, SystemRawEventSource, BINDER_POLL_INTERVAL_MS};
43use pipeline::{timestamp_ms, ProfileSummaryWorker, RuntimeTraceRecorder, WindowProcessingDeps};
44
45/// Context window duration, in seconds.
46const WINDOW_DURATION_SECS: u64 = 10;
47const ANDROID_TRACE_JSONL_ENV: &str = "DIPECS_ANDROID_TRACE_JSONL";
48const RUNTIME_TRACE_OUTPUT_ENV: &str = "DIPECS_RUNTIME_TRACE_OUTPUT";
49const PROFILE_SUMMARY_INTERVAL_ENV: &str = "DIPECS_PROFILE_SUMMARY_INTERVAL_WINDOWS";
50
51pub async fn run() -> anyhow::Result<()> {
52    // 1. Initialize logging
53    tracing_subscriber::fmt()
54        .with_env_filter(
55            tracing_subscriber::EnvFilter::from_default_env().add_directive("dipecs=info".parse()?),
56        )
57        .init();
58
59    // 2. Parse command-line arguments
60    let args: Vec<String> = std::env::args().collect();
61    let no_daemon = args.iter().any(|a| a == "--no-daemon");
62    let android_trace_jsonl = android_trace_jsonl_path(&args);
63    let runtime_trace_output = runtime_trace_output_path(&args);
64
65    if !no_daemon {
66        daemon::daemonize();
67    }
68    tracing::info!("dipecsd starting (no-daemon={})", no_daemon);
69    if let Some(path) = &android_trace_jsonl {
70        tracing::info!(
71            path = %path.display(),
72            "Android collector JSONL ingress enabled"
73        );
74    }
75    if let Some(path) = &runtime_trace_output {
76        tracing::info!(path = %path.display(), "daemon runtime trace enabled");
77    }
78
79    // 3. Initialize ActionBus and shutdown signals
80    // split 交出 raw sender 的所有权(不在 bus 里残留副本): Task 1 收尾落地 sender 后,
81    // raw 通道才会关闭, Task 2 处理循环据此 flush 最后窗口并退出。
82    let (collect_raw_tx, raw_rx, _intent_tx, _intent_rx) = ActionBus::new(4096).split();
83    // ---- Task 1: collection ----
84    let collect_shutdown = daemon::install_signal_handlers();
85    // Task 1 通过真实采集循环把事件推进 raw 通道。事件源是 SystemRawEventSource
86    // (封装 proc/sys/binder/android 采集器); 收到 shutdown 即返回, sender 落地关闭通道。
87    let collect_source = SystemRawEventSource::new(android_trace_jsonl);
88    let collect_handle = tokio::spawn(run_collection_loop(
89        Box::new(collect_source),
90        collect_raw_tx,
91        collect_shutdown,
92        Duration::from_millis(BINDER_POLL_INTERVAL_MS),
93    ));
94
95    // ---- Task 2: processing pipeline (main task) ----
96    tracing::info!("processing task started");
97
98    let sanitizer = DefaultPrivacyAirGap;
99    let router = DecisionRouter::default();
100    let profile_summarizer = ProfileSummarizer::from_env()
101        .map_err(|error| anyhow::anyhow!("profile summarizer configuration failed: {error}"))?;
102    let mut profile_summary_worker =
103        ProfileSummaryWorker::new(profile_summarizer, profile_summary_interval_windows());
104    let policy = PolicyEngine::default();
105    // Adapter selection at startup (not per-action): if the Android bridge is
106    // configured via env, route through the on-device AndroidAdapter; otherwise
107    // use the deterministic desktop stub. This is the minimal AdapterRegistry.
108    let adapter: Box<dyn ActionAdapter> = match AndroidBridgeConfig::from_env() {
109        Some(config) => {
110            tracing::info!(
111                host = %config.host,
112                port = config.port,
113                "Android action bridge enabled; routing through AndroidAdapter"
114            );
115            Box::new(AndroidAdapter::new(config))
116        },
117        None => Box::new(DefaultActionExecutor::new()),
118    };
119    let lifecycle = ActionLifecycle::new(&policy, adapter.as_ref());
120    let mut trace_recorder = match runtime_trace_output {
121        Some(path) => Some(RuntimeTraceRecorder::new(&path).map_err(|error| {
122            anyhow::anyhow!(
123                "opening daemon runtime trace output {} failed: {error}",
124                path.display()
125            )
126        })?),
127        None => None,
128    };
129    let window_dur = Duration::from_secs(WINDOW_DURATION_SECS);
130    let window = WindowAggregator::new(WINDOW_DURATION_SECS, timestamp_ms());
131    let model_memory_config = ModelMemoryConfig::from_env();
132    let mut model_memory = ModelMemoryStore::load_or_default(&model_memory_config);
133
134    // Task 2 独占 raw 通道; Task 1 收尾落地 sender → 通道关闭 → 循环 flush 最后窗口后返回。
135    let mut deps = WindowProcessingDeps {
136        router: &router,
137        lifecycle: &lifecycle,
138        memory: &mut model_memory,
139        memory_config: &model_memory_config,
140        profile_summary_worker: Some(&mut profile_summary_worker),
141        trace_recorder: trace_recorder.as_mut(),
142    };
143    let summary =
144        pipeline::run_processing_loop(raw_rx, &sanitizer, window, window_dur, &mut deps).await;
145    tracing::info!(
146        windows_closed = summary.windows_closed,
147        events_processed = summary.events_processed,
148        terminated_by = ?summary.terminated_by,
149        "processing loop finished"
150    );
151
152    // Wait for collection task to finish
153    let _ = collect_handle.await;
154
155    tracing::info!("dipecsd stopped");
156    Ok(())
157}
158
159fn profile_summary_interval_windows() -> u32 {
160    std::env::var(PROFILE_SUMMARY_INTERVAL_ENV)
161        .ok()
162        .and_then(|value| value.parse::<u32>().ok())
163        .filter(|value| *value > 0)
164        .unwrap_or(10)
165}
166
167fn android_trace_jsonl_path(args: &[String]) -> Option<std::path::PathBuf> {
168    let from_arg = args
169        .windows(2)
170        .find(|pair| pair[0] == "--android-trace-jsonl")
171        .map(|pair| std::path::PathBuf::from(&pair[1]));
172    from_arg.or_else(|| {
173        std::env::var(ANDROID_TRACE_JSONL_ENV)
174            .ok()
175            .filter(|value| !value.trim().is_empty())
176            .map(std::path::PathBuf::from)
177    })
178}
179
180fn runtime_trace_output_path(args: &[String]) -> Option<std::path::PathBuf> {
181    let from_arg = args
182        .windows(2)
183        .find(|pair| pair[0] == "--trace-output")
184        .map(|pair| std::path::PathBuf::from(&pair[1]));
185    from_arg.or_else(|| {
186        std::env::var(RUNTIME_TRACE_OUTPUT_ENV)
187            .ok()
188            .filter(|value| !value.trim().is_empty())
189            .map(std::path::PathBuf::from)
190    })
191}