light-fw-core 0.16.2

Ядро Light: виртуальный DOM, реактивность, раскладка, отрисовка и окно
Documentation
//! TCP-сервер для DevTools: построчный протокол, передающий JSON-снимок
//! состояния UI внешним инструментам (IDE / standalone inspector).
//!
//! Протокол (newline-delimited):
//! * Клиент шлёт `SNAPSHOT\n` — сервер отвечает одной строкой JSON + `\n`
//!   (или `null\n`, если снимка ещё нет).
//! * Клиент шлёт `PING\n` — сервер отвечает `PONG\n`.
//! * Клиент шлёт `CLICK <key>\n` — сервер отправляет команду клика в
//!   UI-поток (имитация нажатия элемента с ключом `key`) и ждёт результата:
//!   `ok:true\n`, если клик обработан, `ok:false\n`, если нет, либо
//!   `timeout\n`, если UI не ответил в течение секунды.
//! * Клиент шлёт `SET_STATE <field> <json>\n` — сервер отправляет команду
//!   изменения реактивного поля в UI-поток (применяет значение к активному
//!   окну) и ждёт результата: `ok:true\n`, если состояние применено,
//!   `ok:false\n`, если активного окна нет, либо `timeout\n`.
//! * Клиент шлёт `SAVE_STATE\n` — сервер просит UI-поток сохранить текущее
//!   состояние компонента в `.light/state.json` и сразу отвечает `ok\n`
//!   (запись асинхронна; результат видно при следующем запуске).
//! * Клиент шлёт `SAVE_ALL\n` — сервер просит UI-поток **синхронно**
//!   сохранить и `.light/state.json`, и принудительно написать
//!   `.light/window.json` (без дебаунса); отвечает `ok\n` только после
//!   подтверждения от UI (ТЗ 0.15.1-fix3, graceful save перед swap-kill).
//! * Клиент шлёт `QUIT\n` — сервер закрывает соединение.
//! * Неизвестная команда — сервер отвечает `unknown command\n` и продолжает
//!   обслуживание.
//!
//! Сервер слушает только на `127.0.0.1` (безопасность). Работа ведётся в
//! отдельном `[std::thread]`, не блокируя UI-поток. Клиенты обрабатываются
//! последовательно (head-of-line blocking) — приемлемо для dev-инструмента.

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::thread;

/// Запускает TCP-сервер на `127.0.0.1:port`.
///
/// Возвращает фактический порт (полезно при `port = 0`, когда ОС выбирает
/// свободный порт сама). Сервер обрабатывает клиентов в отдельном потоке;
/// сам вызов возвращает немедленно.
///
/// # Ошибки
///
/// Возвращает ошибку, если `TcpListener::bind` не удался (например, порт
/// занят).
pub fn start(port: u16) -> std::io::Result<u16> {
    let listener = TcpListener::bind(("127.0.0.1", port))?;
    let addr = listener.local_addr()?;
    thread::spawn(move || {
        for stream in listener.incoming().flatten() {
            handle_client(stream);
        }
    });
    Ok(addr.port())
}

/// Читает одну строку (до `\n` или EOF) из TCP-потока.
fn read_line(stream: &mut TcpStream) -> std::io::Result<String> {
    let mut buf = Vec::new();
    // Читаем байт за байтом до `\n` или EOF. Для коротких команд (десятки
    // байт) накладные расходы пренебрежимо малы.
    let mut byte = [0u8; 1];
    loop {
        match stream.read(&mut byte)? {
            0 => return Ok(String::from_utf8_lossy(&buf).into_owned()),
            _ => {
                if byte[0] == b'\n' {
                    return Ok(String::from_utf8_lossy(&buf).into_owned());
                }
                buf.push(byte[0]);
            }
        }
    }
}

/// Обрабатывает одного клиента до закрытия соединения или команды `QUIT`.
fn handle_client(mut stream: TcpStream) {
    while let Some(command) = read_command(&mut stream) {
        if command.is_empty() {
            continue;
        }
        // QUIT не шлёт ответа — просто закрывает соединение (клиент видит EOF).
        if command == "QUIT" {
            break;
        }
        let response = dispatch_command(&command);
        if write_response(&mut stream, &response).is_none() {
            break;
        }
    }
}

