mod ai;
mod chat;
mod http;
mod schedule;
mod secrets;
mod tasks;
use std::collections::{BTreeMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{mpsc, Arc, Mutex};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Serialize};
use tauri::{
menu::{Menu, MenuItem},
path::BaseDirectory,
tray::TrayIconBuilder,
AppHandle, Emitter, Manager, State, WindowEvent,
};
use tauri_plugin_notification::{NotificationExt, PermissionState};
use tauri_plugin_store::StoreExt;
use crate::schedule::{parse_schedule, resolve_tz, Schedule};
use crate::secrets::SecretsService;
use crate::tasks::{
classify_due, expand_trigger, needs_expansion, reconcile, Disposition, ExpansionState, Task,
TaskOrigin, TaskStore, TriggerRuntimeState, TriggerSpecView,
};
const TICK_INTERVAL_PROD: Duration = Duration::from_secs(60);
const TICK_INTERVAL_DEV: Duration = Duration::from_secs(10);
const SCHEDULE_GRACE_TICKS: u32 = 2;
const STATE_STORE_FILE: &str = "triggers-state.json";
const TASKS_STORE_FILE: &str = "tasks.json";
const TASKS_KEY: &str = "tasks";
const EXPANSION_KEY: &str = "expansion";
const META_NAMESPACE: &str = "__meta__";
const LEGACY_META_FIRE_TIMES_KEY: &str = "fire_times";
fn dev_mode_enabled() -> bool {
matches!(std::env::var("CHAMBERLAIN_DEV").ok().as_deref(), Some("1"))
}
#[derive(Clone, Serialize)]
struct ActivityEvent {
ts: u64,
source: String,
message: String,
}
#[derive(Deserialize)]
struct NotifyPayload {
#[serde(default)]
title: Option<String>,
body: String,
}
#[derive(Deserialize, Default)]
struct TickResult {
#[serde(default)]
notify: Option<NotifyPayload>,
#[serde(default)]
state: Option<serde_json::Value>,
}
#[derive(Clone, Deserialize)]
struct TriggerManifest {
id: String,
name: String,
#[serde(default)]
description: Option<String>,
entry: String,
#[serde(default, rename = "requiredSecrets")]
required_secrets: Vec<String>,
schedule: String,
#[serde(default)]
tz: Option<String>,
}
struct TriggerInfo {
manifest: TriggerManifest,
dir: PathBuf,
paused: Arc<AtomicBool>,
schedule: Schedule,
tz: chrono_tz::Tz,
schedule_error: Option<String>,
}
type TriggersRef = Arc<Vec<TriggerInfo>>;
type TaskStoreRef = Arc<Mutex<TaskStore>>;
struct TickSignal(Mutex<mpsc::Sender<()>>);
impl TickSignal {
fn poke(&self) {
if let Ok(tx) = self.0.lock() {
let _ = tx.send(());
}
}
}
#[derive(Serialize)]
struct TriggerListItem {
id: String,
name: String,
description: Option<String>,
paused: bool,
schedule: String,
#[serde(rename = "nextFireAt")]
next_fire_at: Option<u64>,
error: Option<String>,
}
#[derive(Serialize)]
struct TaskListItem {
id: String,
origin: &'static str,
#[serde(rename = "triggerId")]
trigger_id: Option<String>,
#[serde(rename = "triggerName")]
trigger_name: Option<String>,
#[serde(rename = "scheduledAt")]
scheduled_at: u64,
#[serde(rename = "createdAt")]
created_at: u64,
}
#[derive(Serialize)]
struct DeclaredSecretItem {
name: String,
#[serde(rename = "requiredBy")]
required_by: Vec<String>,
}
fn show_main_window(app: &AppHandle) {
if let Some(window) = app.get_webview_window("main") {
let _ = window.show();
let _ = window.unminimize();
let _ = window.set_focus();
}
}
#[cfg(windows)]
fn register_aumid(app_id: &str, display_name: &str) {
use windows_registry::CURRENT_USER;
if let Ok(key) = CURRENT_USER.create(format!(r"SOFTWARE\Classes\AppUserModelId\{app_id}")) {
let _ = key.set_string("DisplayName", display_name);
}
}
fn send_notification(app: &AppHandle, title: &str, body: &str) {
let notification = app.notification();
match notification.permission_state() {
Ok(PermissionState::Granted) => {
let _ = notification.builder().title(title).body(body).show();
}
_ => {
eprintln!("notification permission not granted; skipping");
}
}
}
pub(crate) fn now_millis() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}
fn emit_activity(app: &AppHandle, source: &str, message: String) {
let _ = app.emit(
"activity",
ActivityEvent {
ts: now_millis(),
source: source.into(),
message,
},
);
}
fn fire_trigger(
app: &AppHandle,
trigger_id: &str,
trigger_name: &str,
title: Option<String>,
body: String,
) {
let effective_title = title.unwrap_or_else(|| trigger_name.to_string());
send_notification(app, &effective_title, &body);
emit_activity(app, trigger_id, body);
}
fn read_trigger_state(app: &AppHandle, trigger_id: &str) -> serde_json::Value {
match app.store(STATE_STORE_FILE) {
Ok(store) => store
.get(trigger_id)
.unwrap_or_else(|| serde_json::json!({})),
Err(e) => {
eprintln!("failed to open state store: {e}");
serde_json::json!({})
}
}
}
fn write_trigger_state(app: &AppHandle, trigger_id: &str, state: serde_json::Value) {
match app.store(STATE_STORE_FILE) {
Ok(store) => {
store.set(trigger_id, state);
if let Err(e) = store.save() {
eprintln!("failed to persist state for {trigger_id}: {e}");
}
}
Err(e) => eprintln!("failed to open state store for write: {e}"),
}
}
fn drop_legacy_fire_times(app: &AppHandle) {
let store = match app.store(STATE_STORE_FILE) {
Ok(s) => s,
Err(e) => {
eprintln!("failed to open state store for legacy cleanup: {e}");
return;
}
};
let Some(mut meta) = store.get(META_NAMESPACE) else {
return;
};
let Some(map) = meta.as_object_mut() else {
return;
};
if map.remove(LEGACY_META_FIRE_TIMES_KEY).is_none() {
return;
}
eprintln!("migrating: dropped legacy __meta__.fire_times (superseded by the task list)");
store.set(META_NAMESPACE, meta);
if let Err(e) = store.save() {
eprintln!("failed to persist legacy cleanup: {e}");
}
}
fn load_task_store(app: &AppHandle) -> TaskStore {
let store = match app.store(TASKS_STORE_FILE) {
Ok(s) => s,
Err(e) => {
eprintln!("failed to open task store: {e}");
return TaskStore::default();
}
};
let tasks = store
.get(TASKS_KEY)
.and_then(|v| match serde_json::from_value::<Vec<Task>>(v) {
Ok(t) => Some(t),
Err(e) => {
eprintln!("tasks.json: unreadable task list, starting empty: {e}");
None
}
})
.unwrap_or_default();
let expansion = store
.get(EXPANSION_KEY)
.and_then(
|v| match serde_json::from_value::<BTreeMap<String, ExpansionState>>(v) {
Ok(e) => Some(e),
Err(e) => {
eprintln!("tasks.json: unreadable expansion state, starting empty: {e}");
None
}
},
)
.unwrap_or_default();
let mut loaded = TaskStore { tasks, expansion };
loaded.normalize();
loaded
}
fn save_task_store(app: &AppHandle, state: &TaskStore) {
let store = match app.store(TASKS_STORE_FILE) {
Ok(s) => s,
Err(e) => {
eprintln!("failed to open task store for write: {e}");
return;
}
};
match serde_json::to_value(&state.tasks) {
Ok(v) => store.set(TASKS_KEY, v),
Err(e) => {
eprintln!("failed to serialize task list: {e}");
return;
}
}
match serde_json::to_value(&state.expansion) {
Ok(v) => store.set(EXPANSION_KEY, v),
Err(e) => {
eprintln!("failed to serialize expansion state: {e}");
return;
}
}
if let Err(e) = store.save() {
eprintln!("failed to persist task store: {e}");
}
}
fn discover_triggers(app: &AppHandle, triggers_dir: &Path) -> Vec<TriggerInfo> {
let entries = match std::fs::read_dir(triggers_dir) {
Ok(e) => e,
Err(e) => {
eprintln!("failed to read triggers dir {triggers_dir:?}: {e}");
return Vec::new();
}
};
let mut result: Vec<TriggerInfo> = Vec::new();
for entry in entries.flatten() {
let path = entry.path();
if !path.is_dir() {
continue;
}
let manifest_path = path.join("manifest.json");
if !manifest_path.exists() {
continue;
}
let text = match std::fs::read_to_string(&manifest_path) {
Ok(t) => t,
Err(e) => {
eprintln!("failed to read {manifest_path:?}: {e}");
continue;
}
};
let manifest: TriggerManifest = match serde_json::from_str(&text) {
Ok(m) => m,
Err(e) => {
eprintln!("invalid manifest {manifest_path:?}: {e}");
continue;
}
};
if manifest.id == META_NAMESPACE {
eprintln!(
"trigger id '{META_NAMESPACE}' is reserved by framework, skipping {manifest_path:?}"
);
continue;
}
let (schedule, schedule_error) = match parse_schedule(&manifest.schedule) {
Ok(spec) => (spec, None),
Err(e) => {
eprintln!(
"invalid schedule for trigger '{}': {e} ({manifest_path:?})",
manifest.id
);
emit_activity(app, &manifest.id, format!("[schedule error] {e}"));
(Schedule::Hourly { minutes: vec![0] }, Some(e))
}
};
let (tz, schedule_error) = match resolve_tz(manifest.tz.as_deref()) {
Ok(t) => (t, schedule_error),
Err(e) => {
eprintln!("trigger '{}' tz error: {e}", manifest.id);
emit_activity(app, &manifest.id, format!("[schedule error] {e}"));
let combined = match schedule_error {
Some(prev) => Some(format!("{prev}; {e}")),
None => Some(e),
};
(chrono_tz::UTC, combined)
}
};
result.push(TriggerInfo {
manifest,
dir: path,
paused: Arc::new(AtomicBool::new(false)),
schedule,
tz,
schedule_error,
});
}
result.sort_by(|a, b| a.manifest.id.cmp(&b.manifest.id));
let mut seen = HashSet::new();
let mut deduped: Vec<TriggerInfo> = Vec::new();
for t in result {
if seen.insert(t.manifest.id.clone()) {
deduped.push(t);
} else {
eprintln!("duplicate trigger id '{}', skipping", t.manifest.id);
}
}
deduped
}
fn lock_tasks(store: &Mutex<TaskStore>) -> std::sync::MutexGuard<'_, TaskStore> {
store
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn find_trigger<'a>(triggers: &'a [TriggerInfo], id: &str) -> Option<&'a TriggerInfo> {
triggers.iter().find(|t| t.manifest.id == id)
}
fn fmt_utc(ms: u64) -> String {
match i64::try_from(ms)
.ok()
.and_then(chrono::DateTime::from_timestamp_millis)
{
Some(dt) => dt.format("%Y-%m-%dT%H:%M:%SZ").to_string(),
None => format!("<invalid ts {ms}>"),
}
}
fn fmt_delay(ms: u64) -> String {
let secs = ms / 1000;
if secs < 60 {
return format!("{secs}s");
}
let mins = secs / 60;
if mins < 60 {
return format!("{mins}m");
}
format!("{}h{}m", mins / 60, mins % 60)
}
fn expand_pending_triggers(
app: &AppHandle,
triggers: &[TriggerInfo],
loaded: &BTreeMap<String, rustyscript::ModuleHandle>,
task_store: &Mutex<TaskStore>,
now: u64,
) -> bool {
let mut store = lock_tasks(task_store);
let mut dirty = false;
for t in triggers {
let id = &t.manifest.id;
if t.schedule_error.is_some() || !loaded.contains_key(id) {
continue;
}
let boundary = store
.expansion
.get(id)
.map(|s| s.expanded_until)
.unwrap_or(now);
if !needs_expansion(boundary, now) {
continue;
}
let (generated, new_boundary) = expand_trigger(id, &t.schedule, &t.tz, boundary, now);
let added = store.extend(generated);
store
.expansion
.entry(id.clone())
.and_modify(|s| s.expanded_until = new_boundary)
.or_insert_with(|| ExpansionState {
expanded_until: new_boundary,
schedule: t.manifest.schedule.clone(),
tz: t.manifest.tz.clone(),
});
dirty = true;
if added > 0 {
emit_activity(
app,
id,
format!(
"[expanded] {added} 件のタスクを積みました (〜{})",
fmt_utc(new_boundary)
),
);
}
}
dirty
}
fn reconcile_at_startup(
app: &AppHandle,
triggers: &[TriggerInfo],
task_store: &Mutex<TaskStore>,
now: u64,
) {
let views: Vec<TriggerSpecView<'_>> = triggers
.iter()
.map(|t| TriggerSpecView {
id: &t.manifest.id,
schedule: &t.manifest.schedule,
tz: t.manifest.tz.as_deref(),
})
.collect();
let mut store = lock_tasks(task_store);
let report = reconcile(&mut store, &views, now);
for (task_id, trigger_id) in &report.orphaned {
eprintln!("dropped task '{task_id}': trigger '{trigger_id}' no longer exists");
emit_activity(
app,
trigger_id,
format!("[orphaned] トリガーが存在しないため予定を破棄しました ({task_id})"),
);
}
for trigger_id in &report.rescheduled {
eprintln!("trigger '{trigger_id}': schedule changed, re-expanding");
emit_activity(
app,
trigger_id,
"[rescheduled] schedule が変更されたため未実行の予定を破棄して再展開します".to_string(),
);
}
save_task_store(app, &store);
}
fn spawn_trigger_worker(
app: AppHandle,
triggers: TriggersRef,
task_store: TaskStoreRef,
secrets_service: SecretsService,
tick_interval: Duration,
) -> mpsc::Sender<()> {
let (tick_tx, tick_rx) = mpsc::channel::<()>();
let app_for_worker = app.clone();
let timer_tx = tick_tx.clone();
let schedule_grace = tick_interval * SCHEDULE_GRACE_TICKS;
std::thread::spawn(move || {
let mut runtime = match rustyscript::Runtime::new(rustyscript::RuntimeOptions {
extensions: vec![secrets::chamberlain_ops::init()],
..Default::default()
}) {
Ok(r) => r,
Err(e) => {
eprintln!("failed to init JS runtime: {e}");
return;
}
};
runtime
.deno_runtime()
.op_state()
.borrow_mut()
.put(secrets_service);
let mut loaded: BTreeMap<String, rustyscript::ModuleHandle> = BTreeMap::new();
for t in triggers.iter() {
if t.schedule_error.is_some() {
continue;
}
let entry_path = t.dir.join(&t.manifest.entry);
let module = match rustyscript::Module::load(&entry_path) {
Ok(m) => m,
Err(e) => {
eprintln!(
"failed to load trigger '{}' at {:?}: {e}",
t.manifest.id, entry_path
);
emit_activity(&app_for_worker, &t.manifest.id, format!("[load error] {e}"));
continue;
}
};
let handle = match runtime.load_module(&module) {
Ok(h) => h,
Err(e) => {
eprintln!("failed to instantiate trigger '{}': {e}", t.manifest.id);
emit_activity(
&app_for_worker,
&t.manifest.id,
format!("[instantiate error] {e}"),
);
continue;
}
};
loaded.insert(t.manifest.id.clone(), handle);
}
drop_legacy_fire_times(&app_for_worker);
reconcile_at_startup(&app_for_worker, &triggers, &task_store, now_millis());
while tick_rx.recv().is_ok() {
let now = now_millis();
let dirty =
expand_pending_triggers(&app_for_worker, &triggers, &loaded, &task_store, now);
let due = lock_tasks(&task_store).due(now);
let mut handled: Vec<String> = Vec::new();
for task in due {
let trigger = task
.trigger_id
.as_deref()
.and_then(|tid| find_trigger(&triggers, tid));
let handle = task.trigger_id.as_deref().and_then(|tid| loaded.get(tid));
let runtime_state = match (trigger, handle) {
(Some(t), Some(_)) => Some(TriggerRuntimeState {
paused: t.paused.load(Ordering::Relaxed),
}),
_ => None,
};
let source = task.trigger_id.clone().unwrap_or_else(|| "__task__".into());
match classify_due(&task, now, runtime_state, schedule_grace) {
Disposition::Run { delay_ms } => {
let (Some(t), Some(handle)) = (trigger, handle) else {
emit_activity(
&app_for_worker,
&source,
"[unsupported] 実行対象のトリガーが無いタスクは Phase 1 では実行できません"
.to_string(),
);
handled.push(task.id.clone());
continue;
};
let id = &t.manifest.id;
let current_state = read_trigger_state(&app_for_worker, id);
let ctx = serde_json::json!({
"now": now,
"state": current_state,
"scheduledAt": task.scheduled_at,
"delayMs": delay_ms,
});
let result: Result<Option<TickResult>, _> = runtime.call_function(
Some(handle),
"tick",
rustyscript::json_args!(ctx),
);
match result {
Ok(Some(res)) => {
if let Some(notify) = res.notify {
fire_trigger(
&app_for_worker,
id,
&t.manifest.name,
notify.title,
notify.body,
);
}
if let Some(new_state) = res.state {
write_trigger_state(&app_for_worker, id, new_state);
}
}
Ok(None) => {}
Err(e) => {
eprintln!("trigger '{id}' tick() error: {e}");
emit_activity(&app_for_worker, id, format!("[error] {e}"));
}
}
}
Disposition::Orphaned => {
let message = if trigger.is_some() {
"[unavailable] トリガーが実行できない状態 (構成エラー / ロード失敗) \
のため予定を破棄しました"
.to_string()
} else {
"[orphaned] トリガーが存在しないため予定を破棄しました".to_string()
};
emit_activity(&app_for_worker, &source, message);
}
Disposition::Paused => {
emit_activity(
&app_for_worker,
&source,
format!(
"[paused] 停止中のため {} の予定を破棄しました",
fmt_utc(task.scheduled_at)
),
);
}
Disposition::SkippedLate { delay_ms } => {
emit_activity(
&app_for_worker,
&source,
format!(
"[skipped] {} の予定に {} 遅れているため実行しませんでした",
fmt_utc(task.scheduled_at),
fmt_delay(delay_ms)
),
);
}
Disposition::Expired { delay_ms } => {
emit_activity(
&app_for_worker,
&source,
format!(
"[expired] {} の予定が猶予を超えた ({} 遅れ) ため未実行のまま破棄しました",
fmt_utc(task.scheduled_at),
fmt_delay(delay_ms)
),
);
}
}
handled.push(task.id.clone());
}
if !handled.is_empty() || dirty {
let mut store = lock_tasks(&task_store);
for id in &handled {
store.remove(id);
}
save_task_store(&app_for_worker, &store);
}
}
});
tauri::async_runtime::spawn(async move {
if timer_tx.send(()).is_err() {
return;
}
loop {
tokio::time::sleep(tick_interval).await;
if timer_tx.send(()).is_err() {
break;
}
}
});
tick_tx
}
#[tauri::command]
fn list_triggers(
triggers: State<'_, TriggersRef>,
task_store: State<'_, TaskStoreRef>,
) -> Vec<TriggerListItem> {
let store = lock_tasks(&task_store);
triggers
.iter()
.map(|t| TriggerListItem {
id: t.manifest.id.clone(),
name: t.manifest.name.clone(),
description: t.manifest.description.clone(),
paused: t.paused.load(Ordering::Relaxed),
schedule: t.manifest.schedule.clone(),
next_fire_at: store.next_scheduled_for(&t.manifest.id),
error: t.schedule_error.clone(),
})
.collect()
}
#[tauri::command]
fn list_tasks(
triggers: State<'_, TriggersRef>,
task_store: State<'_, TaskStoreRef>,
) -> Vec<TaskListItem> {
let store = lock_tasks(&task_store);
store
.tasks
.iter()
.map(|t| TaskListItem {
id: t.id.clone(),
origin: match t.origin {
TaskOrigin::Schedule => "schedule",
TaskOrigin::Adhoc => "adhoc",
},
trigger_id: t.trigger_id.clone(),
trigger_name: t
.trigger_id
.as_deref()
.and_then(|tid| find_trigger(&triggers, tid))
.map(|t| t.manifest.name.clone()),
scheduled_at: t.scheduled_at,
created_at: t.created_at,
})
.collect()
}
#[tauri::command]
fn delete_task(
app: AppHandle,
id: String,
task_store: State<'_, TaskStoreRef>,
) -> Result<(), String> {
let mut store = lock_tasks(&task_store);
if !store.remove(&id) {
return Err(format!("unknown task: {id}"));
}
save_task_store(&app, &store);
drop(store);
emit_activity(
&app,
"__task__",
format!("[deleted] 予定を削除しました ({id})"),
);
Ok(())
}
#[tauri::command]
fn run_trigger_now(
app: AppHandle,
id: String,
triggers: State<'_, TriggersRef>,
task_store: State<'_, TaskStoreRef>,
tick: State<'_, TickSignal>,
) -> Result<(), String> {
let trigger = find_trigger(&triggers, &id).ok_or_else(|| format!("unknown trigger: {id}"))?;
if let Some(err) = &trigger.schedule_error {
return Err(format!("trigger '{id}' has a configuration error: {err}"));
}
let now = now_millis();
{
let mut store = lock_tasks(&task_store);
store.insert(Task {
id: format!("manual-{id}-{now}"),
origin: TaskOrigin::Adhoc,
trigger_id: Some(id.clone()),
scheduled_at: now,
created_at: now,
});
save_task_store(&app, &store);
}
emit_activity(&app, &id, "[manual] 手動実行を予約しました".to_string());
tick.poke();
Ok(())
}
#[tauri::command]
fn pause_trigger(id: String, triggers: State<'_, TriggersRef>) -> Result<(), String> {
match triggers.iter().find(|t| t.manifest.id == id) {
Some(t) => {
t.paused.store(true, Ordering::Relaxed);
Ok(())
}
None => Err(format!("unknown trigger: {id}")),
}
}
#[tauri::command]
fn resume_trigger(id: String, triggers: State<'_, TriggersRef>) -> Result<(), String> {
match triggers.iter().find(|t| t.manifest.id == id) {
Some(t) => {
t.paused.store(false, Ordering::Relaxed);
Ok(())
}
None => Err(format!("unknown trigger: {id}")),
}
}
#[tauri::command]
fn list_declared_secrets(triggers: State<'_, TriggersRef>) -> Vec<DeclaredSecretItem> {
let mut map: BTreeMap<String, Vec<String>> = BTreeMap::new();
map.entry(secrets::ANTHROPIC_API_KEY_NAME.to_string())
.or_default()
.push("Chamberlain".to_string());
for t in triggers.iter() {
for name in &t.manifest.required_secrets {
map.entry(name.clone())
.or_default()
.push(t.manifest.id.clone());
}
}
map.into_iter()
.map(|(name, required_by)| DeclaredSecretItem { name, required_by })
.collect()
}
pub fn builder() -> tauri::Builder<tauri::Wry> {
let _ = dotenvy::dotenv();
tauri::Builder::default()
.plugin(tauri_plugin_notification::init())
.plugin(tauri_plugin_store::Builder::default().build())
.invoke_handler(tauri::generate_handler![
list_triggers,
pause_trigger,
resume_trigger,
run_trigger_now,
list_tasks,
delete_task,
list_declared_secrets,
secrets::set_secret,
secrets::has_secret,
secrets::delete_secret,
chat::chat_history,
chat::chat_send,
chat::chat_clear,
])
.on_window_event(|window, event| {
if let WindowEvent::CloseRequested { api, .. } = event {
let _ = window.hide();
api.prevent_close();
}
})
.setup(move |app| {
#[cfg(windows)]
{
let identifier = app.config().identifier.clone();
let display_name = app
.config()
.product_name
.clone()
.unwrap_or_else(|| identifier.clone());
register_aumid(&identifier, &display_name);
}
{
let notification = app.notification();
if !matches!(
notification.permission_state(),
Ok(PermissionState::Granted)
) {
let _ = notification.request_permission();
}
}
let open_item = MenuItem::with_id(app, "open", "Open Chamberlain", true, None::<&str>)?;
let notify_item =
MenuItem::with_id(app, "notify", "Send test notification", true, None::<&str>)?;
let quit_item = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
let menu = Menu::with_items(app, &[&open_item, ¬ify_item, &quit_item])?;
TrayIconBuilder::new()
.icon(app.default_window_icon().unwrap().clone())
.menu(&menu)
.show_menu_on_left_click(true)
.on_menu_event(|app, event| match event.id.as_ref() {
"open" => show_main_window(app),
"notify" => send_notification(app, "Chamberlain", "テスト通知です"),
"quit" => app.exit(0),
_ => {}
})
.build(app)?;
let dev_mode = dev_mode_enabled();
let tick_interval = if dev_mode {
TICK_INTERVAL_DEV
} else {
TICK_INTERVAL_PROD
};
if dev_mode {
eprintln!(
"CHAMBERLAIN_DEV=1: heartbeat is 10s (use the manual-run button to \
iterate on a trigger; schedule floors are enforced by the DSL now)"
);
}
let triggers_dir = match app.path().resolve("triggers", BaseDirectory::Resource) {
Ok(p) => p,
Err(e) => {
eprintln!("failed to resolve triggers resource dir: {e}");
PathBuf::new()
}
};
let triggers: TriggersRef = Arc::new(discover_triggers(app.handle(), &triggers_dir));
for t in triggers.iter() {
eprintln!(
"discovered trigger: {} ({}) — entry {}, schedule '{}' tz={:?}",
t.manifest.id, t.manifest.name, t.manifest.entry, t.manifest.schedule, t.tz
);
}
let secrets_service = SecretsService(app.config().identifier.clone());
app.manage(secrets_service.clone());
let task_store: TaskStoreRef = Arc::new(Mutex::new(load_task_store(app.handle())));
app.manage(triggers.clone());
app.manage(task_store.clone());
let tick_tx = spawn_trigger_worker(
app.handle().clone(),
triggers,
task_store,
secrets_service,
tick_interval,
);
app.manage(TickSignal(Mutex::new(tick_tx)));
Ok(())
})
}