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

fix(activity): deduplicate interval generation (#6807)

Ezra Elletted5749a084abb
diff --git a/apps/screenpipe-app-tauri/components/activity-ledger.test.tsx b/apps/screenpipe-app-tauri/components/activity-ledger.test.tsx
index 8d284bc4c..672ea41a5 100644
--- a/apps/screenpipe-app-tauri/components/activity-ledger.test.tsx
+++ b/apps/screenpipe-app-tauri/components/activity-ledger.test.tsx
@@ -2131,6 +2131,7 @@ describe("ActivityLedger", () => {
expect(mocks.generateActivityHistory).toHaveBeenCalledWith(
expect.any(String),
expect.any(String),
+ "today",
);
});
diff --git a/apps/screenpipe-app-tauri/components/activity-ledger.tsx b/apps/screenpipe-app-tauri/components/activity-ledger.tsx
index 41c190104..af9e25f1b 100644
--- a/apps/screenpipe-app-tauri/components/activity-ledger.tsx
+++ b/apps/screenpipe-app-tauri/components/activity-ledger.tsx
@@ -1723,6 +1723,7 @@ export function ActivityLedger({
const result = await commands.generateActivityHistory(
generationRange.start.toISOString(),
generationRange.end.toISOString(),
+ preset,
);
if (result.status === "error") throw new Error(result.error);
const persisted = result.data;
diff --git a/apps/screenpipe-app-tauri/lib/utils/tauri.ts b/apps/screenpipe-app-tauri/lib/utils/tauri.ts
index 2d99cfdd9..628b8aac2 100644
--- a/apps/screenpipe-app-tauri/lib/utils/tauri.ts
+++ b/apps/screenpipe-app-tauri/lib/utils/tauri.ts
@@ -501,9 +501,9 @@ async forceRegenerateSuggestions() : Promise<Result<CachedSuggestions, string>>
else return { status: "error", error: e as any };
}
},
-async generateActivityHistory(start: string, end: string) : Promise<Result<PersistedActivityHistory, string>> {
+async generateActivityHistory(start: string, end: string, idempotencyKey: string) : Promise<Result<PersistedActivityHistory, string>> {
try {
- return { status: "ok", data: await TAURI_INVOKE("generate_activity_history", { start, end }) };
+ return { status: "ok", data: await TAURI_INVOKE("generate_activity_history", { start, end, idempotencyKey }) };
} catch (e) {
if(e instanceof Error) throw e;
else return { status: "error", error: e as any };
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/activity_history.rs b/apps/screenpipe-app-tauri/src-tauri/src/activity_history.rs
index 0b7f59c1d..474a8b1e5 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/activity_history.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/activity_history.rs
@@ -15,8 +15,8 @@ use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use specta::Type;
-use std::collections::BTreeMap;
-use std::sync::Arc;
+use std::collections::{BTreeMap, HashSet};
+use std::sync::{Arc, Mutex as StdMutex};
use std::time::{Duration, Instant};
use tauri::{AppHandle, Emitter, Manager};
use tokio::sync::Mutex;
@@ -189,6 +189,37 @@ impl QualityAudit {
#[derive(Default)]
pub struct ActivityHistoryState {
run_lock: Arc<Mutex<()>>,
+ active_idempotency_keys: Arc<StdMutex<HashSet<String>>>,
+}
+
+struct ActivityGenerationKeyGuard {
+ active_idempotency_keys: Arc<StdMutex<HashSet<String>>>,
+ key: String,
+}
+
+impl Drop for ActivityGenerationKeyGuard {
+ fn drop(&mut self) {
+ self.active_idempotency_keys
+ .lock()
+ .unwrap_or_else(|poisoned| poisoned.into_inner())
+ .remove(&self.key);
+ }
+}
+
+impl ActivityHistoryState {
+ fn try_begin(&self, key: String) -> Option<ActivityGenerationKeyGuard> {
+ let mut active = self
+ .active_idempotency_keys
+ .lock()
+ .unwrap_or_else(|poisoned| poisoned.into_inner());
+ if !active.insert(key.clone()) {
+ return None;
+ }
+ Some(ActivityGenerationKeyGuard {
+ active_idempotency_keys: Arc::clone(&self.active_idempotency_keys),
+ key,
+ })
+ }
}
fn track_generation_event(app: &AppHandle, event: &'static str, properties: Value) {
@@ -1278,7 +1309,16 @@ async fn generate(
start: DateTime<Utc>,
end: DateTime<Utc>,
source: &'static str,
+ idempotency_key: String,
) -> Result<PersistedActivityHistory, String> {
+ let Some(_idempotency_guard) = state.try_begin(idempotency_key.clone()) else {
+ info!(
+ activity_source = source,
+ %idempotency_key,
+ "activity generation: matching interval is already running; skipping duplicate"
+ );
+ return Ok(history_in_range(read_all(app)?, start, end));
+ };
let run_id = uuid::Uuid::new_v4().to_string();
let started_at = Instant::now();
track_generation_event(
@@ -1610,13 +1650,22 @@ pub async fn generate_activity_history(
state: tauri::State<'_, ActivityHistoryState>,
start: String,
end: String,
+ idempotency_key: String,
) -> Result<PersistedActivityHistory, String> {
let (start, end) = requested_range(start, end)?;
let restricted = activity_history_is_restricted(&app);
let Some((start, end)) = activity_access_range(start, end, Utc::now(), restricted) else {
return Ok(PersistedActivityHistory::default());
};
- let history = generate(&app, state.inner(), start, end, "manual").await?;
+ let history = generate(
+ &app,
+ state.inner(),
+ start,
+ end,
+ "manual",
+ format!("manual:{idempotency_key}"),
+ )
+ .await?;
Ok(if restricted {
restricted_history_in_range(history, start, end)
} else {
@@ -1732,7 +1781,16 @@ pub fn start(app: AppHandle) {
automatic_generation_start(next_uncovered_start(&app, now), now, interval_minutes);
if start < now {
info!(%start, %now, "activity history: running scheduled generation");
- if let Err(error) = generate(&app, state.inner(), start, now, "automatic").await {
+ if let Err(error) = generate(
+ &app,
+ state.inner(),
+ start,
+ now,
+ "automatic",
+ "automatic".to_string(),
+ )
+ .await
+ {
warn!(%error, "activity history: scheduled generation failed");
}
}
@@ -1748,6 +1806,24 @@ pub fn start(app: AppHandle) {
mod tests {
use super::*;
+ #[test]
+ fn duplicate_selected_interval_is_a_noop_until_the_original_finishes() {
+ let state = ActivityHistoryState::default();
+ let today = state
+ .try_begin("manual:today".to_string())
+ .expect("first Today generation should start");
+
+ assert!(state.try_begin("manual:today".to_string()).is_none());
+
+ let last_24_hours = state
+ .try_begin("manual:24h".to_string())
+ .expect("a different selected interval should keep its own key");
+ drop(last_24_hours);
+ drop(today);
+
+ assert!(state.try_begin("manual:today".to_string()).is_some());
+ }
+
#[test]
fn coverage_merges_touching_ranges() {
let merged = merge_coverage(vec![