Codex release 1 4 0 break flow (#5)

* feat: add idle-aware break skip challenge

* fix: add cross-target preflight checks

* fix: resolve windows clippy issues

* fix: block countdown reload menu

Author: iwangjie

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "restgap"
-version = "1.3.0"
+version = "1.4.1"
 edition = "2024"
 authors = ["iwangjie <345127857@qq.com>"]
 description = "息间（RestGap）— 跨平台休息提醒应用（macOS/Windows/Linux）"
@@ -84,7 +84,9 @@ windows = { version = "0.58", features = [
     "Win32_Foundation",
     "Win32_Globalization",
     "Win32_System_LibraryLoader",
+    "Win32_System_SystemInformation",
     "Win32_System_Threading",
+    "Win32_UI_Input_KeyboardAndMouse",
     "Win32_UI_WindowsAndMessaging",
     "Win32_UI_Shell",
     "Win32_Graphics_Gdi",

Cargo.toml

@@ -13,8 +13,38 @@ if ! command -v cargo >/dev/null 2>&1; then
   exit 1
 fi
 
+if ! command -v rustup >/dev/null 2>&1; then
+  echo "rustup is required but not found in PATH."
+  exit 1
+fi
+
+host_target="$(rustc -vV | awk '/host:/ {print $2}')"
+
+resolve_extra_targets() {
+  if [[ -n "${RESTGAP_EXTRA_TARGETS:-}" ]]; then
+    printf '%s\n' ${RESTGAP_EXTRA_TARGETS}
+    return
+  fi
+
+  rustup target list --installed | while read -r target; do
+    if [[ "${target}" != "${host_target}" ]]; then
+      printf '%s\n' "${target}"
+    fi
+  done
+}
+
 echo "Running release preflight..."
 cargo fmt --check
 cargo clippy --all-targets --all-features -- -D warnings
+
+while read -r target; do
+  if [[ -z "${target}" ]]; then
+    continue
+  fi
+  echo "Running cross-target checks for ${target}..."
+  cargo clippy --target "${target}" --all-targets --all-features -- -D warnings
+  cargo check --target "${target}" --all-targets
+done < <(resolve_extra_targets)
+
 cargo test
 cargo build --release

scripts/release-preflight.sh

@@ -338,6 +338,41 @@ impl Texts {
             Language::Zh => "放松眼睛，伸展身体",
         }
     }
+
+    pub const fn countdown_skip_title(&self) -> &'static str {
+        match self.lang {
+            Language::En => "Type this sentence to skip",
+            Language::Zh => "输入这句话才可跳过",
+        }
+    }
+
+    pub fn countdown_skip_progress(&self, matched: usize, total: usize) -> String {
+        match self.lang {
+            Language::En => format!("Matched {matched}/{total} · each character must be within 2s"),
+            Language::Zh => format!("已匹配 {matched}/{total} · 相邻字符间隔不能超过 2 秒"),
+        }
+    }
+
+    pub const fn countdown_skip_timeout(&self) -> &'static str {
+        match self.lang {
+            Language::En => "Timed out. Restart from the beginning.",
+            Language::Zh => "输入超时，请从头开始。",
+        }
+    }
+
+    pub const fn countdown_skip_mismatch(&self) -> &'static str {
+        match self.lang {
+            Language::En => "Mismatch. Restart from the beginning.",
+            Language::Zh => "输入不匹配，请从头开始。",
+        }
+    }
+
+    pub const fn countdown_skip_success(&self) -> &'static str {
+        match self.lang {
+            Language::En => "Matched. Skipping this break...",
+            Language::Zh => "匹配完成，正在跳过本次休息……",
+        }
+    }
 }
 
 pub fn detect_system_language() -> Language {

src/i18n.rs

@@ -0,0 +1,96 @@
+//! 低功耗闲置跳过判定。
+//!
+//! 仅在工作阶段结束时查询一次系统空闲时长，不做持续轮询。
+
+use std::time::Duration;
+
+const MAX_ALLOWED_ACTIVE_TIME: Duration = Duration::from_secs(8);
+
+pub fn should_skip_break(cycle_elapsed: Duration) -> bool {
+    let Some(idle_duration) = current_idle_duration() else {
+        return false;
+    };
+    should_skip_break_with_idle(cycle_elapsed, idle_duration)
+}
+
+fn should_skip_break_with_idle(cycle_elapsed: Duration, idle_duration: Duration) -> bool {
+    if cycle_elapsed <= MAX_ALLOWED_ACTIVE_TIME {
+        return false;
+    }
+
+    idle_duration + MAX_ALLOWED_ACTIVE_TIME >= cycle_elapsed
+}
+
+#[cfg(target_os = "macos")]
+#[allow(unsafe_code)]
+fn current_idle_duration() -> Option<Duration> {
+    use std::time::Duration;
+
+    type CGEventSourceStateID = u32;
+    type CGEventType = u32;
+
+    const K_CG_EVENT_SOURCE_STATE_COMBINED_SESSION_STATE: CGEventSourceStateID = 0;
+    const K_CG_ANY_INPUT_EVENT_TYPE: CGEventType = !0;
+
+    #[link(name = "ApplicationServices", kind = "framework")]
+    unsafe extern "C" {
+        fn CGEventSourceSecondsSinceLastEventType(
+            source: CGEventSourceStateID,
+            event_type: CGEventType,
+        ) -> f64;
+    }
+
+    let seconds = unsafe {
+        CGEventSourceSecondsSinceLastEventType(
+            K_CG_EVENT_SOURCE_STATE_COMBINED_SESSION_STATE,
+            K_CG_ANY_INPUT_EVENT_TYPE,
+        )
+    };
+
+    if !seconds.is_finite() || seconds.is_sign_negative() {
+        return None;
+    }
+
+    Some(Duration::from_secs_f64(seconds))
+}
+
+#[cfg(target_os = "windows")]
+#[allow(unsafe_code)]
+fn current_idle_duration() -> Option<Duration> {
+    use windows::Win32::System::SystemInformation::GetTickCount;
+    use windows::Win32::UI::Input::KeyboardAndMouse::{GetLastInputInfo, LASTINPUTINFO};
+
+    let mut last_input = LASTINPUTINFO {
+        cbSize: u32::try_from(std::mem::size_of::<LASTINPUTINFO>()).ok()?,
+        ..Default::default()
+    };
+
+    if !unsafe { GetLastInputInfo(&raw mut last_input) }.as_bool() {
+        return None;
+    }
+
+    let now = unsafe { GetTickCount() };
+    let idle_ms = now.wrapping_sub(last_input.dwTime);
+    Some(Duration::from_millis(u64::from(idle_ms)))
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+const fn current_idle_duration() -> Option<Duration> {
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn skips_only_when_idle_almost_covers_cycle() {
+        let cycle = Duration::from_secs(30 * 60);
+        let almost_all_idle = cycle.checked_sub(Duration::from_secs(5)).unwrap();
+        assert!(should_skip_break_with_idle(cycle, almost_all_idle));
+        assert!(!should_skip_break_with_idle(
+            cycle,
+            cycle.checked_sub(Duration::from_secs(20)).unwrap()
+        ));
+    }
+}

src/idle.rs

@@ -106,19 +106,29 @@ pub fn run() {
         } else {
             let remaining = state.time_until_break();
             if remaining == Duration::ZERO {
-                // Time for a break!
-                state.is_breaking = true;
-                state.break_start = Some(Instant::now());
-                let break_secs = state.config.break_seconds;
-                match lang {
-                    Language::Zh => println!("\n休息时间！请休息 {break_secs} 秒\n"),
-                    Language::En => {
-                        println!("\nBreak time! Please rest for {break_secs} seconds\n");
+                if crate::idle::should_skip_break(state.work_start.elapsed()) {
+                    state.work_start = Instant::now();
+                    match lang {
+                        Language::Zh => println!("\n本轮几乎无操作，已跳过本次休息。\n"),
+                        Language::En => {
+                            println!("\nThis cycle was nearly idle, so the break was skipped.\n");
+                        }
+                    }
+                } else {
+                    // Time for a break!
+                    state.is_breaking = true;
+                    state.break_start = Some(Instant::now());
+                    let break_secs = state.config.break_seconds;
+                    match lang {
+                        Language::Zh => println!("\n休息时间！请休息 {break_secs} 秒\n"),
+                        Language::En => {
+                            println!("\nBreak time! Please rest for {break_secs} seconds\n");
+                        }
                     }
-                }
 
-                // In a full implementation, this would show a fullscreen window
-                // For now, we just print to console
+                    // In a full implementation, this would show a fullscreen window
+                    // For now, we just print to console
+                }
             } else if remaining.as_secs() % 60 == 0 && remaining.as_secs() > 0 {
                 // Print update every minute
                 let minutes = remaining.as_secs() / 60;

src/linux/mod.rs

@@ -12,6 +12,7 @@ use objc2_foundation::NSTimer;
 use objc2_web_kit::WKWebView;
 
 use super::config::Config;
+use crate::skip_challenge::SkipChallenge;
 
 /// 工作阶段
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -32,6 +33,7 @@ pub enum NotifyEvent {
 pub struct AppState {
     pub config: Config,
     pub phase: Phase,
+    pub phase_started_at_mono: Option<Instant>,
     pub phase_deadline_mono: Option<Instant>,
     pub phase_deadline_wall: Option<SystemTime>,
     pub timer: Option<Retained<NSTimer>>,
@@ -51,10 +53,9 @@ pub struct AppState {
     pub countdown_webviews: Vec<Retained<WKWebView>>,
     pub countdown_timer: Option<Retained<NSTimer>>,
     pub countdown_end_time: Option<Instant>,
-    // Hidden skip phrase state (only used during breaks)
+    // 跳过挑战状态（仅在休息时使用）
     pub countdown_key_monitor: Option<Retained<AnyObject>>,
-    pub countdown_skip_smart_idx: usize,
-    pub countdown_skip_ascii_idx: usize,
+    pub countdown_skip_challenge: Option<SkipChallenge>,
     pub countdown_skip_requested: bool,
 }
 
@@ -63,6 +64,7 @@ impl AppState {
         Self {
             config,
             phase: Phase::Working,
+            phase_started_at_mono: None,
             phase_deadline_mono: None,
             phase_deadline_wall: None,
             timer: None,
@@ -82,8 +84,7 @@ impl AppState {
             countdown_timer: None,
             countdown_end_time: None,
             countdown_key_monitor: None,
-            countdown_skip_smart_idx: 0,
-            countdown_skip_ascii_idx: 0,
+            countdown_skip_challenge: None,
             countdown_skip_requested: false,
         }
     }

src/macos/state.rs

@@ -23,6 +23,7 @@ pub fn schedule_phase(delegate: &RestGapDelegate, phase: Phase) {
         }
 
         state.phase = phase;
+        let started_at = Instant::now();
         let (duration, tolerance) = match phase {
             Phase::Working => (state.config.work_interval(), state.config.work_tolerance()),
             Phase::Breaking => (
@@ -31,7 +32,8 @@ pub fn schedule_phase(delegate: &RestGapDelegate, phase: Phase) {
             ),
         };
 
-        state.phase_deadline_mono = Some(Instant::now() + duration);
+        state.phase_started_at_mono = Some(started_at);
+        state.phase_deadline_mono = Some(started_at + duration);
         state.phase_deadline_wall = Some(SystemTime::now() + duration);
 
         (duration.as_secs_f64(), tolerance.as_secs_f64())
@@ -74,16 +76,28 @@ fn notify(event: NotifyEvent, config: &Config, delegate: &RestGapDelegate) {
 
 /// 定时器触发时的阶段转换
 pub fn transition_on_timer(delegate: &RestGapDelegate) {
-    let (next_phase, event, config) = with_state(|state| {
+    let transition = with_state(|state| {
         state.timer.take();
         let config = state.config.clone();
         match state.phase {
-            Phase::Working => (Phase::Breaking, NotifyEvent::BreakStart, config),
-            Phase::Breaking => (Phase::Working, NotifyEvent::BreakEnd, config),
+            Phase::Working => {
+                let should_skip = state
+                    .phase_started_at_mono
+                    .is_some_and(|started_at| crate::idle::should_skip_break(started_at.elapsed()));
+                if should_skip {
+                    (Phase::Working, None, config)
+                } else {
+                    (Phase::Breaking, Some(NotifyEvent::BreakStart), config)
+                }
+            }
+            Phase::Breaking => (Phase::Working, Some(NotifyEvent::BreakEnd), config),
         }
     });
 
-    notify(event, &config, delegate);
+    let (next_phase, event, config) = transition;
+    if let Some(event) = event {
+        notify(event, &config, delegate);
+    }
     schedule_phase(delegate, next_phase);
 }