chore: release v0.30.1

- Fix dev-mode "[TAURI] Couldn't find callback id" warning by deferring
  get_network_info to next macrotask + adding disk persistence for
  NETWORK_INFO_CACHE.
- Don't record /annual-report-2025 as lastPath resume target.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: MarkShawn2020

CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.30.1
+
+### Patch Changes
+
+- 修复 dev 模式下偶发的 `[TAURI] Couldn't find callback id` 警告：
+
+  - StatusBar 的 `get_network_info` 调用从挂载即触发改为下一个宏任务，HMR full-reload 期间几乎不会再撞上 5 秒 in-flight invoke。
+  - `NETWORK_INFO_CACHE` 增加磁盘持久化（`~/.lovstudio/lovcode/cache/network.json`），dev 重启 Rust 进程不再丢缓存。
+
+  附带修复：annual-report-2025 路由不再被记录为 lastPath 恢复目标。
+
 ## 0.30.0
 
 ### Minor Changes

package.json

@@ -1,7 +1,7 @@
 {
   "name": "lovcode",
   "private": true,
-  "version": "0.30.0",
+  "version": "0.30.1",
   "type": "module",
   "packageManager": "pnpm@10.18.1",
   "scripts": {

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "lovcode"
-version = "0.30.0"
+version = "0.30.1"
 description = "A Tauri App"
 authors = ["you"]
 edition = "2021"

src-tauri/Cargo.toml

@@ -9900,6 +9900,129 @@ fn is_local_fresh_for_remote(path: &std::path::Path, remote_updated_at: &str) ->
     local_secs >= remote_dt.timestamp()
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+struct NetworkInfo {
+    region: String,
+    ip: String,
+    is_proxy: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    proxy_type: Option<String>,
+}
+
+static NETWORK_INFO_CACHE: LazyLock<Mutex<Option<(std::time::SystemTime, NetworkInfo)>>> =
+    LazyLock::new(|| Mutex::new(None));
+
+const NETWORK_INFO_TTL: Duration = Duration::from_secs(3600);
+
+fn network_info_cache_path() -> PathBuf {
+    dirs::home_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join(".lovstudio/lovcode/cache/network.json")
+}
+
+#[derive(Serialize, Deserialize)]
+struct NetworkInfoCacheFile {
+    fetched_at_unix: u64,
+    info: NetworkInfo,
+}
+
+fn read_network_info_cache_file() -> Option<(std::time::SystemTime, NetworkInfo)> {
+    let raw = std::fs::read(network_info_cache_path()).ok()?;
+    let parsed: NetworkInfoCacheFile = serde_json::from_slice(&raw).ok()?;
+    let fetched_at = std::time::UNIX_EPOCH + Duration::from_secs(parsed.fetched_at_unix);
+    Some((fetched_at, parsed.info))
+}
+
+fn write_network_info_cache_file(fetched_at: std::time::SystemTime, info: &NetworkInfo) {
+    let path = network_info_cache_path();
+    if let Some(parent) = path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    let unix = fetched_at
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0);
+    let payload = NetworkInfoCacheFile { fetched_at_unix: unix, info: info.clone() };
+    if let Ok(bytes) = serde_json::to_vec(&payload) {
+        let _ = std::fs::write(&path, bytes);
+    }
+}
+
+#[tauri::command]
+async fn get_network_info() -> Result<NetworkInfo, String> {
+    if let Ok(mut guard) = NETWORK_INFO_CACHE.lock() {
+        if guard.is_none() {
+            *guard = read_network_info_cache_file();
+        }
+        if let Some((fetched_at, info)) = guard.as_ref() {
+            if fetched_at.elapsed().map(|e| e < NETWORK_INFO_TTL).unwrap_or(false) {
+                return Ok(info.clone());
+            }
+        }
+    }
+
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(5))
+        .build()
+        .map_err(|e| format!("client build failed: {e}"))?;
+
+    let resp = client
+        .get("https://ipinfo.io/json")
+        .send()
+        .await
+        .map_err(|e| format!("request failed: {e}"))?;
+
+    if !resp.status().is_success() {
+        let status = resp.status();
+        if let Ok(guard) = NETWORK_INFO_CACHE.lock() {
+            if let Some((_, info)) = guard.as_ref() {
+                return Ok(info.clone());
+            }
+        }
+        return Err(format!("ipinfo returned {status}"));
+    }
+
+    let data: Value = resp
+        .json()
+        .await
+        .map_err(|e| format!("parse failed: {e}"))?;
+
+    let city = data.get("city").and_then(|v| v.as_str());
+    let country = data.get("country").and_then(|v| v.as_str());
+    let region = match (city, country) {
+        (Some(c), Some(co)) => format!("{c}, {co}"),
+        (None, Some(co)) => co.to_string(),
+        _ => "Unknown".to_string(),
+    };
+    let ip = data.get("ip").and_then(|v| v.as_str()).unwrap_or("").to_string();
+    let privacy = data.get("privacy");
+    let is_vpn = privacy.and_then(|p| p.get("vpn")).and_then(|v| v.as_bool()).unwrap_or(false);
+    let is_proxy_flag = privacy.and_then(|p| p.get("proxy")).and_then(|v| v.as_bool()).unwrap_or(false);
+    let proxy_type = if is_vpn {
+        Some("VPN".to_string())
+    } else if is_proxy_flag {
+        Some("Proxy".to_string())
+    } else {
+        None
+    };
+
+    let info = NetworkInfo {
+        region,
+        ip,
+        is_proxy: is_vpn || is_proxy_flag,
+        proxy_type,
+    };
+
+    let now = std::time::SystemTime::now();
+    if let Ok(mut guard) = NETWORK_INFO_CACHE.lock() {
+        *guard = Some((now, info.clone()));
+    }
+    write_network_info_cache_file(now, &info);
+
+    Ok(info)
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
@@ -10101,6 +10224,7 @@ pub fn run() {
             }
         })
         .invoke_handler(tauri::generate_handler![
+            get_network_info,
             make_window_nonactivating_panel,
             list_projects,
             list_sessions,

src-tauri/src/lib.rs

@@ -244,27 +244,23 @@ export function StatusBar({ onOpenSettings }: StatusBarProps) {
     };
   }, [settings, context]);
 
