futu_opend/startup/

phase2.rs

//! v1.4.110 Layer 3 A: startup Phase 2 — bridge 构造 + 登录 / SMS / setup-only
//! / dev-flag 注入. 抽自原 `mod.rs::run_daemon` 220..475 行段.
//!
//! Phase 2 主要副作用 (按顺序):
//! 1. `GatewayBridge::new()`, `push_receiver=None`
//! 2. `resolve_login_password` 7-tier 解析
//! 3. 如 `(account, password)` 同时存在:
//!    - `--reset-device` 交互式确认 + `reset_device_state`
//!    - `read_or_generate_device_id`
//!    - 构造 `GatewayConfig` + verify_cb (优先 `--verify-code`)
//!    - `bridge.initialize().await`
//!    - Ok → setup_only 早退分支; Err → `hints::print_auth_error_hint`
//! 4. 无凭据 → 跑 offline mode (WARN)
//! 5. `Arc::new(bridge)`
//! 6. dev-flag `--inject-auth-failure-every` 注入 (cfg feature)

#![allow(unused_imports)]

use anyhow::Result;
use std::sync::Arc;

use futu_gateway_core::bridge::{GatewayBridge, GatewayConfig, PushEvent};

use crate::cli::Platform;
use crate::config::RuntimeConfig;
use crate::credentials::resolve_login_password;
use crate::hints;

/// Phase 2 output — bridge (Arc-wrap 完成) + push_receiver (Some 时
/// 表示登录成功并需要后续 push dispatcher) + `setup_only_done` (true 时
/// orchestrator 应早退 Ok(())).
pub(super) struct Phase2Out {
    pub(super) bridge: Arc<GatewayBridge>,
    pub(super) push_receiver: Option<tokio::sync::mpsc::Receiver<PushEvent>>,
    pub(super) setup_only_done: bool,
}

