session_status.c File Reference

Go to the source code of this file.

Data Structures
struct	log_row_ref_t

Macros
#define	TUI_SESSION_STATUS_STATUS_LINE_BUFFER_SIZE   512
#define	TUI_SESSION_STATUS_STATUS_LINE_TRUNCATED_BUFFER_SIZE   512
#define	TUI_SESSION_STATUS_STATUS_LINE_COLORED_BUFFER_SIZE   600
#define	TUI_SESSION_STATUS_UPTIME_BUFFER_SIZE   12
#define	TUI_SESSION_STATUS_ADDR_LINE_BUFFER_SIZE   512
#define	TUI_SESSION_STATUS_ADDR_LINE_TRUNCATED_BUFFER_SIZE   512
#define	TUI_SESSION_STATUS_IPV4_ONLY_BUFFER_SIZE   64
#define	TUI_SESSION_STATUS_IPV6_ONLY_BUFFER_SIZE   64
#define	TUI_SESSION_STATUS_TEXT_BUFFER_SIZE   2048
#define	TUI_SESSION_STATUS_FOOTER_BUFFER_SIZE   128
#define	TUI_SESSION_STATUS_KEYS_BUFFER_SIZE   96

Functions
void	ui_status_render_header (frame_buffer_t *buf, terminal_size_t term_size, void *user_data)
void	terminal_screen_compose (frame_buffer_t *output, terminal_size_t size, const terminal_screen_config_t *config, session_log_buffer_t *logs)
void	terminal_screen_logs_render_help (frame_buffer_t *output, terminal_size_t size)

Macro Definition Documentation

TUI_SESSION_STATUS_ADDR_LINE_BUFFER_SIZE

#define TUI_SESSION_STATUS_ADDR_LINE_BUFFER_SIZE   512

Definition at line 7 of file session_status.c.

Referenced by ui_status_render_header().

TUI_SESSION_STATUS_ADDR_LINE_TRUNCATED_BUFFER_SIZE

#define TUI_SESSION_STATUS_ADDR_LINE_TRUNCATED_BUFFER_SIZE   512

Definition at line 8 of file session_status.c.

Referenced by ui_status_render_header().

TUI_SESSION_STATUS_FOOTER_BUFFER_SIZE

#define TUI_SESSION_STATUS_FOOTER_BUFFER_SIZE   128

Definition at line 12 of file session_status.c.

Referenced by terminal_screen_logs_render_help().

TUI_SESSION_STATUS_IPV4_ONLY_BUFFER_SIZE

#define TUI_SESSION_STATUS_IPV4_ONLY_BUFFER_SIZE   64

Definition at line 9 of file session_status.c.

Referenced by ui_status_render_header().

TUI_SESSION_STATUS_IPV6_ONLY_BUFFER_SIZE

#define TUI_SESSION_STATUS_IPV6_ONLY_BUFFER_SIZE   64

Definition at line 10 of file session_status.c.

Referenced by ui_status_render_header().

TUI_SESSION_STATUS_KEYS_BUFFER_SIZE

#define TUI_SESSION_STATUS_KEYS_BUFFER_SIZE   96

Definition at line 13 of file session_status.c.

Referenced by terminal_screen_logs_render_help().

TUI_SESSION_STATUS_STATUS_LINE_BUFFER_SIZE

#define TUI_SESSION_STATUS_STATUS_LINE_BUFFER_SIZE   512

Definition at line 3 of file session_status.c.

Referenced by ui_status_render_header().

TUI_SESSION_STATUS_STATUS_LINE_COLORED_BUFFER_SIZE

#define TUI_SESSION_STATUS_STATUS_LINE_COLORED_BUFFER_SIZE   600

Definition at line 5 of file session_status.c.

Referenced by ui_status_render_header().

TUI_SESSION_STATUS_STATUS_LINE_TRUNCATED_BUFFER_SIZE

#define TUI_SESSION_STATUS_STATUS_LINE_TRUNCATED_BUFFER_SIZE   512

Definition at line 4 of file session_status.c.

Referenced by ui_status_render_header().

TUI_SESSION_STATUS_TEXT_BUFFER_SIZE

#define TUI_SESSION_STATUS_TEXT_BUFFER_SIZE   2048

Definition at line 11 of file session_status.c.

