AnyBot/src/model.rs

// Data kept between runs: bots, their chats, provider settings and look.

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

use crate::providers::ProviderKind;

#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Debug, Default)]
pub enum Role {
    #[default]
    User,
    Assistant,
    /// The result of one tool call, sent back to the model.
    Tool,
}

#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Debug, Default)]
pub enum ToolStatus {
    Waiting,
    Running,
    #[default]
    Done,
    Denied,
    Failed,
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct ToolCall {
    pub id: String,
    pub name: String,
    /// The arguments as the model wrote them (JSON text).
    pub args: String,
    #[serde(default)]
    pub status: ToolStatus,
}

#[derive(Clone, Serialize, Deserialize, Debug, Default)]
pub struct Message {
    pub role: Role,
    pub text: String,
    #[serde(default)]
    pub thinking: String,
    /// Which provider and model wrote this reply (shown under it).
    #[serde(default)]
    pub via: String,
    #[serde(default)]
    pub error: bool,
    /// Tools the model asked to run in this reply.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub tool_calls: Vec<ToolCall>,
    /// For Role::Tool: which call this answers.
    #[serde(default, skip_serializing_if = "String::is_empty")]
    pub tool_call_id: String,
    #[serde(default, skip_serializing_if = "String::is_empty")]
    pub tool_name: String,
    /// Screenshots (base64 JPEG) shown to the model with this message. Not saved to disk.
    #[serde(skip)]
    pub images: Vec<String>,
    /// A summary standing in for older messages (context compaction).
    #[serde(default)]
    pub summary: bool,
    /// Claude's own content blocks (thinking signatures, tool_use), replayed unchanged.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub blocks: Vec<serde_json::Value>,
    /// A routine (or another bot) woke the bot up: starts a turn like a person's message.
    #[serde(default)]
    pub wake: bool,
    /// Sent while the bot was working: steers the running turn instead of starting a new one.
    #[serde(default)]
    pub steer: bool,
    /// In a group chat: which bot wrote this answer (0 = the chat's own bot).
    #[serde(default, skip_serializing_if = "is_zero")]
    pub author: u64,
    /// 表情回應 the person put on this message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub reactions: Vec<String>,
    /// Files and pictures the person attached, or files the bot sent (kept on disk).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub attachments: Vec<crate::attach::Attachment>,
    /// When it was written (ms since 1970; 0 for messages from before this was kept).
    #[serde(default, skip_serializing_if = "is_zero_i64")]
    pub at: i64,
    /// A card where AnyBot stopping cut a turn off (put there at the next start, see
    /// oplog::recover), with 「繼續」 to go on from there. Never sent to the model.
    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
    pub interrupted: bool,
}

fn is_zero_i64(n: &i64) -> bool {
    *n == 0
}

/// Where the model's view of a chat starts: the newest summary (folding keeps the person's chat
/// whole; the model reads from the fold on).
pub fn model_view_start(msgs: &[Message]) -> usize {
    msgs.iter().rposition(|m| m.summary).unwrap_or(0)
}

/// A summary the turn made (it folded the first `n` messages of its view; `boundary` is the time
/// of the first one it kept) goes into the chat at the fold. Nothing is removed: the person's
/// chat stays whole and the model reads from the newest summary on. The model's view can be
/// shorter than the chat (group chats filter), so the fold lands at the real first-kept message,
/// not the raw index.
pub fn fold_in(msgs: &mut Vec<Message>, n: usize, summary: Message, boundary: i64) {
    let from = model_view_start(msgs);
    let cut = msgs.iter().position(|m| m.at == boundary && m.role == Role::User).filter(|&i| i > from).unwrap_or((from + n).min(msgs.len()));
    // Pictures in what was folded never go to the model again (and aren't saved anyway).
    for m in &mut msgs[..cut] {
        m.images.clear();
    }
    msgs.insert(cut, summary);
}

pub fn now_ms() -> i64 {
    chrono::Utc::now().timestamp_millis()
}

/// How a turn ended: the original's outcomes `["success","cancelled","error"]`
/// (node-agent-coordinator `wl`, read back by `k6` as {turnId, outcome, settledAtMs}).
#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
pub enum TurnOutcome {
    Success,
    Cancelled,
    Error,
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct TurnSettlement {
    pub turn_id: String,
    pub outcome: TurnOutcome,
    pub settled_at_ms: i64,
}

/// Another of the person's computers, reached over SSH. The other two computers are built in:
/// the bot's own (a sealed folder, like the original's cloud "box") and this Mac (only when
/// 在這台電腦上執行 is on).
#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
pub struct RemoteComputer {
    pub name: String,
    /// e.g. `me@studio.local`
    pub ssh_target: String,
    #[serde(default)]
    pub dir: String,
}

fn is_zero(n: &u64) -> bool {
    *n == 0
}

/// A bot's own computer as kept in `Bot::default_computer` (it survives renaming the bot). It is
/// shown and offered under the bot's name: see [`own_computer_name`].
pub const BOT_COMPUTER_NAME: &str = "Bot 的電腦";
/// What older versions kept for "the person's computer". Read as the computer the person is using
/// now; every computer is shown under its own name.
pub const THIS_COMPUTER_NAME: &str = "你的電腦";

/// What a bot calls its own computer: 「Master 的電腦」 for the bot Master. One plain name per
/// computer — 「Bot 的電腦」 and 「你的電腦」 meant different machines to the person and the bot.
pub fn own_computer_name(bot_name: &str) -> String {
    let n = bot_name.trim();
    if n.is_empty() {
        BOT_COMPUTER_NAME.to_string()
    } else {
        format!("{n} 的電腦")
    }
}

impl Message {
    pub fn user(text: &str) -> Self {
        Message { role: Role::User, text: text.to_string(), at: now_ms(), ..Default::default() }
    }
    pub fn assistant(text: &str, via: &str) -> Self {
        Message { role: Role::Assistant, text: text.to_string(), via: via.to_string(), at: now_ms(), ..Default::default() }
    }
    pub fn tool_result(id: &str, name: &str, output: &str) -> Self {
        Message { role: Role::Tool, text: output.to_string(), tool_call_id: id.to_string(), tool_name: name.to_string(), at: now_ms(), ..Default::default() }
    }
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Bot {
    pub id: u64,
    pub name: String,
    #[serde(default)]
    pub description: String,
    /// What the bot should keep in mind (sent as the system prompt).
    #[serde(default)]
    pub instructions: String,
    pub shape: String,
    pub color: String,
    pub provider: ProviderKind,
    pub model: String,
    /// 執行步驟用的模型: "" picks the provider's quick model (providers::step_model), "off" uses
    /// `model` for every step, anything else is that model. The bot's own model plans, checks
    /// and gets the hard steps; the quick one carries out the planned steps in between.
    #[serde(default, skip_serializing_if = "String::is_empty")]
    pub step_model: String,
    #[serde(default)]
    pub pinned: bool,
    /// 資料夾 in the sidebar (empty = 未分區), like the original's groups.
    #[serde(default, skip_serializing_if = "String::is_empty")]
    pub folder: String,
    #[serde(default)]
    pub messages: Vec<Message>,
    #[serde(default)]
    pub unread: bool,
    /// Let this bot search, read and edit files and run commands in `workdir`.
    #[serde(default)]
    pub tools_enabled: bool,
    #[serde(default)]
    pub workdir: String,
    /// "Always allow" grants, e.g. `edit_file` or `shell:git commit`.
    #[serde(default)]
    pub allow_rules: Vec<String>,
    /// 群組聊天: the bots that answer here, in order (empty = an ordinary bot).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub members: Vec<u64>,
    /// 討論串: earlier conversations put aside with 「開始新對話」 (title, messages).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub threads: Vec<(String, Vec<Message>)>,
    /// 記憶: facts this bot keeps across chats.
    #[serde(default)]
    pub memories: Vec<String>,
    /// 語音聊天: read this bot's answers aloud.
    #[serde(default)]
    pub speak_replies: bool,
    /// 語音聊天 › 語音 (a macOS voice; empty = chosen by language), 速度 (1.0 = normal) and
    /// 語言 (spoken language for speech-to-text; empty = detect).
    #[serde(default, skip_serializing_if = "String::is_empty")]
    pub voice: String,
    #[serde(default = "one_f32")]
    pub voice_rate: f32,
    #[serde(default, skip_serializing_if = "String::is_empty")]
    pub voice_lang: String,
    /// 示範教學: tasks the person showed this bot on the Mac.
    #[serde(default)]
    pub demos: Vec<crate::teach::Demo>,
    /// How much the model can read at once, for deciding when to summarize.
    #[serde(default = "default_context_tokens")]
    pub context_tokens: u64,
    #[serde(default)]
    pub routines: Vec<crate::routines::Routine>,
    #[serde(default)]
    pub last_turn: Option<TurnSettlement>,
    /// Name of the computer tools use unless told otherwise.
    #[serde(default = "default_computer")]
    pub default_computer: String,
}

fn one_f32() -> f32 {
    1.0
}

pub fn default_computer() -> String {
    BOT_COMPUTER_NAME.into()
}

pub const INTERRUPTED_NOTE: &str = "（這次的回應被中斷了，可能是 App 關閉或重新啟動。按「重新產生」再試一次。）";

impl Bot {
    /// 「儲存」 in the bot's settings: what the person changed there (`edited`, against `from`
    /// — the bot as the editor opened it) is put onto the bot as it is now. Everything else
    /// stays as it is now: a turn running meanwhile gave it messages, things to remember,
    /// 「永遠允許」 rules, a routine, a conversation put aside. (The editor's copy used to replace
    /// the bot whole, messages aside, and all of that was gone with the save.)
    /// In a list of plain values (記得的事, 永遠允許, 群組成員) what was taken out goes and what
    /// was added comes; the rest of the list is as it is now.
    pub fn take_edit(&mut self, mut from: Bot, mut edited: Bot) {
        use serde_json::Value;
        let messages = std::mem::take(&mut self.messages);
        from.messages.clear();
        edited.messages.clear();
        let fields = |b: &Bot| serde_json::to_value(b).ok().and_then(|v| v.as_object().cloned());
        let merged = (|| {
            let (mut now, from, edited) = (fields(self)?, fields(&from)?, fields(&edited)?);
            let plain = |v: &Value| v.as_array().is_some_and(|a| a.iter().all(|x| x.is_string() || x.is_number()));
            let keys: std::collections::BTreeSet<&String> = from.keys().chain(edited.keys()).collect();
            for k in keys {
                let (was, is) = (from.get(k), edited.get(k));
                if was == is {
                    continue;
                }
                match (was, is, now.get(k)) {
                    (Some(was), Some(is), Some(cur)) if plain(was) && plain(is) && plain(cur) => {
                        let (was, is) = (was.as_array().cloned().unwrap_or_default(), is.as_array().cloned().unwrap_or_default());
                        let mut list: Vec<Value> = cur.as_array().cloned().unwrap_or_default();
                        list.retain(|x| !was.contains(x) || is.contains(x));
                        for x in is.iter().filter(|x| !was.contains(x)) {
                            if !list.contains(x) {
                                list.push(x.clone());
                            }
                        }
                        now.insert(k.clone(), Value::Array(list));
                    }
                    (_, Some(is), _) => {
                        now.insert(k.clone(), is.clone());
                    }
                    // (A field left out when it is empty: emptied in the editor.)
                    (_, None, _) => {
                        now.remove(k);
                    }
                }
            }
            serde_json::from_value::<Bot>(Value::Object(now)).ok()
        })();
        *self = merged.unwrap_or(edited);
        self.messages = messages;
    }

