@agent-native/core 0.91.1 → 0.92.0

package/corpus/templates/clips/desktop/src/styles.css

@@ -25,7 +25,9 @@
   --radius: 12px;
   --radius-sm: 8px;
   --radius-pill: 999px;
-  --popover-shadow-gutter: 12px;
+  /* Must cover `--shadow-md` blur (24px in dark mode) or the transparent
+     Tauri window clips the drop shadow on every edge. */
+  --popover-shadow-gutter: 24px;
   --overlay-shadow-gutter: 18px;
 
   --shadow-sm: 0 1px 2px rgba(23, 23, 23, 0.06);
@@ -1193,6 +1195,7 @@ body[data-clips-route="recording-pill"] #root {
   display: flex;
   flex-direction: column;
   gap: 6px;
+  margin-bottom: 4px;
 }
 
 .popover-list-item {
@@ -1262,6 +1265,27 @@ body[data-clips-route="recording-pill"] #root {
   background: var(--brand-hover);
 }
 
+.popover-list-action-active {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  border-color: rgba(34, 197, 94, 0.36);
+  background: rgba(34, 197, 94, 0.12);
+  color: #4ade80;
+}
+
+.popover-list-action-active:hover {
+  background: rgba(34, 197, 94, 0.18);
+}
+
+.popover-list-action-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 999px;
+  background: currentColor;
+  box-shadow: 0 0 0 3px rgba(34, 197, 94, 0.12);
+}
+
 .popover-kv {
   display: flex;
   align-items: center;
@@ -1419,6 +1443,13 @@ body[data-clips-route="recording-pill"] #root {
   overscroll-behavior: contain;
 }
 
+/* Meetings / dictation drill-ins: a touch more room under the last row so
+   content isn't flush with the panel edge. Must follow `.setup` so it wins
+   over the shorthand padding above. */
+.setup.popover-view {
+  padding-bottom: 26px;
+}
+
 .setup h2 {
   margin: 0;
   font-size: 14px;
@@ -3599,7 +3630,7 @@ body[data-clips-route="recording-pill"] #root {
   position: relative;
   display: flex;
   align-items: center;
-  gap: 10px;
+  gap: 12px;
   padding: 12px 14px;
   border-radius: 14px;
   background: rgba(20, 22, 28, 0.94);
@@ -3611,37 +3642,26 @@ body[data-clips-route="recording-pill"] #root {
     0 2px 6px rgba(0, 0, 0, 0.3);
   color: white;
   pointer-events: auto;
-  min-width: 280px;
-  max-width: 400px;
-}
-
-.meeting-notification-with-join {
-  flex-wrap: wrap;
-  align-items: flex-start;
-  row-gap: 10px;
-}
-
-.meeting-notification-with-join .meeting-notification-actions {
-  flex: 1 1 100%;
-  justify-content: flex-end;
-  padding-left: 13px; /* align under content past the bar */
+  min-width: 320px;
+  max-width: 440px;
 }
 
 .meeting-notification-bar {
   width: 3px;
-  height: 40px;
-  border-radius: 2px;
+  height: 36px;
+  border-radius: 999px;
   flex-shrink: 0;
 }
 
 .meeting-notification-bar-calendar {
-  background: #16a34a;
+  background: #7dd3fc;
 }
 
 .meeting-notification-bar-adhoc {
   background: transparent;
   border-left: 3px dashed #a3a3a3;
   width: 3px;
+  border-radius: 0;
 }
 
 .meeting-notification-content {
@@ -3650,6 +3670,7 @@ body[data-clips-route="recording-pill"] #root {
   display: flex;
   flex-direction: column;
   gap: 2px;
+  padding-right: 4px;
 }
 
 .meeting-notification-title {
@@ -3666,65 +3687,141 @@ body[data-clips-route="recording-pill"] #root {
   color: rgba(255, 255, 255, 0.55);
 }
 