Referenced by terminal_screen_compose().

TUI_SESSION_STATUS_UPTIME_BUFFER_SIZE

#define TUI_SESSION_STATUS_UPTIME_BUFFER_SIZE   12

Definition at line 6 of file session_status.c.

Referenced by ui_status_render_header().

Function Documentation

terminal_screen_compose()

void terminal_screen_compose	(	frame_buffer_t *	output,
		terminal_size_t	size,
		const terminal_screen_config_t *	config,
		session_log_buffer_t *	logs )

Compose the existing status/splash UI without terminal I/O.

Definition at line 262 of file session_status.c.

                                                         {
  if (!output || !config || !config->render_header || size.cols < 1 || size.rows < 1)
    return;
  if (config->show_logs)
    log_search_process_pending();
  frame_buffer_t *body = frame_buffer_create(size.rows, size.cols);
  if (!body)
    return;
  config->render_header(body, size, config->user_data);
 
  // Measure the actual header, including wrapped lines, as the native status UI does.
  int header_rows = 0;
  const char *line = frame_buffer_get_content(body);
  const char *end = line + frame_buffer_get_length(body);
  for (const char *cursor = line; cursor < end; ++cursor) {
    if (*cursor == '\n') {
      char text[TUI_SESSION_STATUS_TEXT_BUFFER_SIZE];
      size_t length = (size_t)(cursor - line);
      if (length >= sizeof(text))
        length = sizeof(text) - 1;
      memcpy(text, line, length);
      text[length] = '\0';
      int height = display_height(text, size.cols);
      header_rows += height > 0 ? height : 1;
      line = cursor + 1;
    }
  }
  if (!header_rows)
    header_rows = config->fixed_header_lines;
  bool entering = config->show_logs && log_search_is_entering();
  // Search owns the final row for its prompt. Otherwise logs fill it.
  int available = size.rows - header_rows - (entering ? 1 : 0);
  bool compact_startup = config->screen == UI_SCREEN_SPLASH;
  session_log_entry_t *entries = NULL;
  size_t count = 0;
  size_t scroll_total = 0, scroll_offset = 0;
  if (config->show_logs && available > 0) {
    if (log_search_is_active())
      log_search_filter_buffer(logs, &entries, &count);
    else {
      entries = SAFE_MALLOC(SESSION_LOG_BUFFER_SIZE * sizeof(*entries), session_log_entry_t *);
      if (entries)
        count = session_log_buffer_get_recent(logs, entries, SESSION_LOG_BUFFER_SIZE);
    }
    log_row_ref_t *rows = SAFE_MALLOC((size_t)available * sizeof(*rows), log_row_ref_t *);
    if (rows) {
      size_t total_rows = 0;
      uint64_t previous_tail_sequence = 0;
      size_t appended_rows = 0;
      for (size_t entry = 0; entry < count; ++entry) {
        size_t height = (size_t)log_message_rows(entries[entry].message, size.cols, compact_startup);
        if (SIZE_MAX - total_rows < height)
          total_rows = SIZE_MAX;
        else
          total_rows += height;
      }
      uint64_t tail_sequence = count ? entries[count - 1].sequence : 0;
      previous_tail_sequence = terminal_screen_logs_last_tail_sequence();
      if (previous_tail_sequence && tail_sequence > previous_tail_sequence) {
        for (size_t entry = 0; entry < count; ++entry) {
          if (entries[entry].sequence > previous_tail_sequence)
            appended_rows += (size_t)log_message_rows(entries[entry].message, size.cols, compact_startup);
        }
      }
      size_t max_offset = total_rows ? total_rows - 1 : 0;
      size_t skip = terminal_screen_logs_retain_position(tail_sequence, appended_rows, max_offset);
      scroll_total = total_rows;
      scroll_offset = total_rows > (size_t)available + skip ? total_rows - (size_t)available - skip : 0;
      size_t row_count = 0;
      for (size_t entry = count; entry && row_count < (size_t)available; --entry) {
        int height = log_message_rows(entries[entry - 1].message, size.cols, compact_startup);
        if (skip >= (size_t)height) {
          skip -= (size_t)height;
          continue;
        }
        int row = height - 1 - (int)skip;
        skip = 0;
        for (; row >= 0 && row_count < (size_t)available; --row)
          rows[row_count++] = (log_row_ref_t){.entry = entry - 1, .row = row};
      }
      for (size_t row = row_count; row; --row)
        append_log_row(body, entries[rows[row - 1].entry].message, rows[row - 1].row, size.cols, compact_startup);
      while (row_count++ < (size_t)available)
        frame_buffer_printf(body, "\n");
      SAFE_FREE(rows);
    }
  }
  SAFE_FREE(entries);
 
  // Preserve the existing repaint-in-place behavior, also supplying CR for browser terminals.
  bool log_help_open = config->show_logs && terminal_screen_logs_help_open();
  bool hide_cursor = log_help_open || (!entering && (config->hide_cursor || config->show_logs));
  frame_buffer_printf(output, "\033[H%s", hide_cursor ? "\033[?25l" : "\033[?25h");
  const char *content = frame_buffer_get_content(body);
  size_t length = frame_buffer_get_length(body);
  for (size_t i = 0; i < length; ++i) {
    // Normalize CRLF before erasing the line; erasing after CR removes its text.
    if (content[i] == '\r' && i + 1 < length && content[i + 1] == '\n')
      continue;
    if (content[i] == '\n') {
      frame_buffer_printf(output, "\033[K\r");
      // Do not advance past the bottom row when the idle log view fills it.
      if (config->show_logs && !entering && i + 1 == length)
        continue;
    }
    frame_buffer_append(output, content + i, 1);
  }
  if (config->show_logs && available > 0 && scroll_total > (size_t)available)
    ui_scrollbar_render(output, header_rows + 1, size.cols, available, scroll_total, (size_t)available, scroll_offset);
  if (entering) {
    mutex_t *mutex = log_search_get_mutex();
    mutex_lock(mutex);
    const char *pattern = log_search_get_input_buffer();
    int cursor = log_search_get_cursor_position();
    // Keep the edit cursor visible even when a pattern exceeds the viewport.
    int offset = cursor >= size.cols - 2 ? cursor - (size.cols - 3) : 0;
    frame_buffer_printf(output, "\033[%d;1H/%.*s\033[K\033[%d;%dH", size.rows, size.cols - 2,
                        pattern ? pattern + offset : "", size.rows, cursor - offset + 2);
    mutex_unlock(mutex);
  }
  if (log_help_open) {
    terminal_screen_logs_render_help(output, size);
  } else if (config->show_logs && terminal_screen_logs_help_too_small()) {
    frame_buffer_printf(output, "\033[%d;1H%s", size.rows, "Help needs at least 12 terminal rows");
  }
  frame_buffer_destroy(body);
}