-  // Fetch network info (only for default mode)
+  // Fetch network info (only for default mode).
+  // Defer to next macrotask so an HMR full-reload arriving mid-startup
+  // doesn't leave a 5s in-flight invoke whose callback ID is gone after reload
+  // (source of "[TAURI] Couldn't find callback id ..." dev warning).
   useEffect(() => {
-    if (settings?.enabled) return; // Skip if script mode
+    if (settings?.enabled) return;
 
-    async function fetchNetworkInfo() {
-      try {
-        const res = await fetch("https://ipinfo.io/json");
-        if (res.ok) {
-          const data = await res.json();
-          setNetworkInfo({
-            region: data.city ? `${data.city}, ${data.country}` : data.country || "Unknown",
-            ip: data.ip || "",
-            isProxy: data.privacy?.proxy || data.privacy?.vpn || false,
-            proxyType: data.privacy?.vpn ? "VPN" : data.privacy?.proxy ? "Proxy" : undefined,
-          });
-        }
-      } catch {
-        // Silently fail
-      }
-    }
-    fetchNetworkInfo();
+    let cancelled = false;
+    const handle = window.setTimeout(() => {
+      invoke<NetworkInfo>("get_network_info")
+        .then((info) => { if (!cancelled) setNetworkInfo(info); })
+        .catch(() => {});
+    }, 0);
+    return () => {
+      cancelled = true;
+      window.clearTimeout(handle);
+    };
   }, [settings?.enabled]);
 
   const formatTime = useCallback((d: Date) => {

src/components/StatusBar.tsx

@@ -101,7 +101,8 @@ export default function RootLayout() {
 
   useEffect(() => {
     const path = location.pathname + location.search;
-    if (path && path !== "/") {
+    // Skip transient overlay routes — they shouldn't be the "resume" target
+    if (path && path !== "/" && location.pathname !== "/annual-report-2025") {
       try { localStorage.setItem("lovcode:lastPath", path); } catch {}
     }
   }, [location.pathname, location.search]);

src/pages/_layout.tsx

@@ -5,7 +5,7 @@ const LAST_PATH_KEY = "lovcode:lastPath";
 function getLastPath(): string {
   try {
     const saved = localStorage.getItem(LAST_PATH_KEY);
-    if (saved && saved !== "/" && saved.startsWith("/")) return saved;
+    if (saved && saved !== "/" && saved.startsWith("/") && saved !== "/annual-report-2025") return saved;
   } catch {}
   return "/workspace";
 }