futucli/cmd/account/

list.rs

use std::path::Path;

#[cfg(unix)]
use std::io::Read;

#[cfg(unix)]
use anyhow::Context;
use anyhow::{Result, bail};
use serde::Serialize;
use tabled::{Table, Tabled, settings::Style};

use crate::cmd::account_view::{
    acc_role_label, acc_status_label, acc_type_label, account_display_label,
    account_market_list_label, display_security_firm_label, env_label, market_label,
    security_firm_label, visible_card_num,
};
use crate::common::connect_gateway;
use crate::output::OutputFormat;
use futu_core::account_locator;

use super::parse_trd_market;

#[derive(Clone, Tabled)]
struct AccRow {
    #[tabled(rename = "Acc ID")]
    acc_id: String,
    #[tabled(rename = "Card Num")]
    card: String,
    #[tabled(rename = "Env")]
    env: String,
    #[tabled(rename = "Broker")]
    broker: String,
    #[tabled(rename = "Type")]
    acc_type: String,
    #[tabled(rename = "Status")]
    status: String,
    #[tabled(rename = "Label")]
    label: String,
    #[tabled(rename = "Markets")]
    markets: String,
}

#[derive(Tabled)]
struct AccGroupedRow {
    #[tabled(rename = "Acc ID")]
    acc_id: String,
    #[tabled(rename = "Card Num")]
    card: String,
    #[tabled(rename = "Env")]
    env: String,
    #[tabled(rename = "Type")]
    acc_type: String,
    #[tabled(rename = "Status")]
    status: String,
    #[tabled(rename = "Label")]
    label: String,
    #[tabled(rename = "Markets")]
    markets: String,
}

#[derive(Serialize)]
pub(super) struct AccJson {
    /// Keep account ids as strings in machine-readable CLI output.
    ///
    /// FTAPI uses uint64 account ids, but many downstream JSON consumers
    /// (browser devtools, spreadsheet importers, JS scripts) round integers
    /// above 2^53. The table output already uses `to_string()`; JSON follows
    /// the same lossless presentation here.
    pub(super) acc_id: String,
    pub(super) trd_env: i32,
    pub(super) env_label: &'static str,
    pub(super) trd_market_auth_list: Vec<i32>,
    pub(super) trd_market_auth_labels: Vec<&'static str>,
    pub(super) acc_type: Option<i32>,
    pub(super) acc_type_label: Option<&'static str>,
    pub(super) card_num: Option<String>,
    pub(super) security_firm: Option<i32>,
    pub(super) security_firm_label: Option<&'static str>,
    pub(super) sim_acc_type: Option<i32>,
    pub(super) acc_status: Option<i32>,
    pub(super) acc_status_label: Option<&'static str>,
    pub(super) acc_role: Option<i32>,
    pub(super) acc_role_label: Option<&'static str>,
    pub(super) acc_label: Option<String>,
    pub(super) acc_label_label: Option<String>,
    pub(super) competition_acc_name: Option<String>,
    pub(super) jp_acc_type: Vec<i32>,
}

pub(super) fn app_visible_card_num_resolution(
    accs: &[futu_trd::account::TrdAcc],
    card_num: &str,
) -> Result<account_locator::CardNumResolution> {
    Ok(account_locator::resolve_card_num_in_records(
        accs, card_num, None,
    )?)
}

#[cfg(unix)]
// A decimal u64 needs at most 20 digits; 128 leaves room for a trailing line
// ending while bounding reads from a concurrently modified local file.
const MAX_PRIVATE_ACCOUNT_ID_FILE_BYTES: u64 = 128;

