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)` 同时存在，或 normal startup 下有 cached credentials:
//!    - `--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. 无账号 / 无密码且无 cached credentials → 跑 offline mode (WARN)
//! 5. `Arc::new(bridge)`
//! 6. dev-flag `--inject-auth-failure-every` 注入 (cfg feature)

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

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

use crate::cli::Platform;
use crate::config::{RuntimeConfig, app_lang_from_runtime_lang};
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(()); 包括 setup-only 完成和用户交互式取消
/// `--reset-device` 这类 CLI-only 早退).
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,
}

#[cfg(test)]
mod tests;

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。normal startup 会再看 setup-only 写入的
    // cached credentials，允许 remember-login；两者都没有才按"无凭据"处理。
    // 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));

    let cached_credentials_available = config
        .login_account
        .as_deref()
        .is_some_and(|account| futu_backend::auth::credential_ticket_status(account).is_some());
    let should_attempt_auth = should_attempt_startup_auth(
        config.login_account.is_some(),
        password.is_some(),
        cached_credentials_available,
        config.setup_only,
        config.reset_device,
    );

    if should_attempt_auth && let Some(account) = &config.login_account {
        let password = password.clone().unwrap_or_default();
        // 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（external reviewer 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) ");
                if let Err(err) = std::io::Write::flush(&mut std::io::stderr()) {
                    tracing::debug!(
                        error = %err,
                        "failed to flush reset-device confirmation prompt"
                    );
                }
                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");
                return Ok(Phase2Out {
                    bridge: Arc::new(bridge),
                    push_receiver: None,
                    setup_only_done: true,
                });
            }
        }
        // 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())
                .map_err(|err| {
                    anyhow::anyhow!(
                        "auth device store unavailable: {err}. \
                 daemon needs a writable 0700 credentials directory before login"
                    )
                })?;
        tracing::info!(
            account_fp = %futu_backend::auth::redact::account_log_fingerprint(account),
            device_id_fp = %futu_backend::auth::redact::device_id_log_fingerprint(&device_id),
            platform = config.platform.name(),
            auth_server = %config.auth_server,
            "login credentials"
        );
        let app_lang = app_lang_from_runtime_lang(&config.lang);
        let gw_config = GatewayConfig {
            auth_server: config.auth_server.clone(),
            account: account.clone(),
            password,
            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,
            client_sig_proactive_refresh: config.client_sig_proactive_refresh,
            client_sig_reactive_refresh: config.client_sig_reactive_refresh,
        };

        // v1.4.57 UX-04: 如果 --verify-code 传入了，构造一个 callback
        // 替代 stdin 交互（Telegram 中继场景等）。
        //
        // v1.4.111 BUG-001 nearby regression fix (CLAUDE.md 坑 #55): 改为 **multi-shot**.
        // 之前 `Arc<Mutex<Option<String>>>.take()` 是 one-shot, 第二次 cb() 返
        // None. authenticate_with_callback 在以下 path 会两次调 cb:
        //   1. remember_login 内部 code=20 → handle_device_verify(cb) → cb 消费第 1 次
        //      → 该 handle_device_verify 任何 reason errored → 外层 fall through
        //   2. Option B/A / password_auth fallback → handle_device_verify(cb) → cb 第 2 次
        //      → 返 None → POST verify_device_code body 的 device_code="" → backend 拒
        //      → ret_type=-1 "verification cancelled by user" 或 11
        // 一次 daemon 启动用户只输一个 SMS 码; 整个 auth 流程内每次需要时返同一码即可
        // (多次 POST 同 code 是安全的, backend 用 device_code_sig 防重放).
        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 = std::sync::Arc::new(code);
            let cb = move || -> Option<String> { Some((*code).clone()) };
            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.caches().login_cache.clear();
                }
            });
        }
    }

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

fn should_attempt_startup_auth(
    has_login_account: bool,
    has_password: bool,
    has_cached_credentials: bool,
    setup_only: bool,
    reset_device: bool,
) -> bool {
    has_login_account && (has_password || (!setup_only && !reset_device && has_cached_credentials))
}