agentmux_srv/server/agent_handlers/

core.rs

// Copyright 2025-2026, AgentMux Corp.
// SPDX-License-Identifier: Apache-2.0


use std::sync::Arc;
use chrono::Utc;

use crate::backend::rpc::engine::WshRpcEngine;
use crate::backend::rpc_types::{
    COMMAND_LIST_AGENTS, COMMAND_CREATE_AGENT, COMMAND_UPDATE_AGENT,
    COMMAND_DELETE_AGENT, COMMAND_GET_AGENT_CONTENT, COMMAND_SET_AGENT_CONTENT,
    COMMAND_GET_ALL_AGENT_CONTENT,
    COMMAND_IMPORT_AGENT_FROM_CLAW, COMMAND_IMPORT_AGENTS, COMMAND_EXPORT_AGENTS,
    COMMAND_RESEED_AGENTS,
    COMMAND_CONTAINER_RUNTIME_AVAILABLE, COMMAND_CONTAINER_IMAGE_CHECK,
    CommandContainerImageCheckData, ContainerImageCheckResult,
    CommandListAgentDefinitionsData,
    CommandContainerRuntimeAvailableData, CommandReseedAgentsData, CommandExportAgentsData,
    ContainerRuntimeAvailableResult, ReseedAgentsResult,
    CommandCreateAgentDefinitionData, CommandUpdateAgentDefinitionData, CommandDeleteAgentDefinitionData,
    CommandGetAgentContentData, CommandSetAgentContentData, CommandGetAllAgentContentData,
    CommandImportAgentFromClawData,
    CommandImportAgentDefinitionsData, ImportAgentDefinitionsResult,
    ExportAgentDefinitionsResult, AgentDefinitionExport, AgentSkillExport,
};
use crate::backend::storage::{AgentDefinition, AgentContent, AgentSkill};

use super::super::AppState;