    /// A turn that was still running when the app closed can't continue: mark its empty
    /// replies and unfinished tool steps as interrupted (an `error` settlement) so the chat
    /// can be retried instead of looking stuck.
    pub fn repair_interrupted(&mut self) -> bool {
        let mut changed = false;
        for m in self.messages.iter_mut().filter(|m| m.role == Role::Assistant && !m.summary) {
            for c in m.tool_calls.iter_mut() {
                if matches!(c.status, ToolStatus::Waiting | ToolStatus::Running) {
                    c.status = ToolStatus::Denied;
                    changed = true;
                }
            }
            if m.text.trim().is_empty() && m.tool_calls.is_empty() {
                m.text = INTERRUPTED_NOTE.into();
                m.error = true;
                changed = true;
            }
        }
        if changed && self.last_turn.as_ref().map(|t| t.outcome != TurnOutcome::Error).unwrap_or(true) {
            self.last_turn = Some(TurnSettlement { turn_id: "interrupted".into(), outcome: TurnOutcome::Error, settled_at_ms: chrono::Utc::now().timestamp_millis() });
        }
        changed
    }
}

pub fn default_context_tokens() -> u64 {
    crate::agent::DEFAULT_CONTEXT_TOKENS
}

#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Debug)]
pub enum Theme {
    Light,
    Dark,
    System,
}

#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Debug)]
pub enum Accent {
    BotColor,
    Black,
}

#[derive(Clone, Serialize, Deserialize, Debug, Default)]
pub struct ProviderSettings {
    #[serde(default)]
    pub api_key: String,
    /// Empty means the provider's usual address.
    #[serde(default)]
    pub base_url: String,
    /// Empty means the provider's suggested model.
    #[serde(default)]
    pub default_model: String,
    /// Models fetched from the provider's model list.
    #[serde(default)]
    pub known_models: Vec<String>,
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct State {
    pub bots: Vec<Bot>,
    pub primary_bot: u64,
    pub selected: u64,
    pub next_id: u64,
    pub theme: Theme,
    pub accent: Accent,
    #[serde(default)]
    pub providers: std::collections::BTreeMap<String, ProviderSettings>,
    #[serde(default)]
    pub sidebar_collapsed: bool,
    /// 語意搜尋: "" = 找 Ollama 裡裝好的 embedding 模型, "off" = 關。
    #[serde(default)]
    pub embed_model: String,
    /// 文件索引的資料夾; 空 = 用這台電腦的「文件」資料夾。
    #[serde(default)]
    pub doc_folders: Vec<String>,
    #[serde(default = "default_sidebar_width")]
    pub sidebar_width: f32,
    /// 允許在這台電腦上執行任務，而不只是在它自己的電腦上 (setting `local-execution`, ids fuUvu2/Hd1KB+).
    #[serde(default)]
    pub local_execution: bool,
    #[serde(default)]
    pub remote_computers: Vec<RemoteComputer>,
    /// 自動審核 with the person's natural-language rules ("先詢問" wins when they conflict).
    #[serde(default)]
    pub auto_review: bool,
    #[serde(default)]
    pub review_allow_rules: Vec<String>,
    #[serde(default)]
    pub review_ask_rules: Vec<String>,
    /// Time zone for schedules and reminders (setting `timezone`, ids 40Gx0U/TO/JdP).
    #[serde(default = "crate::routines::local_timezone")]
    pub timezone: String,
    #[serde(default = "first_routine_id")]
    pub next_routine_id: u64,
    /// 「Bot 完成任務或等你處理時通知你」(ttdOeI): banners when away.
    #[serde(default = "yes")]
    pub notify: bool,
    /// 直接操作: one switch like the reference assistant's local-execution + auto-review; only safety checks and
    /// "always ask" rules stop the bot.
    #[serde(default)]
    pub direct_mode: bool,
    /// 「在你離開時自動更新用戶端」(4vprnG); on by default like the original.
    #[serde(default = "yes")]
    pub auto_update_when_away: bool,
    /// 訊息管道: Slack / Discord / Telegram channels a bot answers.
    #[serde(default)]
    pub channels: Vec<crate::channels::Channel>,
    #[serde(default = "first_routine_id")]
    pub next_channel_id: u64,
    /// MCP connectors the bots can use.
    #[serde(default)]
    pub mcp_servers: Vec<crate::mcp::Server>,
    /// 技能 every bot can load.
    #[serde(default)]
    pub skills: Vec<crate::memory::Skill>,
    /// 頁面 the bots made and keep up to date.
    #[serde(default)]
    pub pages: Vec<crate::pages::Page>,
    #[serde(default = "first_routine_id")]
    pub next_page_id: u64,
    /// 手機與帳號: phone access, the relay account and backups.
    #[serde(default)]
    pub remote: crate::remote::Settings,
    /// 分區 (sidebar sections) in their order, including empty ones.
    #[serde(default)]
    pub folders: Vec<String>,
    /// 你的電腦's label in 設定 → 電腦 (empty = the computer's own name).
    #[serde(default, skip_serializing_if = "String::is_empty")]
    pub machine_label: String,
    /// 在這台電腦上執行 = 永不允許 (bots never ask; local tools are refused).
    #[serde(default)]
    pub local_never: bool,
    /// 訊息: bots may send iMessages / SMS from this Mac.
    #[serde(default = "yes")]
    pub messages_send: bool,
    /// 訊息: send without the approval card each time.
    #[serde(default)]
    pub messages_no_ask: bool,
    /// 已釘選的 Bot, in the order of the grid at the top of the sidebar.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub pin_order: Vec<u64>,
    /// Where 未分區 sits among the 分區 (None = last).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub loose_index: Option<usize>,
    /// Groups folded shut in the sidebar ("" = 未分區).
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub folded: Vec<String>,
    /// 語言: "auto" (follow the Mac) or one of i18n::LANGS.
    #[serde(default = "auto_lang")]
    pub language: String,
}

fn auto_lang() -> String {
    "auto".into()
}

/// "Always ask" rules that direct mode starts with (own wording).
pub const DEFAULT_ASK_RULES: [&str; 3] = ["刪除檔案或資料夾", "付款、購買或轉帳", "用我的帳號發文、留言，或傳訊息給別人"];

fn yes() -> bool {
    true
}

fn first_routine_id() -> u64 {
    1
}

fn default_sidebar_width() -> f32 {
    crate::app::SIDEBAR_DEFAULT_WIDTH
}

impl State {
    /// Every computer name a bot can be told to use here: its own (by its stored name), this
    /// computer, then the SSH ones.
    pub fn computer_names(&self) -> Vec<String> {
        let mut v = vec![BOT_COMPUTER_NAME.to_string(), self.this_computer_name()];
        v.extend(self.remote_computers.iter().map(|c| c.name.clone()));
        v
    }