References display_height(), terminal_screen_config_t::fixed_header_lines, frame_buffer_append(), frame_buffer_create(), frame_buffer_destroy(), frame_buffer_get_content(), frame_buffer_get_length(), frame_buffer_printf(), height, terminal_screen_config_t::hide_cursor, log_search_filter_buffer(), log_search_get_cursor_position(), log_search_get_input_buffer(), log_search_get_mutex(), log_search_is_active(), log_search_is_entering(), log_search_process_pending(), terminal_screen_config_t::render_header, SAFE_FREE, SAFE_MALLOC, terminal_screen_config_t::screen, session_log_entry_t::sequence, session_log_buffer_get_recent(), SESSION_LOG_BUFFER_SIZE, terminal_screen_config_t::show_logs, terminal_screen_logs_help_open(), terminal_screen_logs_help_too_small(), terminal_screen_logs_last_tail_sequence(), terminal_screen_logs_render_help(), terminal_screen_logs_retain_position(), TUI_SESSION_STATUS_TEXT_BUFFER_SIZE, UI_SCREEN_SPLASH, ui_scrollbar_render(), and terminal_screen_config_t::user_data.

Referenced by ui_session_logs_render().

terminal_screen_logs_render_help()

void terminal_screen_logs_render_help	(	frame_buffer_t *	output,
		terminal_size_t	size )

Recompose log-viewer help above modal error notifications.

