futucli/

main.rs

//! FutuOpenD-rs 命令行客户端
//!
//! 连接到运行中的 `futu-opend` 网关，提供行情查询、订阅、交易等子命令，
//! 以及交互式 REPL（`futucli repl`）。

mod cli;
mod cmd;
mod common;
mod output;

use anyhow::Result;
use clap::{Error as ClapError, Parser};
use serde_json::json;
use tracing_subscriber::Layer;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{EnvFilter, fmt};

use crate::cli::Cli;
use crate::output::OutputFormat;

#[tokio::main]
async fn main() {
    let cli = match Cli::try_parse() {
        Ok(cli) => cli,
        Err(err) => {
            if err.exit_code() == 0 {
                err.exit();
            }
            let output =
                detect_output_format_from_args(std::env::args()).unwrap_or(OutputFormat::Table);
            if matches!(output, OutputFormat::Json | OutputFormat::Jsonl) {
                emit_cli_parse_error(output, &err);
                std::process::exit(err.exit_code());
            }
            err.exit();
        }
    };
    let output = cli.output;

    if let Err(err) = run(cli).await {
        emit_cli_error(output, &err);
        std::process::exit(1);
    }
}

fn emit_cli_parse_error(format: OutputFormat, err: &ClapError) {
    let value = cli_usage_error_json(&err.to_string());
    match format {
        OutputFormat::Json => match serde_json::to_string_pretty(&value) {
            Ok(s) => println!("{s}"),
            Err(_) => eprintln!("{err}"),
        },
        OutputFormat::Jsonl => match serde_json::to_string(&value) {
            Ok(s) => println!("{s}"),
            Err(_) => eprintln!("{err}"),
        },
        OutputFormat::Table => eprintln!("{err}"),
    }
}

async fn run(cli: Cli) -> Result<()> {
    let log_level = if cli.verbose {
        "debug"
    } else if matches!(cli.output, OutputFormat::Json | OutputFormat::Jsonl) {
        "error"
    } else {
        "warn"
    };
    let machine_output = matches!(cli.output, OutputFormat::Json | OutputFormat::Jsonl);
    let env_filter = if machine_output && !cli.verbose {
        EnvFilter::new(log_level)
    } else {
        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(log_level))
    };

    // 主 fmt layer 写 stderr（CLI 输出不能污染 stdout，stdout 给 table/JSON 用）
    let stderr_layer = fmt::layer()
        .with_timer(futu_core::log::LocalRfc3339Timer)
        .with_writer(std::io::stderr);

    // v1.2：可选 audit JSONL 层（target = futu_audit 的 event 单独写文件 / 目录）
    let _audit_guard = match cli.audit_log.as_deref() {
        Some(path) => match futu_auth::audit::open_writer(path) {
            Ok((nb_writer, guard)) => {
                let audit_layer = fmt::layer()
                    .json()
                    .with_timer(futu_core::log::LocalRfc3339Timer)
                    .with_writer(nb_writer)
                    .with_filter(tracing_subscriber::filter::filter_fn(|meta| {
                        meta.target() == futu_auth::audit::TARGET
                    }));
                tracing_subscriber::registry()
                    .with(env_filter)
                    .with(stderr_layer)
                    .with(audit_layer)
                    .init();
                Some(guard)
            }
            Err(e) => {
                eprintln!("warning: failed to open audit log {path:?}: {e}");
                tracing_subscriber::registry()
                    .with(env_filter)
                    .with(stderr_layer)
                    .init();
                None
            }
        },
        None => {
            tracing_subscriber::registry()
                .with(env_filter)
                .with(stderr_layer)
                .init();
            None
        }
    };

    // REPL 走专门入口（避免 dispatch 里 async 递归）
    if matches!(cli.command, cli::Command::Repl) {
        return cmd::repl::run(&cli.gateway, cli.output).await;
    }

    cli::dispatch(&cli.gateway, cli.output, cli.command).await
}

fn emit_cli_error(format: OutputFormat, err: &anyhow::Error) {
    let message = if matches!(format, OutputFormat::Json | OutputFormat::Jsonl) {
        format_error_chain_for_machine(err)
    } else {
        err.to_string()
    };
    let kind = classify_error_kind(&message);
    let value = cli_error_json(kind, &message);
    match format {
        OutputFormat::Json => match serde_json::to_string_pretty(&value) {
            Ok(s) => println!("{s}"),
            Err(_) => eprintln!("Error: {message}"),
        },
        OutputFormat::Jsonl => match serde_json::to_string(&value) {
            Ok(s) => println!("{s}"),
            Err(_) => eprintln!("Error: {message}"),
        },
        OutputFormat::Table => eprintln!("Error: {message}"),
    }
}

fn format_error_chain_for_machine(err: &anyhow::Error) -> String {
    let mut parts = Vec::new();
    for cause in err.chain() {
        let s = cause.to_string();
        if parts.last() != Some(&s) {
            parts.push(s);
        }
    }
    parts.join(": ")
}

fn cli_error_json(kind: &str, message: &str) -> serde_json::Value {
    let machine_error_field = futu_surface_spec::ErrorContract::STANDARD.machine_error_field;
    let mut value = json!({ "ok": false });
    if let Some(obj) = value.as_object_mut() {
        obj.insert(
            machine_error_field.to_string(),
            json!({
                "kind": kind,
                "message": message,
            }),
        );
    }
    value
}

fn cli_usage_error_json(message: &str) -> serde_json::Value {
    cli_error_json("cli_usage_error", message)
}

fn detect_output_format_from_args<I, S>(args: I) -> Option<OutputFormat>
where
    I: IntoIterator<Item = S>,
    S: AsRef<str>,
{
    let mut iter = args.into_iter().map(|s| s.as_ref().to_string()).peekable();
    while let Some(arg) = iter.next() {
        if arg == "-o" || arg == "--output" {
            if let Some(next) = iter.next() {
                return parse_output_format_token(&next);
            }
            return None;
        }
        if let Some(value) = arg.strip_prefix("--output=") {
            return parse_output_format_token(value);
        }
        if let Some(value) = arg.strip_prefix("-o=") {
            return parse_output_format_token(value);
        }
        if let Some(value) = arg.strip_prefix("-o")
            && !value.is_empty()
        {
            return parse_output_format_token(value);
        }
    }
    None
}

fn parse_output_format_token(value: &str) -> Option<OutputFormat> {
    match value.to_ascii_lowercase().as_str() {
        "json" => Some(OutputFormat::Json),
        "jsonl" => Some(OutputFormat::Jsonl),
        "table" => Some(OutputFormat::Table),
        _ => None,
    }
}

fn classify_error_kind(message: &str) -> &'static str {
    if message.contains("connect to futu gateway") {
        futu_surface_spec::ErrorContract::STANDARD.gateway_unreachable_kind
    } else {
        "cli_error"
    }
}

#[cfg(test)]
mod tests;