Skip to content

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

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.rs
index 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.rs
index 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.rs
index 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() {