{

const std::time_t raw_time = std::time(nullptr);

std::tm local_time {};

#if defined(_WIN32)

localtime_s(&local_time, &raw_time);

#else

localtime_r(&raw_time, &local_time);

#endif

char buffer[16] {};

std::strftime(buffer, sizeof(buffer), "%H:%M:%S", &local_time);

return buffer;

{

std::vector<std::string> objects;

const std::string needle = "\"" + key + "\":";

const size_t array_key = json.find(needle);

if (array_key == std::string::npos)

{

return objects;

}

size_t cursor = json.find('[', array_key);

if (cursor == std::string::npos)

{

return objects;

}

++cursor;

while (cursor < json.size())

{

while (cursor < json.size() && (json[cursor] == ' ' || json[cursor] == '\t'

|| json[cursor] == '\n' || json[cursor] == '\r' || json[cursor] == ','))

{

++cursor;

}

if (cursor >= json.size() || json[cursor] == ']')

{

break;

}

if (json[cursor] != '{')

{

break;

}

size_t depth = 0;

const size_t start = cursor;

for (; cursor < json.size(); ++cursor)

{

if (json[cursor] == '{')

{

++depth;

}

else if (json[cursor] == '}')

{

--depth;

if (depth == 0)

{

++cursor;

break;

}

}

}

objects.push_back(json.substr(start, cursor - start));

}

return objects;

std::string id;

std::string kind;

std::string base_url;

std::string launch_cmd;

bool enabled = true;

std::string live_status = "unknown";

std::string id;

std::string connector_id;

std::string command;

std::string status;

// Absolute epoch-ms deadline (0 = runnable immediately) - see

// Task::scheduled_for_ms, src/app/tasks.hpp. Rendered as a countdown in

// the Tasks panel while still in the future.

int64_t scheduled_for_ms = 0;

{

std::vector<ConnectorRow> rows;

for (const std::string& object : extract_json_object_array(json, "connectors"))

{

ConnectorRow row;

row.id = net::extract_json_string_field(object, "id");

row.kind = net::extract_json_string_field(object, "kind");

row.base_url = net::extract_json_string_field(object, "base_url");

row.launch_cmd = net::extract_json_string_field(object, "launch_cmd");

bool enabled = true;

if (net::extract_json_bool_field(object, "enabled", enabled))

{

row.enabled = enabled;

}

if (!row.id.empty())

{

rows.push_back(row);

}

}

return rows;

{

std::vector<TaskRow> rows;

for (const std::string& object : extract_json_object_array(json, "tasks"))

{

TaskRow row;

row.id = net::extract_json_string_field(object, "id");

row.connector_id = net::extract_json_string_field(object, "connector_id");

row.command = net::extract_json_string_field(object, "command");

row.status = net::extract_json_string_field(object, "status");

int64_t scheduled_for_ms = 0;

net::extract_json_int_field(object, "scheduled_for_ms", scheduled_for_ms);

row.scheduled_for_ms = scheduled_for_ms;

if (!row.id.empty())

{

rows.push_back(row);

}

}

return rows;

std::string name;

std::string resolved_path;

std::string updated_at;

{

LocationsSnapshot snapshot;

const std::string cwd = net::extract_json_string_field(json, "cwd");

if (!cwd.empty())

{

snapshot.system_locations.push_back(LocationEntry{"Current Directory", cwd});

}

const std::string desktop_path = net::extract_json_string_field(json, "desktop_path");

if (!desktop_path.empty())

{

snapshot.system_locations.push_back(LocationEntry{"Desktop", desktop_path});

}

for (const std::string& object : extract_json_object_array(json, "system_locations"))

{

LocationEntry entry;

entry.name = net::extract_json_string_field(object, "name");

entry.path = net::extract_json_string_field(object, "path");

if (!entry.name.empty())

{

snapshot.system_locations.push_back(entry);

}

}

for (const std::string& object : extract_json_object_array(json, "known_locations"))

{

LocationRow row;

row.name = net::extract_json_string_field(object, "name");

row.resolved_path = net::extract_json_string_field(object, "resolved_path");

row.updated_at = net::extract_json_string_field(object, "updated_at");

if (!row.name.empty())

{

snapshot.remembered.push_back(row);

}

}

return snapshot;

std::string timestamp;

std::string channel;

std::string direction;

std::string summary;

bool success = true;

{

std::vector<LogRow> rows;

for (const std::string& object : extract_json_object_array(json, "entries"))

{

LogRow row;

row.timestamp = net::extract_json_string_field(object, "timestamp");

row.channel = net::extract_json_string_field(object, "channel");

row.direction = net::extract_json_string_field(object, "direction");

row.summary = net::extract_json_string_field(object, "summary");

bool success = true;

if (net::extract_json_bool_field(object, "success", success))

{

row.success = success;

}

rows.push_back(row);

}

return rows;

{

bool ok = false;

net::extract_json_bool_field(status_json, "ok", ok);

if (!ok)

{

return "error";

}

if (kind == "launched_process")

{

bool running = false;

net::extract_json_bool_field(status_json, "running", running);

const std::string status_text = net::extract_json_string_field(status_json, "status");

return running ? ("running: " + status_text) : ("stopped: " + status_text);

}

bool online = false;

net::extract_json_bool_field(status_json, "online", online);

return online ? "online" : "offline";

std::mutex mutex;

std::vector<ConnectorRow> connectors;

std::vector<TaskRow> tasks;

std::vector<LogRow> log_lines;

LocationsSnapshot locations;

// Pulled models available on the active Ollama daemon (DroidHost::

// build_ollama_status_json's "models" field) - drives the model

// dropdown in the top status line. A cheap HTTP GET to /api/tags, not

// the heavier ollama_setup_status_json() (which shells out to `where

// ollama`) - safe to poll on the same cadence as everything else here.

std::vector<std::string> ollama_models;

// Every session id with at least one persisted message, most recently

// active first (DroidHost::build_agent_sessions_json - a local SQLite

// read via MemoryStore, no network call) - drives the session dropdown

// in the top status line.

std::vector<std::string> agent_session_ids;

std::string role; // "user" | "assistant" | "thinking" | "tool" | "error" | "info"

std::string text;

std::string timestamp;

// Collapsed by default (see chat_log_view's Collapsible-style rendering

// below) - only meaningful for "thinking"/"tool" roles, but every entry

// carries it rather than a role-keyed lookup, since it's one bool and

// this way it survives exactly as long as the entry itself does with no

// separate structure to keep in sync across chat_entries' several

// push_back/clear call sites.

bool expanded = false;

ChatEntry(std::string role_, std::string text_)

: role(std::move(role_)), text(std::move(text_)), timestamp(current_time_hms()) {}

ChatEntry(std::string role_, std::string text_, std::string timestamp_)

: role(std::move(role_)), text(std::move(text_)), timestamp(std::move(timestamp_)) {}

{

std::ostringstream stream;

for (const ChatEntry& entry : entries)

{

const std::string ts_prefix = "[" + entry.timestamp + "] ";

if (entry.role == "user")

{

stream << ts_prefix << "[USER] " << entry.text << "\n";

}

else if (entry.role == "assistant")

{

stream << ts_prefix << "[AGENT] " << entry.text << "\n";

}

else if (entry.role == "thinking")

{

stream << ts_prefix << "[AGENT] [THINKING] " << entry.text << "\n";

}

else if (entry.role == "tool")

{

stream << ts_prefix << "[AGENT] [EXECUTION] " << entry.text << "\n";

}

else if (entry.role == "error")

{

stream << ts_prefix << "error: " << entry.text << "\n";

}

else

{

stream << ts_prefix << "[SYSTEM] " << entry.text << "\n";

}

}

return stream.str();

std::mutex mutex;

std::vector<ChatEntry> pending_entries;

bool clear_in_flight = false;

// Set whenever an agent_turn response carries a "session_id" - drained

// into the UI thread's current_session_id the same way pending_entries

// is, so the TUI can display it and include it in the next request

// (resuming a session across a restart - see "Persistent memory" in

// ARCHITECTURE.md). Empty means "no update this round", not "clear it".

std::string session_id;

// Set whenever a response carries a "pending_tool_call" - drained into

// the UI thread's pending_tool_approval the same way session_id is, so

// the TUI shows the proposal and waits for a yes/no instead of treating

// the turn as finished. See PendingToolApproval below.

bool has_pending_tool_call = false;

std::string pending_tool_name;

std::string pending_tool_args;

const std::string& json,

std::string& out_session_id,

bool& out_has_pending_tool_call,

std::string& out_pending_tool_name,

std::string& out_pending_tool_args)

{

std::vector<ChatEntry> entries;

out_session_id = net::extract_json_string_field(json, "session_id");

out_has_pending_tool_call = false;

out_pending_tool_name.clear();

out_pending_tool_args.clear();

bool ok = false;

net::extract_json_bool_field(json, "ok", ok);

if (!ok)

{

const std::string error = net::extract_json_string_field(json, "error");

entries.push_back(ChatEntry{"error", error.empty() ? "agent turn failed" : error});

return entries;

}

// DroidHost::classify_via_llm's own chain-of-thought (see "The LLM

// provider" in ARCHITECTURE.md) - shown first, since it's what actually

// drove whichever tool call/reply follows. Never the assistant's real

// reply - a distinct role/line so it can never be mistaken for one.

const std::string thinking = net::extract_json_string_field(json, "thinking");

if (!thinking.empty())

{

entries.push_back(ChatEntry{"thinking", thinking});

}

for (const std::string& action : extract_json_object_array(json, "actions"))

{

const std::string tool = net::extract_json_string_field(action, "tool");

const std::string args = net::extract_json_string_field(action, "arguments_json");

const std::string result = net::extract_json_string_field(action, "result_json");

// The raw tool result (list_windows_locations' full candidate list,

// find_application's matches, etc.) used to only reach the App Log

// panel via DroidHost::append_app_log's own "chat" channel line -

// Agent Chat showed just the call, never what it actually returned,

// so a request answered from a long candidate list looked like it

// vanished into a vague "returned a comprehensive list" summary with

// no way to see the list itself without switching panels.

entries.push_back(ChatEntry{"tool",

"called " + tool + "(" + args + ")" + (result.empty() ? "" : " -> " + result)});

}

// build_pending_tool_call_response() (cli/host.cpp) always writes

// "pending_tool_call" before "actions" in the response, so slicing from

// its key onward and taking the first "tool"/"arguments_json" match

// lands on the pending call's own fields, not a later action's -

// matches this file's existing first-occurrence JSON field lookups

// (extract_json_object_array et al.), not a real parser.

const size_t pending_index = json.find("\"pending_tool_call\":");

if (pending_index != std::string::npos)

{

const std::string pending_object = json.substr(pending_index);

out_has_pending_tool_call = true;

out_pending_tool_name = net::extract_json_string_field(pending_object, "tool");

out_pending_tool_args = net::extract_json_string_field(pending_object, "arguments_json");

bool looks_destructive = false;

net::extract_json_bool_field(pending_object, "looks_destructive", looks_destructive);

// A visibility aid, not a gate (cli/host.cpp's looks_like_destructive_command -

// "Phase 26" - never blocks anything on its own) - a human skimming

// past a routine "yes" is more likely to actually stop and read this

// particular prompt with the warning prefixed.

const std::string prefix = looks_destructive ? "[!! DESTRUCTIVE !!] " : "";

entries.push_back(ChatEntry{"info",

prefix + "[AGENT WANTS TO] " + out_pending_tool_name + "(" + out_pending_tool_args + ") - approve? (yes/no, or say why not)"});

return entries;

}

const std::string assistant = net::extract_json_string_field(json, "assistant");

entries.push_back(ChatEntry{"assistant", assistant.empty() ? "(no reply)" : assistant});

return entries;

bool active = false;

std::string session_id;

std::string tool;

std::string arguments_json;

{

std::vector<std::string> values;

const std::string needle = "\"" + key + "\":";

const size_t key_index = json.find(needle);

if (key_index == std::string::npos)

{

return values;

}

size_t cursor = json.find('[', key_index);

if (cursor == std::string::npos)

{

return values;

}

++cursor;

while (cursor < json.size())

{

while (cursor < json.size() && (json[cursor] == ' ' || json[cursor] == '\t'

|| json[cursor] == '\n' || json[cursor] == '\r' || json[cursor] == ','))

{

++cursor;

}

if (cursor >= json.size() || json[cursor] == ']')

{

break;

}

if (json[cursor] != '"')

{

break;

}

++cursor;

std::string value;

while (cursor < json.size() && json[cursor] != '"')

{

if (json[cursor] == '\\' && cursor + 1 < json.size())

{

value += json[cursor + 1];

cursor += 2;

continue;

}

value += json[cursor++];

}

if (cursor < json.size())

{

++cursor; // skip closing quote

}

values.push_back(value);

}

return values;

bool installed = false;

bool online = false;

std::vector<std::string> models;

std::string configured_model;

bool configured_model_pulled = false;

{

OllamaSetupStatus status;

net::extract_json_bool_field(json, "installed", status.installed);

net::extract_json_bool_field(json, "online", status.online);

status.models = parse_json_string_array(json, "models");

status.configured_model = net::extract_json_string_field(json, "configured_model");

net::extract_json_bool_field(json, "configured_model_pulled", status.configured_model_pulled);

return status;

{

if (!status.installed)

{

return OllamaSetupState::NeedsInstall;

}

if (!status.online)

{

return OllamaSetupState::NeedsStart;

}

if (status.models.empty() || !status.configured_model_pulled)

{

return OllamaSetupState::NeedsModel;

}

return OllamaSetupState::Ready;

{

size_t start = 0;

size_t end = value.size();

while (start < end && std::isspace(static_cast<unsigned char>(value[start])))

{

++start;

}

while (end > start && std::isspace(static_cast<unsigned char>(value[end - 1])))

{

--end;

}

return value.substr(start, end - start);

{

std::string result = value;

std::transform(result.begin(), result.end(), result.begin(),

[](unsigned char c) { return static_cast<char>(std::tolower(c)); });

return result;

{

switch (state)

{

case OllamaSetupState::NeedsInstall:

return "Ollama isn't installed. Type 'install ollama' to install it automatically "

"(via winget), or install it yourself from ollama.com.";

case OllamaSetupState::NeedsStart:

return "Ollama is installed but not running. Type 'start ollama' to launch it.";

case OllamaSetupState::NeedsModel:

{

if (status.models.empty())

{

return "No Ollama models found on this machine. Type a model name to download it "

"(e.g. 'llama3.2', 'qwen2.5', 'mistral-nemo') and I'll pull it for you.";

}

std::string list_text;

for (size_t index = 0; index < status.models.size(); ++index)

{

if (index > 0)

{

list_text += " ";

}

list_text += std::to_string(index + 1) + ") " + status.models[index];

}

return "Ollama has these models available: " + list_text

+ ". Type a number or name to use one (Enter = 1), or 'pull <name>' to download a different model.";

}

case OllamaSetupState::Ready:

default:

return {};

}

const std::string& trimmed_message,

const OllamaSetupStatus& status,

std::string& out_model)

{

if (status.models.empty())

{

return false;

}

if (trimmed_message.empty())

{

out_model = status.models.front();

return true;

}

bool is_number = !trimmed_message.empty();

for (const char character : trimmed_message)

{

if (std::isdigit(static_cast<unsigned char>(character)) == 0)

{

is_number = false;

break;

}

}

if (is_number)

{

const int index = std::atoi(trimmed_message.c_str());

if (index >= 1 && static_cast<size_t>(index) <= status.models.size())

{

out_model = status.models[static_cast<size_t>(index) - 1];

return true;

}

return false;

}

const std::string lower_message = to_lower(trimmed_message);

for (const std::string& model : status.models)

{

if (to_lower(model) == lower_message)

{

out_model = model;

return true;

}

}

return false;

{

std::ifstream file(kLastSessionIdFile);

if (!file)

{

return {};

}

std::ostringstream buffer;

buffer << file.rdbuf();

return trim(net::extract_json_string_field(buffer.str(), "session_id"));

{

std::ofstream file(kLastSessionIdFile, std::ios::trunc);

if (file)

{

file << '{' << net::json_string_field("session_id", session_id) << '}' << std::endl;

}

{

std::vector<ChatEntry> entries;

bool saw_system_prompt = false;

for (const std::string& message : extract_json_object_array(json, "messages"))

{

const std::string role = net::extract_json_string_field(message, "role");

const std::string content = net::extract_json_string_field(message, "content");

if (role == "system")

{

saw_system_prompt = true;

continue;

}

// created_at is stored/reported as "YYYY-MM-DD HH:MM:SS"

// (MemoryStore, DroidHost::make_full_log_timestamp) - the trailing 8

// characters are the HH:MM:SS this panel actually displays, so a

// resumed message shows when it really happened instead of the

// session-resume time ChatEntry's default ("now") would give it.

const std::string created_at = net::extract_json_string_field(message, "created_at");

const std::string resumed_timestamp = created_at.size() >= 8

? created_at.substr(created_at.size() - 8)

: current_time_hms();

if (role == "assistant")

{

entries.push_back(ChatEntry{"assistant", content, resumed_timestamp});

}

else if (role == "tool")

{

entries.push_back(ChatEntry{"tool", "(resumed) " + content, resumed_timestamp});

}

else

{

entries.push_back(ChatEntry{"user", content, resumed_timestamp});

}

}

if (!entries.empty())

{

std::string summary = "Resumed a prior session (" + std::to_string(entries.size()) + " message"

+ (entries.size() == 1 ? "" : "s");

if (saw_system_prompt)

{

summary += ", plus the system prompt";

}

summary += "). Press 'n' to start a new session instead.";

entries.insert(entries.begin(), ChatEntry{"info", summary});

}

return entries;

{

return ftxui::window(panel_title(title), std::move(content))

| ftxui::bgcolor(kAppBackground) | ftxui::color(kAppForeground);

std::string title,

std::function<std::string()> message_fn,

std::function<void()> on_confirm,

bool* show_flag)

{

using namespace ftxui;

// True (not palette-remappable) white-on-black: named ANSI colors like

// Color::White are index 15, which plenty of terminal color schemes

// (Solarized, etc.) remap to a muted off-white - RGB(255,255,255) forces

// the actual color regardless of the user's terminal theme.

const Color kWhite = Color::RGB(255, 255, 255);

const Color kBlack = Color::RGB(0, 0, 0);

// A single-line label, not the library's default bordered/boxed look

// (ButtonOption::Animated() pads with an empty border, which reads as an

// oversized button) - just the text itself, colored via animated_colors

// so focus/hover still shows a red fill against the dialog's black

// background.

ButtonOption button_style;

button_style.transform = [](const EntryState& s) -> Element

{

Element label = text(s.label);

return s.focused ? label | bold : label;

};

button_style.animated_colors.background.Set(kBlack, Color::Red);

button_style.animated_colors.foreground.Set(kWhite, kWhite);

Component yes_button = Button(" Yes ", [on_confirm, show_flag]

{

on_confirm();

*show_flag = false;

}, button_style);

Component no_button = Button(" No ", [show_flag]

{

*show_flag = false;

}, button_style);

Component buttons = Container::Horizontal({yes_button, no_button});

Component dialog = Renderer(buttons, [title, message_fn, buttons, kWhite, kBlack]() -> Element

{

return window(text(" " + title + " ") | bold | color(Color::Red),

vbox({

paragraph(message_fn()) | color(kWhite),

text(""),

hbox({filler(), buttons->Render(), filler()}),

}) | size(WIDTH, GREATER_THAN, 44)) | bgcolor(kBlack);

});

return CatchEvent(dialog, [on_confirm, show_flag](Event event) -> bool

{

if (event == Event::y)

{

on_confirm();

*show_flag = false;

return true;

}

if (event == Event::n || event == Event::Escape)

{

*show_flag = false;

return true;

}

// Anything else (a mouse click on Yes/No, Tab between them, ...)

// falls through to the buttons container below rather than being

// swallowed - Modal() already routes every event exclusively to

// this popup while it's shown, so there is nothing else in the

// tree for an unhandled event to leak into.

return false;

});

{

using namespace ftxui;

PolledState polled;

ScreenInteractive screen = ScreenInteractive::Fullscreen();

// UI-thread-owned state. Only ever mutated inside the FTXUI event loop (in

// response to Event::Custom), so it needs no locking of its own - the

// PolledState mutex above is the only cross-thread hand-off point.

std::vector<ConnectorRow> connectors;

std::vector<std::string> connector_entries;

int selected_connector = 0;

std::vector<TaskRow> tasks;

std::vector<LogRow> log_lines;

LocationsSnapshot locations;

// Backs the model dropdown in the top status line. model_menu_selected is

// written directly by FTXUI's Dropdown component on click/keyboard

// selection - there is no on-change callback, so

// apply_model_menu_selection() below detects a change by comparing

// against model_menu_known_model every render frame instead.

std::vector<std::string> model_menu_entries;

int model_menu_selected = 0;