pub(super) async fn run_phase2(
    config: &RuntimeConfig,
    listen_addr: &str,
    _inject_auth_failure_every: Option<u64>,
) -> Result<Phase2Out> {
    // 2. 创建并初始化业务桥接层
    let mut bridge = GatewayBridge::new();
    let mut push_receiver = None;

    // v1.4.18：7 层优先级密码解析。前面几条保留老行为兼容（老用户 --login-pwd
    // 继续能用，但会打 WARN 推他们迁移），后面几条是新加的安全存储路径。
    //
    // 1. --login-pwd-file <path>   读文件（Docker secrets / systemd LoadCredential）
    // 2. --login-pwd <plain>       明文 argv（WARN）—— 暴露在 ps aux / shell history
    // 3. --login-pwd-md5 <hex>     md5 argv（WARN）—— 同样 argv 暴露（md5 等同明文）
    // 4. FUTU_PWD env var          环境变量
    // 5. OS keychain               `futucli set-login-pwd --account X` 写入的
    // 6. 交互式 prompt（stdin 是 tty） 不回显、不进 shell history
    // 7. 以上都没有 → 返回 None，上层按"无凭据"处理
    // codex 0547 F2 (P2) fix: explicit `--login-pwd-file` 读失败 = fail-closed
    // (Err propagated → daemon abort), 不再 silent fallback. `?` 让 explicit
    // failure 立即终止 daemon. `unwrap_or((None, false))` 仅吃 7 层全无 / Ok(None).
    let (password, password_is_md5) =
        resolve_login_password(config.login_account.as_deref(), config)?.unwrap_or((None, false));

    if let (Some(account), Some(password)) = (&config.login_account, &password) {
        // v1.4.17：device_id 生命周期独立管理
        //   1. `--reset-device` 先删除现有 device + credentials 文件
        //   2. `read_or_generate_device_id` 从 ~/.futu-opend-rs/device-{hash}.dat
        //      读；首次启动 / reset 后随机生成 16-hex 并持久化
        //   3. `--device-id <hex>` 显式指定时覆盖文件值
        if config.reset_device {
            // v1.4.74 A3 BUG-003 fix（eli v1.4.71 AI tester §4.2 Layer 4）：
            // `--reset-device` 是**破坏性操作**（删凭证 + 删 device 文件，下次
            // 必 SMS 验证），之前无二次确认。在交互终端下加 `(y/N)` prompt，
            // 防止用户误触。非交互（systemd / Docker / CI）保持旧行为直接执行
            // （无 tty 的 `read_line` 会返 empty string → 判 abort 不安全，
            // 所以非 tty 场景跳过 prompt，by-design）。
            let confirm = if std::io::IsTerminal::is_terminal(&std::io::stdin()) {
                eprintln!();
                eprintln!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
                eprintln!("⚠️  --reset-device: 即将**删除**以下文件：");
                eprintln!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
                eprintln!("   ~/.futu-opend-rs/device-{{hash}}.dat       (device_id 持久化)");
                eprintln!("   ~/.futu-opend-rs/credentials-{{hash}}.json (remember-login 凭证)");
                eprintln!();
                eprintln!("   执行后下次启动必须重新走 SMS 验证流程。");
                eprintln!("   适用场景：device_id 被服务端锁定（ret_type=15/21 无法恢复）。");
                eprintln!();
                eprint!("   继续？(y/N) ");
                let _ = std::io::Write::flush(&mut std::io::stderr());
                let mut answer = String::new();
                if std::io::stdin().read_line(&mut answer).is_err() {
                    false
                } else {
                    matches!(answer.trim().to_ascii_lowercase().as_str(), "y" | "yes")
                }
            } else {
                // 非交互（systemd / Docker / CI）—— 直接执行（没 tty 交互能力）
                tracing::warn!(
                    "⚠️  --reset-device running in non-interactive mode; skipping \
                     confirmation prompt (proceeding with destructive reset)"
                );
                true
            };

            if confirm {
                match futu_backend::auth::reset_device_state(account) {
                    Ok(()) => tracing::info!(
                        "⚠️  --reset-device: deleted device_id + credentials files, \
                         will start fresh (SMS verification required)"
                    ),
                    Err(e) => {
                        tracing::warn!(error = %e, "reset_device failed (non-fatal)")
                    }
                }
            } else {
                eprintln!();
                eprintln!("已取消 --reset-device（未做任何修改）。");
                eprintln!("若只想验证 device_id 当前值而不重置，请用：`ls ~/.futu-opend-rs/`");
                tracing::info!("--reset-device aborted by user via interactive prompt");
                std::process::exit(0);
            }
        }
        // v1.4.102 codex 27 F11 (P2): tighten_secret_files_at_startup 已搬到
        // main() 早期无条件执行 (见下方 ~ line 904 附近), 不再依赖 login 分支.
        // 此处保留 placeholder 注释让 git history 看到 migration 历程.

        let device_id =
            futu_backend::auth::read_or_generate_device_id(account, config.device_id.as_deref());
        tracing::info!(
            account = %account,
            device_id = %device_id,
            platform = config.platform.name(),
            auth_server = %config.auth_server,
            "login credentials"
        );
        let app_lang = match config.lang.to_lowercase().as_str() {
            "chs" => 0, // 简体中文
            "cht" => 1, // 繁体中文
            "en" => 2,  // 英文
            _ => 0,     // 默认简体
        };
        let gw_config = GatewayConfig {
            auth_server: config.auth_server.clone(),
            account: account.clone(),
            password: password.clone(),
            password_is_md5,
            region: config.login_region.clone(),
            listen_addr: listen_addr.to_string(),
            device_id,
            app_lang,
            // v1.4.15：moomoo 的 auth.moomoo.com 对 client-type=40 直接拒绝，
            // 必须发 60（`NN_ClientType_FutuOpenDMooMoo`）。对齐 C++
            // `FTGTW_Inner_API.cpp:491-492` 的 AppType → ClientType 映射。
            client_type: match config.platform {
                Platform::Futunn => 40,
                Platform::Moomoo => 60,
            },
            setup_only: config.setup_only,
        };

        // v1.4.57 UX-04: 如果 --verify-code 传入了，构造一个一次性 callback
        // 替代 stdin 交互（Telegram 中继场景等）。
        let verify_cb: Option<futu_backend::auth::VerifyCodeCallback> = if let Some(code) =
            config.verify_code.clone()
        {
            tracing::info!("v1.4.57 UX-04: using --verify-code for SMS input (no stdin prompt)");
            let code_cell = std::sync::Arc::new(std::sync::Mutex::new(Some(code)));
            let cb = move || -> Option<String> { code_cell.lock().ok().and_then(|mut g| g.take()) };
            Some(Box::new(cb))
        } else {
            None
        };

        match bridge.initialize(&gw_config, verify_cb).await {
            Ok(push_rx) => {
                push_receiver = Some(push_rx);

                // v1.4.17：--setup-only 完成认证 + 凭据缓存后直接退出
                // （不启动任何 server）。用于 systemd / Docker 场景：先手动
                // 前台跑一次完成 SMS 验证，生产启动时自动跳过 SMS。
                if config.setup_only {
                    tracing::info!(
                        "✅ --setup-only: authentication succeeded and credentials cached. \
                         Exiting. You can now start futu-opend in production (credentials \
                         file at ~/.futu-opend-rs/ will be reused automatically)."
                    );
                    return Ok(Phase2Out {
                        bridge: Arc::new(bridge),
                        push_receiver: None,
                        setup_only_done: true,
                    });
                }
            }
            Err(e) => {
                // v1.4.17：识别 device_id 锁定类错误（21），给用户恢复建议
                // v1.4.21：ret_type=15 不再简单归为 "device_id 锁定"——三类来源：
                //   1. device_id 毒化（空 SMS 提交 / 长时间不用）→ --reset-device 可解
                //   2. 服务端反刷限流（短时间连发 authority 请求）→ sleep 后重试
                //   3. 账号级风控（账号状态异常，未在 App 激活等）→ 换 device_id 解不了
                // 所以分别给 21 / 15 两种场景不同提示
                hints::print_auth_error_hint(&e, config);
                if config.setup_only {
                    // setup 失败就退，不继续 offline mode
                    return Err(anyhow::anyhow!("--setup-only: auth failed: {e}"));
                }
            }
        }
    } else {
        if config.setup_only {
            return Err(anyhow::anyhow!(
                "--setup-only requires --login-account and --login-pwd"
            ));
        }
        tracing::warn!("no login credentials provided, starting in offline mode");
        tracing::warn!("use --login-account and --login-pwd to connect to backend");
    }

    // v1.4.32+ login 阶段结束，bridge 后续只需共享只读访问（register_handlers
    // / start_push_dispatcher / admin snapshot 都是 &self）。封装成 Arc 方便
    // admin_status_provider closure 长期持有一份。
    let bridge = std::sync::Arc::new(bridge);

    // v1.4.97 P1-D-C: dev-only auth failure injection (per CLAUDE.md pitfall
    // #50 SPKI dev pattern — release build does NOT compile this branch).
    // Tester real-machine verify P1-D ladder by combining:
    //   FUTU_QOT_RELOGIN_BACKOFF_MS=5000,10000,20000,40000 \
    //   futu-opend --inject-auth-failure-every=10 ...
    // Expected log within ~75s: P1-D ladder cells 5s/10s/20s/40s each fire.
    #[cfg(feature = "dev-flags")]
    if let Some(inject_secs) = _inject_auth_failure_every {
        if inject_secs == 0 {
            tracing::warn!("v1.4.97 P1-D-C: --inject-auth-failure-every=0 ignored (must be > 0)");
        } else {
            tracing::warn!(
                inject_secs,
                "v1.4.97 P1-D-C: DEV-ONLY auth-failure injection ENABLED — \
                 will clear login_cache every {}s to trigger P1-D self-heal \
                 ladder. DO NOT USE IN PRODUCTION.",
                inject_secs
            );
            let bridge_for_inject = std::sync::Arc::clone(&bridge);
            tokio::spawn(async move {
                let mut ticker = tokio::time::interval(std::time::Duration::from_secs(inject_secs));
                ticker.tick().await; // skip first immediate
                loop {
                    ticker.tick().await;
                    tracing::warn!("v1.4.97 P1-D-C: injecting qot_logined=false (DEV-ONLY)");
                    bridge_for_inject.login_cache.clear();
                }
            });
        }
    }

    Ok(Phase2Out {
        bridge,
        push_receiver,
        setup_only_done: false,
    })
}