fix #183

Author: louis030195

screenpipe-server/src/bin/screenpipe-server.rs

@@ -87,10 +87,6 @@ async fn main() -> anyhow::Result<()> {
     if cli.debug {
         builder.filter_module("screenpipe", LevelFilter::Debug);
     }
-    // Example usage of the new flag
-    if cli.save_text_files {
-        debug!("Text files will be saved.");
-    }
 
     let local_data_dir = get_base_dir(cli.data_dir)?;
     let local_data_dir_clone = local_data_dir.clone();
@@ -134,7 +130,7 @@ async fn main() -> anyhow::Result<()> {
     if cli.list_monitors {
         println!("Available monitors:");
         for (_, monitor) in all_monitors.iter().enumerate() {
-            println!("  {}. {:?}", monitor.id(), monitor);
+            println!("  {}. {:?}", monitor.id, monitor);
         }
         return Ok(());
     }
@@ -238,7 +234,7 @@ async fn main() -> anyhow::Result<()> {
 
     let warning_ocr_engine_clone = cli.ocr_engine.clone();
     let warning_audio_transcription_engine_clone = cli.audio_transcription_engine.clone();
-    let monitor_id = cli.monitor_id.unwrap_or(all_monitors.first().unwrap().id());
+    let monitor_id = cli.monitor_id.unwrap_or(all_monitors.first().unwrap().id);
 
     // try to use the monitor selected, if not available throw an error
     get_monitor_by_id(monitor_id).await.unwrap_or_else(|| {
@@ -291,7 +287,6 @@ async fn main() -> anyhow::Result<()> {
                     Duration::from_secs(cli.audio_chunk_duration),
                     vision_control,
                     audio_devices_control,
-                    cli.save_text_files,
                     audio_transcription_engine,
                     ocr_engine,
                     friend_wearable_uid_clone, // Use the cloned version
@@ -374,7 +369,6 @@ async fn main() -> anyhow::Result<()> {
     println!("│ Port                │ {:<34} │", cli.port);
     println!("│ Audio Disabled      │ {:<34} │", cli.disable_audio);
     println!("│ Self Healing        │ {:<34} │", cli.self_healing);
-    println!("│ Save Text Files     │ {:<34} │", cli.save_text_files);
     println!(
         "│ Audio Engine        │ {:<34} │",
         format!("{:?}", warning_audio_transcription_engine_clone)

screenpipe-server/src/cli.rs

@@ -64,9 +64,8 @@ pub struct Cli {
     /// 5 FPS = 150 GB / month
     /// Optimise based on your needs.
     /// Your screen rarely change more than 1 times within a second, right?
-    #[cfg_attr(not(target_os = "macos"), arg(short, long, default_value_t = 1.0))]
-    #[cfg_attr(target_os = "macos", arg(short, long, default_value_t = 0.2))] 
-    pub fps: f64, // ! not crazy about this (unconsistent behaviour across platforms) see https://github.com/mediar-ai/screenpipe/issues/173
+    #[arg(short, long, default_value_t = 1)]
+    pub fps: u32, // ! not crazy about this (unconsistent behaviour across platforms) see https://github.com/mediar-ai/screenpipe/issues/173
 
     /// Audio chunk duration in seconds
     #[arg(short = 'd', long, default_value_t = 30)]
@@ -101,10 +100,6 @@ pub struct Cli {
     #[arg(long)]
     pub debug: bool,
 
-    /// Save text files
-    #[arg(long, default_value_t = false)]
-    pub save_text_files: bool,
-
     /// Audio transcription engine to use.
     /// Deepgram is a very high quality cloud-based transcription service (free of charge on us for now), recommended for high quality audio.
     /// WhisperTiny is a local, lightweight transcription model, recommended for high data privacy.

screenpipe-server/src/core.rs

@@ -21,11 +21,10 @@ use tokio::task::JoinHandle;
 pub async fn start_continuous_recording(
     db: Arc<DatabaseManager>,
     output_path: Arc<String>,
-    fps: f64,
+    fps: u32,
     audio_chunk_duration: Duration,
     vision_control: Arc<AtomicBool>,
     audio_devices_control: Arc<SegQueue<(AudioDevice, DeviceControl)>>,
-    save_text_files: bool,
     audio_transcription_engine: Arc<AudioTranscriptionEngine>,
     ocr_engine: Arc<OcrEngine>,
     friend_wearable_uid: Option<String>,
@@ -59,7 +58,6 @@ pub async fn start_continuous_recording(
             output_path_video,
             fps,
             is_running_video,
-            save_text_files,
             ocr_engine,
             friend_wearable_uid_video,
             monitor_id,
@@ -99,9 +97,8 @@ pub async fn start_continuous_recording(
 async fn record_video(
     db: Arc<DatabaseManager>,
     output_path: Arc<String>,
-    fps: f64,
+    fps: u32,
     is_running: Arc<AtomicBool>,
-    save_text_files: bool,
     ocr_engine: Arc<OcrEngine>,
     _friend_wearable_uid: Option<String>,
     monitor_id: u32,
@@ -125,52 +122,38 @@ async fn record_video(
         &output_path,
         fps,
         new_chunk_callback,
-        save_text_files,
         Arc::clone(&ocr_engine),
         monitor_id,
     );
 
     while is_running.load(Ordering::SeqCst) {
         if let Some(frame) = video_capture.ocr_frame_queue.pop() {
-            for window_result in &frame.window_ocr_results {
-                match db.insert_frame().await {
-                    Ok(frame_id) => {
-                        let text_json =
-                            serde_json::to_string(&window_result.text_json).unwrap_or_default();
-
-                        let text = if use_pii_removal {
-                            &remove_pii(&window_result.text)
-                        } else {
-                            &window_result.text
-                        };
-                        if let Err(e) = db
-                            .insert_ocr_text(
-                                frame_id,
-                                text,
-                                &text_json,
-                                &window_result.app_name,
-                                &window_result.window_name,
-                                Arc::clone(&ocr_engine),
-                                window_result.focused, // Add this line
-                            )
-                            .await
-                        {
-                            error!(
-                                "Failed to insert OCR text: {}, skipping window {} of frame {}",
-                                e, window_result.window_name, frame_id
-                            );
-                            continue;
-                        }
-                    }
-                    Err(e) => {
-                        warn!("Failed to insert frame: {}", e);
-                        tokio::time::sleep(Duration::from_millis(100)).await;
+            match db.insert_frame().await {
+                Ok(frame_id) => {
+                    let text = if use_pii_removal {
+                        &remove_pii(&frame.ocr_results)
+                    } else {
+                        &frame.ocr_results
+                    };
+                    if let Err(e) = db
+                        .insert_ocr_text(frame_id, text, &frame.raw_json, Arc::clone(&ocr_engine))
+                        .await
+                    {
+                        error!(
+                            "Failed to insert OCR text: {}, skipping frame {}",
+                            e, frame_id
+                        );
                         continue;
                     }
                 }
+                Err(e) => {
+                    warn!("Failed to insert frame: {}", e);
+                    tokio::time::sleep(Duration::from_millis(100)).await;
+                    continue;
+                }
             }
         }
-        tokio::time::sleep(Duration::from_secs_f64(1.0 / fps)).await;
+        tokio::time::sleep(Duration::from_millis(100)).await;
     }
 
     Ok(())

screenpipe-server/src/db.rs

@@ -337,27 +337,16 @@ impl DatabaseManager {
         &self,
         frame_id: i64,
         text: &str,
-        text_json: &str,
-        app_name: &str,
-        window_name: &str,
+        raw_json: &str,
         ocr_engine: Arc<OcrEngine>,
-        focused: bool,
     ) -> Result<(), sqlx::Error> {
         const MAX_RETRIES: u32 = 3;
         const TIMEOUT_DURATION: TokioDuration = TokioDuration::from_secs(10);
 
         for attempt in 1..=MAX_RETRIES {
             match timeout(
                 TIMEOUT_DURATION,
-                self.insert_ocr_text_old(
-                    frame_id,
-                    text,
-                    text_json,
-                    app_name,
-                    window_name,
-                    Arc::clone(&ocr_engine),
-                    focused,
-                ),
+                self.insert_ocr_text_old(frame_id, text, raw_json, Arc::clone(&ocr_engine)),
             )
             .await
             {
@@ -459,39 +448,26 @@ impl DatabaseManager {
         &self,
         frame_id: i64,
         text: &str,
-        text_json: &str,
-        app_name: &str,
-        window_name: &str,
+        raw_json: &str,
         ocr_engine: Arc<OcrEngine>,
-        focused: bool,
     ) -> Result<(), sqlx::Error> {
-        let display_window_name = if window_name.chars().count() > 20 {
-            format!("{}...", window_name.chars().take(20).collect::<String>())
-        } else {
-            window_name.to_string()
-        };
-
         debug!(
-            "Inserting OCR: frame_id {}, app {}, window {}, focused {}, text {}{}",
+            "Inserting OCR: frame_id {}, text {}{}",
             frame_id,
-            app_name,
-            display_window_name,
-            focused,
             text.replace('\n', " ").chars().take(60).collect::<String>(),
             if text.len() > 60 { "..." } else { "" },
         );
 
         let mut tx = self.pool.begin().await?;
-        sqlx::query("INSERT INTO ocr_text (frame_id, text, text_json, app_name, ocr_engine, window_name, focused) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)")
-            .bind(frame_id)
-            .bind(text)
-            .bind(text_json)
-            .bind(app_name)
-            .bind(format!("{:?}", *ocr_engine))
-            .bind(window_name)
-            .bind(focused)
-            .execute(&mut *tx)
-            .await?;
+        sqlx::query(
+            "INSERT INTO ocr_text (frame_id, text, text_json, ocr_engine) VALUES (?1, ?2, ?3, ?4)",
+        )
+        .bind(frame_id)
+        .bind(text)
+        .bind(raw_json)
+        .bind(format!("{:?}", *ocr_engine))
+        .execute(&mut *tx)
+        .await?;
 
         tx.commit().await?;
         debug!("OCR text inserted into db successfully");

screenpipe-server/src/resource_monitor.rs

@@ -180,7 +180,6 @@ impl ResourceMonitor {
         let client = reqwest::Client::new();
         match client.get("http://localhost:3030/health").send().await {
             Ok(response) => {
-                debug!("Health check response: {:?}", response);
                 if response.status().is_success() {
                     *self.health_check_failures.lock().await = 0;
                 } else {

screenpipe-server/src/server.rs

@@ -313,11 +313,11 @@ pub async fn api_list_monitors(
     let monitor_info: Vec<MonitorInfo> = monitors
         .into_iter()
         .map(|monitor| MonitorInfo {
-            id: monitor.id(),
-            name: monitor.name().to_string(),
-            width: monitor.width(),
-            height: monitor.height(),
-            is_default: monitor.is_primary(),
+            id: monitor.id,
+            name: monitor.name,
+            width: monitor.width,
+            height: monitor.height,
+            is_default: monitor.is_primary,
         })
         .collect();