    /// This computer's own name: the one given in 設定 › 電腦, else its name in the account, else
    /// the name the system gives it.
    pub fn this_computer_name(&self) -> String {
        for n in [&self.machine_label, &self.remote.host_name] {
            if !n.trim().is_empty() {
                return n.trim().to_string();
            }
        }
        crate::remote::default_host_name()
    }

    pub fn routine_owner(&self, routine_id: u64) -> Option<u64> {
        self.bots.iter().find(|b| b.routines.iter().any(|r| r.id == routine_id)).map(|b| b.id)
    }
}

/// The save on disk couldn't be read at start and couldn't be moved aside: never write over it.
static KEEP_UNREAD_SAVE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);

impl State {
    pub fn path() -> PathBuf {
        // A server (or a second copy for testing) can keep its data elsewhere.
        if let Ok(d) = std::env::var("ANYBOT_DATA_DIR") {
            if !d.trim().is_empty() {
                return PathBuf::from(d).join("state.json");
            }
        }
        let base = dirs::data_dir().unwrap_or_else(std::env::temp_dir);
        base.join("AnyBot").join("state.json")
    }

    pub fn load() -> State {
        Self::load_from(&Self::path())
    }

    fn load_from(p: &std::path::Path) -> State {
        let raw = std::fs::read_to_string(p);
        let parsed = raw.as_ref().ok().and_then(|s| serde_json::from_str::<State>(s).ok());
        let mut s = match parsed {
            Some(s) => s,
            None => {
                let stamp = chrono::Utc::now().timestamp();
                match raw.as_ref() {
                    // A damaged save must not vanish quietly: keep the bytes (so the person can
                    // recover them), then start fresh. Silently wiping left no trace before.
                    Ok(raw) => {
                        let damaged = p.with_extension(format!("json.damaged-{stamp}"));
                        let _ = std::fs::write(&damaged, raw);
                    }
                    // No save yet: a first run.
                    Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
                    // A save that is there but can't be read (its permissions, a disk error,
                    // bytes that aren't text) is no first run: the next save would have written
                    // an empty AnyBot over it. It is moved aside whole, and if even that fails
                    // nothing is saved over it this run.
                    Err(e) => {
                        let aside = p.with_extension(format!("json.unreadable-{stamp}"));
                        eprintln!("AnyBot：讀不到 {}（{e}）。原檔會留著，不會被新的設定蓋掉。", p.display());
                        if std::fs::rename(p, &aside).is_err() {
                            KEEP_UNREAD_SAVE.store(true, std::sync::atomic::Ordering::SeqCst);
                        }
                    }
                }
                State::first_run()
            }
        };
        s.drop_untouched_samples();
        for b in s.bots.iter_mut() {
            b.repair_interrupted();
        }
        s.fix_primary();
        s
    }

