diff --git a/src/agent/CLAUDE.md b/src/agent/CLAUDE.md index e55c9591..686753de 100644 --- a/src/agent/CLAUDE.md +++ b/src/agent/CLAUDE.md @@ -113,7 +113,7 @@ Check-insert is done under a single write lock to prevent TOCTOU races. A cleanu 4. Detects broken tools via `store.get_broken_tools(5)` (threshold: 5 failures). Requires `with_store()` to be called; returns empty without a store. 5. Attempts to rebuild broken tools via `SoftwareBuilder`. Requires `with_builder()` to be called; returns `ManualRequired` without a builder. -Note: the `stuck_threshold` duration is stored but currently unused (marked `#[allow(dead_code)]`). Stuck detection relies on `JobState::Stuck` being set by the state machine, not wall-clock time comparison. +The `stuck_threshold` duration is used for time-based detection of `InProgress` jobs that have been running longer than the threshold. When `detect_stuck_jobs()` finds such jobs, it transitions them to `Stuck` before returning them, enabling the normal `attempt_recovery()` path. Repair results: `Success`, `Retry`, `Failed`, `ManualRequired`. `Retry` does NOT notify the user (to avoid spam). diff --git a/src/agent/agent_loop.rs b/src/agent/agent_loop.rs index c31145d5..dbc9d38b 100644 --- a/src/agent/agent_loop.rs +++ b/src/agent/agent_loop.rs @@ -120,6 +120,17 @@ async fn resolve_routine_notification_target( .await } +pub(crate) fn chat_tool_execution_metadata(message: &IncomingMessage) -> serde_json::Value { + serde_json::json!({ + "notify_channel": message.channel, + "notify_user": message + .routing_target() + .unwrap_or_else(|| message.user_id.clone()), + "notify_thread_id": message.thread_id, + "notify_metadata": message.metadata, + }) +} + fn should_fallback_routine_notification(error: &ChannelError) -> bool { !matches!(error, ChannelError::MissingRoutingTarget { .. }) } @@ -1177,9 +1188,10 @@ impl Agent { #[cfg(test)] mod tests { use super::{ - resolve_routine_notification_user, should_fallback_routine_notification, - truncate_for_preview, + chat_tool_execution_metadata, resolve_routine_notification_user, + should_fallback_routine_notification, truncate_for_preview, }; + use crate::channels::IncomingMessage; use crate::error::ChannelError; #[test] @@ -1275,6 +1287,50 @@ mod tests { assert_eq!(resolve_routine_notification_user(&metadata), None); // safety: test-only assertion } + #[test] + fn chat_tool_execution_metadata_prefers_message_routing_target() { + let message = IncomingMessage::new("telegram", "owner-scope", "hello") + .with_sender_id("telegram-user") + .with_thread("thread-7") + .with_metadata(serde_json::json!({ + "chat_id": 424242, + "chat_type": "private", + })); + + let metadata = chat_tool_execution_metadata(&message); + assert_eq!( + metadata.get("notify_channel").and_then(|v| v.as_str()), + Some("telegram") + ); // safety: test-only assertion + assert_eq!( + metadata.get("notify_user").and_then(|v| v.as_str()), + Some("424242") + ); // safety: test-only assertion + assert_eq!( + metadata.get("notify_thread_id").and_then(|v| v.as_str()), + Some("thread-7") + ); // safety: test-only assertion + } + + #[test] + fn chat_tool_execution_metadata_falls_back_to_user_scope_without_route() { + let message = IncomingMessage::new("gateway", "owner-scope", "hello").with_sender_id(""); + + let metadata = chat_tool_execution_metadata(&message); + assert_eq!( + metadata.get("notify_channel").and_then(|v| v.as_str()), + Some("gateway") + ); // safety: test-only assertion + assert_eq!( + metadata.get("notify_user").and_then(|v| v.as_str()), + Some("owner-scope") + ); // safety: test-only assertion + assert_eq!( + metadata.get("notify_thread_id"), + Some(&serde_json::Value::Null) + ); // safety: test-only assertion + } + #[test] fn targeted_routine_notifications_do_not_fallback_without_owner_route() { let error = ChannelError::MissingRoutingTarget { diff --git a/src/agent/dispatcher.rs b/src/agent/dispatcher.rs index 0b47c928..fc3da61b 100644 --- a/src/agent/dispatcher.rs +++ b/src/agent/dispatcher.rs @@ -144,12 +144,7 @@ impl Agent { .with_requester_id(&message.sender_id); job_ctx.http_interceptor = self.deps.http_interceptor.clone(); job_ctx.user_timezone = user_tz.name().to_string(); - job_ctx.metadata = serde_json::json!({ - "notify_channel": message.channel, - "notify_user": message.user_id, - "notify_thread_id": message.thread_id, - "notify_metadata": message.metadata, - }); + job_ctx.metadata = crate::agent::agent_loop::chat_tool_execution_metadata(message); // Build system prompts once for this turn. Two variants: with tools // (normal iterations) and without (force_text final iteration). diff --git a/src/agent/job_monitor.rs b/src/agent/job_monitor.rs index 6497861a..675d0426 100644 --- a/src/agent/job_monitor.rs +++ b/src/agent/job_monitor.rs @@ -14,12 +14,15 @@ //! Agent Loop //! ``` +use std::sync::Arc; + use tokio::sync::{broadcast, mpsc}; use tokio::task::JoinHandle; use uuid::Uuid; use crate::channels::IncomingMessage; use crate::channels::web::types::SseEvent; +use crate::context::{ContextManager, JobState}; /// Route context for forwarding job monitor events back to the user's channel. #[derive(Debug, Clone)] @@ -40,10 +43,23 @@ pub struct JobMonitorRoute { /// Tool use/result and status events are intentionally skipped (too noisy for /// the main agent's context window). pub fn spawn_job_monitor( + job_id: Uuid, + event_rx: broadcast::Receiver<(Uuid, SseEvent)>, + inject_tx: mpsc::Sender, + route: JobMonitorRoute, +) -> JoinHandle<()> { + spawn_job_monitor_with_context(job_id, event_rx, inject_tx, route, None) +} + +/// Like `spawn_job_monitor`, but also transitions the job's in-memory state +/// when it receives a `JobResult` event. This ensures fire-and-forget sandbox +/// jobs don't stay `InProgress` forever in the `ContextManager`. +pub fn spawn_job_monitor_with_context( job_id: Uuid, mut event_rx: broadcast::Receiver<(Uuid, SseEvent)>, inject_tx: mpsc::Sender, route: JobMonitorRoute, + context_manager: Option>, ) -> JoinHandle<()> { let short_id = job_id.to_string()[..8].to_string(); @@ -77,6 +93,26 @@ pub fn spawn_job_monitor( } } SseEvent::JobResult { status, .. } => { + // Transition in-memory state so the job frees its + // max_jobs slot and query tools show the final state. + if let Some(ref cm) = context_manager { + let target = if status == "completed" { + JobState::Completed + } else { + JobState::Failed + }; + let reason = if status != "completed" { + Some(format!("Container finished: {}", status)) + } else { + None + }; + let _ = cm + .update_context(job_id, |ctx| { + let _ = ctx.transition_to(target, reason); + }) + .await; + } + let mut msg = IncomingMessage::new( route.channel.clone(), route.user_id.clone(), @@ -121,6 +157,62 @@ pub fn spawn_job_monitor( }) } +/// Lightweight watcher that only transitions ContextManager state on job +/// completion. Used when monitor routing metadata is absent (no channel to +/// inject messages into) but we still need to free the `max_jobs` slot. +pub fn spawn_completion_watcher( + job_id: Uuid, + mut event_rx: broadcast::Receiver<(Uuid, SseEvent)>, + context_manager: Arc, +) -> JoinHandle<()> { + let short_id = job_id.to_string()[..8].to_string(); + + tokio::spawn(async move { + loop { + match event_rx.recv().await { + Ok((ev_job_id, SseEvent::JobResult { status, .. })) if ev_job_id == job_id => { + let target = if status == "completed" { + JobState::Completed + } else { + JobState::Failed + }; + let reason = if status != "completed" { + Some(format!("Container finished: {}", status)) + } else { + None + }; + let _ = context_manager + .update_context(job_id, |ctx| { + let _ = ctx.transition_to(target, reason); + }) + .await; + tracing::debug!( + job_id = %short_id, + status = %status, + "Completion watcher exiting (job finished)" + ); + break; + } + Ok(_) => {} + Err(broadcast::error::RecvError::Lagged(n)) => { + tracing::warn!( + job_id = %short_id, + skipped = n, + "Completion watcher lagged" + ); + } + Err(broadcast::error::RecvError::Closed) => { + tracing::debug!( + job_id = %short_id, + "Broadcast channel closed, stopping completion watcher" + ); + break; + } + } + } + }) +} + #[cfg(test)] mod tests { use super::*; @@ -294,4 +386,139 @@ mod tests { let msg = IncomingMessage::new("monitor", "system", "test").into_internal(); assert!(msg.is_internal); } + + // === Regression: fire-and-forget sandbox jobs must transition out of InProgress === + // Before this fix, spawn_job_monitor only forwarded SSE messages but never + // updated ContextManager. Background sandbox jobs stayed InProgress forever, + // permanently consuming a max_jobs slot. + + #[tokio::test] + async fn test_monitor_transitions_context_on_completion() { + use crate::context::{ContextManager, JobState}; + + let cm = Arc::new(ContextManager::new(5)); + let job_id = Uuid::new_v4(); + cm.register_sandbox_job(job_id, "user-1", "Build app", "desc") + .await + .unwrap(); + + let (event_tx, _) = broadcast::channel::<(Uuid, SseEvent)>(16); + let (inject_tx, mut inject_rx) = mpsc::channel::(16); + + let handle = spawn_job_monitor_with_context( + job_id, + event_tx.subscribe(), + inject_tx, + test_route(), + Some(Arc::clone(&cm)), + ); + + // Send completion event + event_tx + .send(( + job_id, + SseEvent::JobResult { + job_id: job_id.to_string(), + status: "completed".to_string(), + session_id: None, + fallback_deliverable: None, + }, + )) + .unwrap(); + + // Drain the injected message + let _ = tokio::time::timeout(std::time::Duration::from_secs(1), inject_rx.recv()).await; + + // Wait for monitor to exit + tokio::time::timeout(std::time::Duration::from_secs(1), handle) + .await + .expect("monitor should exit") + .expect("monitor should not panic"); + + // Job should now be Completed, not InProgress + let ctx = cm.get_context(job_id).await.unwrap(); + assert_eq!(ctx.state, JobState::Completed); + } + + #[tokio::test] + async fn test_monitor_transitions_context_on_failure() { + use crate::context::{ContextManager, JobState}; + + let cm = Arc::new(ContextManager::new(5)); + let job_id = Uuid::new_v4(); + cm.register_sandbox_job(job_id, "user-1", "Build app", "desc") + .await + .unwrap(); + + let (event_tx, _) = broadcast::channel::<(Uuid, SseEvent)>(16); + let (inject_tx, mut inject_rx) = mpsc::channel::(16); + + let handle = spawn_job_monitor_with_context( + job_id, + event_tx.subscribe(), + inject_tx, + test_route(), + Some(Arc::clone(&cm)), + ); + + // Send failure event + event_tx + .send(( + job_id, + SseEvent::JobResult { + job_id: job_id.to_string(), + status: "failed".to_string(), + session_id: None, + fallback_deliverable: None, + }, + )) + .unwrap(); + + let _ = tokio::time::timeout(std::time::Duration::from_secs(1), inject_rx.recv()).await; + tokio::time::timeout(std::time::Duration::from_secs(1), handle) + .await + .expect("monitor should exit") + .expect("monitor should not panic"); + + let ctx = cm.get_context(job_id).await.unwrap(); + assert_eq!(ctx.state, JobState::Failed); + } + + // === Regression: completion watcher (no route metadata) === + // When monitor_route_from_ctx() returns None, spawn_completion_watcher + // must still transition the job so the max_jobs slot is freed. + + #[tokio::test] + async fn test_completion_watcher_transitions_on_result() { + use crate::context::{ContextManager, JobState}; + + let cm = Arc::new(ContextManager::new(5)); + let job_id = Uuid::new_v4(); + cm.register_sandbox_job(job_id, "user-1", "Build app", "desc") + .await + .unwrap(); + + let (event_tx, _) = broadcast::channel::<(Uuid, SseEvent)>(16); + let handle = spawn_completion_watcher(job_id, event_tx.subscribe(), Arc::clone(&cm)); + + event_tx + .send(( + job_id, + SseEvent::JobResult { + job_id: job_id.to_string(), + status: "completed".to_string(), + session_id: None, + fallback_deliverable: None, + }, + )) + .unwrap(); + + tokio::time::timeout(std::time::Duration::from_secs(1), handle) + .await + .expect("watcher should exit") + .expect("watcher should not panic"); + + let ctx = cm.get_context(job_id).await.unwrap(); + assert_eq!(ctx.state, JobState::Completed); + } } diff --git a/src/agent/self_repair.rs b/src/agent/self_repair.rs index db491194..4e58cb15 100644 --- a/src/agent/self_repair.rs +++ b/src/agent/self_repair.rs @@ -66,6 +66,7 @@ pub trait SelfRepair: Send + Sync { /// Default self-repair implementation. pub struct DefaultSelfRepair { context_manager: Arc, + /// Jobs in `InProgress` longer than this are treated as stuck. stuck_threshold: Duration, max_repair_attempts: u32, store: Option>, @@ -111,15 +112,58 @@ impl DefaultSelfRepair { #[async_trait] impl SelfRepair for DefaultSelfRepair { async fn detect_stuck_jobs(&self) -> Vec { - let stuck_ids = self.context_manager.find_stuck_jobs().await; + let stuck_ids = self + .context_manager + .find_stuck_jobs_with_threshold(Some(self.stuck_threshold)) + .await; let mut stuck_jobs = Vec::new(); for job_id in stuck_ids { if let Ok(ctx) = self.context_manager.get_context(job_id).await - && ctx.state == JobState::Stuck + && matches!(ctx.state, JobState::Stuck | JobState::InProgress) { - // Measure stuck_duration from the most recent Stuck transition, - // not from started_at (which reflects when the job first ran). + // InProgress jobs detected by threshold need to be transitioned + // to Stuck before they can be repaired (attempt_recovery requires + // Stuck state). These jobs already passed the threshold check in + // find_stuck_jobs_with_threshold, so skip the duration filter below. + let just_transitioned = ctx.state == JobState::InProgress; + if just_transitioned { + let reason = "exceeded stuck_threshold"; + let transition = self + .context_manager + .update_context(job_id, |ctx| ctx.mark_stuck(reason)) + .await; + match transition { + Ok(Ok(())) => {} + Ok(Err(e)) => { + tracing::warn!( + job = %job_id, + "Failed to mark InProgress job as Stuck: {}", + e + ); + continue; + } + Err(e) => { + tracing::warn!( + job = %job_id, + "Failed to transition InProgress job to Stuck: {}", + e + ); + continue; + } + } + } + + // Re-fetch context after potential InProgress->Stuck transition + // so that stuck_since picks up the new transition timestamp. + let ctx = match self.context_manager.get_context(job_id).await { + Ok(c) => c, + Err(_) => continue, + }; + + // Use the timestamp of the most recent Stuck transition, not started_at. + // A job that ran for hours before becoming stuck should not immediately + // exceed the threshold — we measure from when it actually became stuck. let stuck_since = ctx .transitions .iter() @@ -134,8 +178,10 @@ impl SelfRepair for DefaultSelfRepair { }) .unwrap_or_default(); - // Only report jobs that have been stuck long enough - if stuck_duration < self.stuck_threshold { + // Only report already-Stuck jobs that have been stuck long enough. + // Jobs just transitioned from InProgress skip this check — they + // were already vetted by find_stuck_jobs_with_threshold. + if !just_transitioned && stuck_duration < self.stuck_threshold { continue; } @@ -163,10 +209,17 @@ impl SelfRepair for DefaultSelfRepair { }); } - // Try to recover the job + // Try to recover the job. + // If the job is still InProgress (detected via stuck_threshold), transition + // it to Stuck first so that attempt_recovery() can move it back to InProgress. let result = self .context_manager - .update_context(job.job_id, |ctx| ctx.attempt_recovery()) + .update_context(job.job_id, |ctx| { + if ctx.state == JobState::InProgress { + ctx.transition_to(JobState::Stuck, Some("exceeded stuck_threshold".into()))?; + } + ctx.attempt_recovery() + }) .await; match result { @@ -489,6 +542,82 @@ mod tests { ); } + #[tokio::test] + async fn detect_and_repair_in_progress_job_via_threshold() { + let cm = Arc::new(ContextManager::new(10)); + let job_id = cm.create_job("Long running", "desc").await.unwrap(); + + // Transition to InProgress. + cm.update_context(job_id, |ctx| ctx.transition_to(JobState::InProgress, None)) + .await + .unwrap() + .unwrap(); + + // Backdate started_at to simulate a job running for 10 minutes. + cm.update_context(job_id, |ctx| { + ctx.started_at = Some(Utc::now() - chrono::Duration::seconds(600)); + }) + .await + .unwrap(); + + // Use a 5-minute threshold so the 10-minute job is detected. + let repair = DefaultSelfRepair::new(Arc::clone(&cm), Duration::from_secs(300), 3); + + // detect_stuck_jobs should find it and transition InProgress -> Stuck. + let stuck = repair.detect_stuck_jobs().await; + assert_eq!(stuck.len(), 1); + assert_eq!(stuck[0].job_id, job_id); + + // After detection the job should now be in Stuck state. + let ctx = cm.get_context(job_id).await.unwrap(); + assert_eq!(ctx.state, JobState::Stuck); + + // Repair should recover it: Stuck -> InProgress. + let result = repair.repair_stuck_job(&stuck[0]).await.unwrap(); + assert!( + matches!(result, RepairResult::Success { .. }), + "Expected Success, got: {:?}", + result + ); + + // Job should be back to InProgress after recovery. + let ctx = cm.get_context(job_id).await.unwrap(); + assert_eq!(ctx.state, JobState::InProgress); + } + + #[tokio::test] + async fn detect_broken_tools_returns_empty_without_store() { + let cm = Arc::new(ContextManager::new(10)); + let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3); + + // No store configured, should return empty. + let broken = repair.detect_broken_tools().await; + assert!(broken.is_empty()); + } + + #[tokio::test] + async fn repair_broken_tool_returns_manual_without_builder() { + let cm = Arc::new(ContextManager::new(10)); + let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3); + + let broken = BrokenTool { + name: "test-tool".to_string(), + failure_count: 10, + last_error: Some("crash".to_string()), + first_failure: Utc::now(), + last_failure: Utc::now(), + last_build_result: None, + repair_attempts: 0, + }; + + let result = repair.repair_broken_tool(&broken).await.unwrap(); + assert!( + matches!(result, RepairResult::ManualRequired { .. }), + "Expected ManualRequired without builder, got: {:?}", + result + ); + } + #[tokio::test] async fn detect_stuck_jobs_filters_by_threshold() { let cm = Arc::new(ContextManager::new(10)); @@ -581,39 +710,6 @@ mod tests { ); } - #[tokio::test] - async fn detect_broken_tools_returns_empty_without_store() { - let cm = Arc::new(ContextManager::new(10)); - let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3); - - // No store configured, should return empty. - let broken = repair.detect_broken_tools().await; - assert!(broken.is_empty()); - } - - #[tokio::test] - async fn repair_broken_tool_returns_manual_without_builder() { - let cm = Arc::new(ContextManager::new(10)); - let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3); - - let broken = BrokenTool { - name: "test-tool".to_string(), - failure_count: 10, - last_error: Some("crash".to_string()), - first_failure: Utc::now(), - last_failure: Utc::now(), - last_build_result: None, - repair_attempts: 0, - }; - - let result = repair.repair_broken_tool(&broken).await.unwrap(); - assert!( - matches!(result, RepairResult::ManualRequired { .. }), - "Expected ManualRequired without builder, got: {:?}", - result - ); - } - /// Mock SoftwareBuilder that returns a successful build result. struct MockBuilder { build_count: std::sync::atomic::AtomicU32, diff --git a/src/agent/thread_ops.rs b/src/agent/thread_ops.rs index e8b8d09a..0fb968f1 100644 --- a/src/agent/thread_ops.rs +++ b/src/agent/thread_ops.rs @@ -939,6 +939,7 @@ impl Agent { JobContext::with_user(&message.user_id, "chat", "Interactive chat session") .with_requester_id(&message.sender_id); job_ctx.http_interceptor = self.deps.http_interceptor.clone(); + job_ctx.metadata = crate::agent::agent_loop::chat_tool_execution_metadata(message); // Prefer a valid timezone from the approval message, fall back to the // resolved timezone stored when the approval was originally requested. let tz_candidate = message diff --git a/src/app.rs b/src/app.rs index f9e43458..729d2269 100644 --- a/src/app.rs +++ b/src/app.rs @@ -694,7 +694,10 @@ impl AppBuilder { // Post-init validation: if a non-nearai backend was selected but // credentials were never resolved (deferred resolution found no keys), // fail early with a clear error instead of a confusing runtime failure. - if self.config.llm.backend != "nearai" && self.config.llm.provider.is_none() { + if self.config.llm.backend != "nearai" + && self.config.llm.backend != "bedrock" + && self.config.llm.provider.is_none() + { let backend = &self.config.llm.backend; anyhow::bail!( "LLM_BACKEND={backend} is configured but no credentials were found. \ diff --git a/src/channels/wasm/wrapper.rs b/src/channels/wasm/wrapper.rs index 8f0c9db4..be7768d0 100644 --- a/src/channels/wasm/wrapper.rs +++ b/src/channels/wasm/wrapper.rs @@ -3314,6 +3314,7 @@ mod tests { use std::sync::Arc; use crate::channels::Channel; + use crate::channels::OutgoingResponse; use crate::channels::wasm::capabilities::ChannelCapabilities; use crate::channels::wasm::runtime::{ PreparedChannelModule, WasmChannelRuntime, WasmChannelRuntimeConfig, @@ -3401,6 +3402,16 @@ mod tests { assert!(channel.health_check().await.is_err()); } + #[tokio::test] + async fn test_broadcast_delegates_to_call_on_broadcast() { + let channel = create_test_channel(); + // With `component: None`, call_on_broadcast short-circuits to Ok(()). + let result = channel + .broadcast("146032821", OutgoingResponse::text("hello")) + .await; + assert!(result.is_ok()); + } + #[tokio::test] async fn test_execute_poll_no_wasm_returns_empty() { // When there's no WASM module (None component), execute_poll diff --git a/src/channels/web/server.rs b/src/channels/web/server.rs index 887a107d..964452a4 100644 --- a/src/channels/web/server.rs +++ b/src/channels/web/server.rs @@ -354,6 +354,7 @@ pub async fn start_server( .route("/", get(index_handler)) .route("/style.css", get(css_handler)) .route("/app.js", get(js_handler)) + .route("/theme-init.js", get(theme_init_handler)) .route("/favicon.ico", get(favicon_handler)) .route("/i18n/index.js", get(i18n_index_handler)) .route("/i18n/en.js", get(i18n_en_handler)) @@ -475,6 +476,16 @@ async fn js_handler() -> impl IntoResponse { ) } +async fn theme_init_handler() -> impl IntoResponse { + ( + [ + (header::CONTENT_TYPE, "application/javascript"), + (header::CACHE_CONTROL, "no-cache"), + ], + include_str!("static/theme-init.js"), + ) +} + async fn favicon_handler() -> impl IntoResponse { ( [ diff --git a/src/channels/web/static/app.js b/src/channels/web/static/app.js index c8c4e71d..dea704ba 100644 --- a/src/channels/web/static/app.js +++ b/src/channels/web/static/app.js @@ -1,5 +1,69 @@ // IronClaw Web Gateway - Client +// --- Theme Management (dark / light / system) --- +// Icon switching is handled by pure CSS via data-theme-mode on . + +function getSystemTheme() { + return window.matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark'; +} + +const VALID_THEME_MODES = { dark: true, light: true, system: true }; + +function getThemeMode() { + const stored = localStorage.getItem('ironclaw-theme'); + return (stored && VALID_THEME_MODES[stored]) ? stored : 'system'; +} + +function resolveTheme(mode) { + return mode === 'system' ? getSystemTheme() : mode; +} + +function applyTheme(mode) { + const resolved = resolveTheme(mode); + document.documentElement.setAttribute('data-theme', resolved); + document.documentElement.setAttribute('data-theme-mode', mode); + const titleKeys = { dark: 'theme.tooltipDark', light: 'theme.tooltipLight', system: 'theme.tooltipSystem' }; + const btn = document.getElementById('theme-toggle'); + if (btn) btn.title = (typeof I18n !== 'undefined' && titleKeys[mode]) ? I18n.t(titleKeys[mode]) : ('Theme: ' + mode); + const announce = document.getElementById('theme-announce'); + if (announce) announce.textContent = (typeof I18n !== 'undefined') ? I18n.t('theme.announce', { mode: mode }) : ('Theme: ' + mode); +} + +function toggleTheme() { + const cycle = { dark: 'light', light: 'system', system: 'dark' }; + const current = getThemeMode(); + const next = cycle[current] || 'dark'; + localStorage.setItem('ironclaw-theme', next); + applyTheme(next); +} + +// Apply theme immediately (FOUC prevention is done via inline script in , +// but we call again here to ensure tooltip is set after DOM is ready). +applyTheme(getThemeMode()); + +// Delay enabling theme transition to avoid flash on initial load. +requestAnimationFrame(function() { + requestAnimationFrame(function() { + document.body.classList.add('theme-transition'); + }); +}); + +// Listen for OS theme changes — only re-apply when in 'system' mode. +const mql = window.matchMedia('(prefers-color-scheme: light)'); +const onSchemeChange = function() { + if (getThemeMode() === 'system') { + applyTheme('system'); + } +}; +if (mql.addEventListener) { + mql.addEventListener('change', onSchemeChange); +} else if (mql.addListener) { + mql.addListener(onSchemeChange); +} + +// Bind theme toggle button (CSP-compliant — no inline onclick). +document.getElementById('theme-toggle').addEventListener('click', toggleTheme); + let token = ''; let eventSource = null; let logEventSource = null; diff --git a/src/channels/web/static/i18n/en.js b/src/channels/web/static/i18n/en.js index 9ba2cc65..5c559ab9 100644 --- a/src/channels/web/static/i18n/en.js +++ b/src/channels/web/static/i18n/en.js @@ -24,6 +24,12 @@ I18n.register('en', { 'restart.progressSubtitle': 'Please wait for the process to restart...', 'restart.checkLogs': 'Check the Logs tab for details after restart completes.', + // Theme + 'theme.tooltipDark': 'Theme: Dark (click for Light)', + 'theme.tooltipLight': 'Theme: Light (click for System)', + 'theme.tooltipSystem': 'Theme: System (click for Dark)', + 'theme.announce': 'Theme: {mode}', + // Tabs 'tab.chat': 'Chat', 'tab.memory': 'Memory', diff --git a/src/channels/web/static/i18n/zh-CN.js b/src/channels/web/static/i18n/zh-CN.js index 305c5cd1..98c728cf 100644 --- a/src/channels/web/static/i18n/zh-CN.js +++ b/src/channels/web/static/i18n/zh-CN.js @@ -24,6 +24,12 @@ I18n.register('zh-CN', { 'restart.progressSubtitle': '请等待进程重启...', 'restart.checkLogs': '重启完成后，请查看日志标签页了解详情。', + // 主题 + 'theme.tooltipDark': '主题：深色（点击切换浅色）', + 'theme.tooltipLight': '主题：浅色（点击切换跟随系统）', + 'theme.tooltipSystem': '主题：跟随系统（点击切换深色）', + 'theme.announce': '主题：{mode}', + // 标签页 'tab.chat': '聊天', 'tab.memory': '记忆', diff --git a/src/channels/web/static/index.html b/src/channels/web/static/index.html index 2a74dcc3..8632a270 100644 --- a/src/channels/web/static/index.html +++ b/src/channels/web/static/index.html @@ -25,6 +25,7 @@ integrity="sha384-pN9zSKOnTZwXRtYZAu0PBPEgR2B7DOC1aeLxQ33oJ0oy5iN1we6gm57xldM2irDG" crossorigin="anonymous" > + @@ -163,6 +164,18 @@ + +