{

core::String result;

result.reserve(value.size());

for (const unsigned char c : value)

{

if (std::isalnum(c))

{

result += static_cast<char>(std::tolower(c));

}

}

return result;

{

static const char* const kRetriableTools[] = {

"run_command", "run_ffmpeg",

"read_file", "write_file", "copy_file", "move_path", "delete_file", "create_directory",

"open_application"

};

for (const char* retriable_tool : kRetriableTools)

{

if (tool_name == retriable_tool)

{

return true;

}

}

return false;

{

if (query.empty())

{

return {};

}

const core::String normalized_query = normalize_for_match(query);

if (normalized_query.empty())

{

return {};

}

for (const InstalledApp& app : apps)

{

if (normalize_for_match(app.name) == normalized_query)

{

return app.path;

}

}

for (const InstalledApp& app : apps)

{

const core::String normalized_name = normalize_for_match(app.name);

if (normalized_name.find(normalized_query) != core::String::npos

|| normalized_query.find(normalized_name) != core::String::npos)

{

return app.path;

}

}

return {};

const core::Array<InstalledApp>& apps, const core::String& query, size_t max_results)

{

core::Array<InstalledApp> matches;

const core::String normalized_query = normalize_for_match(query);

if (normalized_query.empty())

{

return matches;

}

for (const InstalledApp& app : apps)

{

if (normalize_for_match(app.name) == normalized_query)

{

// An exact normalized-name match is unambiguous regardless of

// how many substring matches also exist - return it alone.

matches.clear();

matches.push_back(app);

return matches;

}

}

for (const InstalledApp& app : apps)

{

const core::String normalized_name = normalize_for_match(app.name);

if (normalized_name.find(normalized_query) != core::String::npos

|| normalized_query.find(normalized_name) != core::String::npos)

{

matches.push_back(app);

if (matches.size() >= max_results)

{

break;

}

}

}

return matches;

{

core::String display_name;

core::String path_or_name;

core::String args;

{

core::Array<core::String> words;

core::String current;

for (const unsigned char c : value)

{

if (std::isalnum(c))

{

current += static_cast<char>(std::tolower(c));

}

else if (!current.empty())

{

words.push_back(current);

current.clear();

}

}

if (!current.empty())

{

words.push_back(current);

}

return words;

{

if (query_words.size() < 2)

{

return false;

}

for (const core::String& query_word : query_words)

{

bool found = false;

for (const core::String& alias_word : alias_words)

{

if (query_word == alias_word)

{

found = true;

break;

}

}

if (!found)

{

return false;

}

}

return true;

const core::String& query, const core::Array<WindowsLocationEntry>& targets, WellKnownWindowsTarget& out)

{

const core::String normalized_query = normalize_for_match(query);

if (normalized_query.empty())

{

return false;

}

for (const WindowsLocationEntry& target : targets)

{

const core::String normalized_alias = normalize_for_match(target.alias);

if (normalized_alias == normalized_query

|| normalized_alias.find(normalized_query) != core::String::npos

|| normalized_query.find(normalized_alias) != core::String::npos)

{

out.display_name = target.display_name;

out.path_or_name = target.path_or_name;

out.args = target.args;

return true;

}

}

// Fallback: word-order-independent match. A real transcript showed

// "open the partition disk" fail outright - the curated alias is

// "disk partition", and neither phrase is a substring of the other, so

// the exact/substring check above (correctly) never matches reversed

// word order. See "Search before giving up" in ARCHITECTURE.md.

const core::Array<core::String> query_words = split_words_for_match(query);

for (const WindowsLocationEntry& target : targets)

{

const core::Array<core::String> alias_words = split_words_for_match(target.alias);

if (words_all_present(query_words, alias_words))

{

out.display_name = target.display_name;

out.path_or_name = target.path_or_name;

out.args = target.args;

return true;

}

}

return false;

{

core::Array<core::String> seen_names;

std::ostringstream stream;

stream << '{' << net::json_bool_field("ok", true) << ",\"locations\":[";

bool first = true;

for (const WindowsLocationEntry& target : targets)

{

const core::String display_name = target.display_name;

bool duplicate = false;

for (const core::String& existing : seen_names)

{

if (existing == display_name)

{

duplicate = true;

break;

}

}

if (duplicate)

{

continue;

}

seen_names.push_back(display_name);

if (!first)

{

stream << ',';

}

first = false;

stream << '"' << net::escape_json_string(display_name) << '"';

}

stream << "]}";

return stream.str();

{

core::Array<core::String> names;

const size_t models_index = tags_json.find("\"models\":");

if (models_index == core::String::npos)

{

return names;

}

size_t cursor = models_index;

while (cursor < tags_json.size())

{

const size_t name_key = tags_json.find("\"name\":", cursor);

if (name_key == core::String::npos)

{

break;

}

const core::String name = net::extract_json_string_field(tags_json, "name", name_key);

if (name.empty())

{

break;

}

bool duplicate = false;

for (const core::String& existing : names)

{

if (existing == name)

{

duplicate = true;

break;

}

}

if (!duplicate)

{

names.push_back(name);

}

cursor = name_key + 6;

}

return names;

{

while (!value.empty() && value.back() == '/')

{

value.pop_back();

}

return value;

{

const core::String trimmed_base = strip_trailing_slashes(base);

if (path.empty())

{

return trimmed_base;

}

return path.front() == '/' ? trimmed_base + path : trimmed_base + "/" + path;

{

const core::String needle = "\"" + field_name + "\":";

const size_t field_index = json.find(needle);

if (field_index == core::String::npos)

{

return false;

}

size_t cursor = field_index + needle.size();

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

{

++cursor;

}

const size_t start = cursor;

if (cursor < json.size() && json[cursor] == '-')

{

++cursor;

}

while (cursor < json.size() && std::isdigit(static_cast<unsigned char>(json[cursor])))

{

++cursor;

}

if (cursor == start)

{

return false;

}

out_value = std::atoi(json.substr(start, cursor - start).c_str());

return true;

{

const core::String needle = "\"" + field_name + "\":";

const size_t field_index = json.find(needle);

if (field_index == core::String::npos)

{

return json;

}

size_t cursor = field_index + needle.size();

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

{

++cursor;

}

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

{

return json;

}

const size_t value_start = cursor;

++cursor;

while (cursor < json.size())

{

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

{

cursor += 2;

continue;

}

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

{

++cursor;

break;

}

++cursor;

}

const size_t value_end = cursor;

return json.substr(0, value_start) + "\"" + net::escape_json_string(new_value) + "\"" + json.substr(value_end);

{

return tool_name == "run_command"

|| tool_name == "run_ffmpeg"

|| tool_name == "write_file"

|| tool_name == "open_application"

|| tool_name == "launch_connector"

|| tool_name == "stop_connector"

|| tool_name == "enqueue_task"

|| tool_name == "cancel_task"

|| tool_name == "copy_file"

|| tool_name == "move_path"

|| tool_name == "delete_file"

|| tool_name == "create_directory"

|| tool_name == "write_clipboard";

{

core::Array<core::String> lines;

size_t start = 0;

while (start <= text.size())

{

const size_t newline = text.find('\n', start);

core::String line = text.substr(start, newline == core::String::npos ? core::String::npos : newline - start);

while (!line.empty() && (line.back() == '\r' || line.back() == ' '))

{

line.pop_back();

}

if (!line.empty())

{

lines.push_back(line);

}

if (newline == core::String::npos)

{

break;

}

start = newline + 1;

}

const size_t take = lines.size() < max_lines ? lines.size() : max_lines;

core::String joined;

for (size_t index = lines.size() - take; index < lines.size(); ++index)

{

if (!joined.empty())

{

joined += " | ";

}

joined += lines[index];

}

return joined;

{

if (!result.error_message.empty())

{

return result.error_message;

}

const core::String stderr_tail = last_nonempty_lines(result.stderr_text, 3);

if (!stderr_tail.empty())

{

return stderr_tail;

}

return last_nonempty_lines(result.stdout_text, 3);

{

std::lock_guard<std::mutex> lock(mutex_);

config_ = config;

{

{

std::lock_guard<std::mutex> lock(mutex_);

droidcli::initialize_defaults();

// Queried once, up front, so every route/tool/log line that reports

// "where droidcli is running" (build_system_info_json, the

// get_system_info agent tool, the system prompt below) agrees with

// each other instead of re-querying the OS independently.

system_info_ = get_system_info();

// Hardware inventory only runs if the human opted in at startup

// (--enable-hardware-scan) - see HostConfig::enable_hardware_scan.

// Left default-constructed (empty) otherwise; build_hardware_info_json

// reports that honestly rather than presenting zeroed fields as data.

if (config_.enable_hardware_scan)

{

hardware_info_ = scan_hardware_info();

}

// Durable session log: logs/log.jsonl accumulates across restarts so

// a crash or a bug report can be diagnosed after the fact, not just

// while the process happens to still be up. Structured JSONL (one

// JSON object per line, see append_app_log()), not the bracketed

// plain-text format the console gets. Created relative to the

// working directory droidcli was launched from - if that directory

// isn't writable, log_file_ just stays closed and append_app_log()

// silently skips the file write (console/in-memory logging still

// works either way).

std::error_code log_dir_error;

std::filesystem::create_directories("logs", log_dir_error);

log_file_.open("logs/log.jsonl", std::ios::app);

if (log_file_)

{

log_file_ << "{" << net::json_string_field("event", "session_started") << ","

<< net::json_string_field("ts", make_full_log_timestamp()) << "}" << std::endl;

log_file_ << "{" << net::json_string_field("event", "system_detected") << ","

<< net::json_string_field("os_name", system_info_.os_name) << ","

<< net::json_string_field("os_version", system_info_.os_version) << ","

<< net::json_string_field("architecture", system_info_.architecture) << ","

<< net::json_string_field("hostname", system_info_.hostname) << ","

<< net::json_string_field("cwd", system_info_.cwd) << ","

<< net::json_string_field("ts", make_full_log_timestamp()) << "}" << std::endl;

}

session_.active = true;

session_.map_name = "droidcli";

session_.build_label = "daemon";

session_.http_enabled = true;

session_.http_router_bound = true;

session_.features.networking = true;

session_.features.ui = false;

session_.features.ai = config_.enable_ai;

session_.features.recording = true;

language_ai_transport_.post_json = [](

const core::String& url,

const core::String& body,

const core::Array<core::String>& headers,

int32_t& status_code_out,

core::String& response_body_out)

{

return tools::sync_http_post_json(url, body, status_code_out, response_body_out, headers);

};

if (config_.enable_ai)

{

language_ai_.set_runtime_enabled(true);

ai::OpenAICompatConfig ollama_config;

ollama_config.base_url = config_.ollama_url;

ollama_config.model = config_.ollama_model;

ollama_config.enabled = true;

ollama_config.num_ctx = config_.ollama_num_ctx;

language_ai_.set_ollama_config(ollama_config);

if (!config_.system_prompt.empty())

{

// Appended rather than baked into HostConfig::system_prompt's

// static default text, since system_info_ is only known once

// initialize() actually queries the OS.

const core::String prompt_with_system_info = config_.system_prompt

+ " You are currently running on " + system_info_.os_name

+ " " + system_info_.os_version + " (" + system_info_.architecture

+ "), hostname " + system_info_.hostname

+ ", working directory " + system_info_.cwd

+ (system_info_.desktop_path.empty()

? core::String()

: ", the user's Desktop folder is at " + system_info_.desktop_path

+ " - use this exact path when a request mentions \"the Desktop\", "

"never guess a \"C:\\Users\\<name>\\Desktop\"-style path yourself")

+ " - call get_system_info if you need these details again mid-conversation.";

language_ai_.set_system_prompt(prompt_with_system_info);

}

}

else

{

language_ai_.set_runtime_enabled(false);

}

// Scan once at startup, not per-lookup: this walks potentially

// hundreds of registry keys (Windows Uninstall/Add-Remove-Programs

// entries) and touches disk to resolve some paths. Lets

// open_application()/find_application resolve names like "Blender"

// or "KiCad" that installers never add to PATH or the App Paths

// registry key - most installers only ever register an Add/Remove

// Programs entry.

installed_apps_ = scan_installed_applications();

// Real, discoverable Windows locations (known folders, Administrative

// Tools shortcuts) plus the small hardcoded exception list for the

// two categories with no discoverable API - see windows_locations.hpp.

// Same scan-once-at-startup lifecycle as installed_apps_ above.

windows_locations_ = scan_windows_locations();

// Persistent agent-turn memory (see "Persistent memory" in

// ARCHITECTURE.md's extension plan) - a fresh session id every

// process start (no auto-resume; a caller opts in by passing a

// prior session_id explicitly, see agent_turn()). A failed open()

// (bad working directory, disk full) leaves memory_store_ closed;

// record_agent_message()/history routes degrade to in-memory-only

// behavior rather than crashing the daemon over it.

current_session_id_ = generate_session_id();

std::error_code db_dir_error;

std::filesystem::create_directories("db", db_dir_error);

if (!memory_store_.open("db/droidcli_memory.sqlite3"))

{

append_app_log("host", "event", "warning: could not open db/droidcli_memory.sqlite3 - agent history will not persist across restarts", false);

}

}

append_app_log("host", "event",

"droidcli host initialized (" + std::to_string(installed_apps_.size()) + " installed apps indexed"

+ (config_.enable_hardware_scan ? ", hardware scan enabled" : ", hardware scan disabled") + ")",

true);

{

(void)delta_seconds;

tick_watchdog();

tick_tasks();

{

net::HandlerContext context;

context.session = session_;

if (config_.enable_ai)

{

context.language_ai = &language_ai_;

context.language_ai_transport = &language_ai_transport_;

}

return context;

{

std::lock_guard<std::mutex> lock(mutex_);

net::RouteDispatchResult result = routes_.dispatch(request, make_handler_context());

if (result.notify.has_notify_message)

{

on_notify(result.notify.notify_message.text);

}

return result;

{

notify_log_.push_back(message);

if (notify_log_.size() > 64)

{

notify_log_.erase(notify_log_.begin());

}

std::cout << "[notify] " << message << std::endl;

{

std::lock_guard<std::mutex> lock(mutex_);

std::ostringstream stream;

stream << "{\"entries\":[";

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

{

if (index > 0)

{

stream << ',';

}

stream << '{';

stream << net::json_string_field("message", notify_log_[index]);

stream << '}';

}

stream << "]}";

return stream.str();

{

std::lock_guard<std::mutex> lock(mutex_);

std::ostringstream stream;

stream << '{';

stream << net::json_string_field("host", "droidcli") << ',';

stream << net::json_string_field("map", session_.map_name) << ',';

stream << net::json_string_field("build", session_.build_label) << ',';

stream << net::json_bool_field("active", session_.active) << ',';

stream << net::json_bool_field("ai_enabled", config_.enable_ai) << ',';

stream << "\"connector_count\":" << connectors_.list_connectors().size() << ',';

stream << "\"task_count\":" << tasks_.list().size();

stream << '}';

return stream.str();

{

std::lock_guard<std::mutex> lock(mutex_);

std::ostringstream stream;

stream << '{';

stream << net::json_bool_field("ai_enabled", config_.enable_ai) << ',';

stream << net::json_string_field("ollama_url", config_.ollama_url) << ',';

stream << net::json_string_field("ollama_model", config_.ollama_model);

stream << '}';

return stream.str();

{

std::lock_guard<std::mutex> lock(mutex_);

return config_.ollama_model;

{

std::lock_guard<std::mutex> lock(mutex_);

const core::String ollama_url = net::extract_json_string_field(body, "ollama_url");

if (!ollama_url.empty())

{

config_.ollama_url = ollama_url;

}

const core::String ollama_model = net::extract_json_string_field(body, "ollama_model");

if (!ollama_model.empty())

{

config_.ollama_model = ollama_model;

}

if (config_.enable_ai)

{

ai::OpenAICompatConfig ollama_config;

ollama_config.base_url = config_.ollama_url;

ollama_config.model = config_.ollama_model;

ollama_config.enabled = true;

ollama_config.num_ctx = config_.ollama_num_ctx;

language_ai_.set_ollama_config(ollama_config);

}

persist_current_settings_locked();

std::ostringstream stream;

stream << '{';

stream << net::json_bool_field("success", true) << ',';

stream << net::json_bool_field("ai_enabled", config_.enable_ai) << ',';

stream << net::json_string_field("ollama_url", config_.ollama_url) << ',';

stream << net::json_string_field("ollama_model", config_.ollama_model);

stream << '}';

return stream.str();

const core::String& channel,

const core::String& direction,

const core::String& summary,

const bool success,

const core::String& session_id,

const core::String& extra_json_fields)

{

std::lock_guard<std::mutex> lock(mutex_);

AppLogEntry entry;

entry.timestamp = make_log_timestamp();

entry.channel = channel;

entry.direction = direction;

entry.summary = summary;

entry.success = success;

app_log_.push_back(entry);

if (app_log_.size() > 256)

{

app_log_.erase(app_log_.begin());

}

// Console/stderr output stays a human-readable line - this is for a

// person watching the terminal, not for durable structured storage.

const core::String line = "[" + entry.timestamp + "] ["

+ entry.channel + "] [" + entry.direction + "] " + entry.summary;

if (success)

{

std::cout << line << std::endl;

}

else

{

std::cerr << line << std::endl;

}

// Durable file log (logs/log.jsonl) is structured JSONL - one JSON

// object per line, no bracketed-text formatting - so any tool can parse

// it without re-deriving the console format's escaping rules. See

// "Structured JSONL logging" in ARCHITECTURE.md's extension plan.

if (log_file_)

{

core::String json_line = "{"

+ net::json_string_field("ts", make_full_log_timestamp()) + ","

+ net::json_string_field("channel", channel) + ","

+ net::json_string_field("direction", direction) + ","

+ net::json_string_field("summary", summary) + ","

+ net::json_bool_field("success", success);

if (!session_id.empty())

{

json_line += "," + net::json_string_field("session_id", session_id);

}

if (!extra_json_fields.empty())

{

json_line += "," + extra_json_fields;

}

json_line += "}";

log_file_ << json_line << std::endl;

}

{

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[32] {};

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

return buffer;

{

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[32] {};

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

return buffer;

{

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[32] {};

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

// A timestamp alone can collide if two sessions start within the same

// second (e.g. --no-ai smoke tests launched back to back); a few bits

// of the address of a stack-local disambiguate without pulling in a

// UUID/random dependency for something that only needs to be

// locally-unique, not globally-unique or unpredictable.

int disambiguator = 0;

const auto address_bits = reinterpret_cast<std::uintptr_t>(&disambiguator);

std::ostringstream stream;

stream << buffer << "-" << std::hex << (address_bits & 0xffff);

return stream.str();

const std::time_t now_utc,

std::time_t& last_emit_utc,

const int32_t min_interval_seconds)

{

if (now_utc <= 0)

{

return true;

}

if (last_emit_utc == 0 || (now_utc - last_emit_utc) >= min_interval_seconds)

{

last_emit_utc = now_utc;

return true;

}

return false;

{

if (!config_.enable_ai)

{

// --no-ai means there's nothing to watch - don't manufacture

// "Ollama unreachable" noise for a backend the operator deliberately

// turned off.

return;

}

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

std::time_t last_check = watchdog_last_check_utc_;

if (!should_emit_periodic_log(now_utc, last_check, kWatchdogIntervalSeconds))

{

return;

}

watchdog_last_check_utc_ = last_check;

core::String ollama_url_copy;

{

std::lock_guard<std::mutex> lock(mutex_);

ollama_url_copy = config_.ollama_url;

}

const core::String tags_url = strip_trailing_slashes(ollama_url_copy) + "/api/tags";

int32_t status_code = 0;

core::String response_body;

const bool transport_ok = tools::sync_http_get(tags_url, status_code, response_body);

const bool reachable = transport_ok && status_code >= 200 && status_code < 300;

using namespace std::chrono;

const int64_t checked_at_ms = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();

bool was_reachable = true;

{

std::lock_guard<std::mutex> lock(mutex_);

was_reachable = ollama_reachable_;

ollama_reachable_ = reachable;