Definition at line 391 of file session_status.c.

                                                                                    {
  const ui_help_entry_t entries[] = {{"Down", "newer log"},    {"Up", "older log"},        {"PageDown", "newer page"},
                                     {"PageUp", "older page"}, {"End", "newest log"},      {"Home", "oldest log"},
                                     {"/", "search logs"},     {"q / Esc", "close viewer"}};
  char footer[TUI_SESSION_STATUS_FOOTER_BUFFER_SIZE], keys[TUI_SESSION_STATUS_KEYS_BUFFER_SIZE];
  ui_help_keys(keys, sizeof(keys), "? / Esc");
  snprintf(footer, sizeof(footer), "%s closes this help", keys);
  ui_help_menu_t menu = {.title = "Log Viewer Keyboard Controls",
                         .entries = entries,
                         .count = sizeof(entries) / sizeof(*entries),
                         .footer = footer};
  (void)ui_help_menu_render(output, size, &menu);
}

References TUI_SESSION_STATUS_FOOTER_BUFFER_SIZE, TUI_SESSION_STATUS_KEYS_BUFFER_SIZE, ui_help_keys(), and ui_help_menu_render().

Referenced by terminal_screen_compose().

ui_status_render_header()

void ui_status_render_header	(	frame_buffer_t *	buf,
		terminal_size_t	term_size,
		void *	user_data )

Server status presentation shared by native and browser sessions.

Definition at line 34 of file session_status.c.

                                                                                              {
  const ui_status_t *status = (const ui_status_t *)user_data;
  if (!status) {
    return;
  }
 
  // Calculate uptime
  time_t now = time(NULL);
  time_t uptime_secs = now - status->start_time;
  int uptime_hours = uptime_secs / SEC_PER_HOUR;
  int uptime_mins = (uptime_secs % SEC_PER_HOUR) / SEC_PER_MIN;
  int uptime_secs_rem = uptime_secs % 60;
 
  // Line 1: Top border
  bool unicode = terminal_should_use_utf8(GET_OPTION(force_utf8));
  bool colors = !GET_OPTION(strip_ansi) &&
                terminal_should_color_output(frame_buffer_get_screen_output_fd(), options_terminal_settings());
  frame_buffer_render_divider(buf, term_size.cols - 1, unicode, colors);
 
  // The bundled browser font does not contain the emoji used in native status titles.
#ifdef __EMSCRIPTEN__
  bool status_icons = false;
#else
  bool status_icons = unicode;
#endif
 
  // Line 2: Title + Stats (centered)
  char status_line[TUI_SESSION_STATUS_STATUS_LINE_BUFFER_SIZE];
  char status_line_truncated[TUI_SESSION_STATUS_STATUS_LINE_TRUNCATED_BUFFER_SIZE];
  char status_line_colored[TUI_SESSION_STATUS_STATUS_LINE_COLORED_BUFFER_SIZE];
  char uptime_str[TUI_SESSION_STATUS_UPTIME_BUFFER_SIZE];
  format_uptime_hms(uptime_hours, uptime_mins, uptime_secs_rem, uptime_str, sizeof(uptime_str));
  bool generic_log_header = status->detail && strstr(status->detail, "keyboard controls") != NULL;
  if (generic_log_header)
    snprintf(status_line, sizeof(status_line), status_icons ? "ascii-chat | ⏱️ %s" : "ascii-chat | uptime %s",
             uptime_str);
  else if (status->detail)
    snprintf(status_line, sizeof(status_line), status_icons ? "ascii-chat %s | ⏱️ %s" : "ascii-chat %s | uptime %s",
             status->mode_name, uptime_str);
  else
    snprintf(status_line, sizeof(status_line),
             status_icons ? "ascii-chat %s | 👥 %zu | ⏱️ %s" : "ascii-chat %s | clients %zu | uptime %s",
             status->mode_name, status->connected_count, uptime_str);
 
  // Truncate if needed (ANSI-aware)
  truncate_with_ellipsis(status_line, status_line_truncated, sizeof(status_line_truncated), term_size.cols - 2);
  snprintf(status_line_colored, sizeof(status_line_colored), "\033[1m%s\033[0m",
           colored_string(LOG_COLOR_DEBUG, status_line_truncated));
 
  int padding = display_center_horizontal(status_line_truncated, term_size.cols);
  for (int i = 0; i < padding; i++) {
    frame_buffer_printf(buf, " ");
  }
  frame_buffer_printf(buf, "%s\n", status_line_colored);
 
  // Line 3: Session + Addresses (centered)
  char addr_line[TUI_SESSION_STATUS_ADDR_LINE_BUFFER_SIZE] = {0};
  char addr_line_truncated[TUI_SESSION_STATUS_ADDR_LINE_TRUNCATED_BUFFER_SIZE];
  int pos = 0;
  if (status->session_string[0] != '\0') {
    pos += snprintf(addr_line + pos, sizeof(addr_line) - pos, unicode ? "🔗 %s" : "Session %s", status->session_string);
  }
  if (status->ipv4_bound && pos < (int)sizeof(addr_line) - 30) {
    if (pos > 0) {
      pos += snprintf(addr_line + pos, sizeof(addr_line) - pos, " | ");
    }
    // Extract IP and get type
    char ipv4_only[TUI_SESSION_STATUS_IPV4_ONLY_BUFFER_SIZE];
    if (extract_ip_from_address(status->ipv4_address, ipv4_only, sizeof(ipv4_only)) == 0) {
      const char *type = get_ip_type_string(ipv4_only);
      pos += snprintf(addr_line + pos, sizeof(addr_line) - pos, "%s (%s)", status->ipv4_address, type);
    } else {
      pos += snprintf(addr_line + pos, sizeof(addr_line) - pos, "%s", status->ipv4_address);
    }
  }
  if (status->ipv6_bound && pos < (int)sizeof(addr_line) - 30) {
    if (pos > 0) {
      pos += snprintf(addr_line + pos, sizeof(addr_line) - pos, " | ");
    }
    // Extract IP and get type
    char ipv6_only[TUI_SESSION_STATUS_IPV6_ONLY_BUFFER_SIZE];
    if (extract_ip_from_address(status->ipv6_address, ipv6_only, sizeof(ipv6_only)) == 0) {
      const char *type = get_ip_type_string(ipv6_only);
      snprintf(addr_line + pos, sizeof(addr_line) - pos, "%s (%s)", status->ipv6_address, type);
    } else {
      snprintf(addr_line + pos, sizeof(addr_line) - pos, "%s", status->ipv6_address);
    }
  }
 
  if (status->detail)
    SAFE_STRNCPY(addr_line, status->detail, sizeof(addr_line));
 
  // Truncate if needed (ANSI-aware)
  truncate_with_ellipsis(addr_line, addr_line_truncated, sizeof(addr_line_truncated), term_size.cols - 2);
 
  int addr_padding = display_center_horizontal(addr_line_truncated, term_size.cols);
  for (int i = 0; i < addr_padding; i++) {
    frame_buffer_printf(buf, " ");
  }
  frame_buffer_printf(buf, "%s\n", addr_line_truncated);
 
  // Line 4: Bottom border
  frame_buffer_render_divider(buf, term_size.cols - 1, unicode, colors);
}