-.meeting-notification-btn {
-  border: none;
-  border-radius: 8px;
-  padding: 6px 12px;
-  background: rgba(255, 255, 255, 0.1);
-  color: white;
-  font-size: 12px;
-  font-weight: 600;
-  cursor: pointer;
-  white-space: nowrap;
+.meeting-notification-split {
+  position: relative;
+  display: inline-flex;
+  align-items: stretch;
   flex-shrink: 0;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  border-radius: 10px;
+  overflow: visible;
+  background: rgba(255, 255, 255, 0.04);
 }
 
-.meeting-notification-btn:hover {
-  background: rgba(255, 255, 255, 0.16);
+.meeting-notification-split-main {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  border: none;
+  background: transparent;
+  color: white;
+  padding: 6px 10px;
+  cursor: pointer;
+  text-align: left;
+  min-height: 40px;
 }
 
-.meeting-notification-btn:active {
-  transform: scale(0.96);
+.meeting-notification-split-main:hover {
+  background: rgba(255, 255, 255, 0.06);
 }
 
-.meeting-notification-btn:disabled {
-  opacity: 0.6;
+.meeting-notification-split-main:disabled {
+  opacity: 0.65;
   cursor: progress;
 }
 
-.meeting-notification-btn-primary {
-  background: #ffffff;
-  color: #111827;
+.meeting-notification-split-copy {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  line-height: 1.15;
 }
 
-.meeting-notification-btn-primary:hover {
-  background: #f3f4f6;
+.meeting-notification-split-primary {
+  font-size: 12px;
+  font-weight: 600;
+  color: white;
+  white-space: nowrap;
 }
 
-.meeting-notification-btn-primary:disabled {
-  background: rgba(255, 255, 255, 0.7);
-  color: #374151;
+.meeting-notification-split-secondary {
+  font-size: 10px;
+  font-weight: 500;
+  color: rgba(255, 255, 255, 0.55);
+  white-space: nowrap;
 }
 
-.meeting-notification-actions {
+.meeting-notification-split-chevron {
   display: inline-flex;
   align-items: center;
-  gap: 6px;
-  flex-shrink: 0;
+  justify-content: center;
+  width: 28px;
+  border: none;
+  border-left: 1px solid rgba(255, 255, 255, 0.12);
+  background: transparent;
+  color: rgba(255, 255, 255, 0.75);
+  cursor: pointer;
+  border-radius: 0 10px 10px 0;
+}
+
+.meeting-notification-split-chevron:hover {
+  background: rgba(255, 255, 255, 0.06);
+  color: white;
 }
 
-.meeting-notification-btn-secondary {
+.meeting-notification-provider {
+  width: 22px;
+  height: 22px;
+  border-radius: 6px;
   display: inline-flex;
   align-items: center;
-  gap: 4px;
-  padding: 6px 8px;
-  background: rgba(255, 255, 255, 0.06);
-  color: rgba(255, 255, 255, 0.85);
+  justify-content: center;
+  flex-shrink: 0;
+  color: white;
+}
+
+.meeting-notification-provider-zoom {
+  background: #2d8cff;
+}
+
+.meeting-notification-provider-meet {
+  background: #34a853;
 }
 
-.meeting-notification-btn-secondary:hover {
+.meeting-notification-provider-teams {
+  background: #6264a7;
+}
+
+.meeting-notification-provider-other {
   background: rgba(255, 255, 255, 0.12);
-  color: white;
+}
+
+.meeting-notification-menu {
+  position: absolute;
+  top: calc(100% + 6px);
+  right: 0;
+  min-width: 160px;
+  padding: 4px;
+  border-radius: 10px;
+  background: rgba(24, 26, 32, 0.98);
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  box-shadow: 0 12px 28px rgba(0, 0, 0, 0.4);
+  z-index: 5;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.meeting-notification-menu-item {
+  border: none;
+  background: transparent;
+  color: rgba(255, 255, 255, 0.9);
+  text-align: left;
+  font-size: 12px;
+  font-weight: 500;
+  padding: 8px 10px;
+  border-radius: 7px;
+  cursor: pointer;
+  white-space: nowrap;
+}
+
+.meeting-notification-menu-item:hover {
+  background: rgba(255, 255, 255, 0.08);
+}
+
+.meeting-notification-menu-item:disabled {
+  opacity: 0.5;
+  cursor: progress;
 }
 
 .meeting-notification-error {

package/corpus/templates/clips/desktop/src-tauri/src/adhoc_meetings_watcher.rs

@@ -0,0 +1,362 @@
+//! Granola-style adhoc Zoom / Teams detection.
+//!
+//! Polls the frontmost macOS app every few seconds. When Zoom or Teams stays
+//! frontmost for a short dwell window, creates a meeting row via
+//! `create-meeting` and shows the same meeting-notification overlay used for
+//! calendar reminders — with `type: "adhoc"`.
+//!
+//! Reuses `MeetingsWatcherState` session (server URL + cookie + auth token)
+//! so the popover only needs to push credentials once.
+
+use std::collections::HashMap;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+use tauri::{AppHandle, Emitter, Manager};
+
+use crate::config::{feature_config, MeetingTranscriptionMode};
+use crate::dlog;
+use crate::meetings_watcher::MeetingsWatcherState;
+
+/// How often to sample the frontmost app.
+const POLL_SECS: u64 = 4;
+
+/// Require this many consecutive frontmost seconds before firing.
+const DWELL_SECS: u64 = 9;
+
+/// After dismiss / fire, suppress re-prompts for this platform until the
+/// cooldown elapses (or the VC app leaves front — see tick logic).
+const COOLDOWN_SECS: i64 = 30 * 60;
+
+/// Soft guard: skip adhoc if a calendar reminder for the same platform fired
+/// this recently.
+const CALENDAR_SOFT_GUARD_SECS: i64 = 3 * 60;
+
+const STRONG_VC_BUNDLES: &[(&str, &str, &str)] = &[
+    // (bundle_id, platform, display title)
+    ("us.zoom.xos", "zoom", "Zoom meeting detected"),
+    ("us.zoom.ZoomClips", "zoom", "Zoom meeting detected"),
+    ("com.microsoft.teams2", "teams", "Teams meeting detected"),
+    ("com.microsoft.teams", "teams", "Teams meeting detected"),
+];
+
+#[derive(Default)]
+pub struct AdhocMeetingsWatcherState {
+    inner: Mutex<AdhocMeetingsWatcherInner>,
+}
+
+#[derive(Default)]
+struct AdhocMeetingsWatcherInner {
+    /// platform -> unix-seconds when we last fired (or dismissed via cooldown).
+    cooldown_until: HashMap<String, i64>,
+    /// Current dwell: which platform is accumulating frontmost time.
+    dwell_platform: Option<String>,
+    dwell_since: Option<Instant>,
+    /// Platforms already notified for the current continuous foreground session.
+    session_notified: HashMap<String, bool>,
+}
+
+/// Spawn the long-running adhoc watcher. Idempotent — gated by OnceLock.
+pub fn spawn_watcher(app: AppHandle) {
+    use std::sync::OnceLock;
+    static STARTED: OnceLock<()> = OnceLock::new();
+    if STARTED.set(()).is_err() {
+        return;
+    }
+    tauri::async_runtime::spawn(async move {
+        run_watcher(app).await;
+    });
+}
+
+async fn run_watcher(app: AppHandle) {
+    let mut interval = tokio::time::interval(Duration::from_secs(POLL_SECS));
+    // Skip the first tick — give the frontend time to push session creds.
+    interval.tick().await;
+    let client = match reqwest::Client::builder()
+        .timeout(Duration::from_secs(10))
+        .build()
+    {
+        Ok(c) => c,
+        Err(err) => {
+            eprintln!("[clips-tray] adhoc_meetings_watcher: reqwest build failed: {err}");
+            return;
+        }
+    };
+    loop {
+        interval.tick().await;
+        if let Err(err) = tick_once(&app, &client).await {
+            eprintln!("[clips-tray] adhoc_meetings_watcher tick failed: {err}");
+        }
+    }
+}
+
+fn match_vc_bundle(bundle: &str) -> Option<(&'static str, &'static str)> {
+    STRONG_VC_BUNDLES
+        .iter()
+        .find(|(id, _, _)| *id == bundle)
+        .map(|(_, platform, title)| (*platform, *title))
+}
+
+async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), String> {
+    let config = feature_config(app);
+    if !config.meetings_enabled {
+        reset_dwell(app);
+        return Ok(());
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    {
+        let _ = (app, client);
+        return Ok(());
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        tick_macos(app, client, &config).await
+    }
+}
+
+#[cfg(target_os = "macos")]
+async fn tick_macos(
+    app: &AppHandle,
+    client: &reqwest::Client,
+    config: &crate::config::FeatureConfig,
+) -> Result<(), String> {
+    let front = crate::util::frontmost_bundle_id();
+    let matched = front.as_deref().and_then(match_vc_bundle);
+
+    let Some((platform, title)) = matched else {
+        // VC app left front — clear session dedupe so a later re-focus can
+        // fire again (cooldown still applies).
+        clear_session_if_left(app, None);
+        reset_dwell(app);
+        return Ok(());
+    };
+
+    clear_session_if_left(app, Some(platform));
+
+    // Skip while already transcribing a meeting.
+    if crate::util::is_meeting_active(app) {
+        reset_dwell(app);
+        return Ok(());
+    }
+
+    if config.meeting_transcription_mode == MeetingTranscriptionMode::Manual
+        && !config.show_meeting_widget_enabled
+    {
+        reset_dwell(app);
+        return Ok(());
+    }
+
+    // Soft guard against double-prompting after a calendar reminder.
+    if let Some(state) = app.try_state::<MeetingsWatcherState>() {
+        if state.recent_calendar_notify(platform, CALENDAR_SOFT_GUARD_SECS) {
+            dlog!(
+                "[clips-tray] adhoc skip: recent calendar notify for {}",
+                platform
+            );
+            reset_dwell(app);
+            return Ok(());
+        }
+    }
+
+    let now_ts = chrono::Utc::now().timestamp();
+    let should_fire = {
+        let state = app
+            .try_state::<AdhocMeetingsWatcherState>()
+            .ok_or_else(|| "no AdhocMeetingsWatcherState".to_string())?;
+        let mut g = state.inner.lock().map_err(|e| e.to_string())?;
+
+        // Prune expired cooldowns.
+        g.cooldown_until.retain(|_, until| *until > now_ts);
+
+        if g.cooldown_until.get(platform).copied().unwrap_or(0) > now_ts {
+            return Ok(());
+        }
+        if g.session_notified.get(platform).copied().unwrap_or(false) {
+            return Ok(());
+        }
+
+        match (g.dwell_platform.as_deref(), g.dwell_since) {
+            (Some(p), Some(since)) if p == platform => {
+                if since.elapsed() >= Duration::from_secs(DWELL_SECS) {
+                    g.session_notified.insert(platform.to_string(), true);
+                    g.cooldown_until
+                        .insert(platform.to_string(), now_ts + COOLDOWN_SECS);
+                    g.dwell_platform = None;
+                    g.dwell_since = None;
+                    true
+                } else {
+                    false
+                }
+            }
+            _ => {
+                g.dwell_platform = Some(platform.to_string());
+                g.dwell_since = Some(Instant::now());
+                false
+            }
+        }
+    };
+
+    if !should_fire {
+        return Ok(());
+    }
+
+    dlog!(
+        "[clips-tray] adhoc dwell met for {} — creating meeting",
+        platform
+    );
+
+    let meeting_id = match create_adhoc_meeting(app, client, platform).await {
+        Ok(id) => id,
+        Err(err) => {
+            // Allow retry on next dwell if create failed.
+            if let Some(state) = app.try_state::<AdhocMeetingsWatcherState>() {
+                if let Ok(mut g) = state.inner.lock() {
+                    g.session_notified.remove(platform);
+                    g.cooldown_until.remove(platform);
+                }
+            }
+            return Err(err);
+        }
+    };
+
+    let auto_start = config.meeting_transcription_mode == MeetingTranscriptionMode::Auto;
+    let show_widget = config.show_meeting_widget_enabled
+        || config.meeting_transcription_mode == MeetingTranscriptionMode::Ask
+        || auto_start;
+
+    if show_widget {
+        let app_clone = app.clone();
+        let id_clone = meeting_id.clone();
+        let title_clone = title.to_string();
+        let platform_clone = platform.to_string();
+        let scheduled_start = chrono::Utc::now().to_rfc3339();
+        tauri::async_runtime::spawn(async move {
+            let _ = crate::notifications::notify_meeting_starting(
+                app_clone,
+                id_clone,
+                title_clone,
+                0,
+                None,
+                Some(scheduled_start),
+                None,
+                Some(platform_clone),
+                Some(auto_start),
+                Some("adhoc".to_string()),
+            )
+            .await;
+        });
+    }
+
+    if auto_start {
+        let _ = app.emit(
+            "meetings:start-transcription",
+            serde_json::json!({
+                "meetingId": meeting_id,
+                "joinUrl": null,
+                "reason": "adhoc-auto",
+            }),
+        );
+    }
+
+    Ok(())
+}
+
+fn reset_dwell(app: &AppHandle) {
+    if let Some(state) = app.try_state::<AdhocMeetingsWatcherState>() {
+        if let Ok(mut g) = state.inner.lock() {
+            g.dwell_platform = None;
+            g.dwell_since = None;
+        }
+    }
+}
+
+/// When the frontmost VC platform changes (or clears), drop session_notified
+/// for platforms that are no longer front. Keep `cooldown_until` so leaving
+/// and re-focusing Zoom within the cooldown does not spam another popup.
+fn clear_session_if_left(app: &AppHandle, current: Option<&str>) {
+    if let Some(state) = app.try_state::<AdhocMeetingsWatcherState>() {
+        if let Ok(mut g) = state.inner.lock() {
+            g.session_notified
+                .retain(|platform, _| current == Some(platform.as_str()));
+        }
+    }
+}
+
+async fn create_adhoc_meeting(
+    app: &AppHandle,
+    client: &reqwest::Client,
+    platform: &str,
+) -> Result<String, String> {
+    let session = app
+        .try_state::<MeetingsWatcherState>()
+        .map(|s| s.session_snapshot())
+        .unwrap_or_default();
+    let Some(server_url) = session.server_url else {
+        return Err("no server_url for create-meeting".to_string());
+    };
+
+    let url = format!("{}/_agent-native/actions/create-meeting", server_url);
+    let row_title = if platform == "zoom" {
+        "Zoom meeting"
+    } else {
+        "Teams meeting"
+    };
+    let body = serde_json::json!({
+        "title": row_title,
+        "platform": platform,
+        "source": "adhoc",
+        "scheduledStart": chrono::Utc::now().to_rfc3339(),
+    });
+
+    let mut req = client
+        .post(&url)
+        .header("Content-Type", "application/json")
+        .header("X-Request-Source", "clips-desktop")
+        .json(&body);
+    if let Some(c) = session.session_cookie.as_deref() {
+        req = req.header("Cookie", c);
+    }
+    if let Some(token) = session.auth_token.as_deref() {
+        req = req.bearer_auth(token);
+    }
+
+    let resp = req
+        .send()
+        .await
+        .map_err(|e| format!("create-meeting fetch: {e}"))?;
+    let status = resp.status();
+    if status == reqwest::StatusCode::UNAUTHORIZED {
+        let _ = app.emit("meetings:auth-needed", serde_json::json!({}));
+        return Err("create-meeting http 401".to_string());
+    }
+    if !status.is_success() {
+        let text = resp.text().await.unwrap_or_default();
+        return Err(format!(
+            "create-meeting http {} — {}",
+            status,
+            text.chars().take(180).collect::<String>()
+        ));
+    }
+    let body: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
+    extract_meeting_id(&body).ok_or_else(|| {
+        format!(
+            "create-meeting response missing meeting id: {}",
+            body.to_string().chars().take(200).collect::<String>()
+        )
+    })
+}
+
+fn extract_meeting_id(body: &serde_json::Value) -> Option<String> {
+    // Framework wraps action returns as `{ result: { meeting, created } }`.
+    let meeting = body
+        .get("result")
+        .and_then(|r| r.get("meeting"))
+        .or_else(|| body.get("meeting"))
+        .or_else(|| body.get("result"));
+    meeting
+        .and_then(|m| m.get("id"))
+        .and_then(|id| id.as_str())
+        .map(|s| s.to_string())
+}