    /// Write everything to disk; true once it is there.
    pub fn save(&self) -> bool {
        let p = Self::path();
        // (The save that couldn't be read at start, nor moved aside, is still there.)
        if KEEP_UNREAD_SAVE.load(std::sync::atomic::Ordering::SeqCst) && p.exists() {
            return false;
        }
        if let Some(dir) = p.parent() {
            let _ = std::fs::create_dir_all(dir);
        }
        if let Ok(s) = serde_json::to_string_pretty(self) {
            let tmp = p.with_extension("json.tmp");
            // Flush the bytes before renaming, so a power cut cannot leave a renamed-but-empty
            // file where load() would find it (and treat it as a first run).
            if let Ok(mut f) = std::fs::File::create(&tmp) {
                use std::io::Write;
                if f.write_all(s.as_bytes()).and_then(|_| f.sync_all()).is_ok() {
                    // state.json carries model keys: owner-only, like the vault's key file.
                    #[cfg(unix)]
                    {
                        use std::os::unix::fs::PermissionsExt;
                        let _ = std::fs::set_permissions(&tmp, std::fs::Permissions::from_mode(0o600));
                    }
                    return std::fs::rename(&tmp, &p).is_ok();
                }
            }
        }
        false
    }

    pub fn provider(&self, kind: ProviderKind) -> ProviderSettings {
        self.providers.get(kind.key()).cloned().unwrap_or_default()
    }

