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: toggle starred sessions with a default hour and clear status

Louis Beaumontb2597deecf48
diff --git a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx
index 7c4e18037..1a3a3ffb4 100644
--- a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx
+++ b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx
@@ -506,7 +506,7 @@ describe("recording health hover detail", () => {
render(<ShortcutReminderPage />);
fireEvent.mouseEnter(await screen.findByTestId("shortcut-reminder-root"));
fireEvent.mouseEnter(screen.getByRole("button", { name: "Starred work sessions" }));
- expect(await screen.findByText("star work session")).toBeVisible();
+ expect(await screen.findByText("Star work session")).toBeVisible();
expect(screen.queryByText(formatShortcut("Alt+Shift+J", "macos"), { exact: false })).toBeNull();
expect(screen.queryByText(formatShortcut("Control+Super+B", "macos"), { exact: false })).toBeNull();
});
diff --git a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx
index 3105d0b8f..79b6afb73 100644
--- a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx
+++ b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx
@@ -774,7 +774,7 @@ export default function ShortcutReminderPage() {
}
const disclosure = hoveredControl === "star"
- ? ["star work session", starShortcut]
+ ? [starredSessions.active ? "Starred session in progress" : "Star work session", starShortcut]
: hoveredControl === "search"
? ["search", searchShortcut]
: hoveredControl === "brand"
diff --git a/apps/screenpipe-app-tauri/app/starred-sessions/page.test.tsx b/apps/screenpipe-app-tauri/app/starred-sessions/page.test.tsx
index e1857655f..98ee8781a 100644
--- a/apps/screenpipe-app-tauri/app/starred-sessions/page.test.tsx
+++ b/apps/screenpipe-app-tauri/app/starred-sessions/page.test.tsx
@@ -21,8 +21,8 @@ vi.mock("@/lib/utils/tauri", () => ({
}));
vi.mock("@/lib/api", () => ({ localFetch: mocks.fetch }));
vi.mock("@/lib/hooks/use-tauri-event", () => ({
- useTauriEvent: (_: string, callback: typeof mocks.visibility) => {
- mocks.visibility = callback;
+ useTauriEvent: (name: string, callback: typeof mocks.visibility) => {
+ if (name === "starred-sessions-visibility") mocks.visibility = callback;
},
}));
vi.mock("@/lib/chat-utils", () => ({ showChatWithPrefill: vi.fn() }));
@@ -32,7 +32,7 @@ beforeEach(() => {
mocks.hide.mockResolvedValue({ status: "ok", data: null });
mocks.fetch.mockResolvedValue({ ok: true, json: async () => ({ data: [] }) });
});
-afterEach(cleanup);
+afterEach(() => { cleanup(); vi.useRealTimers(); });
it("opens just the duration picker and dismisses with Escape", async () => {
render(<Page />);
@@ -81,3 +81,36 @@ it("does not dismiss when an editor consumes Escape", () => {
window.dispatchEvent(event);
expect(mocks.hide).not.toHaveBeenCalled();
});
+
+it("dismisses after five idle seconds without changing the saved session", async () => {
+ const session = { id: "active", start: new Date().toISOString(), end: new Date(Date.now() + 3600000).toISOString(), revision: 1, hd_requested: false, has_audio: false };
+ mocks.fetch.mockResolvedValue({ ok: true, json: async () => ({ data: [session] }) });
+ render(<Page />);
+ await screen.findByText("Starred session in progress");
+ vi.useFakeTimers();
+ fireEvent.pointerMove(screen.getByRole("region", { name: "Starred work sessions" }));
+ await act(async () => { await vi.advanceTimersByTimeAsync(4999); });
+ expect(mocks.hide).not.toHaveBeenCalled();
+ await act(async () => { await vi.advanceTimersByTimeAsync(1); });
+ expect(mocks.hide).toHaveBeenCalledTimes(1);
+ expect(mocks.fetch.mock.calls.every(([, init]) => init?.method !== "POST")).toBe(true);
+});
+it("keeps the popup open during inline time edits", async () => {
+ const session = { id: "active", start: new Date().toISOString(), end: new Date(Date.now() + 3600000).toISOString(), revision: 1, hd_requested: false, has_audio: false };
+ mocks.fetch.mockResolvedValue({ ok: true, json: async () => ({ data: [session] }) });
+ render(<Page />);
+ await screen.findByText("Starred session in progress");
+ fireEvent.click(screen.getByRole("button", { name: "Edit session end" }));
+ vi.useFakeTimers();
+ await act(async () => { await vi.advanceTimersByTimeAsync(10000); });
+ expect(mocks.hide).not.toHaveBeenCalled();
+ expect(screen.getByLabelText("Session end")).toBeVisible();
+});
+it("does not auto-dismiss a storage error", async () => {
+ mocks.fetch.mockResolvedValue({ ok: false, json: async () => ({ error: "Save unavailable" }) });
+ render(<Page />);
+ await screen.findByRole("alert");
+ vi.useFakeTimers();
+ await act(async () => { await vi.advanceTimersByTimeAsync(10000); });
+ expect(mocks.hide).not.toHaveBeenCalled();
+});
diff --git a/apps/screenpipe-app-tauri/app/starred-sessions/page.tsx b/apps/screenpipe-app-tauri/app/starred-sessions/page.tsx
index 8fe1f3420..c6c2f437a 100644
--- a/apps/screenpipe-app-tauri/app/starred-sessions/page.tsx
+++ b/apps/screenpipe-app-tauri/app/starred-sessions/page.tsx
@@ -9,8 +9,8 @@ import { useTauriEvent } from "@/lib/hooks/use-tauri-event";
import { StarredSessionPanel } from "@/components/starred-sessions/starred-session-panel";
import { useStarredSessions } from "@/components/starred-sessions/use-starred-sessions";
-function SessionControls() {
- return <StarredSessionPanel state={useStarredSessions()} inDialog />;
+function SessionControls({ onDismiss }: { onDismiss?: () => void }) {
+ return <StarredSessionPanel state={useStarredSessions()} inDialog onDismiss={onDismiss} />;
}
export default function StarredSessionsPage() {
@@ -53,7 +53,7 @@ export default function StarredSessionsPage() {
>
<X className="h-4 w-4" />
</button>
- <SessionControls />
+ <SessionControls onDismiss={closeError ? undefined : hide} />
{closeError && (
<p role="alert" className="px-3 pb-3 text-xs">
Could not close the panel. Try again.
diff --git a/apps/screenpipe-app-tauri/components/starred-sessions/starred-session-panel.tsx b/apps/screenpipe-app-tauri/components/starred-sessions/starred-session-panel.tsx
index ae6b93f1c..b83fda661 100644
--- a/apps/screenpipe-app-tauri/components/starred-sessions/starred-session-panel.tsx
+++ b/apps/screenpipe-app-tauri/components/starred-sessions/starred-session-panel.tsx
@@ -1,7 +1,7 @@
// screenpipe — AI that knows everything you've seen, said, or heard
// https://screenpipe.com
-import { useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
import { revealItemInDir } from "@tauri-apps/plugin-opener";
import { showChatWithPrefill } from "@/lib/chat-utils";
import {
@@ -20,13 +20,16 @@ const localTime = (iso: string) => {
export function StarredSessionPanel({
state,
inDialog = false,
+ onDismiss,
}: {
state: ReturnType<typeof useStarredSessions>;
inDialog?: boolean;
+ onDismiss?: () => void;
}) {
const [selected, setSelected] = useState<string>();
const [hd, setHd] = useState(false);
- const [starting, setStarting] = useState(false);
+ const [activity, setActivity] = useState(0);
+ const [expanded, setExpanded] = useState(false);
type TimeEdit = { session: StarredSession; key: "start" | "end" };
const [editing, setEditing] = useState<TimeEdit | null>(null);
const editRef = useRef<TimeEdit | null>(null);
@@ -79,8 +82,11 @@ export function StarredSessionPanel({
state.sessions.find((s) => s.id === selected) ??
state.active ??
state.sessions[0];
+ useEffect(() => {
+ if (state.active) setSelected(undefined);
+ }, [state.active?.id]);
const completed = session && Date.parse(session.end) <= state.now;
- const showSession = session && !starting;
+ const showSession = session;
const active = showSession && session.id === state.active?.id;
const timeLabel = (iso: string) =>
new Date(iso).toLocaleTimeString([], {
@@ -94,6 +100,18 @@ export function StarredSessionPanel({
const action =
"rounded-md border border-white/30 px-2 py-1.5 hover:bg-white/10 focus-visible:outline focus-visible:outline-1 focus-visible:outline-offset-2 disabled:opacity-50";
const disabled = !state.ready || state.busy || working;
+ useEffect(() => {
+ if (!onDismiss || disabled || editing || expanded || error || state.error) return;
+ const timer = window.setTimeout(onDismiss, 5000);
+ return () => window.clearTimeout(timer);
+ }, [onDismiss, disabled, editing, expanded, error, state.error, activity, session?.id, session?.end]);
+ async function newSession() {
+ closeEditor();
+ if (await state.start(60, hd)) {
+ setSelected(undefined);
+ setExpanded(false);
+ }
+ }
async function run(fn: () => Promise<unknown>) {
if (working) return;
setWorking(true);
@@ -112,18 +130,19 @@ export function StarredSessionPanel({
<section
aria-label="Starred work sessions"
className="w-full rounded-lg bg-black p-3 text-xs text-white/90"
- onPointerDown={(e) => e.stopPropagation()}
+ onPointerDown={(e) => { e.stopPropagation(); setActivity((v) => v + 1); }}
+ onPointerMove={() => setActivity((v) => v + 1)}
+ onKeyDown={() => setActivity((v) => v + 1)}
>
<div className={`flex items-center justify-between gap-2 ${inDialog ? "pr-8" : ""}`}>
<p className="font-medium">
{active
- ? `${Math.max(1, Math.ceil((Date.parse(session.end) - state.now) / 60000))} min left`
+ ? "Starred session in progress"
: showSession
? "Starred session"
: "Star for"}
{active && session.hd_requested && <span className="ml-2 text-white/50" title="HD requested for this session">HD</span>}
</p>
- {starting && session && <button className={action} disabled={disabled} onClick={() => setStarting(false)}>Cancel</button>}
{active && (
<button
className={action}
@@ -134,18 +153,22 @@ export function StarredSessionPanel({
</button>
)}
</div>
- {!showSession && (
+ {active && <p role="status" className="mt-1 text-white/60">{Math.max(1, Math.ceil((Date.parse(session.end) - state.now) / 60000))} min left</p>}
+ {(!showSession || active) && (
<div className="mt-3 grid grid-cols-4 gap-1" aria-label="Star for">
{[5, 15, 30, 60].map((minutes) => (
<button
key={minutes}
- className={action}
- disabled={disabled}
+ className={`${action} aria-pressed:bg-white/20 aria-pressed:border-white/70`}
+ disabled={disabled || Boolean(active && Date.parse(session.start) + minutes * 60000 <= state.now)}
+ aria-pressed={active ? Math.abs(Date.parse(session.end) - Date.parse(session.start) - minutes * 60000) < 1000 : minutes === 60}
onClick={() =>
- void state.start(minutes, hd).then((saved) => {
+ void (active
+ ? state.save({ ...session, end: new Date(Date.parse(session.start) + minutes * 60000).toISOString() })
+ : state.start(minutes, hd)).then((saved) => {
if (saved) {
setSelected(undefined);
- setStarting(false);
+ setExpanded(false);
}
})
}
@@ -162,7 +185,7 @@ export function StarredSessionPanel({
className={action}
disabled={state.busy || working}
onClick={() => void state.retry().then((saved) => {
- if (saved && starting) { setSelected(undefined); setStarting(false); }
+ if (saved) setSelected(undefined);
})}
>
Retry save
@@ -252,7 +275,12 @@ export function StarredSessionPanel({
)}
</div>
)}
- <details className="mt-3 text-white/60">
+ {showSession && !state.active && (
+ <button className={`${action} mt-3`} disabled={disabled} onClick={() => void newSession()}>
+ New session
+ </button>
+ )}
+ <details open={expanded} className="mt-3 text-white/60" onToggle={(e) => setExpanded(e.currentTarget.open)}>
<summary className="w-fit cursor-pointer rounded py-1 hover:text-white focus-visible:outline">
More
</summary>
@@ -291,7 +319,7 @@ export function StarredSessionPanel({
disabled={disabled}
onChange={(e) => {
setSelected(e.target.value);
- setStarting(false);
+ setExpanded(false);
closeEditor();
}}
>
@@ -302,18 +330,6 @@ export function StarredSessionPanel({
))}
</select>
)}
- {showSession && !state.active && (
- <button
- className={action}
- disabled={disabled}
- onClick={() => {
- closeEditor();
- setStarting(true);
- }}
- >
- New session
- </button>
- )}
{showSession && !editing && (
<div className="flex flex-wrap gap-2">
{completed && (
diff --git a/apps/screenpipe-app-tauri/components/starred-sessions/starred-sessions.test.tsx b/apps/screenpipe-app-tauri/components/starred-sessions/starred-sessions.test.tsx
index df17b07cf..c5dba97d2 100644
--- a/apps/screenpipe-app-tauri/components/starred-sessions/starred-sessions.test.tsx
+++ b/apps/screenpipe-app-tauri/components/starred-sessions/starred-sessions.test.tsx
@@ -22,8 +22,9 @@ const mocks = vi.hoisted(() => ({
fetch: vi.fn(),
chat: vi.fn(),
reveal: vi.fn(),
+ events: new Map<string, () => void>(),
}));
-vi.mock("@/lib/hooks/use-tauri-event", () => ({ useTauriEvent: vi.fn() }));
+vi.mock("@/lib/hooks/use-tauri-event", () => ({ useTauriEvent: (name: string, callback: () => void) => { mocks.events.set(name, callback); } }));
vi.mock("@/lib/api", () => ({ localFetch: mocks.fetch }));
vi.mock("@/lib/chat-utils", () => ({ showChatWithPrefill: mocks.chat }));
vi.mock("@tauri-apps/plugin-opener", () => ({ revealItemInDir: mocks.reveal }));
@@ -42,6 +43,7 @@ const response = (value: unknown, ok = true) => ({
});
beforeEach(() => {
vi.clearAllMocks();
+ mocks.events.clear();
saved = [];
mocks.fetch.mockImplementation(async (_path, init) => {
if (init?.method === "POST") {
@@ -71,11 +73,10 @@ describe("starred sessions", () => {
<StarredTimeline showStrip />
</>,
);
- fireEvent.click(
- screen.getByRole("button", { name: "Star session", exact: true }),
- );
+ await waitFor(() => expect(screen.getByRole("button", { name: "Star session", exact: true })).toBeEnabled());
+ fireEvent.click(screen.getByRole("button", { name: "Star session", exact: true }));
await waitFor(() => expect(screen.getAllByRole("dialog")).toHaveLength(1));
- expect(screen.getByRole("button", { name: "15 min" })).toBeVisible();
+ expect(await screen.findByRole("button", { name: "15 min" })).toBeVisible();
});
it("keeps secondary actions collapsed and offers a new session after ending", async () => {
@@ -93,9 +94,21 @@ describe("starred sessions", () => {
fireEvent.click(screen.getByRole("button", { name: "End session" }));
await screen.findByRole("button", { name: "New session" });
fireEvent.click(screen.getByRole("button", { name: "New session" }));
- fireEvent.click(screen.getByRole("button", { name: "5 min" }));
await screen.findByRole("button", { name: "End session" });
expect(saved).toHaveLength(2);
+ expect(Date.parse(saved[0].end) - Date.parse(saved[0].start)).toBe(60 * 60000);
+ expect(screen.getByText("Starred session in progress")).toBeVisible();
+ fireEvent.click(screen.getByRole("button", { name: "5 min" }));
+ await waitFor(() => expect(Date.parse(saved[0].end) - Date.parse(saved[0].start)).toBe(5 * 60000));
+ expect(saved).toHaveLength(2);
+ });
+ it("shows a session started by the native shortcut as soon as it refreshes", async () => {
+ const hook = renderHook(useStarredSessions);
+ await waitFor(() => expect(hook.result.current.ready).toBe(true));
+ const now = Date.now();
+ saved = [{ ...session, start: new Date(now).toISOString(), end: new Date(now + 3600000).toISOString() }];
+ act(() => mocks.events.get("starred-sessions-changed")!());
+ await waitFor(() => expect(hook.result.current.active?.id).toBe(session.id));
});
it("persists a timed boundary and restores it on remount", async () => {
const hook = renderHook(useStarredSessions);
diff --git a/apps/screenpipe-app-tauri/components/starred-sessions/starred-timeline.tsx b/apps/screenpipe-app-tauri/components/starred-sessions/starred-timeline.tsx
index 254cedcd5..a1ea81f87 100644
--- a/apps/screenpipe-app-tauri/components/starred-sessions/starred-timeline.tsx
+++ b/apps/screenpipe-app-tauri/components/starred-sessions/starred-timeline.tsx
@@ -1,7 +1,7 @@
// screenpipe — AI that knows everything you've seen, said, or heard
// https://screenpipe.com
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
import { Star } from "lucide-react";
import { emit } from "@tauri-apps/api/event";
import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
@@ -16,6 +16,7 @@ export function StarredTimeline({
}) {
const state = useStarredSessions();
const [open, setOpen] = useState(false);
+ const dismiss = useCallback(() => setOpen(false), []);
useEffect(() => {
if (showStrip) return;
const openControls = () => setOpen(true);
@@ -47,9 +48,11 @@ export function StarredTimeline({
>
<button
className="flex shrink-0 items-center gap-1.5 rounded-md border px-2 py-1.5 hover:bg-muted"
- onClick={() =>
- window.dispatchEvent(new Event("open-starred-sessions"))
- }
+ disabled={!state.ready || state.busy}
+ onClick={async () => {
+ if (!state.active) await state.start(60);
+ window.dispatchEvent(new Event("open-starred-sessions"));
+ }}
>
<Star
className={`h-3.5 w-3.5 ${state.active ? "fill-current" : ""}`}
@@ -80,7 +83,7 @@ export function StarredTimeline({
<Dialog open={open} onOpenChange={setOpen}>
<DialogContent aria-describedby={undefined} className="max-h-[85vh] max-w-sm overflow-y-auto border-white/20 bg-black p-0 text-white">
<DialogTitle className="sr-only">Starred sessions</DialogTitle>
- <StarredSessionPanel state={state} inDialog />
+ <StarredSessionPanel state={state} inDialog onDismiss={dismiss} />
</DialogContent>
</Dialog>
)}
diff --git a/apps/screenpipe-app-tauri/components/starred-sessions/use-starred-sessions.ts b/apps/screenpipe-app-tauri/components/starred-sessions/use-starred-sessions.ts
index eccb32b65..53682e324 100644
--- a/apps/screenpipe-app-tauri/components/starred-sessions/use-starred-sessions.ts
+++ b/apps/screenpipe-app-tauri/components/starred-sessions/use-starred-sessions.ts
@@ -1,7 +1,9 @@
// screenpipe — AI that knows everything you've seen, said, or heard
// https://screenpipe.com
+import { emit } from "@tauri-apps/api/event";
import { useCallback, useEffect, useRef, useState } from "react";
+import { useTauriEvent } from "@/lib/hooks/use-tauri-event";
import { localFetch } from "@/lib/api";
export interface StarredSession {
@@ -59,6 +61,7 @@ export function useStarredSessions() {
throw new Error("Could not read starred sessions.");
if (mounted.current && generation.current === epoch) {
setSessions(result.data);
+ setNow(Date.now());
setReady(true);
if (!pending.current) setError(null);
}
@@ -84,9 +87,17 @@ export function useStarredSessions() {
window.removeEventListener("starred-sessions-changed", load);
};
}, [refresh]);
+ useTauriEvent("starred-sessions-changed", () => {
+ if (!lock.current) void refresh().catch((e) => {
+ if (mounted.current) setError(e.message);
+ });
+ });
const active = sessions.find(
(s) => Date.parse(s.start) <= now && Date.parse(s.end) > now,
);
+ useEffect(() => {
+ if (ready) void emit("starred-session-state", active?.end ?? null).catch(() => {});
+ }, [ready, active?.end]);
async function save(value: SessionWrite) {
if (lock.current) return false;
lock.current = true;
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs b/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs
index bf469a2f7..b9d6f10cc 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs
@@ -12,6 +12,7 @@ use tracing::{error, info, warn};
/// Global app handle stored so native action callbacks can emit events.
static GLOBAL_APP_HANDLE: std::sync::OnceLock<tauri::AppHandle> = std::sync::OnceLock::new();
+static STARRED_STATE_INSTALLED: std::sync::OnceLock<()> = std::sync::OnceLock::new();
static NATIVE_TIMELINE_PLACEMENT_INSTALLED: std::sync::OnceLock<()> = std::sync::OnceLock::new();
fn handle_shortcut_overlay_hour_snooze(app: &tauri::AppHandle) {
@@ -77,6 +78,15 @@ pub(super) fn install_shortcut_action_callback(app_handle: &tauri::AppHandle) {
// here rather than adding a second startup hook that could drift.
crate::native_timeline::set_action_callback(native_timeline_action_callback);
install_native_timeline_placement(app_handle);
+ if STARRED_STATE_INSTALLED.set(()).is_err() { return; }
+ use tauri::Listener;
+ app_handle.listen("starred-session-state", |event| {
+ if let Ok(end) = serde_json::from_str::<Option<String>>(event.payload()) {
+ let until = end.and_then(|value| chrono::DateTime::parse_from_rfc3339(&value).ok())
+ .map(|value| value.timestamp_millis()).unwrap_or(0);
+ native_shortcut_reminder::set_starred_until(until);
+ }
+ });
}
/// Lets the webview pin the native timeline over a slice of its own layout.
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/commands/starred_sessions.rs b/apps/screenpipe-app-tauri/src-tauri/src/commands/starred_sessions.rs
index e7d2e125d..47abf1234 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/commands/starred_sessions.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/commands/starred_sessions.rs
@@ -153,13 +153,106 @@ pub(crate) fn hide(app: &tauri::AppHandle) -> Result<(), String> {
Ok(())
}
-/// Called on the main thread by both the global shortcut and overlay star button.
-pub(crate) fn toggle(app: &tauri::AppHandle) -> Result<(), String> {
- if let Some(window) = app.get_webview_window(LABEL) {
- if window.is_visible().unwrap_or(false) {
- return hide(app);
- }
+// Serialize shortcut/button presses through the persisted engine state. Window
+// visibility is independent: dismissing controls must never end a session.
+static TOGGLE_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
+fn toggle_body(
+ rows: &[serde_json::Value],
+ now: chrono::DateTime<chrono::Utc>,
+) -> serde_json::Value {
+ let active = rows.iter().find(|row| {
+ let start = row["start"]
+ .as_str()
+ .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok());
+ let end = row["end"]
+ .as_str()
+ .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok());
+ matches!((start, end), (Some(start), Some(end)) if start <= now && end > now)
+ });
+ if let Some(active) = active {
+ let mut row = active.clone();
+ let start = chrono::DateTime::parse_from_rfc3339(row["start"].as_str().unwrap()).unwrap();
+ row["end"] = serde_json::json!(
+ now.max(start.with_timezone(&chrono::Utc) + chrono::Duration::milliseconds(1))
+ );
+ row
+ } else {
+ serde_json::json!({
+ "id": uuid::Uuid::new_v4().to_string(), "start": now,
+ "end": now + chrono::Duration::minutes(60), "hd_requested": false, "revision": 0
+ })
}
+}
+
+fn toggle_saved_session(app: &tauri::AppHandle) -> Result<(), String> {
+ let _guard = TOGGLE_LOCK.lock().map_err(|e| e.to_string())?;
+ let api = crate::recording::local_api_context_from_app(app);
+ let client = reqwest::blocking::Client::builder()
+ .timeout(std::time::Duration::from_secs(5))
+ .build()
+ .map_err(|e| e.to_string())?;
+ let now = chrono::Utc::now();
+ let result: serde_json::Value = api
+ .apply_auth_blocking(client.get(api.url("/starred-sessions")).query(&[
+ ("start_time", now.to_rfc3339()),
+ (
+ "end_time",
+ (now + chrono::Duration::milliseconds(1)).to_rfc3339(),
+ ),
+ ]))
+ .send()
+ .map_err(|e| e.to_string())?
+ .error_for_status()
+ .map_err(|e| e.to_string())?
+ .json()
+ .map_err(|e| e.to_string())?;
+ let rows = result["data"]
+ .as_array()
+ .ok_or("Could not read starred sessions")?;
+ let body = toggle_body(rows, now);
+ api.apply_auth_blocking(client.post(api.url("/starred-sessions")).json(&body))
+ .send()
+ .map_err(|e| e.to_string())?
+ .error_for_status()
+ .map_err(|e| e.to_string())?;
+ let until = body["end"]
+ .as_str()
+ .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok())
+ .map(|date| date.timestamp_millis())
+ .unwrap_or(0);
+ crate::native_shortcut_reminder::set_starred_until(until);
+ let _ = app.emit("starred-sessions-changed", ());
+ Ok(())
+}
+
+/// Both the global shortcut and overlay button start/stop the saved session.
+/// HTTP stays off the UI thread, and every press reads the latest persisted state.
+pub(crate) fn toggle(app: &tauri::AppHandle) -> Result<(), String> {
+ let app = app.clone();
+ std::thread::Builder::new()
+ .name("starred-session-toggle".into())
+ .spawn(move || {
+ if let Err(error) = toggle_saved_session(&app) {
+ tracing::warn!("could not toggle starred session: {error}");
+ crate::notifications::client::send(
+ "Could not update starred session",
+ "Try again. Your saved sessions have not been removed.",
+ );
+ return;
+ }
+ let handle = app.clone();
+ let _ = app.run_on_main_thread(move || {
+ if let Err(error) = show(&handle) {
+ tracing::warn!("could not show starred session controls: {error}");
+ }
+ });
+ })
+ .map(|_| ())
+ .map_err(|e| e.to_string())
+}
+
+fn show(app: &tauri::AppHandle) -> Result<(), String> {
let window = match app.get_webview_window(LABEL) {
Some(window) => window,
None => {
@@ -271,6 +364,35 @@ pub async fn hide_starred_sessions(app_handle: tauri::AppHandle) -> Result<(), S
#[cfg(test)]
mod tests {
use super::*;
+ #[test]
+ fn shortcut_starts_for_an_hour_and_second_press_ends_the_same_session() {
+ let now = chrono::DateTime::parse_from_rfc3339("2026-10-07T17:00:00Z")
+ .unwrap()
+ .with_timezone(&chrono::Utc);
+ let mut first = toggle_body(&[], now);
+ assert_eq!(first["revision"], 0);
+ assert_eq!(first["hd_requested"], false);
+ assert_eq!(
+ chrono::DateTime::parse_from_rfc3339(first["end"].as_str().unwrap()).unwrap(),
+ now + chrono::Duration::minutes(60)
+ );
+ first["revision"] = serde_json::json!(1);
+ let stopped = toggle_body(&[first.clone()], now + chrono::Duration::minutes(1));
+ assert_eq!(stopped["id"], first["id"]);
+ assert_eq!(stopped["revision"], 1);
+ assert_eq!(
+ chrono::DateTime::parse_from_rfc3339(stopped["end"].as_str().unwrap()).unwrap(),
+ now + chrono::Duration::minutes(1)
+ );
+ let next = toggle_body(&[stopped], now + chrono::Duration::minutes(2));
+ assert_ne!(next["id"], first["id"]);
+ let immediate = toggle_body(&[first], now);
+ assert_eq!(
+ chrono::DateTime::parse_from_rfc3339(immediate["end"].as_str().unwrap()).unwrap(),
+ now + chrono::Duration::milliseconds(1)
+ );
+ }
+
#[test]
fn starred_panel_hugs_trigger_and_stays_on_its_display() {
assert_eq!(
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/native_shortcut_reminder.rs b/apps/screenpipe-app-tauri/src-tauri/src/native_shortcut_reminder.rs
index 052d6a0db..f33abf742 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/native_shortcut_reminder.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/native_shortcut_reminder.rs
@@ -258,3 +258,12 @@ pub use ffi::*;
#[cfg(not(target_os = "macos"))]
pub fn set_ui_locale(_json: &str) {}
+
+/// Persisted starred-session end time, projected into the macOS pill.
+#[cfg(target_os = "macos")]
+pub fn set_starred_until(until_ms: i64) {
+ extern "C" { fn shortcut_set_starred_until(until_ms: i64); }
+ unsafe { shortcut_set_starred_until(until_ms); }
+}
+#[cfg(not(target_os = "macos"))]
+pub fn set_starred_until(_until_ms: i64) {}
diff --git a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift
index e83b7ca5d..a2b81faba 100644
--- a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift
+++ b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift
@@ -98,6 +98,7 @@ public func shortcutSetHealthState(_ statePtr: UnsafePointer<CChar>?) -> Int32 {
// MARK: - Metrics data pushed from Rust
final class OverlayMetrics: ObservableObject {
+ @Published var starredActive: Bool = false
@Published var audioActive: Bool = false
@Published var speechRatio: Double = 0
@Published var meetingActive: Bool = false
@@ -827,7 +828,7 @@ func disclosureContent(
) -> (String, String?)? {
switch control {
case "brand": return ("screenpipe", uiText("right-click"))
- case "star": return (uiText("star work session"), starShortcut)
+ case "star": return (uiText(metrics.starredActive ? "Starred session in progress" : "star work session"), starShortcut)
case "timeline": return (uiText("timeline"), overlayShortcut)
case "chat": return (uiText("ask chat"), chatShortcut)
case "search": return (uiText("search"), searchShortcut)
@@ -1187,10 +1188,10 @@ struct ShortcutReminderView: View {
DockIconButton(icon: "bubble.left.fill", active: metrics.hoveredControl == "chat", scale: scale) {
onAction("open_chat")
}
- DockIconButton(icon: "star", active: metrics.hoveredControl == "star", scale: scale) {
+ DockIconButton(icon: metrics.starredActive ? "star.fill" : "star", active: metrics.hoveredControl == "star", scale: scale) {
onAction("open_starred_sessions")
}
- .accessibilityLabel("Star a work session")
+ .accessibilityLabel(metrics.starredActive ? "Stop starred session" : "Star a work session")
DockIconButton(icon: "rectangle.split.1x2", active: metrics.hoveredControl == "timeline", scale: scale) {
onAction("open_timeline")
}
@@ -1588,6 +1589,8 @@ class ShortcutReminderController: NSObject, NSWindowDelegate {
private var chatShortcut = "⌘⌃L"
private var searchShortcut = "⌘⌃K"
private var starShortcut = "⌘⌃B"
+ private var starredUntil: Int64 = 0
+ private var starredExpiry: DispatchWorkItem?
private var metrics = OverlayMetrics()
private var wsTask: URLSessionWebSocketTask?
private var wsRetryTimer: Timer?
@@ -2099,6 +2102,26 @@ class ShortcutReminderController: NSObject, NSWindowDelegate {
DispatchQueue.main.asyncAfter(deadline: .now() + 6, execute: timeout)
}
+ func setStarredUntil(_ until: Int64) {
+ DispatchQueue.main.async { [self] in
+ guard until != starredUntil else { return }
+ starredUntil = until
+ starredExpiry?.cancel()
+ let seconds = Double(until) / 1000 - Date().timeIntervalSince1970
+ metrics.starredActive = seconds > 0
+ refreshActiveDisclosure()
+ if seconds > 0 {
+ let expiry = DispatchWorkItem { [weak self] in
+ guard let self, self.starredUntil == until else { return }
+ self.metrics.starredActive = false
+ self.refreshActiveDisclosure()
+ }
+ starredExpiry = expiry
+ DispatchQueue.main.asyncAfter(deadline: .now() + seconds, execute: expiry)
+ }
+ }
+ }
+
/// Apply a recording-health state pushed from Rust. Kept even while the
/// panel is hidden so a later show renders the active incident. The panel
/// frame is deliberately NOT resized — all health content is sized to fit
@@ -3804,3 +3827,10 @@ public func shortcutGetFrame(
public func shortcut_set_ui_locale(_ json: UnsafePointer<CChar>?) {
UILocalization.shared.update(json)
}
+
+@_cdecl("shortcut_set_starred_until")
+public func shortcutSetStarredUntil(_ until: Int64) {
+ if #available(macOS 13.0, *) {
+ ShortcutReminderController.shared.setStarredUntil(until)
+ }
+}
diff --git a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder_tests.swift b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder_tests.swift
index f15889bd8..1b2166d75 100644
--- a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder_tests.swift
+++ b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder_tests.swift
@@ -520,7 +520,7 @@ private func testClampWithoutDisplaysIsIdentity() {
/// Selecting a UI locale must translate labels and leave shortcut tokens intact.
private func testLocalizedDisclosure() {
- let sources = ["right-click", "star work session", "timeline", "ask chat", "search", "mic capture", "live", "idle", "settings"]
+ let sources = ["right-click", "star work session", "Starred session in progress", "timeline", "ask chat", "search", "mic capture", "live", "idle", "settings"]
let translations = Dictionary(uniqueKeysWithValues: sources.map { source in
(SHA256.hash(data: Data(source.utf8)).prefix(8).map { String(format: "%02x", $0) }.joined(), "localized " + source)
})
@@ -534,6 +534,11 @@ private func testLocalizedDisclosure() {
if control == "star" { expect(content?.1 == "⌥B", "star shortcut was not preserved") }
if control == "timeline" { expect(content?.1 == "⌥Space", "shortcut was translated") }
}
+ metrics.starredActive = true
+ let activeStar = disclosureContent(for: "star", overlayShortcut: "", chatShortcut: "", searchShortcut: "", starShortcut: "⌥B", metrics: metrics)
+ expect(activeStar?.0 == "localized Starred session in progress", "active session status must replace the start hint")
+ expect(activeStar?.1 == "⌥B", "active session preserves its stop shortcut")
+ metrics.starredActive = false
let disabledStar = disclosureContent(for: "star", overlayShortcut: "", chatShortcut: "", searchShortcut: "", starShortcut: "", metrics: metrics)
expect(disabledStar?.1 == "", "disabled star shortcut must not show a chord")
let brand = disclosureContent(for: "brand", overlayShortcut: "", chatShortcut: "", searchShortcut: "", starShortcut: "", metrics: metrics)
diff --git a/docs/assets/pr/7529-starred-sessions/after.png b/docs/assets/pr/7529-starred-sessions/after.png
new file mode 100644
index 000000000..4f169a57a
Binary files /dev/null and b/docs/assets/pr/7529-starred-sessions/after.png differ
diff --git a/docs/assets/pr/7529-starred-sessions/before.png b/docs/assets/pr/7529-starred-sessions/before.png
new file mode 100644
index 000000000..8d0515bc0
Binary files /dev/null and b/docs/assets/pr/7529-starred-sessions/before.png differ
diff --git a/docs/assets/pr/7529-starred-sessions/ended.png b/docs/assets/pr/7529-starred-sessions/ended.png
new file mode 100644
index 000000000..a733ec6f4
Binary files /dev/null and b/docs/assets/pr/7529-starred-sessions/ended.png differ
diff --git a/docs/assets/pr/7529-starred-sessions/new-session.png b/docs/assets/pr/7529-starred-sessions/new-session.png
new file mode 100644
index 000000000..0725b7a4a
Binary files /dev/null and b/docs/assets/pr/7529-starred-sessions/new-session.png differ