Function cmd_start_inner

src/main.rs:674–769

(config_path: &str)

}

async fn cmd_start_inner(config_path: &str) -> Result<(), Box<dyn std::error::Error>> {
    // Validate configuration
    let path = PathBuf::from(config_path);
    ensure_config_migrated(&path)?;
    let config = Config::from_file(&path)
        .map_err(|e| format!("Failed to load configuration from '{}': {}", config_path, e))?;

    // Build OAuth registry if any OAuth providers are configured
    let oauth_registry = build_oauth_registry(&config).await?;
    let app_state = AppState::from_config_with_registry(&config, Some(oauth_registry))
        .map_err(|e| format!("Failed to initialize app state: {e}"))?;

    tui::print_success("Configuration validated successfully.");

    // Ensure runtime directories exist (for log files)
    process::ensure_runtime_dirs()?;

    let env_filter: tracing_subscriber::EnvFilter = config
        .log_level
        .parse()
        .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info"));
    tracing_subscriber::fmt()
        .with_env_filter(env_filter)
        .with_target(true)
        .init();

    let listen_addr = config
        .resolved_listen_addr()
        .map_err(|e| format!("invalid server environment override: {e}"))?;

    info!(
        listen = %listen_addr,
        upstream = config.upstream.openai_base_url,
        keys = config.keys.len(),
        oauth_providers = config.oauth_providers.len(),
        "ClawShell starting"
    );
    debug!(
        dlp_patterns = config.dlp.patterns.len(),
        scan_responses = config.dlp.scan_responses,
        log_level = %config.log_level,
        "Configuration loaded"
    );

    // Spawn background OAuth refresh tasks
    let cancel = tokio_util::sync::CancellationToken::new();
    app_state.oauth_registry.spawn_refresh_tasks(cancel.clone());

    // Periodically persist stats counters so they survive restarts.
    let stats_for_task = app_state.stats.clone();
    let stats_cancel = cancel.clone();
    tokio::spawn(async move {
        let interval = std::time::Duration::from_secs(30);
        loop {
            tokio::select! {
                _ = stats_cancel.cancelled() => break,
                _ = tokio::time::sleep(interval) => {
                    if let Err(err) = stats_for_task.persist() {