    pub fn provider_mut(&mut self, kind: ProviderKind) -> &mut ProviderSettings {
        self.providers.entry(kind.key().to_string()).or_default()
    }

    pub fn bot(&self, id: u64) -> Option<&Bot> {
        self.bots.iter().find(|b| b.id == id)
    }

    pub fn bot_mut(&mut self, id: u64) -> Option<&mut Bot> {
        self.bots.iter_mut().find(|b| b.id == id)
    }

    /// Older versions started with five sample bots. If they are all still there and were never
    /// used (no chat, routine or memory, nothing renamed) and there is nothing else, it is a fresh
    /// install: start empty, with the guide, like a new one.
    pub fn drop_untouched_samples(&mut self) {
        let samples = Self::sample_bots();
        let untouched = |b: &Bot| {
            samples.iter().any(|x| x.id == b.id && x.name == b.name && x.description == b.description && x.instructions == b.instructions)
                && b.messages.is_empty()
                && b.routines.is_empty()
                && b.memories.is_empty()
                && b.threads.is_empty()
        };
        if self.bots.len() == samples.len() && self.bots.iter().all(untouched) {
            self.bots.clear();
            self.primary_bot = 0;
            self.selected = 0;
        }
    }

    /// The first bot made becomes the main one; with none at all, nothing is selected.
    pub fn fix_primary(&mut self) {
        if self.bot(self.primary_bot).is_none() {
            self.primary_bot = self.bots.first().map(|b| b.id).unwrap_or(0);
        }
        if self.bot(self.selected).is_none() {
            self.selected = self.primary_bot;
        }
    }

    /// Bots that aren't here yet (another computer's, a backup's), as new bots with new ids.
    /// A bot counts as already here when one has the same name and the same chat (or it was
    /// never used). Returns how many were added.
    pub fn take_in_bots(&mut self, other: &State) -> usize {
        let last = |b: &Bot| b.messages.last().map(|m| (m.at, m.text.clone()));
        let mut n = 0;
        let mut reid: Vec<(u64, u64)> = vec![];
        for b in &other.bots {
            if self.bots.iter().any(|o| o.name == b.name && (b.messages.is_empty() || (o.messages.len() == b.messages.len() && last(o) == last(b)))) {
                continue;
            }
            let mut b = b.clone();
            let old_id = b.id;
            b.id = self.next_id.max(1);
            reid.push((old_id, b.id));
            self.next_id = b.id + 1;
            for r in b.routines.iter_mut() {
                r.id = self.next_routine_id.max(1);
                self.next_routine_id = r.id + 1;
            }
            self.bots.push(b);
            n += 1;
        }
        // Group members are bot ids from the other machine: follow them to the copies that
        // just landed, or a group answers with bots that have nothing to do with it.
        if !reid.is_empty() {
            for g in self.bots.iter_mut() {
                if g.members.is_empty() {
                    continue;
                }
                for m in g.members.iter_mut() {
                    if let Some((_, new)) = reid.iter().find(|(o, _)| *o == *m) {
                        *m = *new;
                    }
                }
            }
        }
        // Keys, skills and connectors this computer doesn't have yet.
        for (k, v) in &other.providers {
            let mine = self.providers.entry(k.clone()).or_default();
            if mine.api_key.is_empty() && !v.api_key.is_empty() {
                *mine = v.clone();
            }
        }
        for sk in &other.skills {
            if !self.skills.iter().any(|m| m.name == sk.name) {
                self.skills.push(sk.clone());
            }
        }
        for m in &other.mcp_servers {
            if !self.mcp_servers.iter().any(|o| o.name == m.name) {
                self.mcp_servers.push(m.clone());
            }
        }
        self.fix_primary();
        n
    }

