YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context
Rust agentsagiaiai-memoryaudio-recordingcomputer-visionhermeshermes-agentllmlocal-ailocal-firstmachine-learningmcpmultimodalopenclawprivacyrewindscreen-recordingspeech-to-textycombinator
Checkpoint screenshots with each historical backfill page (#7445)
Ezra Elletted0530992e74b
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/enterprise/backfill.rs b/apps/screenpipe-app-tauri/src-tauri/src/enterprise/backfill.rsindex 53526fac6..371aad5ec 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/enterprise/backfill.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/enterprise/backfill.rs@@ -26,6 +26,10 @@ pub(super) struct BackfillRequest {start_at: chrono::DateTime<chrono::Utc>,end_at: chrono::DateTime<chrono::Utc>,streams: Vec<BackfillStream>,+ #[serde(default)]+ pub(super) images_only: bool,+ #[serde(default)]+ pub(super) source_id: Option<String>,}impl BackfillRequest {@@ -36,6 +40,10 @@ impl BackfillRequest {|| self.start_at >= self.end_at|| self.end_at > chrono::Utc::now()|| self.streams.is_empty()+ || self.images_only+ && (self.source_id.as_deref().is_none_or(str::is_empty)+ || self.streams.len() != 1+ || !matches!(self.streams[0], BackfillStream::Frames)){return Err(EnterpriseSyncError::Configuration("invalid backfill target or range".into(),@@ -48,6 +56,12 @@ impl BackfillRequest {&self,policy: SyncStreams,) -> Result<SyncStreams, EnterpriseSyncError> {+ if self.images_only && policy.frame_images != crate::enterprise_policy::FrameImagesMode::All+ {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_policy_disabled",+ ));+ }let mut result = SyncStreams {frames: false,audio: false,@@ -166,6 +180,149 @@ struct Pending {request: Option<BackfillRequest>,}+/// Outcomes acknowledged by storage, checkpointed with the telemetry page.+/// Missing pixels are never counted as uploaded screenshots.+#[derive(Debug, Clone, Default, Serialize, Deserialize)]+pub(super) struct ImageProgress {+ pub uploaded: u64,+ pub unavailable: u64,+}++#[derive(Deserialize)]+struct ImageAck {+ stored: Vec<i64>,+ // Older servers do not acknowledge terminal outcomes explicitly. Keep+ // the page pending until the server upgrade rather than infer success.+ #[serde(default)]+ unavailable: Vec<i64>,+ #[serde(default)]+ failed: Vec<ImageFailure>,+}++#[derive(Deserialize)]+struct ImageFailure {+ frame_id: Option<i64>,+ reason: String,+}++pub(super) async fn upload_page_images(+ cfg: &EnterpriseSyncConfig,+ local: &dyn LocalApiClient,+ http: &reqwest::Client,+ frames: &[FrameRow],+) -> Result<ImageProgress, EnterpriseSyncError> {+ if !matches!(+ cfg.upload_mode,+ EnterpriseUploadMode::HostedIngest | EnterpriseUploadMode::DirectReadable(_)+ ) {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_storage_mode_blocked",+ ));+ }+ let base = control_plane_base(&cfg.ingest_url).ok_or(EnterpriseSyncError::BackfillImages(+ "screenshot_endpoint_unavailable",+ ))?;+ let guard_source = cfg.stable_device_id.is_some()+ || uuid::Uuid::parse_str(&cfg.device_id).is_ok_and(|id| id.get_version_num() == 4);+ let mut progress = ImageProgress::default();+ // Retain only one transport batch of JPEGs. The existing timestamp + tie+ // offset cursor regenerates a failed page after a restart; no image spool.+ for chunk in frames.chunks(FRAME_UPLOAD_ENTRIES_PER_REQUEST) {+ if crate::enterprise_policy::current_sync_streams().frame_images+ != crate::enterprise_policy::FrameImagesMode::All+ {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_policy_disabled",+ ));+ }+ let mut entries = Vec::with_capacity(chunk.len());+ for frame in chunk {+ if frame.frame_id <= 0 {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_invalid_frame",+ ));+ }+ let entry = match local.fetch_frame_jpeg(frame.frame_id).await {+ Ok(Some(bytes)) => {+ let jpeg = tokio::task::spawn_blocking(move || downscale_frame_jpeg(&bytes))+ .await+ .map_err(|_| {+ EnterpriseSyncError::BackfillImages("screenshot_processing_failed")+ })?+ .map_err(|_| {+ EnterpriseSyncError::BackfillImages("screenshot_processing_failed")+ })?;+ FrameUploadEntry::image(frame.frame_id, &jpeg)+ }+ Ok(None) => FrameUploadEntry::err(frame.frame_id, "not_found"),+ Err(EnterpriseSyncError::BackfillImages(code)) => {+ return Err(EnterpriseSyncError::BackfillImages(code))+ }+ Err(_) => {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_fetch_failed",+ ))+ }+ };+ entries.push(entry);+ }+ for batch in split_frame_upload_requests(entries) {+ if crate::enterprise_policy::current_sync_streams().frame_images+ != crate::enterprise_policy::FrameImagesMode::All+ {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_policy_disabled",+ ));+ }+ if guard_source+ && local.upload_source_id().await.ok().as_deref() != Some(cfg.device_id.as_str())+ {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_source_changed",+ ));+ }+ let response = http+ .post(format!("{base}/api/enterprise/frame-uploads"))+ .header("X-License-Key", &cfg.license_key)+ .header("X-Device-Id", &cfg.device_id)+ .json(&serde_json::json!({"frames": batch}))+ .send()+ .await+ .map_err(|_| EnterpriseSyncError::BackfillImages("screenshot_upload_failed"))?+ .error_for_status()+ .map_err(|_| EnterpriseSyncError::BackfillImages("screenshot_upload_failed"))?;+ let ack: ImageAck = response+ .json()+ .await+ .map_err(|_| EnterpriseSyncError::BackfillImages("screenshot_ack_incomplete"))?;+ // HTTP 200 may contain partial storage failures. Require every+ // exact ID's matching durable outcome before acknowledging the page.+ for entry in batch {+ if entry.image_b64.is_some() && ack.stored.contains(&entry.frame_id) {+ progress.uploaded += 1;+ } else if entry.error == Some("not_found")+ && ack.unavailable.contains(&entry.frame_id)+ {+ progress.unavailable += 1;+ } else {+ let code = match ack+ .failed+ .iter()+ .find(|failure| failure.frame_id == Some(entry.frame_id))+ .map(|failure| failure.reason.as_str())+ {+ Some("storage write failed") => "screenshot_storage_write_failed",+ Some("status write failed") => "screenshot_status_write_failed",+ _ => "screenshot_ack_incomplete",+ };+ return Err(EnterpriseSyncError::BackfillImages(code));+ }+ }+ }+ }+ Ok(progress)+}+async fn report(cfg: &EnterpriseSyncConfig,http: &reqwest::Client,@@ -173,11 +330,14 @@ async fn report(request: &BackfillRequest,cursor: &Cursor,status: &str,- failed: bool,+ failure: Option<&EnterpriseSyncError>,) -> Result<(), EnterpriseSyncError> {let response = http.post(url).header("X-License-Key", &cfg.license_key).header("X-Device-Id", &cfg.device_id).json(&serde_json::json!({- "id": request.id, "status": status, "uploaded_records": cursor.boundary.backfill_records.unwrap_or(0), "last_error": if failed { Some("retrying") } else { None },+ "id": request.id, "status": status, "uploaded_records": cursor.boundary.backfill_records.unwrap_or(0),+ "screenshots": cursor.boundary.backfill_images,+ "images_only": request.images_only,+ "last_error": failure.map(|error| match error { EnterpriseSyncError::BackfillImages(code) => *code, _ => "retrying" }),"cursors": { "frames": cursor.last_frame_ts, "audio": cursor.last_audio_ts, "ui_events": cursor.last_ui_ts,"parsed": cursor.last_parsed_ts, "memories": cursor.last_memory_ts, "feedback": cursor.last_feedback_ts }}))@@ -247,7 +407,7 @@ mod tests {self.reads.fetch_add(1, Ordering::SeqCst);let ts = "2026-01-01T01:00:00+00:00";// 501 rows at one timestamp exercise the durable tie offset.- let rows = (0..501).map(|id| FrameRow {+ let rows = (1..=501).map(|id| FrameRow {frame_id: id,timestamp: ts.into(),app_name: None,@@ -468,7 +628,7 @@ mod tests {}#[tokio::test]- async fn direct_backfill_capacity_failure_drains_and_retries_without_advancing_history() {+ async fn direct_backfill_images_ack_before_telemetry_and_cursor_survive_retry() {let _guard = crate::enterprise_policy::sync_streams_test_lock();crate::enterprise_policy::set_sync_streams(true,@@ -481,6 +641,19 @@ mod tests {"all".into(),);let server = MockServer::start().await;+ let image_attempts = Arc::new(AtomicUsize::new(0));+ let attempts = image_attempts.clone();+ Mock::given(method("POST")).and(path("/api/enterprise/frame-uploads"))+ .respond_with(move |r: &wiremock::Request| {+ let body: serde_json::Value = serde_json::from_slice(&r.body).unwrap();+ let ids: Vec<_> = body["frames"].as_array().unwrap().iter().map(|f| f["frame_id"].clone()).collect();+ // HTTP success does not mean every image/status was persisted.+ if attempts.fetch_add(1, Ordering::SeqCst) == 0 {+ ResponseTemplate::new(200).set_body_json(serde_json::json!({"stored": [], "unavailable": [], "failed": [{"frame_id": 1, "reason": "status write failed"}]}))+ } else {+ ResponseTemplate::new(200).set_body_json(serde_json::json!({"stored": [], "unavailable": ids, "failed": []}))+ }+ }).mount(&server).await;Mock::given(method("POST")).and(path("/ticket")).respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({"ok": true, "method": "PUT", "upload_url": format!("{}/blob", server.uri()), "headers": {}@@ -490,28 +663,18 @@ mod tests {.respond_with(ResponseTemplate::new(200)).mount(&server).await;- let full = Arc::new(std::sync::atomic::AtomicBool::new(true));- let is_full = full.clone();- Mock::given(method("POST")).and(path("/complete"))+ let completes = Arc::new(AtomicUsize::new(0));+ let calls = completes.clone();+ Mock::given(method("POST"))+ .and(path("/complete")).and(header("x-screenpipe-backfill", "1")).respond_with(move |_: &wiremock::Request| {- if is_full.load(Ordering::SeqCst) {- ResponseTemplate::new(429).set_body_json(serde_json::json!({"error":"screenshot queue is full; retry after the device syncs","code":"frame_queue_full"}))- } else { ResponseTemplate::new(200) }- }).mount(&server).await;- Mock::given(method("GET"))- .and(path("/api/enterprise/frame-requests"))- .respond_with(- ResponseTemplate::new(200).set_body_json(serde_json::json!({"frame_ids":[1]})),- )- .mount(&server)- .await;- Mock::given(method("POST"))- .and(path("/api/enterprise/frame-uploads"))- .respond_with(- ResponseTemplate::new(200)- .set_body_json(serde_json::json!({"stored":[1],"failed":[]})),- )+ if calls.fetch_add(1, Ordering::SeqCst) == 0 {+ ResponseTemplate::new(503)+ } else {+ ResponseTemplate::new(200)+ }+ }).mount(&server).await;let dir = tempfile::TempDir::new().unwrap();@@ -533,31 +696,223 @@ mod tests {let error = run_one_sync_inner(&cfg, &mut cursor, &local, &http, false, Some(&request)).await.unwrap_err();- assert!(error.to_string().contains("frame_queue_full"));+ assert!(error.to_string().contains("screenshot_status_write_failed"));+ assert_eq!(cursor.last_frame_ts, initial);+ assert!(!cfg.cursor_path.exists());+ assert_eq!(completes.load(Ordering::SeqCst), 0);+ // Next image pass succeeds but telemetry fails: still no checkpoint.+ assert!(+ run_one_sync_inner(&cfg, &mut cursor, &local, &http, false, Some(&request))+ .await+ .is_err()+ );assert_eq!(cursor.last_frame_ts, initial);assert_eq!(cursor.boundary.backfill_records, None);assert!(!cfg.cursor_path.exists());- // This is the production order after a failed historical pass: screenshot- // fulfillment remains reachable, then the same page retries next tick.- let drained = fulfill_frame_requests(&cfg, &local, &http).await;- assert_eq!(drained.requested, 1);- full.store(false, Ordering::SeqCst);run_one_sync_inner(&cfg, &mut cursor, &local, &http, false, Some(&request)).await.unwrap();assert_eq!(cursor.boundary.backfill_records, Some(500));+ let mut restarted = Cursor::load(&cfg.cursor_path);assert_eq!(- Cursor::load(&cfg.cursor_path).last_frame_ts,- cursor.last_frame_ts+ restarted+ .boundary+ .backfill_images+ .as_ref()+ .unwrap()+ .uploaded,+ 0);+ assert_eq!(+ restarted+ .boundary+ .backfill_images+ .as_ref()+ .unwrap()+ .unavailable,+ 500+ );+ run_one_sync_inner(&cfg, &mut restarted, &local, &http, false, Some(&request))+ .await+ .unwrap();+ assert_eq!(restarted.boundary.backfill_records, Some(501));+ assert_eq!(restarted.boundary.backfill_images.unwrap().unavailable, 501);let requests = server.received_requests().await.unwrap();+ assert!(!requests+ .iter()+ .any(|r| r.url.path() == "/api/enterprise/frame-requests"));let completions: Vec<serde_json::Value> = requests.iter().filter(|r| r.url.path() == "/complete").map(|r| serde_json::from_slice(&r.body).unwrap()).collect();- assert!(completions.len() >= 2);- assert_eq!(completions.first().unwrap(), completions.last().unwrap());+ assert_eq!(completions[0], completions[1]);+ // Restore defaults for the shared policy fixture.+ crate::enterprise_policy::set_sync_streams(+ true,+ false,+ true,+ true,+ true,+ true,+ "off".into(),+ "cited".into(),+ );+ }++ #[tokio::test]+ async fn image_continuation_uses_its_own_checkpoint_and_never_replays_telemetry() {+ let _guard = crate::enterprise_policy::sync_streams_test_lock();+ crate::enterprise_policy::set_sync_streams(+ true,+ false,+ false,+ false,+ false,+ false,+ "off".into(),+ "all".into(),+ );+ let server = MockServer::start().await;+ let dir = tempfile::TempDir::new().unwrap();+ let cfg = cfg(&dir, &server);+ let req = request();+ let telemetry_checkpoint = dir.path().join(format!(+ "enterprise_backfill_{}_{}.json",+ req.license_id, req.id+ ));+ std::fs::write(&cfg.cursor_path, "live checkpoint").unwrap();+ std::fs::write(+ &telemetry_checkpoint,+ "original completed telemetry checkpoint",+ )+ .unwrap();+ let mut body = pending();+ body["request"]["images_only"] = serde_json::json!(true);+ body["request"]["source_id"] = serde_json::json!("dev-1");+ Mock::given(method("GET"))+ .and(path("/api/enterprise/backfill-requests"))+ .and(header("x-screenpipe-backfill-images", "cursor-v1"))+ .respond_with(ResponseTemplate::new(200).set_body_json(body))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path("/api/enterprise/backfill-requests"))+ .respond_with(+ ResponseTemplate::new(200).set_body_json(serde_json::json!({"accepted": true})),+ )+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path("/api/enterprise/frame-uploads"))+ .respond_with(|r: &wiremock::Request| {+ let body: serde_json::Value = serde_json::from_slice(&r.body).unwrap();+ let ids: Vec<_> = body["frames"]+ .as_array()+ .unwrap()+ .iter()+ .map(|f| f["frame_id"].clone())+ .collect();+ ResponseTemplate::new(200)+ .set_body_json(serde_json::json!({"stored": [], "unavailable": ids}))+ })+ .mount(&server)+ .await;+ let local = Local {+ reads: AtomicUsize::new(0),+ fail_ui: false,+ };+ let (_, shutdown) = tokio::sync::watch::channel(false);+ let http = enterprise_http_client();+ fulfill_requests(&cfg, &local, &http, &shutdown)+ .await+ .unwrap();+ let image_checkpoint = dir.path().join(format!(+ "enterprise_backfill_{}_{}_images.json",+ req.license_id, req.id+ ));+ assert_eq!(+ Cursor::load(&image_checkpoint).boundary.backfill_records,+ Some(500)+ );+ fulfill_requests(&cfg, &local, &http, &shutdown)+ .await+ .unwrap();+ assert_eq!(+ Cursor::load(&image_checkpoint)+ .boundary+ .backfill_images+ .unwrap()+ .unavailable,+ 501+ );+ assert_eq!(+ std::fs::read_to_string(&cfg.cursor_path).unwrap(),+ "live checkpoint"+ );+ assert_eq!(+ std::fs::read_to_string(&telemetry_checkpoint).unwrap(),+ "original completed telemetry checkpoint"+ );+ let requests = server.received_requests().await.unwrap();+ assert!(requests.iter().all(|r| [+ "/api/enterprise/backfill-requests",+ "/api/enterprise/frame-uploads"+ ]+ .contains(&r.url.path())));+ let last: serde_json::Value = serde_json::from_slice(+ &requests+ .iter()+ .rev()+ .find(|r| r.method == "POST" && r.url.path().ends_with("backfill-requests"))+ .unwrap()+ .body,+ )+ .unwrap();+ assert_eq!(last["images_only"], true);+ assert_eq!(last["status"], "completed");+ assert_eq!(+ last["screenshots"],+ serde_json::json!({"uploaded": 0, "unavailable": 501})+ );+ let mut wrong_source = request();+ wrong_source.images_only = true;+ wrong_source.source_id = Some("different-source".into());+ let reads = local.reads.load(Ordering::SeqCst);+ assert!(run_one_sync_inner(+ &cfg,+ &mut wrong_source.initial_cursor(),+ &local,+ &http,+ false,+ Some(&wrong_source)+ )+ .await+ .unwrap_err()+ .to_string()+ .contains("screenshot_source_changed"));+ assert_eq!(local.reads.load(Ordering::SeqCst), reads);+ let mut strict_cfg = cfg.clone();+ strict_cfg.upload_mode =+ EnterpriseUploadMode::DirectWriteOnly(enterprise_upload::DirectUploadConfig {+ ticket_url: format!("{}/ticket", server.uri()),+ complete_url: format!("{}/complete", server.uri()),+ pinned_hosts: vec![],+ });+ wrong_source.source_id = Some("dev-1".into());+ assert!(run_one_sync_inner(+ &strict_cfg,+ &mut wrong_source.initial_cursor(),+ &local,+ &http,+ false,+ Some(&wrong_source)+ )+ .await+ .unwrap_err()+ .to_string()+ .contains("screenshot_storage_mode_blocked"));+ assert_eq!(local.reads.load(Ordering::SeqCst), reads);crate::enterprise_policy::set_sync_streams(true,false,@@ -683,6 +1038,7 @@ pub(super) async fn fulfill_requests(}let response = http.get(&url)+ .header("X-Screenpipe-Backfill-Images", "cursor-v1").header("X-License-Key", &cfg.license_key).header("X-Device-Id", &cfg.device_id).send()@@ -705,8 +1061,10 @@ pub(super) async fn fulfill_requests(request.validate(cfg)?;let mut replay_cfg = cfg.clone();replay_cfg.cursor_path = cfg.cursor_path.with_file_name(format!(- "enterprise_backfill_{}_{}.json",- request.license_id, request.id+ "enterprise_backfill_{}_{}{}.json",+ request.license_id,+ request.id,+ if request.images_only { "_images" } else { "" }));// Stable label keeps retries deterministic even after a hostname change.replay_cfg.device_label = cfg.device_id.clone();@@ -731,13 +1089,13 @@ pub(super) async fn fulfill_requests(&request,&request.initial_cursor(),"running",- true,+ Some(&error),).await;return Err(error);}};- report(cfg, http, &url, &request, &cursor, "running", false).await?;+ report(cfg, http, &url, &request, &cursor, "running", None).await?;match run_one_sync_inner(&replay_cfg, &mut cursor, local, http, false, Some(&request)).await{Ok(page) => {@@ -752,15 +1110,17 @@ pub(super) async fn fulfill_requests(&request,&cursor,if complete { "completed" } else { "running" },- false,+ None,).await?;- if complete {+ // JPEG pages are heavier than telemetry pages. Yield to live+ // sync after one acknowledged image page, retaining its cursor.+ if complete || cursor.boundary.backfill_images.is_some() {break;}}Err(error) => {- let _ = report(cfg, http, &url, &request, &cursor, "running", true).await;+ let _ = report(cfg, http, &url, &request, &cursor, "running", Some(&error)).await;return Err(error);}}diff --git a/apps/screenpipe-app-tauri/src-tauri/src/enterprise/sync.rs b/apps/screenpipe-app-tauri/src-tauri/src/enterprise/sync.rsindex 9d9dbb66b..b6fa647c1 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/enterprise/sync.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/enterprise/sync.rs@@ -256,6 +256,8 @@ struct CursorBoundary {/// Recovery-only counter, checkpointed atomically with the acknowledged cursor.#[serde(default, skip_serializing_if = "Option::is_none")]backfill_records: Option<u64>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ backfill_images: Option<backfill::ImageProgress>,frames: u32,audio: u32,ui: u32,@@ -465,6 +467,8 @@ pub use screenpipe_telemetry_wire::{#[derive(Debug, thiserror::Error)]pub enum EnterpriseSyncError {+ #[error("historical screenshots: {0}")]+ BackfillImages(&'static str),#[error("local api request failed: {0}")]LocalApi(String),#[error("ingest request failed: {0}")]@@ -783,6 +787,24 @@ async fn run_one_sync_inner(}let prepared = prepare_upload_identity(cfg, local, http).await?;+ if backfill.is_some_and(|request| request.images_only)+ && !matches!(+ prepared.upload_mode,+ EnterpriseUploadMode::HostedIngest | EnterpriseUploadMode::DirectReadable(_)+ )+ {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_storage_mode_blocked",+ ));+ }+ if backfill+ .and_then(|request| request.source_id.as_deref())+ .is_some_and(|source| source != prepared.device_id)+ {+ return Err(EnterpriseSyncError::BackfillImages(+ "screenshot_source_changed",+ ));+ }let export = local.begin_export().await?;let cfg = &prepared;if cfg.stable_device_id.is_none()@@ -1063,6 +1085,21 @@ async fn run_one_sync_inner());let bytes = body.len();+ // The history cursor is the retry checkpoint for images as well as text.+ // Store this page's images first: the existing server sees them as already+ // resolved, so it need not accumulate another historical request backlog.+ let images = if backfill.is_some()+ && streams.frame_images == crate::enterprise_policy::FrameImagesMode::All+ && matches!(+ cfg.upload_mode,+ EnterpriseUploadMode::HostedIngest | EnterpriseUploadMode::DirectReadable(_)+ )+ && !frames.is_empty()+ {+ Some(backfill::upload_page_images(cfg, local, http, &frames).await?)+ } else {+ None+ };let mut next_cursor = cursor.clone();advance_timestamp_boundary(&mut next_cursor.last_frame_ts,@@ -1102,88 +1139,94 @@ async fn run_one_sync_inner(|row| &row.timestamp,);- match &cfg.upload_mode {- EnterpriseUploadMode::HostedIngest => {- for request_body in split_jsonl_requests(body, HOSTED_INGEST_REQUEST_BYTES) {+ if !backfill.is_some_and(|request| request.images_only) {+ match &cfg.upload_mode {+ EnterpriseUploadMode::HostedIngest => {+ for request_body in split_jsonl_requests(body, HOSTED_INGEST_REQUEST_BYTES) {+ let admission = match &export {+ Some(token) => token.admit().await?,+ None => None,+ };+ let upload = post_jsonl_with_identity(+ http,+ &cfg.ingest_url,+ &cfg.license_key,+ request_body,+ cfg.stable_device_id.as_deref(),+ backfill.is_some(),+ );+ drop(admission);+ upload.await?;+ }+ }+ EnterpriseUploadMode::DirectWriteOnly(direct) => {+ let counts = DirectUploadRecordCounts {+ frames: frames.len(),+ parsed: parsed.len(),+ activities: activities.len(),+ audio: audio.len(),+ ui: ui.len(),+ snapshots: snapshots.len(),+ memories: memories.len(),+ feedback: feedback.len(),+ };+ let admission = match &export {+ Some(token) => token.admit().await?,+ None => None,+ };+ let upload = upload_direct_write_only_batch(+ http,+ cfg,+ direct,+ body,+ counts,+ enterprise_upload::direct_upload_cursors(&next_cursor),+ );+ drop(admission);+ upload.await?;+ }+ EnterpriseUploadMode::DirectReadable(direct) => {+ let counts = DirectUploadRecordCounts {+ frames: frames.len(),+ parsed: parsed.len(),+ activities: activities.len(),+ audio: audio.len(),+ ui: ui.len(),+ snapshots: snapshots.len(),+ memories: memories.len(),+ feedback: feedback.len(),+ };let admission = match &export {Some(token) => token.admit().await?,None => None,};- let upload = post_jsonl_with_identity(+ let upload = upload_direct_readable_batch(http,- &cfg.ingest_url,- &cfg.license_key,- request_body,- cfg.stable_device_id.as_deref(),+ cfg,+ direct,+ body,+ counts,+ enterprise_upload::direct_upload_cursors(&next_cursor),backfill.is_some(),);drop(admission);upload.await?;}- }- EnterpriseUploadMode::DirectWriteOnly(direct) => {- let counts = DirectUploadRecordCounts {- frames: frames.len(),- parsed: parsed.len(),- activities: activities.len(),- audio: audio.len(),- ui: ui.len(),- snapshots: snapshots.len(),- memories: memories.len(),- feedback: feedback.len(),- };- let admission = match &export {- Some(token) => token.admit().await?,- None => None,- };- let upload = upload_direct_write_only_batch(- http,- cfg,- direct,- body,- counts,- enterprise_upload::direct_upload_cursors(&next_cursor),- );- drop(admission);- upload.await?;- }- EnterpriseUploadMode::DirectReadable(direct) => {- let counts = DirectUploadRecordCounts {- frames: frames.len(),- parsed: parsed.len(),- activities: activities.len(),- audio: audio.len(),- ui: ui.len(),- snapshots: snapshots.len(),- memories: memories.len(),- feedback: feedback.len(),- };- let admission = match &export {- Some(token) => token.admit().await?,- None => None,- };- let upload = upload_direct_readable_batch(- http,- cfg,- direct,- body,- counts,- enterprise_upload::direct_upload_cursors(&next_cursor),- backfill.is_some(),- );- drop(admission);- upload.await?;- }- EnterpriseUploadMode::Blocked(reason) => {- return Err(EnterpriseSyncError::Configuration(reason.clone()));+ EnterpriseUploadMode::Blocked(reason) => {+ return Err(EnterpriseSyncError::Configuration(reason.clone()));+ }}}-if backfill.is_some() {let records =frames.len() + audio.len() + ui.len() + parsed.len() + memories.len() + feedback.len();next_cursor.boundary.backfill_records =Some(cursor.boundary.backfill_records.unwrap_or(0) + records as u64);+ if let Some(images) = images {+ let total = next_cursor.boundary.backfill_images.get_or_insert_default();+ total.uploaded += images.uploaded;+ total.unavailable += images.unavailable;+ }}// Advance cursor only on success — partial failure must not skip records.@@ -4539,7 +4582,7 @@ pub(crate) mod tests {async fn direct_upload_completion_auto_cites_only_readable_all_images() {let _guard = crate::enterprise_policy::sync_streams_test_lock();let _restore = RestoreDefaultSyncStreams;- for (readable, historical) in [(false, false), (true, false), (true, true)] {+ for (readable, historical) in [(false, false), (false, true), (true, false), (true, true)] {for frame_mode in ["off", "cited", "all"] {let mode_json = format!("\"mode\":\"{}\"",@@ -4600,11 +4643,20 @@ pub(crate) mod tests {} else {direct_test_cfg};- let cfg = make_cfg(+ let mut cfg = make_cfg(&dir,format!("{}/ticket", server.uri()),format!("{}/complete", server.uri()),);+ cfg.ingest_url = format!("{}/api/enterprise/ingest", server.uri());+ wiremock::Mock::given(wiremock::matchers::method("POST"))+ .and(wiremock::matchers::path("/api/enterprise/frame-uploads"))+ .respond_with(wiremock::ResponseTemplate::new(200).set_body_json(+ serde_json::json!({"stored": [], "unavailable": [1], "failed": []}),+ ))+ .expect(usize::from(readable && historical && frame_mode == "all") as u64)+ .mount(&server)+ .await;let mut cursor = Cursor {source_id: None,last_frame_ts: Some("2026-05-07T09:00:00Z".to_string()),@@ -4648,7 +4700,7 @@ pub(crate) mod tests {.unwrap();assert_eq!(complete.headers.contains_key("x-screenpipe-backfill"),- historical+ readable && historical);for request in &requests {if request.url.path() == "/blob" {@@ -5110,6 +5162,100 @@ pub(crate) mod tests {}}+ #[tokio::test]+ async fn historical_images_require_matching_durable_ack_and_preserve_policy_source_gates() {+ let _guard = crate::enterprise_policy::sync_streams_test_lock();+ let _restore = RestoreDefaultSyncStreams;+ crate::enterprise_policy::set_sync_streams(+ true,+ false,+ true,+ true,+ true,+ true,+ "off".into(),+ "all".into(),+ );+ let server = wiremock::MockServer::start().await;+ let attempt = Arc::new(std::sync::atomic::AtomicUsize::new(0));+ let calls = attempt.clone();+ wiremock::Mock::given(wiremock::matchers::method("POST"))+ .and(wiremock::matchers::path("/api/enterprise/frame-uploads"))+ .respond_with(move |r: &wiremock::Request| {+ let body: serde_json::Value = serde_json::from_slice(&r.body).unwrap();+ assert_eq!(body["frames"][0]["frame_id"], 1);+ assert!(body["frames"][0]["image_b64"].as_str().unwrap().len() > 100);+ assert_eq!(body["frames"][1]["error"], "not_found");+ if calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0 {+ wiremock::ResponseTemplate::new(200)+ .set_body_json(serde_json::json!({"stored": [2], "unavailable": [1]}))+ } else {+ wiremock::ResponseTemplate::new(200)+ .set_body_json(serde_json::json!({"stored": [1], "unavailable": [2]}))+ }+ })+ .mount(&server)+ .await;+ let dir = TempDir::new().unwrap();+ let mut cfg = frame_test_cfg(&server.uri(), &dir);+ let rows = vec![+ frame(1, "2026-01-01T00:00:00Z", "test", ""),+ frame(2, "2026-01-01T00:00:00Z", "test", ""),+ ];+ let http = reqwest::Client::new();+ assert!(backfill::upload_page_images(&cfg, &FrameMock, &http, &rows)+ .await+ .unwrap_err()+ .to_string()+ .contains("screenshot_ack_incomplete"));+ let result = backfill::upload_page_images(&cfg, &FrameMock, &http, &rows)+ .await+ .unwrap();+ assert_eq!((result.uploaded, result.unavailable), (1, 1));+ let failed = vec![frame(3, "2026-01-01T00:00:00Z", "test", "")];+ assert!(+ backfill::upload_page_images(&cfg, &FrameMock, &http, &failed)+ .await+ .unwrap_err()+ .to_string()+ .contains("screenshot_fetch_failed")+ );+ cfg.device_id = "33333333-3333-4333-8333-333333333333".into();+ assert!(backfill::upload_page_images(&cfg, &FrameMock, &http, &rows)+ .await+ .unwrap_err()+ .to_string()+ .contains("screenshot_source_changed"));+ cfg.upload_mode =+ EnterpriseUploadMode::DirectWriteOnly(enterprise_upload::DirectUploadConfig {+ ticket_url: format!("{}/ticket", server.uri()),+ complete_url: format!("{}/complete", server.uri()),+ pinned_hosts: vec![],+ });+ assert!(backfill::upload_page_images(&cfg, &FrameMock, &http, &rows)+ .await+ .unwrap_err()+ .to_string()+ .contains("screenshot_storage_mode_blocked"));+ cfg.upload_mode = EnterpriseUploadMode::HostedIngest;+ crate::enterprise_policy::set_sync_streams(+ true,+ false,+ true,+ true,+ true,+ true,+ "off".into(),+ "off".into(),+ );+ assert!(backfill::upload_page_images(&cfg, &FrameMock, &http, &rows)+ .await+ .unwrap_err()+ .to_string()+ .contains("screenshot_policy_disabled"));+ assert_eq!(server.received_requests().await.unwrap().len(), 2);+ }+#[test]fn control_plane_base_derives_from_ingest_url() {assert_eq!(diff --git a/apps/screenpipe-app-tauri/src-tauri/src/enterprise_sync.rs b/apps/screenpipe-app-tauri/src-tauri/src/enterprise_sync.rsindex 575d806b1..1cd81646e 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/enterprise_sync.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/enterprise_sync.rs@@ -686,7 +686,8 @@ mod imp {frame_id: i64,) -> Result<Option<Vec<u8>>, EnterpriseSyncError> {if !self.image_uploads_allowed() {- return Ok(None);+ // A settings refusal is not evidence that the local image is missing.+ return Err(EnterpriseSyncError::BackfillImages("screenshot_policy_disabled"));}// Same image `/frames/{id}` serves in the UI — decoded from local@@ -700,8 +701,7 @@ mod imp {.await.map_err(|e| EnterpriseSyncError::LocalApi(e.to_string()))?;if resp.status() == reqwest::StatusCode::NOT_FOUND {- // Expired from retention or never existed — report back so the- // server drops the id from the manifest instead of looping.+ // Exact local lookup returned 404; its underlying cause is unknown.return Ok(None);}if !resp.status().is_success() {