References colored_string(), colors, ui_status_t::connected_count, ui_status_t::detail, display_center_horizontal(), extract_ip_from_address(), format_uptime_hms(), frame_buffer_get_screen_output_fd(), frame_buffer_printf(), frame_buffer_render_divider(), get_ip_type_string(), GET_OPTION, ui_status_t::ipv4_address, ui_status_t::ipv4_bound, ui_status_t::ipv6_address, ui_status_t::ipv6_bound, LOG_COLOR_DEBUG, ui_status_t::mode_name, options_terminal_settings, SAFE_STRNCPY, SEC_PER_HOUR, SEC_PER_MIN, ui_status_t::session_string, ui_status_t::start_time, truncate_with_ellipsis(), TUI_SESSION_STATUS_ADDR_LINE_BUFFER_SIZE, TUI_SESSION_STATUS_ADDR_LINE_TRUNCATED_BUFFER_SIZE, TUI_SESSION_STATUS_IPV4_ONLY_BUFFER_SIZE, TUI_SESSION_STATUS_IPV6_ONLY_BUFFER_SIZE, TUI_SESSION_STATUS_STATUS_LINE_BUFFER_SIZE, TUI_SESSION_STATUS_STATUS_LINE_COLORED_BUFFER_SIZE, TUI_SESSION_STATUS_STATUS_LINE_TRUNCATED_BUFFER_SIZE, and TUI_SESSION_STATUS_UPTIME_BUFFER_SIZE.

Referenced by ui_session_logs_render(), ui_status_display(), and ui_status_display_interactive().