    fn sample_bots() -> Vec<Bot> {
        let mk = |id, name: &str, desc: &str, shape: &str, color: &str, provider: ProviderKind, pinned| Bot {
            id,
            name: name.into(),
            description: desc.into(),
            instructions: String::new(),
            shape: shape.into(),
            color: color.into(),
            provider,
            model: provider.suggested_model().into(),
            step_model: String::new(),
            pinned,
            messages: vec![],
            unread: false,
            tools_enabled: false,
            workdir: String::new(),
            allow_rules: vec![],
            demos: vec![],
            speak_replies: false,
            voice: String::new(),
            voice_rate: 1.0,
            voice_lang: String::new(),
            folder: String::new(),
            memories: vec![],
            members: vec![],
            threads: vec![],
            context_tokens: default_context_tokens(),
            routines: vec![],
            last_turn: None,
            default_computer: default_computer(),
        };
        let mut helper = mk(5, "電腦助手", "幫你整理檔案、跑指令。動手前會先問你。", "gem", "blue", ProviderKind::Anthropic, true);
        helper.tools_enabled = true;
        helper.workdir = default_workdir();
        vec![
            mk(1, "Bot", "你的主要聯絡窗口，什麼都可以問。", "squircle", "black", ProviderKind::Xai, false),
            mk(2, "研究助理", "幫你查資料、整理重點。", "blob", "green", ProviderKind::Anthropic, true),
            mk(3, "寫作夥伴", "改稿、翻譯、想標題。", "cloud", "purple", ProviderKind::OpenAi, true),
            helper,
            mk(4, "本機模型", "在你自己的電腦上跑，不用連網。", "hex", "brown", ProviderKind::Ollama, false),
        ]
    }

    /// A new install: no bots yet — the main window walks the person through making the first
    /// one (or signing in to bring their bots from another computer).
    pub fn first_run() -> State {
        State {
            bots: vec![],
            primary_bot: 0,
            selected: 0,
            next_id: 1,
            theme: Theme::Light,
            accent: Accent::Black,
            providers: Default::default(),
            sidebar_collapsed: false,
        embed_model: String::new(),
        doc_folders: vec![],
            sidebar_width: default_sidebar_width(),
            local_execution: false,
            remote_computers: vec![],
            auto_review: false,
            review_allow_rules: vec![],
            review_ask_rules: vec![],
            timezone: crate::routines::local_timezone(),
            next_routine_id: 1,
            notify: true,
            direct_mode: false,
            auto_update_when_away: true,
            channels: vec![],
            next_channel_id: 1,
            mcp_servers: vec![],
            skills: vec![],
            pages: vec![],
            next_page_id: 1,
            remote: Default::default(),
            language: auto_lang(),
            folders: vec![],
            pin_order: vec![],
            machine_label: String::new(),
            local_never: false,
            messages_send: true,
            messages_no_ask: false,
            loose_index: None,
            folded: vec![],
        }
    }

    /// The five sample bots (for pictures and tests, never a real first start).
    pub fn samples() -> State {
        State { bots: Self::sample_bots(), primary_bot: 1, selected: 1, next_id: 6, ..State::first_run() }
    }