/// Выполняет одну команду протокола и возвращает строку-ответ.
fn dispatch_command(command: &str) -> String {
    // Разбираем команду: первое слово — имя, остальное — аргументы.
    // Для FIND аргумент — JSON (может содержать пробелы), поэтому берём
    // весь остаток строки как единый `rest`.
    let (name, rest) = command.split_once(' ').unwrap_or((command, ""));

    match name {
        "SNAPSHOT" => super::read_latest_snapshot().unwrap_or_else(|| "null".to_owned()),
        "PING" => "PONG".to_owned(),
        "CLICK" => {
            let key = rest.trim();
            if !key.is_empty() {
                // Ожидаем результат обработки клика из UI-потока (1 с —
                // достаточно, чтобы UI успел проснуться и обработать команду;
                // если окно не запущено/зависло — ответим `timeout`).
                let (tx, rx) = std::sync::mpsc::channel();
                super::send_command(super::DevToolsCommand::Click {
                    key: key.to_owned(),
                    response_tx: tx,
                });
                match rx.recv_timeout(std::time::Duration::from_secs(1)) {
                    Ok(true) => "ok:true".to_owned(),
                    Ok(false) => "ok:false".to_owned(),
                    _ => "timeout".to_owned(),
                }
            } else {
                "missing key".to_owned()
            }
        }
        "SET_STATE" => {
            // `rest` = `<field> <json>` (JSON может содержать пробелы).
            let mut sp = rest.splitn(2, ' ');
            let field = sp.next().unwrap_or("");
            let raw_value = sp.next().unwrap_or("");
            if field.is_empty() {
                return "missing field".to_owned();
            }
            // `raw_value` — JSON-значение поля; при его отсутствии или ошибке
            // разбора отвечаем сразу, не отправляя команду в UI-поток.
            let value = match serde_json::from_str::<serde_json::Value>(raw_value) {
                Ok(value) => value,
                Err(_) => return "invalid json".to_owned(),
            };
            // Как и для CLICK: ожидаем применения состояния из UI-потока
            // (1 с достаточно; если окна нет или оно зависло — `ok:false` /
            // `timeout`).
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::SetState {
                field: field.to_owned(),
                value,
                response_tx: tx,
            });
            match rx.recv_timeout(std::time::Duration::from_secs(1)) {
                Ok(true) => "ok:true".to_owned(),
                Ok(false) => "ok:false".to_owned(),
                _ => "timeout".to_owned(),
            }
        }
        "SAVE_STATE" => {
            // Сохранение состояния выполняется асинхронно в UI-потоке (см.
            // `window/mod.rs`); сервер отвечает сразу, не ожидая записи.
            super::send_command(super::DevToolsCommand::SaveState);
            "ok".to_owned()
        }
        "RELOAD_TEMPLATE" => {
            // Перечтение HTML-шаблона выполняется асинхронно в UI-потоке;
            // сервер отвечает сразу, не ожидая перерисовки.
            super::send_command(super::DevToolsCommand::ReloadTemplate);
            "ok".to_owned()
        }
        "SAVE_ALL" => {
            // ТЗ 0.15.1-fix3: supervisor шлёт SAVE_ALL перед kill. Ожидаем
            // подтверждения из UI-потока (до 1 с), что state.json + window.json
            // записаны, и отвечаем `ok` / `timeout`.
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::SaveAll { response_tx: tx });
            match rx.recv_timeout(std::time::Duration::from_secs(1)) {
                Ok(true) => "ok".to_owned(),
                Ok(false) => "error".to_owned(),
                _ => "timeout".to_owned(),
            }
        }
        // ─── ТЗ 0.16.0: агентовые команды ──────────────────────────────────
        // TREE / LAYOUT / FIND / SHOT требуют доступа к живому VDOM-дереву,
        // раскладке и буферу кадра — поэтому доставляются в UI-поток как
        // команды с каналом возврата (как TYPE/KEY). Результат — JSON-строка
        // или `base64:...`, либо `null` / `error: ...`.
        "TREE" => {
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::Tree { response_tx: tx });
            match rx.recv_timeout(std::time::Duration::from_secs(2)) {
                Ok(Some(s)) => s,
                Ok(None) | Err(_) => "timeout".to_owned(),
            }
        }
        "LAYOUT" => {
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::LayoutCmd { response_tx: tx });
            match rx.recv_timeout(std::time::Duration::from_secs(2)) {
                Ok(Some(s)) => s,
                Ok(None) | Err(_) => "timeout".to_owned(),
            }
        }
        "FIND" => {
            let query = rest.trim();
            if query.is_empty() {
                return "missing query".to_owned();
            }
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::Find {
                query: query.to_owned(),
                response_tx: tx,
            });
            match rx.recv_timeout(std::time::Duration::from_secs(2)) {
                Ok(Some(s)) => s,
                Ok(None) | Err(_) => "timeout".to_owned(),
            }
        }
        "TYPE" => {
            // `rest` = `<key> <text>` (текст может содержать пробелы).
            let mut sp = rest.splitn(2, ' ');
            let key = sp.next().unwrap_or("").trim();
            let text = sp.next().unwrap_or("");
            if key.is_empty() {
                return "missing key".to_owned();
            }
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::Type {
                key: key.to_owned(),
                text: text.to_owned(),
                response_tx: tx,
            });
            match rx.recv_timeout(std::time::Duration::from_secs(1)) {
                Ok(Some(s)) => s,
                Ok(None) | Err(_) => "timeout".to_owned(),
            }
        }
        "KEY" => {
            // `rest` = `<key> <KeyName>`.
            let mut sp = rest.splitn(2, ' ');
            let key = sp.next().unwrap_or("").trim();
            let keyname = sp.next().unwrap_or("").trim();
            if key.is_empty() || keyname.is_empty() {
                return "missing key or keyname".to_owned();
            }
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::Key {
                key: key.to_owned(),
                keyname: keyname.to_owned(),
                response_tx: tx,
            });
            match rx.recv_timeout(std::time::Duration::from_secs(1)) {
                Ok(Some(s)) => s,
                Ok(None) | Err(_) => "timeout".to_owned(),
            }
        }
        "SHOT" => {
            // Захват кадра требует доступа к буферу рендера — доставляем
            // команду в UI-поток через вариант Shot { response_tx }; ответ —
            // `base64:<png>` либо `error: ...` / `timeout`.
            let (tx, rx) = std::sync::mpsc::channel();
            super::send_command(super::DevToolsCommand::Shot { response_tx: tx });
            match rx.recv_timeout(std::time::Duration::from_secs(2)) {
                Ok(Some(s)) => s,
                Ok(None) | Err(_) => "timeout".to_owned(),
            }
        }
        _ => "unknown command".to_owned(),
    }
}

/// Читает следующую команду от клиента; `None` при EOF или ошибке.
fn read_command(stream: &mut TcpStream) -> Option<String> {
    let line = read_line(stream).ok()?;
    if line.is_empty() {
        None
    } else {
        Some(line.trim().to_owned())
    }
}

/// Отправляет строку-ответ клиенту; `None` если соединение обрвано.
fn write_response(stream: &mut TcpStream, text: &str) -> Option<()> {
    writeln!(stream, "{}", text).ok()?;
    stream.flush().ok()?;
    Some(())
}