/// Read an account id without placing the value in process argv.
///
/// On Unix the opened descriptor itself is checked after `O_NOFOLLOW`: it must
/// be an owner-only (`0600`) regular file owned by the effective user, with a
/// single hard link. This ordering avoids a path `stat`/open TOCTOU window.
/// Other platforms fail closed because this exact owner/mode/no-follow contract
/// has no portable `std` equivalent.
#[cfg(unix)]
pub(crate) fn read_private_account_id_file(path: &Path) -> Result<u64> {
    use std::os::unix::fs::{MetadataExt, OpenOptionsExt};

    let mut options = std::fs::OpenOptions::new();
    options.read(true);
    options.custom_flags(libc::O_CLOEXEC | libc::O_NOFOLLOW);

    let file = options
        .open(path)
        .with_context(|| format!("cannot securely open --acc-id-file {}", path.display()))?;
    let meta = file
        .metadata()
        .context("cannot inspect opened --acc-id-file")?;
    if !meta.is_file() {
        bail!("--acc-id-file must be a regular file");
    }
    if meta.len() == 0 || meta.len() > MAX_PRIVATE_ACCOUNT_ID_FILE_BYTES {
        bail!("--acc-id-file must contain 1..=128 bytes");
    }

    if meta.mode() & 0o7777 != 0o600 {
        bail!("--acc-id-file must have exact mode 0600");
    }
    // SAFETY: geteuid has no preconditions and only reads process identity.
    let effective_uid = unsafe { libc::geteuid() };
    if meta.uid() != effective_uid {
        bail!("--acc-id-file must be owned by the current user");
    }
    if meta.nlink() != 1 {
        bail!("--acc-id-file must have exactly one hard link");
    }

    let mut bytes = Vec::with_capacity(meta.len() as usize);
    file.take(MAX_PRIVATE_ACCOUNT_ID_FILE_BYTES + 1)
        .read_to_end(&mut bytes)
        .context("cannot read --acc-id-file")?;
    if bytes.len() as u64 > MAX_PRIVATE_ACCOUNT_ID_FILE_BYTES {
        bail!("--acc-id-file exceeds 128 bytes");
    }
    let value = std::str::from_utf8(&bytes)
        .map(str::trim)
        .ok()
        .filter(|value| !value.is_empty() && value.bytes().all(|byte| byte.is_ascii_digit()))
        .and_then(|value| value.parse::<u64>().ok())
        .filter(|value| *value > 0)
        .ok_or_else(|| {
            anyhow::anyhow!("--acc-id-file must contain one positive decimal account id")
        })?;
    Ok(value)
}

#[cfg(not(unix))]
pub(crate) fn read_private_account_id_file(_path: &Path) -> Result<u64> {
    bail!(
        "--acc-id-file is supported only on Unix, where owner and exact mode 0600 can be verified"
    )
}

pub async fn resolve_account_locator(
    gateway: &str,
    acc_id: Option<u64>,
    acc_id_file: Option<&Path>,
    card_num: Option<&str>,
    command: &str,
) -> Result<u64> {
    let acc_id = match acc_id_file {
        Some(path) => {
            if acc_id.is_some() || card_num.is_some() {
                bail!(
                    "{command}: --acc-id-file cannot be combined with --acc-id, a positional account id, or --card-num"
                );
            }
            Some(read_private_account_id_file(path)?)
        }
        None => acc_id,
    };
    let Some(card_num) = card_num else {
        return acc_id.ok_or_else(|| {
            anyhow::anyhow!(
                "{command}: 需要 --acc-id <ACC_ID>、--acc-id-file <MODE_0600_FILE> 或 --card-num <CARD_NUM>"
            )
        });
    };

    let (client, _push_rx) = connect_gateway(gateway, "futucli-card-num-resolve").await?;
    let raw_accs = futu_trd::account::get_acc_list_for_account_discovery(&client).await?;
    let app_visible_accs = futu_trd::account::app_visible_accounts(raw_accs);
    let resolution = app_visible_card_num_resolution(&app_visible_accs, card_num)?;

    let resolved = match resolution {
        account_locator::CardNumResolution::NotFound => bail!(
            "{command}: card_num 在 App 可见账户集合中找不到。请运行 `futucli account` \
             确认 Card Num，或改用 `--acc-id`；排障时可用 `futucli account --all` 查看 raw discovery"
        ),
        account_locator::CardNumResolution::Resolved(only) => only,
        account_locator::CardNumResolution::Ambiguous(many) => bail!(
            "{command}: card_num 匹配 {} 个账户 ({})，请改用 16 位完整卡号或 `--acc-id`",
            many.len(),
            many.iter()
                .map(u64::to_string)
                .collect::<Vec<_>>()
                .join(", ")
        ),
    };

    if let Some(explicit) = acc_id
        && explicit != resolved
    {
        bail!(
            "{command}: --acc-id ({explicit}) 与 --card-num 解析结果 ({resolved}) 不一致；\
             请只传一个，或确认它们指向同一账户"
        );
    }

    Ok(resolved)
}