    /// A filled-in state for the --screenshot picture (never saved).
    pub fn demo() -> State {
        let mut s = State::samples();
        let via = format!("{} · {}", ProviderKind::Xai.label(), ProviderKind::Xai.suggested_model());
        s.bots[0].messages = vec![
            Message::user("幫我規劃這週末去台南兩天一夜的行程"),
            Message {
                role: Role::Assistant,
                text: "好的！這是一個輕鬆的兩天一夜台南行程：\n\n# 第一天\n- 上午：赤崁樓、祀典武廟\n- 中午：國華街小吃（牛肉湯、碗粿）\n- 下午：神農街散步、林百貨\n- 晚上：花園夜市（週四、六、日）\n\n# 第二天\n- 上午：安平古堡、安平樹屋\n- 下午：四草綠色隧道搭船\n\n需要我幫你排交通和住宿嗎？".into(),
                thinking: "使用者想要週末兩天一夜，台南景點集中在中西區與安平。".into(),
                via: via.clone(),
                ..Default::default()
            },
            Message::user("換成用 Claude 回答看看，有什麼不同建議？"),
            Message::assistant("如果想避開人潮，可以這樣調整：\n\n- 第一天早上先去安平，避開中午的觀光團\n- 晚餐改到保安路，選擇比夜市多\n- 第二天加一站奇美博物館，下雨也不怕", "Claude · claude-opus-5-5"),
        ];
        s.bots[0].provider = ProviderKind::Anthropic;
        s.bots[0].model = ProviderKind::Anthropic.suggested_model().into();
        s.bots[1].unread = true;
        // Talking to the bot sets up a routine.
        let schedule = crate::routines::Schedule {
            frequency: crate::routines::Frequency::Weekly,
            interval: 1,
            days_of_week: crate::routines::WORKWEEK.iter().map(|d| d.to_string()).collect(),
            month_day: None,
            weekday_of_month: None,
            month: None,
            time: "09:00".into(),
            timezone: s.timezone.clone(),
            once: false,
            flexible: false,
        };
        let created = crate::routines::now();
        s.bots[1].routines = vec![crate::routines::Routine {
            id: 1,
            title: "AI 新聞早報".into(),
            prompt: "整理過去一天最重要的三則 AI 新聞，每則兩句話。".into(),
            next_run: crate::routines::next_run(&schedule, created, created),
            schedule,
            paused: false,
            created_at: created,
            last_run: None,
            computer: String::new(),
            trigger: None,
        }];
        s.next_routine_id = 2;
        s.bots[1].messages = vec![
            Message::user("每個工作日早上 9 點幫我整理 AI 新聞"),
            Message {
                role: Role::Assistant,
                via: "Claude · claude-opus-5-5".into(),
                tool_calls: vec![ToolCall { id: "r1".into(), name: "create_routine".into(), args: r#"{"title":"AI 新聞早報"}"#.into(), status: ToolStatus::Done }],
                ..Default::default()
            },
            Message::tool_result("r1", "create_routine", "已建立例行任務 #1「AI 新聞早報」：每個工作日 09:00"),
            Message::assistant("好，已經設定好了：每個工作日 09:00 我會整理三則重點給你。", "Claude · claude-opus-5-5"),
        ];
        s.bots[2].messages = vec![Message::user("幫我想五個標題"), Message::assistant("1. 慢慢走，才看得見風景…", "OpenAI · gpt-5")];
        // The computer helper mid-task: two tools done, one waiting for approval.
        let via = "Claude · claude-opus-5-5";
        let call = |id: &str, name: &str, args: &str, status| ToolCall { id: id.into(), name: name.into(), args: args.into(), status };
        s.bots[3].messages = vec![
            Message::user("幫我把下載資料夾裡的照片依照月份整理好"),
            Message {
                role: Role::Assistant,
                text: "我先看看有哪些照片。".into(),
                via: via.into(),
                tool_calls: vec![call("c1", "list_dir", r#"{"path":"~/Downloads"}"#, ToolStatus::Done)],
                ..Default::default()
            },
            Message::tool_result("c1", "list_dir", "IMG_0412.jpg  2.1 MB\nIMG_0533.jpg  3.4 MB\nIMG_0601.heic  1.8 MB\n… 共 48 個檔案"),
            Message {
                role: Role::Assistant,
                text: "找到 48 張照片，拍攝時間在 4 到 6 月。我會建立三個資料夾，再把照片搬進去。".into(),
                via: via.into(),
                tool_calls: vec![call("c2", "shell", r#"{"command":"mkdir -p 2026-04 2026-05 2026-06 && mv IMG_04*.jpg 2026-04/"}"#, ToolStatus::Waiting)],
                ..Default::default()
            },
        ];
        s.bots[3].default_computer = THIS_COMPUTER_NAME.into();
        s.local_execution = true;
        s.selected = 5;
        s
    }
}

/// Where a bot starts on this Mac (你的電腦) unless told otherwise.
pub fn default_workdir() -> String {
    dirs::home_dir().map(|h| h.display().to_string()).unwrap_or_default()
}

/// The sealed folder that is the bot's own computer.
pub fn bot_computer_dir(bot_id: u64) -> PathBuf {
    dirs::home_dir().unwrap_or_else(std::env::temp_dir).join("AnyBot 工作區").join(format!("bot-{bot_id}"))
}

#[cfg(test)]
mod start_tests {
    use super::*;

    /// 「儲存」 in a bot's settings puts on the bot what the person changed there, and leaves
    /// what the bot got while the settings were open.
    #[test]
    fn saving_a_bots_settings_keeps_what_it_got_meanwhile() {
        let mut bot = State::samples().bots.remove(0);
        bot.memories = vec!["喜歡靠窗".into(), "住台南".into()];
        bot.allow_rules = vec!["edit_file".into()];
        bot.messages = vec![Message::user("嗨")];
        bot.voice.clear();
        let from = bot.clone();
        // In the editor: a new name, one memory forgotten, a voice picked.
        let mut edited = from.clone();
        edited.name = "新名字".into();
        edited.memories.retain(|m| m != "喜歡靠窗");
        edited.voice = "Meijia".into();
        // Meanwhile, in the chat: an answer, something remembered, 「永遠允許」, a conversation
        // put aside, a folder to work in.
        bot.messages.push(Message::assistant("你好", "x"));
        bot.memories.push("咖啡不加糖".into());
        bot.allow_rules.push("shell:git".into());
        bot.threads.push(("舊對話".into(), vec![Message::user("之前")]));
        bot.workdir = "/tmp/work".into();
        bot.tools_enabled = !from.tools_enabled;
        bot.take_edit(from.clone(), edited);
        assert_eq!((bot.name.as_str(), bot.voice.as_str()), ("新名字", "Meijia"));
        assert_eq!(bot.memories, vec!["住台南".to_string(), "咖啡不加糖".to_string()]);
        assert_eq!(bot.allow_rules, vec!["edit_file".to_string(), "shell:git".to_string()]);
        assert_eq!((bot.messages.len(), bot.threads.len(), bot.workdir.as_str()), (2, 1, "/tmp/work"));
        assert_eq!(bot.tools_enabled, !from.tools_enabled);
        // A field emptied in the editor is emptied (it is left out of the file when empty).
        let from = bot.clone();
        let mut edited = bot.clone();
        edited.voice.clear();
        bot.take_edit(from, edited);
        assert_eq!(bot.voice, "");
    }

    /// Folding keeps the person's chat whole: each summary goes in at its fold, and the model's
    /// view starts at the newest one.
    #[test]
    fn folding_keeps_every_message() {
        let mut chat: Vec<Message> = (0..10).map(|i| Message { at: i + 1, ..if i % 2 == 0 { Message::user(&format!("問 {i}")) } else { Message::assistant(&format!("答 {i}"), "x") } }).collect();
        let sum = |t: &str, at| Message { summary: true, at, ..Message::assistant(t, "x") };
        // The turn folded the first 4 messages; the first it kept is 「問 4」 (at 5).
        fold_in(&mut chat, 4, sum("摘要一", 100), 5);
        assert_eq!(chat.len(), 11);
        assert!(chat[4].summary && chat[5].text == "問 4");
        assert_eq!(model_view_start(&chat), 4);
        // Again later: the model's view started at 「摘要一」; it folded 3 of it (the summary,
        // 問 4, 答 5) and kept from 「問 6」 (at 7).
        fold_in(&mut chat, 3, sum("摘要二", 200), 7);
        assert_eq!(chat.len(), 12);
        assert_eq!(chat.iter().filter(|m| m.summary).count(), 2);
        assert_eq!(model_view_start(&chat), 7);
        assert_eq!(chat[8].text, "問 6");
        assert_eq!(chat.iter().filter(|m| !m.summary).count(), 10, "nothing the person saw was removed");
        // A boundary the chat can't find: the fold lands by count within the model's view.
        fold_in(&mut chat, 2, sum("摘要三", 300), 9999);
        assert!(chat[9].summary && chat[9].text == "摘要三");
    }

    #[test]
    fn a_new_install_has_no_bots() {
        let mut s = State::first_run();
        assert!(s.bots.is_empty());
        s.fix_primary();
        assert_eq!((s.primary_bot, s.selected), (0, 0));
    }

    #[test]
    fn old_unused_sample_bots_go_away() {
        let mut s = State::samples();
        s.drop_untouched_samples();
        assert!(s.bots.is_empty());
        // Used once: they stay.
        let mut s = State::samples();
        s.bots[2].messages.push(Message::user("幫我改稿"));
        s.drop_untouched_samples();
        assert_eq!(s.bots.len(), 5);
        // Renamed: it stays.
        let mut s = State::samples();
        s.bots[0].name = "小幫手".into();
        s.drop_untouched_samples();
        assert_eq!(s.bots.len(), 5);
    }

    #[test]
    fn signing_in_takes_in_only_the_bots_not_here_yet() {
        let other = State::samples();
        let mut here = State::first_run();
        assert_eq!(here.take_in_bots(&other), 5);
        assert_eq!(here.primary_bot, here.bots[0].id);
        // The same bots again: nothing doubles.
        assert_eq!(here.take_in_bots(&other), 0);
        // A bot of the same name with a different chat is a different bot.
        let mut used = State::samples();
        used.bots[1].messages.push(Message::user("嗨"));
        assert_eq!(here.take_in_bots(&used), 1);
        let ids: std::collections::HashSet<u64> = here.bots.iter().map(|b| b.id).collect();
        assert_eq!(ids.len(), here.bots.len());
    }

    /// A save that is there but can't be read is kept, not taken for a first run (the next save
    /// wrote a fresh AnyBot over it).
    #[test]
    fn a_save_that_cannot_be_read_is_kept() {
        let d = std::env::temp_dir().join(format!("anybot-load-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&d);
        std::fs::create_dir_all(&d).unwrap();
        let p = d.join("state.json");
        let kept = |mark: &str| std::fs::read_dir(&d).unwrap().flatten().map(|e| e.path()).find(|f| f.to_string_lossy().contains(mark));
        // No save at all: a first run, and nothing is set aside.
        State::load_from(&p);
        assert_eq!(std::fs::read_dir(&d).unwrap().count(), 0);
        // Bytes that aren't text (a disk gone wrong): moved aside whole.
        let bytes = [0xff, 0xfe, 0x00, 0x41, 0xff];
        std::fs::write(&p, bytes).unwrap();
        State::load_from(&p);
        assert!(!p.exists());
        assert_eq!(std::fs::read(kept("unreadable").unwrap()).unwrap(), bytes);
        // Text that isn't a save: a copy is kept, as before.
        std::fs::write(&p, "{ not json").unwrap();
        State::load_from(&p);
        assert_eq!(std::fs::read_to_string(kept("damaged").unwrap()).unwrap(), "{ not json");
        // A good save loads.
        let mut s = State::samples();
        s.bots[0].name = "留著的".into();
        std::fs::write(&p, serde_json::to_string(&s).unwrap()).unwrap();
        assert_eq!(State::load_from(&p).bots[0].name, "留著的");
        let _ = std::fs::remove_dir_all(&d);
    }
}