pub fn register(engine: &Arc<WshRpcEngine>, state: &AppState) {
    // listagents → return all agent definitions, optionally filtered by
    // `is_seeded`. Filter input is backward-compatible: callers that
    // pass `null` / `{}` (every existing caller) get the full list.
    // The two-tier picker (Phase 1) passes `{ is_seeded: 0 }` for the
    // "My Agents" section and `{ is_seeded: 1 }` for the "Templates"
    // section — see SPEC_AGENT_PICKER_TWO_TIER_2026_05_24.md.
    //
    // Phase 2 (Q2 Decision Y — hide templates): templates with
    // `user_hidden = 1` are filtered out by default. Callers that want
    // them back (the settings panel's "Hidden templates" surface) pass
    // `include_hidden: true`. Hide filter applies ONLY to templates —
    // user-owned definitions are unaffected (their `user_hidden` is
    // always 0 by backend invariant; `agent_def_set_hidden` rejects
    // non-template ids).
    let mstore_lfa = state.mstore.clone();
    // NOT migrated to `register_typed`, deliberately. `register_typed`
    // deserializes the payload strictly and answers Err on failure, but this
    // command tolerates a null/malformed body on purpose: older clients never
    // sent one, and the server defaults a missing `data` field to
    // `Value::Null`, which cannot deserialize into a struct. Typing it would
    // turn "older client asks for the unfiltered list" into an RPC error.
    //
    // Same rule as `bundle.validate` and `widget.health`: a handler that
    // deliberately accepts loose input keeps its `Value` request. Its RESPONSE
    // is still `Vec<AgentDefinition>`, which IS generated -- that is where the
    // drift risk lived.
    engine.register_typed(COMMAND_LIST_AGENTS, move |data: serde_json::Value, _ctx| {
        let mstore = mstore_lfa.clone();
        async move {
                // unwrap_or_default — both `null` and `{}` deserialize
                // to the default (no filter). Anything malformed falls
                // back to no-filter rather than erroring; older clients
                // never sent a body for this RPC and we can't know
                // which JSON shape they're on.
                let cmd: CommandListAgentDefinitionsData =
                    serde_json::from_value(data).unwrap_or_default();
                let agents = mstore.agent_def_list().map_err(|e| format!("listagents: {e}"))?;
                let is_seeded_filter = cmd.is_seeded;
                let include_hidden = cmd.include_hidden;
                let filtered: Vec<_> = agents
                    .into_iter()
                    .filter(|a| match is_seeded_filter {
                        Some(flag) => a.is_seeded == flag,
                        None => true,
                    })
                    // Default behaviour: drop hidden templates. The
                    // settings panel opts back in with include_hidden.
                    // User-owned rows (is_seeded == 0) are never
                    // hideable; the conditional below is a no-op for
                    // them.
                    .filter(|a| {
                        include_hidden || a.is_seeded != 1 || a.user_hidden == 0
                    })
                    .collect();
                Ok(filtered)
        }
    });

    // createagent → insert new agent, broadcast agents:changed
    let mstore_cfa = state.mstore.clone();
    let id_store_cfa = state.id_store.clone();
    let broker_cfa = state.broker.clone();
    engine.register_typed(
        COMMAND_CREATE_AGENT,
        move |cmd: CommandCreateAgentDefinitionData, _ctx| {
            let mstore = mstore_cfa.clone();
            let id_store = id_store_cfa.clone();
            let broker = broker_cfa.clone();
            async move {
                let now = agentmux_common::time::now_ms();
                // slug is empty here — agent_def_insert auto-derives it
                // from name AND collision-resolves AND mutates the
                // struct so we serialize the resolved value back to
                // the frontend (not "").
                let mut agent = AgentDefinition {
                    id: uuid::Uuid::new_v4().to_string(),
                    slug: String::new(),
                    name: cmd.name,
                    icon: cmd.icon,
                    provider: cmd.provider,
                    description: cmd.description,
                    working_directory: cmd.working_directory,
                    shell: cmd.shell,
                    provider_flags: cmd.provider_flags,
                    auto_start: cmd.auto_start,
                    restart_on_crash: cmd.restart_on_crash,
                    idle_timeout_minutes: cmd.idle_timeout_minutes,
                    created_at: now,
                    agent_type: cmd.agent_type,
                    environment: cmd.environment,
                    agent_bus_id: cmd.agent_bus_id,
                    is_seeded: 0,
                    accounts: String::new(),
                    parent_id: String::new(),
                    branch_label: String::new(),
                    updated_at: now,
                    user_hidden: 0,
                    container_image: String::new(),
                    container_volumes: "[]".to_string(),
                    container_name: String::new(),
                    // Inert (see the field's doc); always 0.
                    use_ambient_login: 0,
                    // Not settable via this RPC yet — only `agent.define`
                    // (the App-API/MCP path) can set a model vendor override.
                    model_vendor_base_url: String::new(),
                    // Opt-in required. Toggled from the Warden Supervisor
                    // panel (not this RPC) once that ships.
                    auto_continue_enabled: 0,
                    memory_id: String::new(),
                    conversation_visibility: crate::backend::storage::agents::default_conversation_visibility(),
                };
                mstore.agent_def_insert(&mut agent).map_err(|e| format!("createagent: {e}"))?;
                // Every agent gets its own dedicated ABF bundle
                // (ARCHITECTURE_MANDATORY_ABF_RETHINK_2026_08_14.md §3.2).
                // Best-effort, same posture as the color assignment below.
                // Bundle goes into id_store (the effective identity/memory
                // store), not mstore — see agent_def_provision_and_bind_
                // bundle's own doc comment for why they must differ.
                mstore.agent_def_provision_and_bind_bundle(&id_store, &mut agent, now);
                // Assign the agent its display color at creation
                // (SPEC_AGENT_COLOR_2026_08_08.md). Best-effort: a failure
                // here shouldn't fail the create — agent.open assigns a
                // color on first open as the fallback.
                let _ = mstore.agent_content_set(&crate::backend::storage::store::AgentContent {
                    agent_id: agent.id.clone(),
                    content_type: "ui:color".to_string(),
                    content: crate::backend::agent_color::pick_agent_color(&agent.id).to_string(),
                    updated_at: now,
                });
                broker.publish_event::<crate::backend::mps_events::AgentsChanged>(&(), vec![], 0);
                Ok(agent)
            }
        },
    );

    // updateagent → update existing agent, broadcast agents:changed
    let mstore_ufa = state.mstore.clone();
    let broker_ufa = state.broker.clone();
    engine.register_typed(
        COMMAND_UPDATE_AGENT,
        move |cmd: CommandUpdateAgentDefinitionData, _ctx| {
            let mstore = mstore_ufa.clone();
            let broker = broker_ufa.clone();
            async move {
                // Fetch existing to preserve created_at
                let existing = mstore.agent_def_list().map_err(|e| format!("updateagent: {e}"))?;
                let old = existing.iter().find(|a| a.id == cmd.id)
                    .ok_or_else(|| format!("updateagent: agent {} not found", cmd.id))?;
                crate::server::app_api::check_provider_unchanged(&old.id, &old.provider, &cmd.provider)
                    .map_err(|e| format!("updateagent: {e}"))?;
                // Model vendor base URL: `None` (omitted) preserves the
                // stored value; `Some(url)` overrides it (including
                // `Some("")` to explicitly clear). Validated against the
                // (possibly also-updated) `cmd.provider` — same check
                // `agent.define` applies.
                let chosen_model_vendor_base_url = match &cmd.model_vendor_base_url {
                    Some(url) => {
                        crate::server::app_api::validate_vendor_base_url(&cmd.provider, url)
                            .map_err(|e| format!("updateagent: {e}"))?;
                        url.clone()
                    }
                    None => old.model_vendor_base_url.clone(),
                };
                // slug is preserved from the existing row — it's
                // immutable after creation. The update path never
                // accepts a new slug from the client.
                let mut agent = AgentDefinition {
                    id: cmd.id,
                    slug: old.slug.clone(),
                    name: cmd.name,
                    icon: cmd.icon,
                    provider: cmd.provider,
                    description: cmd.description,
                    working_directory: cmd.working_directory,
                    shell: cmd.shell,
                    provider_flags: cmd.provider_flags,
                    auto_start: cmd.auto_start,
                    restart_on_crash: cmd.restart_on_crash,
                    idle_timeout_minutes: cmd.idle_timeout_minutes,
                    created_at: old.created_at,
                    agent_type: cmd.agent_type,
                    environment: cmd.environment,
                    agent_bus_id: cmd.agent_bus_id,
                    is_seeded: old.is_seeded,
                    // Preserve existing accounts when the caller omits the field
                    // (cmd.accounts defaults to "" via #[serde(default)]). Callers
                    // that only update name/icon/etc. (AgentDefForm, AgentPicker rename)
                    // don't carry accounts, so falling back to old.accounts prevents
                    // silently wiping saved assignments.
                    accounts: if cmd.accounts.is_empty() { old.accounts.clone() } else { cmd.accounts },
                    // parent_id + branch_label describe provenance and
                    // are immutable post-insert (forks are separate rows,
                    // not in-place edits).
                    parent_id: old.parent_id.clone(),
                    branch_label: old.branch_label.clone(),
                    // Placeholder — agent_def_update self-stamps the real
                    // timestamp and writes it back into `agent` below, so
                    // the response body carries the fresh value.
                    updated_at: old.updated_at,
                    // Preserve user_hidden — updateagent edits the
                    // definition payload, not the per-user view-state
                    // flag. Hide/unhide go through their dedicated RPCs
                    // (`agentdefhide` / `agentdefunhide`). Phase 2 of
                    // SPEC_AGENT_PICKER_TWO_TIER_2026_05_24.md.
                    user_hidden: old.user_hidden,
                    // Preserve existing container config when the caller omits the field
                    // (cmd.container_image defaults to "" via #[serde(default)]). Callers
                    // that only update name/icon/etc. (AgentDefForm) don't carry container
                    // fields, so falling back to old values prevents silently wiping a
                    // container agent's image and volumes — same guard as `accounts` above.
                    container_image: if cmd.container_image.is_empty() { old.container_image.clone() } else { cmd.container_image },
                    container_volumes: if cmd.container_volumes == "[]" { old.container_volumes.clone() } else { cmd.container_volumes },
                    // container_name is server-managed; preserve the existing value.
                    container_name: old.container_name.clone(),
                    // Inert; carried over unchanged (see the field's doc).
                    use_ambient_login: old.use_ambient_login,
                    model_vendor_base_url: chosen_model_vendor_base_url,
                    // Preserve the auto-continue opt-in when the caller omits
                    // the field (Option — most callers only edit name/icon/
                    // accounts). The Warden Supervisor panel sends Some(0|1)
                    // to flip it.
                    auto_continue_enabled: cmd.auto_continue_enabled.unwrap_or(old.auto_continue_enabled),
                    // Immutable post-insert, same as slug/parent_id/branch_label
                    // above — agent_def_update's SET clause doesn't even
                    // touch this column, but the in-memory struct still
                    // needs the real value: it's what gets serialized back
                    // to the frontend as the "updated" agent.
                    memory_id: old.memory_id.clone(),
                    // Not yet exposed by this RPC's own command schema
                    // (CommandUpdateAgentData has no conversation_visibility
                    // field) — preserve the existing value, same as
                    // memory_id just above, rather than silently resetting
                    // a configured agent back to the default on an
                    // unrelated name/icon/accounts edit.
                    conversation_visibility: old.conversation_visibility.clone(),
                };
                let found = mstore.agent_def_update(&mut agent).map_err(|e| format!("updateagent: {e}"))?;
                if !found {
                    return Err(format!("updateagent: agent {} not found", agent.id));
                }
                broker.publish_event::<crate::backend::mps_events::AgentsChanged>(&(), vec![], 0);
                Ok(agent)
            }
        },
    );

    // deleteagent → delete agent by id, broadcast agents:changed
    let mstore_dfa = state.mstore.clone();
    let broker_dfa = state.broker.clone();
    let identity_store_dfa = state.identity_store.clone();
    let id_store_dfa = state.id_store.clone();
    engine.register_typed(
        COMMAND_DELETE_AGENT,
        move |cmd: CommandDeleteAgentDefinitionData, _ctx| {
            let mstore = mstore_dfa.clone();
            let broker = broker_dfa.clone();
            let identity_store = identity_store_dfa.clone();
            let id_store = id_store_dfa.clone();
            async move {
                mstore.agent_def_delete(&cmd.id).map_err(|e| format!("deleteagent: {e}"))?;
                super::purge_identity_store_rows(&identity_store, &id_store, &cmd.id, "deleteagent");
                broker.publish_event::<crate::backend::mps_events::AgentsChanged>(&(), vec![], 0);
                Ok(())
            }
        },
    );

    // containerruntimeavailable → does the Docker DAEMON answer a ping
    // right now? Returns `{ available: bool }`. The create-from-template
    // modal (via the frontend's shared toolchain-capabilities store) uses
    // this to gate/default the container runtime. Distinct from
    // `resolvecli docker`, which only confirms the CLI binary is on PATH —
    // that false-positives when Docker is installed but the daemon is
    // stopped, steering users into a container agent that can't start
    // (codex P1 on #1576). `ContainerRuntimeHandle::is_available()` retries
    // the connection on demand, so a daemon that came up or went down
    // since launch is reflected without an app restart.
    let container_manager_cra = state.container_manager.clone();
    engine.register_typed(
        COMMAND_CONTAINER_RUNTIME_AVAILABLE,
        move |_cmd: Option<CommandContainerRuntimeAvailableData>, _ctx| {
            let cm = container_manager_cra.clone();
            async move {
                let available = cm.is_available().await;
                Ok(ContainerRuntimeAvailableResult { available })
            }
        },
    );

    // containerimagecheck → can this image be had on this machine? Answers from
    // the daemon's own cache first, then an anonymous registry check, so the
    // create modal does not preselect a container that cannot start.
    let container_manager_cic = state.container_manager.clone();
    engine.register_typed(
        COMMAND_CONTAINER_IMAGE_CHECK,
        move |cmd: Option<CommandContainerImageCheckData>, _ctx| {
            let cm = container_manager_cic.clone();
            async move {
                let image = cmd.unwrap_or_default().image;
                let manager = cm.get().await;
                let status = crate::backend::container_image::check_image_access(manager.as_ref(), &image).await;
                Ok(ContainerImageCheckResult { status })
            }
        },
    );

    // getagentcontent → return a single content blob for an agent
    let mstore_gfc = state.mstore.clone();
    engine.register_typed(
        COMMAND_GET_AGENT_CONTENT,
        move |cmd: CommandGetAgentContentData, _ctx| {
            let mstore = mstore_gfc.clone();
            async move {
                let content = mstore.agent_content_get(&cmd.agent_id, &cmd.content_type)
                    .map_err(|e| format!("getagentcontent: {e}"))?;
                // `Option<AgentContent>`, not a hand-serialized Value: the schema
                // registry records the Resp type, so serializing here would have it
                // record `Value` and leave this one endpoint outside the drift net.
                // Serializes identically -- `None` is JSON null, matching the stub's
                // `Promise<AgentContent | null>`.
                Ok(content)
            }
        },
    );

    // setagentcontent → upsert a content blob, broadcast agentcontent:changed
    let mstore_sfc = state.mstore.clone();
    let broker_sfc = state.broker.clone();
    engine.register_typed(
        COMMAND_SET_AGENT_CONTENT,
        move |cmd: CommandSetAgentContentData, _ctx| {
            let mstore = mstore_sfc.clone();
            let broker = broker_sfc.clone();
            async move {
                let now = agentmux_common::time::now_ms();
                let content = AgentContent {
                    agent_id: cmd.agent_id,
                    content_type: cmd.content_type,
                    content: cmd.content,
                    updated_at: now,
                };
                mstore.agent_content_set(&content).map_err(|e| format!("setagentcontent: {e}"))?;
                broker.publish_event::<crate::backend::mps_events::AgentContentChanged>(&(), vec![], 0);
                Ok(content)
            }
        },
    );

    // getallagentcontent → return all content blobs for an agent
    let mstore_gafc = state.mstore.clone();
    engine.register_typed(
        COMMAND_GET_ALL_AGENT_CONTENT,
        move |cmd: CommandGetAllAgentContentData, _ctx| {
            let mstore = mstore_gafc.clone();
            async move {
                let contents = mstore.agent_content_get_all(&cmd.agent_id)
                    .map_err(|e| format!("getallagentcontent: {e}"))?;
                Ok(contents)
            }
        },
    );

    // ── Agent Import handler ───────────────────────────────────────────────

    // importagentfromclaw → read claw workspace, create agent + content
    let mstore_ifc = state.mstore.clone();
    let id_store_ifc = state.id_store.clone();
    let broker_ifc = state.broker.clone();
    engine.register_typed(
        COMMAND_IMPORT_AGENT_FROM_CLAW,
        move |cmd: CommandImportAgentFromClawData, _ctx| {
            let mstore = mstore_ifc.clone();
            let id_store = id_store_ifc.clone();
            let broker = broker_ifc.clone();
            async move {

                let workspace_path = std::path::Path::new(&cmd.workspace_path);
                if !workspace_path.exists() {
                    return Err(format!("importagentfromclaw: path does not exist: {}", cmd.workspace_path));
                }

                let now = agentmux_common::time::now_ms();

                // Detect provider from .claude/settings.json if present
                let mut provider = "claude".to_string();
                let settings_path = workspace_path.join(".claude").join("settings.json");
                if settings_path.exists() {
                    if let Ok(settings_str) = std::fs::read_to_string(&settings_path) {
                        if let Ok(settings) = serde_json::from_str::<serde_json::Value>(&settings_str) {
                            if let Some(p) = settings.get("provider").and_then(|v| v.as_str()) {
                                provider = p.to_string();
                            }
                        }
                    }
                }

                // Create the agent — slug is empty, agent_def_insert will
                // auto-derive from agent_name and mutate the struct
                // so the resolved slug is returned to the frontend.
                let mut agent = AgentDefinition {
                    id: uuid::Uuid::new_v4().to_string(),
                    slug: String::new(),
                    name: cmd.agent_name.clone(),
                    icon: "\u{2726}".to_string(),
                    provider,
                    description: format!("Imported from {}", cmd.workspace_path),
                    working_directory: cmd.workspace_path.clone(),
                    shell: String::new(),
                    provider_flags: String::new(),
                    auto_start: 0,
                    restart_on_crash: 0,
                    idle_timeout_minutes: 0,
                    created_at: now,
                    agent_type: "standalone".to_string(),
                    environment: String::new(),
                    agent_bus_id: String::new(),
                    is_seeded: 0,
                    accounts: String::new(),
                    parent_id: String::new(),
                    branch_label: String::new(),
                    updated_at: now,
                    user_hidden: 0,
                    container_image: String::new(),
                    container_volumes: "[]".to_string(),
                    container_name: String::new(),
                    use_ambient_login: 0,
                    model_vendor_base_url: String::new(),
                    auto_continue_enabled: 0,
                    memory_id: String::new(),
                    conversation_visibility: crate::backend::storage::agents::default_conversation_visibility(),
                };
                mstore.agent_def_insert(&mut agent).map_err(|e| format!("importagentfromclaw: {e}"))?;
                mstore.agent_def_provision_and_bind_bundle(&id_store, &mut agent, now);

                // Read CLAUDE.md → agentmd content
                let claude_md_path = workspace_path.join("CLAUDE.md");
                if claude_md_path.exists() {
                    if let Ok(content) = std::fs::read_to_string(&claude_md_path) {
                        let fc = AgentContent {
                            agent_id: agent.id.clone(),
                            content_type: "agentmd".to_string(),
                            content,
                            updated_at: now,
                        };
                        let _ = mstore.agent_content_set(&fc);
                    }
                }

                // Read .mcp.json → mcp content
                let mcp_path = workspace_path.join(".mcp.json");
                if mcp_path.exists() {
                    if let Ok(content) = std::fs::read_to_string(&mcp_path) {
                        let fc = AgentContent {
                            agent_id: agent.id.clone(),
                            content_type: "mcp".to_string(),
                            content,
                            updated_at: now,
                        };
                        let _ = mstore.agent_content_set(&fc);
                    }
                }

                broker.publish_event::<crate::backend::mps_events::AgentsChanged>(&(), vec![], 0);
                Ok(agent)
            }
        },
    );

    // reseedagents → delete all seeded agents and re-run seed from manifest
    let mstore_rsfa = state.mstore.clone();
    let broker_rsfa = state.broker.clone();
    engine.register_typed(
        COMMAND_RESEED_AGENTS,
        move |_cmd: Option<CommandReseedAgentsData>, _ctx| {
            let mstore = mstore_rsfa.clone();
            let broker = broker_rsfa.clone();
            async move {
                // Delete all previously seeded agents (cascade deletes content, skills, history)
                let deleted = mstore.agent_def_delete_seeded()
                    .map_err(|e| format!("reseedagents: delete seeded: {e}"))?;

                // Re-run seed
                let report = crate::backend::agent_seed::seed_agents(&mstore)
                    .map_err(|e| format!("reseedagents: seed: {e}"))?;

                broker.publish_event::<crate::backend::mps_events::AgentsChanged>(&(), vec![], 0);
                Ok(ReseedAgentsResult {
                    deleted,
                    created: report.created,
                    skipped: report.skipped,
                })
            }
        },
    );

    // importagents — bulk import from JSON export format
    let mstore_ifa = state.mstore.clone();
    let id_store_ifa = state.id_store.clone();
    let broker_ifa = state.broker.clone();
    engine.register_typed(
        COMMAND_IMPORT_AGENTS,
        move |cmd: CommandImportAgentDefinitionsData, _ctx| {
            let mstore = mstore_ifa.clone();
            let id_store = id_store_ifa.clone();
            let broker = broker_ifa.clone();
            async move {

                let now = agentmux_common::time::now_ms();

                let mut imported: Vec<String> = Vec::new();
                let mut skipped: Vec<String> = Vec::new();
                let mut failed: Vec<String> = Vec::new();

                for agent_import in cmd.agents {
                    // Check for existing agent by slug (id field from export)
                    let existing = mstore.agent_def_list()
                        .unwrap_or_default()
                        .into_iter()
                        .any(|a| a.slug == agent_import.id);

                    if existing {
                        skipped.push(agent_import.name.clone());
                        continue;
                    }

                    let mut agent = AgentDefinition {
                        id: uuid::Uuid::new_v4().to_string(),
                        slug: agent_import.id.clone(),
                        name: agent_import.name.clone(),
                        icon: agent_import.icon.clone(),
                        provider: agent_import.provider.clone(),
                        description: agent_import.description.clone(),
                        working_directory: agent_import.working_directory.clone(),
                        shell: agent_import.shell.clone(),
                        provider_flags: String::new(),
                        auto_start: 0,
                        restart_on_crash: if agent_import.restart_on_crash { 1 } else { 0 },
                        idle_timeout_minutes: 0,
                        created_at: now,
                        agent_type: agent_import.agent_type.clone(),
                        environment: agent_import.environment.clone(),
                        agent_bus_id: agent_import.agent_bus_id.clone(),
                        is_seeded: 0,
                        accounts: String::new(),
                        parent_id: String::new(),
                        branch_label: String::new(),
                        updated_at: now,
                        user_hidden: 0,
                        container_image: String::new(),
                        container_volumes: "[]".to_string(),
                        container_name: String::new(),
                        use_ambient_login: 0,
                        model_vendor_base_url: String::new(),
                        auto_continue_enabled: 0,
                        memory_id: String::new(),
                        conversation_visibility: crate::backend::storage::agents::default_conversation_visibility(),
                    };

                    if let Err(e) = mstore.agent_def_insert(&mut agent) {
                        failed.push(format!("{}: {e}", agent_import.name));
                        continue;
                    }
                    mstore.agent_def_provision_and_bind_bundle(&id_store, &mut agent, now);

                    // Insert content types
                    let mut content_ok = true;
                    for (content_type, content) in &agent_import.content {
                        let fc = AgentContent {
                            agent_id: agent.id.clone(),
                            content_type: content_type.clone(),
                            content: content.clone(),
                            updated_at: now,
                        };
                        if let Err(e) = mstore.agent_content_set(&fc) {
                            tracing::warn!("import: failed to set content for agent {}: {e}", agent.id);
                            content_ok = false;
                        }
                    }

                    // Insert skills
                    let mut skills_ok = true;
                    for skill_import in &agent_import.skills {
                        let skill = AgentSkill {
                            id: uuid::Uuid::new_v4().to_string(),
                            agent_id: agent.id.clone(),
                            name: skill_import.name.clone(),
                            trigger: skill_import.trigger.clone(),
                            skill_type: skill_import.skill_type.clone(),
                            description: skill_import.description.clone(),
                            content: skill_import.content.clone(),
                            created_at: now,
                        };
                        if let Err(e) = mstore.agent_skill_insert(&skill) {
                            tracing::warn!("import: failed to insert skill '{}' for agent {}: {e}", skill.name, agent.id);
                            skills_ok = false;
                        }
                    }

                    if content_ok && skills_ok {
                        imported.push(agent_import.name.clone());
                    } else {
                        failed.push(agent_import.name.clone());
                    }
                }

                broker.publish_event::<crate::backend::mps_events::AgentsChanged>(&(), vec![], 0);

                let result = ImportAgentDefinitionsResult { imported, skipped, failed };
                Ok(result)
            }
        },
    );

    // exportagents — export all agent definitions with content and skills
    let mstore_efa = state.mstore.clone();
    let id_store_efa = state.id_store.clone();
    engine.register_typed(
        COMMAND_EXPORT_AGENTS,
        move |_cmd: Option<CommandExportAgentsData>, _ctx| {
            let mstore = mstore_efa.clone();
            let id_store = id_store_efa.clone();
            async move {
                let agents = mstore.agent_def_list()
                    .map_err(|e| format!("exportagents: list: {e}"))?;

                let mut agent_exports: Vec<AgentDefinitionExport> = Vec::new();

                for agent in agents {
                    let content_map = mstore.agent_content_get_all(&agent.id)
                        .unwrap_or_default()
                        .into_iter()
                        .map(|fc| (fc.content_type, fc.content))
                        .collect::<std::collections::HashMap<String, String>>();

                    let skills = mstore.agent_skill_list(&agent.id)
                        .unwrap_or_default()
                        .into_iter()
                        .map(|s| AgentSkillExport {
                            name: s.name,
                            trigger: s.trigger,
                            skill_type: s.skill_type,
                            description: s.description,
                            content: s.content,
                        })
                        .collect::<Vec<_>>();

                    // The provider the agent runs, from the shared resolver
                    // (#2594; SPEC_AGENT_BUNDLE_FORMAT_V0_3_2026_10_05.md §3.1): `importagents` gives it to the new
                    // agent, so the import runs the same CLI.
                    let effective_provider = id_store.resolve_effective_provider_id(&agent);
                    agent_exports.push(AgentDefinitionExport {
                        id: agent.slug.clone(),
                        name: agent.name,
                        icon: agent.icon,
                        description: agent.description,
                        provider: effective_provider,
                        shell: agent.shell,
                        working_directory: agent.working_directory,
                        agent_bus_id: agent.agent_bus_id,
                        agent_type: agent.agent_type,
                        environment: agent.environment,
                        restart_on_crash: agent.restart_on_crash != 0,
                        content: content_map,
                        skills,
                    });
                }

                let exported_at = Utc::now().to_rfc3339();

                let result = ExportAgentDefinitionsResult {
                    version: 4,
                    exported_at,
                    source: "agentmux-export".to_string(),
                    agents: agent_exports,
                };
                Ok(result)
            }
        },
    );

}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::backend::rpc_types::RpcMessage;
    use crate::backend::storage::bundles::Bundle;
    use crate::server::tests::test_state;

    fn seed_bundle(state: &AppState, id: &str, provider: &str) {
        let bundle = Bundle {
            id: id.to_string(),
            name: "Bundle".to_string(),
            description: String::new(),
            is_blank: false,
            is_global: false,
            provider: provider.to_string(),
            model: String::new(),
            instructions: String::new(),
            instructions_by_provider: "{}".to_string(),
            context_files: "[]".to_string(),
            mcp_servers: "[]".to_string(),
            skills: "[]".to_string(),
            sort_order: 0,
            created_at: 0,
            updated_at: 0,
            is_system: false,
        };
        state.id_store.bundle_upsert(&bundle).unwrap();
    }

    // The agent says "codex"; its bound bundle, from before bundles stopped
    // carrying a harness, says "claude". The agent owns its harness
    // (SPEC_AGENT_BUNDLE_FORMAT_V0_3_2026_10_05.md §3.1), so the export
    // carries "codex", which `importagents` gives the imported agent.
    fn seed_drifted_agent(state: &AppState, def_id: &str, bundle_id: &str) {
        let mut def = AgentDefinition {
            conversation_visibility: crate::backend::storage::agents::default_conversation_visibility(),
            id: def_id.to_string(),
            slug: def_id.to_string(),
            name: "Drifted Agent".to_string(),
            icon: String::new(),
            provider: "codex".to_string(),
            description: String::new(),
            working_directory: String::new(),
            shell: String::new(),
            provider_flags: String::new(),
            auto_start: 0,
            restart_on_crash: 0,
            idle_timeout_minutes: 0,
            created_at: 0,
            agent_type: "host".to_string(),
            environment: String::new(),
            agent_bus_id: String::new(),
            is_seeded: 0,
            accounts: String::new(),
            parent_id: String::new(),
            branch_label: String::new(),
            updated_at: 0,
            user_hidden: 0,
            container_image: String::new(),
            container_volumes: "[]".to_string(),
            container_name: String::new(),
            use_ambient_login: 0,
            auto_continue_enabled: 0,
            model_vendor_base_url: String::new(),
            memory_id: bundle_id.to_string(),
        };
        state.mstore.agent_def_insert(&mut def).unwrap();
    }

    #[tokio::test]
    async fn exportagents_carries_the_agents_own_provider_not_its_bundles() {
        let state = test_state();
        seed_bundle(&state, "bundle-claude", "claude");
        seed_drifted_agent(&state, "agent-drift", "bundle-claude");

        let (engine, mut output_rx) = WshRpcEngine::new();
        register(&engine, &state);

        engine.handle_message(RpcMessage {
            command: COMMAND_EXPORT_AGENTS.to_string(),
            reqid: "req-1".to_string(),
            data: Some(serde_json::json!({})),
            ..Default::default()
        });
        let resp = tokio::time::timeout(std::time::Duration::from_secs(2), output_rx.recv())
            .await
            .unwrap()
            .unwrap();
        assert!(resp.error.is_empty(), "unexpected error: {}", resp.error);
        let result: ExportAgentDefinitionsResult =
            serde_json::from_value(resp.data.expect("expected result data")).unwrap();

        let exported = result
            .agents
            .iter()
            .find(|a| a.id == "agent-drift")
            .expect("exported agent should be present");
        assert_eq!(
            exported.provider, "codex",
            "the agent owns its harness; the bundle's provider is a hint (SPEC_AGENT_BUNDLE_FORMAT_V0_3_2026_10_05.md §3.1)"
        );
    }
}