pub(super) fn parse_account_market_filter(s: &str) -> Result<Option<i32>> {
    match s.trim().to_ascii_lowercase().as_str() {
        "" | "all" | "*" | "none" => Ok(None),
        _ => Ok(Some(parse_trd_market(s)? as i32)),
    }
}

pub(super) fn parse_account_security_firm_filter(s: &str) -> Result<Option<i32>> {
    let normalized = s.trim().to_ascii_lowercase().replace(['_', '-'], "");
    let firm = match normalized.as_str() {
        "" | "all" | "*" | "none" => return Ok(None),
        "futuhk" | "futusecurities" | "hk" | "1" => 1,
        "futuinc" | "futuus" | "us" | "moomoo" | "mm" | "2" => 2,
        "futusg" | "sg" | "3" => 3,
        "futuau" | "au" | "4" => 4,
        "futuca" | "ca" | "5" => 5,
        "futumy" | "my" | "6" => 6,
        "futujp" | "jp" | "7" => 7,
        other => bail!(
            "unknown security firm {other:?} \
             (FutuHK|FutuInc|FutuUS|FutuSG|FutuAU|FutuCA|FutuMY|FutuJP|hk|us|sg|au|ca|my|jp|1..7|all)"
        ),
    };
    Ok(Some(firm))
}

pub(super) fn account_matches_sdk_filter(
    a: &futu_trd::account::TrdAcc,
    market_filter: Option<i32>,
    security_firm_filter: Option<i32>,
) -> bool {
    // Official Python SDK applies `filter_trdmarket` and `security_firm`
    // locally after Trd_GetAccList. Sim accounts are environment-level demo
    // rows and may carry security_firm=0/None, but SDK HK/US account panels
    // still keep the matching sim market rows. Therefore broker filtering is
    // only meaningful for real rows; market filtering remains mandatory when
    // requested.
    let market_ok = match market_filter {
        Some(market) => a.trd_market_auth_list.contains(&market),
        None => true,
    };
    let firm_ok = match (security_firm_filter, a.trd_env, a.security_firm) {
        (Some(_), env, _) if env != 1 => true,
        (Some(expected), _, Some(actual)) => actual == expected,
        (Some(_), _, None) => true,
        (None, _, _) => true,
    };
    market_ok && firm_ok
}

fn acc_group_label(row: &AccRow) -> &'static str {
    if row.env == "simulate" {
        "模拟账户"
    } else if row.status == "active" {
        "真实账户"
    } else {
        "已禁用账户"
    }
}

fn print_account_grouped_tables(rows: &[AccRow]) -> std::io::Result<()> {
    if rows.is_empty() {
        println!("(empty)");
        return Ok(());
    }

    let mut broker_order: Vec<&str> = Vec::new();
    for row in rows {
        if !broker_order.iter().any(|b| *b == row.broker) {
            broker_order.push(&row.broker);
        }
    }

    for (broker_idx, broker) in broker_order.iter().enumerate() {
        if broker_idx > 0 {
            println!();
        }
        println!("=== {broker} ===");
        for group in ["真实账户", "模拟账户", "已禁用账户"] {
            let group_rows = rows
                .iter()
                .filter(|row| row.broker == *broker && acc_group_label(row) == group)
                .map(|row| AccGroupedRow {
                    acc_id: row.acc_id.clone(),
                    card: row.card.clone(),
                    env: row.env.clone(),
                    acc_type: row.acc_type.clone(),
                    status: row.status.clone(),
                    label: row.label.clone(),
                    markets: row.markets.clone(),
                })
                .collect::<Vec<_>>();
            if group_rows.is_empty() {
                continue;
            }
            println!("-- {group} ({}) --", group_rows.len());
            let mut table = Table::new(&group_rows);
            table.with(Style::rounded());
            println!("{table}");
        }
    }
    Ok(())
}

