Struct AppManager 

pub struct AppManager { /* private fields */ }

Application lifecycle manager.

Tracks installed applications and their lifecycle state. Agent spawning and service starting are delegated to the supervisor and container manager respectively – those integrations are wired in the kernel boot sequence.

When a persist path is configured (see Self::with_persist_path), installed apps survive kernel restarts via an atomic on-disk manifest store (same pattern as cluster peer membership).

Implementations

impl AppManager

pub fn new() -> Self

Create a new application manager.

pub fn with_persist_path(self, path: impl AsRef<Path>) -> Self

Enable installed-app persistence at the given path (builder style).

If the file exists and is readable, apps are rehydrated into the in-memory map so installs survive kernel restarts. Parse errors log a warning and leave the map empty. Subsequent mutations write back to the same path via Self::persist.

Runtime handles (agent PIDs, service names) are cleared on rehydrate, and transient lifecycle states (Starting / Running / Stopping) are normalized to Stopped because those processes do not survive a kernel restart.

pub fn set_chain_manager(&mut self, chain_manager: Option<Arc<ChainManager>>)

Attach a chain manager for audit logging.

pub fn set_governance_gate(&mut self, gate: Option<Arc<GovernanceGate>>)

Attach a governance gate for policy enforcement.

pub fn install(&self, manifest: AppManifest) -> Result<String, AppError>

Register an application from a parsed manifest.

The app is placed in the Installed state. Call transition_to to advance the state (e.g., to Starting or Running).

Errors

Returns AppError::AlreadyInstalled if an app with the same name is already registered.

pub fn transition_to( &self, name: &str, new_state: AppState, ) -> Result<(), AppError>

Transition an app to a new state.

Validates that the transition is legal per the state machine:

• Installed -> Starting
• Starting -> Running | Failed
• Running -> Stopping
• Stopping -> Stopped | Failed
• Stopped -> Starting

Errors

Returns AppError::NotFound or AppError::InvalidState.

pub fn add_agent_pid(&self, name: &str, pid: Pid) -> Result<(), AppError>

Record an agent PID for a running app.

pub fn add_service_name( &self, name: &str, service_name: String, ) -> Result<(), AppError>

Record a service name for a running app.

pub fn remove(&self, name: &str) -> Result<AppManifest, AppError>

Remove an installed application.

The app must be in Installed, Stopped, or Failed state.

pub fn list(&self) -> Vec<(String, AppState, String)>

List all installed applications.

pub fn inspect(&self, name: &str) -> Result<InstalledApp, AppError>

Get details for an installed application.

pub fn len(&self) -> usize

Get the number of installed apps.

pub fn is_empty(&self) -> bool

Check whether any apps are installed.

pub fn namespaced_agent_ids(manifest: &AppManifest) -> Vec<String>

Get namespaced agent IDs for an app’s manifest.

Returns IDs in the form app-name/agent-id.

pub fn namespaced_tool_names(manifest: &AppManifest) -> Vec<String>

Get namespaced tool names for an app’s manifest.

Returns names in the form app-name/tool-name.

pub fn start(&self, name: &str) -> Result<Vec<SpawnRequest>, AppError>

Start an installed or stopped application.

Transitions the app through Starting to Running and builds SpawnRequests for each agent declared in the manifest. The caller (kernel boot / CLI) is responsible for executing the spawn requests via the [AgentSupervisor].

Returns the list of spawn requests so the caller can hand them to the supervisor.

Errors

Returns AppError::NotFound if the app is not installed, or AppError::InvalidState if the app is not in Installed or Stopped state.

pub fn stop(&self, name: &str) -> Result<(), AppError>

Stop a running application.

Transitions Running -> Stopping -> Stopped and clears the recorded agent PIDs and service names.

Errors

Returns AppError::NotFound or AppError::InvalidState.

pub fn build_spawn_requests(manifest: &AppManifest) -> Vec<SpawnRequest>

Build SpawnRequests for every agent declared in a manifest.

Each request carries the agent’s capabilities from the manifest and a namespaced agent ID (app-name/agent-id).

Trait Implementations

impl Default for AppManager

fn default() -> Self

Returns the “default value” for a type.