pub async fn list_accounts(
    gateway: &str,
    format: OutputFormat,
    market: Option<&str>,
    security_firm: Option<&str>,
    all: bool,
) -> Result<()> {
    let (client, _push_rx) = connect_gateway(gateway, "futucli-acc-list").await?;
    // CLI `account` is a user-facing discovery view for selecting usable
    // `acc_id` values. The daemon returns raw discovery for routing and
    // diagnostics; by default CLI projects that to the App-visible account set
    // (for example crypto / equity-incentive rows stay visible, futures-only
    // rows wrapped under a comprehensive account stay hidden). `--all` shows
    // raw discovery for troubleshooting.
    let mut accs = futu_trd::account::get_acc_list_for_account_discovery(&client).await?;
    if !all {
        accs = futu_trd::account::app_visible_accounts(accs);
    }
    if market.is_some() || security_firm.is_some() {
        let market_filter = match market {
            Some(m) => parse_account_market_filter(m)?,
            None => None,
        };
        let security_firm_filter = match security_firm {
            Some(firm) => parse_account_security_firm_filter(firm)?,
            None => None,
        };
        accs.retain(|a| account_matches_sdk_filter(a, market_filter, security_firm_filter));
    }

    let rows: Vec<AccRow> = accs
        .iter()
        .map(|a| AccRow {
            acc_id: a.acc_id.to_string(),
            card: visible_card_num(a).unwrap_or_else(|| "-".into()),
            env: env_label(a.trd_env).to_string(),
            broker: display_security_firm_label(a),
            acc_type: a
                .acc_type
                .map(|v| acc_type_label(v).to_string())
                .unwrap_or_else(|| "-".into()),
            status: a
                .acc_status
                .map(|v| acc_status_label(v).to_string())
                .unwrap_or_else(|| "-".into()),
            label: account_display_label(a),
            markets: account_market_list_label(a),
        })
        .collect();

    let jsons: Vec<AccJson> = accs
        .iter()
        .map(|a| AccJson {
            acc_id: a.acc_id.to_string(),
            trd_env: a.trd_env,
            env_label: env_label(a.trd_env),
            trd_market_auth_list: a.trd_market_auth_list.clone(),
            trd_market_auth_labels: a
                .trd_market_auth_list
                .iter()
                .map(|m| market_label(*m))
                .collect(),
            acc_type: a.acc_type,
            acc_type_label: a.acc_type.map(acc_type_label),
            card_num: visible_card_num(a),
            security_firm: a.security_firm,
            security_firm_label: a.security_firm.map(security_firm_label),
            sim_acc_type: a.sim_acc_type,
            acc_status: a.acc_status,
            acc_status_label: a.acc_status.map(acc_status_label),
            acc_role: a.acc_role,
            acc_role_label: a.acc_role.map(acc_role_label),
            acc_label: a.acc_label.clone(),
            acc_label_label: a
                .acc_label
                .as_deref()
                .map(crate::cmd::account_view::account_special_label),
            competition_acc_name: a.competition_acc_name.clone(),
            jp_acc_type: a.jp_acc_type.clone(),
        })
        .collect();

    match format {
        OutputFormat::Table => print_account_grouped_tables(&rows)?,
        _ => format.print_rows(&rows, &jsons)?,
    }
    Ok(())
}