/**
 * Copyright (c) 2007-2022, Timothy Stack
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * * Neither the name of Timothy Stack nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <fstream>
#include <regex>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

#include "lnav.hh"

#include <fnmatch.h>
#include <glob.h>
#include <sys/stat.h>
#include <termios.h>

#include "base/attr_line.builder.hh"
#include "base/auto_mem.hh"
#include "base/fs_util.hh"
#include "base/humanize.network.hh"
#include "base/injector.hh"
#include "base/isc.hh"
#include "base/itertools.hh"
#include "base/paths.hh"
#include "base/string_util.hh"
#include "bound_tags.hh"
#include "command_executor.hh"
#include "config.h"
#include "curl_looper.hh"
#include "db_sub_source.hh"
#include "field_overlay_source.hh"
#include "fmt/printf.h"
#include "lnav.indexing.hh"
#include "lnav_commands.hh"
#include "lnav_config.hh"
#include "lnav_util.hh"
#include "log_data_helper.hh"
#include "log_data_table.hh"
#include "log_search_table.hh"
#include "readline_callbacks.hh"
#include "readline_curses.hh"
#include "readline_highlighters.hh"
#include "readline_possibilities.hh"
#include "relative_time.hh"
#include "scn/scn.h"
#include "service_tags.hh"
#include "session.export.hh"
#include "session_data.hh"
#include "shlex.hh"
#include "spectro_impls.hh"
#include "sqlite-extension-func.hh"
#include "sysclip.hh"
#include "tailer/tailer.looper.hh"
#include "url_loader.hh"
#include "yajl/api/yajl_parse.h"
#include "yajlpp/json_op.hh"
#include "yajlpp/yajlpp.hh"

using namespace lnav::roles::literals;

static std::string
remaining_args(const std::string& cmdline,
               const std::vector<std::string>& args,
               size_t index = 1)
{
    size_t start_pos = 0;

    require(index > 0);

    if (index >= args.size()) {
        return "";
    }
    for (size_t lpc = 0; lpc < index; lpc++) {
        start_pos += args[lpc].length();
    }

    size_t index_in_cmdline = cmdline.find(args[index], start_pos);

    require(index_in_cmdline != std::string::npos);

    return cmdline.substr(index_in_cmdline);
}

static string_fragment
remaining_args_frag(const std::string& cmdline,
                    const std::vector<std::string>& args,
                    size_t index = 1)
{
    size_t start_pos = 0;

    require(index > 0);

    if (index >= args.size()) {
        return string_fragment{};
    }
    for (size_t lpc = 0; lpc < index; lpc++) {
        start_pos += args[lpc].length();
    }

    size_t index_in_cmdline = cmdline.find(args[index], start_pos);

    require(index_in_cmdline != std::string::npos);

    return string_fragment::from_str_range(
        cmdline, index_in_cmdline, cmdline.size());
}

static nonstd::optional<std::string>
find_arg(std::vector<std::string>& args, const std::string& flag)
{
    auto iter = find_if(args.begin(), args.end(), [&flag](const auto elem) {
        return startswith(elem, flag);
    });

    if (iter == args.end()) {
        return nonstd::nullopt;
    }

    auto index = iter->find('=');
    if (index == std::string::npos) {
        return "";
    }

    auto retval = iter->substr(index + 1);

    args.erase(iter);

    return retval;
}

static bookmark_vector<vis_line_t>
combined_user_marks(vis_bookmarks& vb)
{
    const auto& bv = vb[&textview_curses::BM_USER];
    const auto& bv_expr = vb[&textview_curses::BM_USER_EXPR];
    bookmark_vector<vis_line_t> retval;

    for (const auto row : bv) {
        retval.insert_once(row);
    }
    for (const auto row : bv_expr) {
        retval.insert_once(row);
    }
    return retval;
}

static Result<std::string, lnav::console::user_message>
com_adjust_log_time(exec_context& ec,
                    std::string cmdline,
                    std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("line-time");
    } else if (lnav_data.ld_views[LNV_LOG].get_inner_height() == 0) {
        return ec.make_error("no log messages");
    } else if (args.size() >= 2) {
        auto& lss = lnav_data.ld_log_source;
        struct timeval top_time, time_diff;
        struct timeval new_time = {0, 0};
        content_line_t top_content;
        date_time_scanner dts;
        vis_line_t top_line;
        struct exttm tm;
        struct tm base_tm;
        std::shared_ptr<logfile> lf;

        top_line = lnav_data.ld_views[LNV_LOG].get_selection();
        top_content = lss.at(top_line);
        lf = lss.find(top_content);

        auto& ll = (*lf)[top_content];

        top_time = ll.get_timeval();
        localtime_r(&top_time.tv_sec, &base_tm);

        dts.set_base_time(top_time.tv_sec, base_tm);
        args[1] = remaining_args(cmdline, args);

        auto parse_res = relative_time::from_str(args[1]);
        if (parse_res.isOk()) {
            new_time = parse_res.unwrap().adjust(top_time).to_timeval();
        } else if (dts.scan(
                       args[1].c_str(), args[1].size(), nullptr, &tm, new_time)
                   != nullptr)
        {
            // nothing to do
        } else {
            return ec.make_error("could not parse timestamp -- {}", args[1]);
        }

        timersub(&new_time, &top_time, &time_diff);
        if (ec.ec_dry_run) {
            char buffer[1024];

            snprintf(
                buffer,
                sizeof(buffer),
                "info: log timestamps will be adjusted by %ld.%06ld seconds",
                time_diff.tv_sec,
                (long) time_diff.tv_usec);

            retval = buffer;
        } else {
            lf->adjust_content_time(top_content, time_diff, false);

            lss.set_force_rebuild();

            retval = "info: adjusted time";
        }
    } else {
        return ec.make_error("expecting new time value");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_unix_time(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (args.size() >= 2) {
        bool parsed = false;
        struct tm log_time;
        time_t u_time;
        size_t millis;
        char* rest;

        u_time = time(nullptr);
        log_time = *localtime(&u_time);

        log_time.tm_isdst = -1;

        args[1] = remaining_args(cmdline, args);
        if ((millis = args[1].find('.')) != std::string::npos
            || (millis = args[1].find(',')) != std::string::npos)
        {
            args[1] = args[1].erase(millis, 4);
        }
        if (((rest = strptime(args[1].c_str(), "%b %d %H:%M:%S %Y", &log_time))
                 != nullptr
             && (rest - args[1].c_str()) >= 20)
            || ((rest
                 = strptime(args[1].c_str(), "%Y-%m-%d %H:%M:%S", &log_time))
                    != nullptr
                && (rest - args[1].c_str()) >= 19))
        {
            u_time = mktime(&log_time);
            parsed = true;
        } else if (sscanf(args[1].c_str(), "%ld", &u_time)) {
            log_time = *localtime(&u_time);

            parsed = true;
        }
        if (parsed) {
            char ftime[128];
            int len;

            strftime(ftime,
                     sizeof(ftime),
                     "%a %b %d %H:%M:%S %Y  %z %Z",
                     localtime(&u_time));
            len = strlen(ftime);
            snprintf(ftime + len, sizeof(ftime) - len, " -- %ld", u_time);
            retval = std::string(ftime);
        } else {
            return ec.make_error("invalid unix time -- {}", args[1]);
        }
    } else {
        return ec.make_error("expecting a unix time value");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_current_time(exec_context& ec,
                 std::string cmdline,
                 std::vector<std::string>& args)
{
    char ftime[128];
    struct tm localtm;
    std::string retval;
    time_t u_time;
    size_t len;

    memset(&localtm, 0, sizeof(localtm));
    u_time = time(nullptr);
    strftime(ftime,
             sizeof(ftime),
             "%a %b %d %H:%M:%S %Y  %z %Z",
             localtime_r(&u_time, &localtm));
    len = strlen(ftime);
    snprintf(ftime + len, sizeof(ftime) - len, " -- %ld", u_time);
    retval = std::string(ftime);

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_goto(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    static const char* INTERACTIVE_FMTS[] = {
        "%B %e %H:%M:%S",
        "%b %e %H:%M:%S",
        "%B %e %H:%M",
        "%b %e %H:%M",
        "%B %e %I:%M%p",
        "%b %e %I:%M%p",
        "%B %e %I%p",
        "%b %e %I%p",
        "%B %e",
        "%b %e",
        nullptr,
    };

    std::string retval;

    if (args.empty()) {
        args.emplace_back("move-args");
    } else if (args.size() > 1) {
        std::string all_args = remaining_args(cmdline, args);
        auto* tc = *lnav_data.ld_view_stack.top();
        nonstd::optional<vis_line_t> dst_vl;

        if (startswith(all_args, "#")) {
            auto* ta = dynamic_cast<text_anchors*>(tc->get_sub_source());

            if (ta == nullptr) {
                return ec.make_error("view does not support anchor links");
            }

            dst_vl = ta->row_for_anchor(all_args);
            if (!dst_vl) {
                return ec.make_error("unable to find anchor: {}", all_args);
            }
        }

        auto* ttt = dynamic_cast<text_time_translator*>(tc->get_sub_source());
        int line_number, consumed;
        date_time_scanner dts;
        const char* scan_end = nullptr;
        struct timeval tv;
        struct exttm tm;
        float value;
        auto parse_res = relative_time::from_str(all_args);

        if (ttt != nullptr && tc->get_inner_height() > 0_vl) {
            auto top_time_opt = ttt->time_for_row(tc->get_top());

            if (top_time_opt) {
                auto top_time_tv = top_time_opt.value();
                struct tm top_tm;

                localtime_r(&top_time_tv.tv_sec, &top_tm);
                dts.set_base_time(top_time_tv.tv_sec, top_tm);
            }
        }

        if (dst_vl) {

        }
        else if (parse_res.isOk()) {
            if (ttt == nullptr) {
                return ec.make_error(
                    "relative time values only work in a time-indexed view");
            }
            if (tc->get_inner_height() == 0_vl) {
                return ec.make_error("view is empty");
            }
            auto tv_opt = ttt->time_for_row(tc->get_top());
            if (!tv_opt) {
                return ec.make_error("cannot get time for the top row");
            }
            tv = tv_opt.value();

            vis_line_t vl = tc->get_top(), new_vl;
            bool done = false;
            auto rt = parse_res.unwrap();

            if (rt.is_relative()) {
                injector::get<relative_time&, last_relative_time_tag>() = rt;
            }

            do {
                auto tm = rt.adjust(tv);

                tv = tm.to_timeval();
                auto new_vl_opt = ttt->row_for_time(tv);
                if (!new_vl_opt) {
                    break;
                }

                new_vl = new_vl_opt.value();
                if (new_vl == 0_vl || new_vl != vl || !rt.is_relative()) {
                    vl = new_vl;
                    done = true;
                }
            } while (!done);

            dst_vl = vl;

            if (!ec.ec_dry_run && !rt.is_absolute()
                && lnav_data.ld_rl_view != nullptr)
            {
                lnav_data.ld_rl_view->set_alt_value(HELP_MSG_2(
                    r, R, "to move forward/backward the same amount of time"));
            }
        } else if ((scan_end = dts.scan(
                        all_args.c_str(), all_args.size(), nullptr, &tm, tv))
                   != nullptr ||
                   (scan_end = dts.scan(
                        all_args.c_str(), all_args.size(), INTERACTIVE_FMTS, &tm, tv))
                   != nullptr)
        {
            if (ttt == nullptr) {
                return ec.make_error(
                    "time values only work in a time-indexed view");
            }

            size_t matched_size = scan_end - all_args.c_str();
            if (matched_size != all_args.size()) {
                auto um
                    = lnav::console::user_message::error(
                          attr_line_t("invalid timestamp: ").append(all_args))
                          .with_reason(
                              attr_line_t("the leading part of the timestamp "
                                          "was matched, however, the trailing "
                                          "text ")
                                  .append_quoted(scan_end)
                                  .append(" was not"))
                          .with_snippets(ec.ec_source)
                          .with_note(
                              attr_line_t("input matched time format ")
                                  .append_quoted(
                                      PTIMEC_FORMATS[dts.dts_fmt_lock].pf_fmt))
                          .with_help(
                              "fix the timestamp or remove the trailing text");

                auto unmatched_size = all_args.size() - matched_size;
                auto& snippet_copy = um.um_snippets.back();
                attr_line_builder alb(snippet_copy.s_content);

                alb.append("\n")
                    .append(1 + cmdline.find(all_args), ' ')
                    .append(matched_size, ' ');
                {
                    auto attr_guard
                        = alb.with_attr(VC_ROLE.value(role_t::VCR_COMMENT));

                    alb.append("^").append(unmatched_size - 2, '-');
                    if (unmatched_size > 1) {
                        alb.append("^");
                    }
                    alb.append(" unrecognized input");
                }
                return Err(um);
            }

            if (!(tm.et_flags & ETF_DAY_SET)) {
                tm.et_tm.tm_mday = 1;
            }
            if (!(tm.et_flags & ETF_HOUR_SET)) {
                tm.et_tm.tm_hour = 0;
            }
            if (!(tm.et_flags & ETF_MINUTE_SET)) {
                tm.et_tm.tm_min = 0;
            }
            if (!(tm.et_flags & ETF_SECOND_SET)) {
                tm.et_tm.tm_sec = 0;
            }
            if (!(tm.et_flags & ETF_MICROS_SET) &&
                !(tm.et_flags & ETF_MILLIS_SET)) {
                tm.et_nsec = 0;
            }
            tv.tv_sec = tm2sec(&tm.et_tm);
            tv.tv_usec = tm.et_nsec / 1000;
            dst_vl = ttt->row_for_time(tv);
        } else if (sscanf(args[1].c_str(), "%f%n", &value, &consumed) == 1) {
            if (args[1][consumed] == '%') {
                line_number
                    = (int) ((double) tc->get_inner_height() * (value / 100.0));
            } else {
                line_number = (int) value;
                if (line_number < 0) {
                    line_number = tc->get_inner_height() + line_number;
                }
            }

            dst_vl = vis_line_t(line_number);
        } else {
            auto um = lnav::console::user_message::error(
                          attr_line_t("invalid argument: ").append(args[1]))
                          .with_reason(
                              "expecting line number/percentage, timestamp, or "
                              "relative time");
            ec.add_error_context(um);
            return Err(um);
        }

        dst_vl | [&ec, tc, &retval](auto new_top) {
            if (ec.ec_dry_run) {
                retval = "info: will move to line "
                    + std::to_string((int) new_top);
            } else {
                tc->get_sub_source()->get_location_history() |
                    [new_top](auto lh) { lh->loc_history_append(new_top); };
                tc->set_selection(new_top);

                retval = "";
            }
        };
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_relative_goto(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    std::string retval = "error: ";

    if (args.empty()) {
    } else if (args.size() > 1) {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        int line_offset, consumed;
        float value;

        if (sscanf(args[1].c_str(), "%f%n", &value, &consumed) == 1) {
            if (args[1][consumed] == '%') {
                line_offset
                    = (int) ((double) tc->get_inner_height() * (value / 100.0));
            } else {
                line_offset = (int) value;
            }

            if (ec.ec_dry_run) {
                retval = "info: shifting top by " + std::to_string(line_offset)
                    + " lines";
            } else {
                tc->shift_top(vis_line_t(line_offset), true);

                retval = "";
            }
        } else {
            return ec.make_error("invalid line number -- {}", args[1]);
        }
    } else {
        return ec.make_error("expecting line number/percentage");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_mark(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty() || lnav_data.ld_view_stack.empty()) {
    } else if (!ec.ec_dry_run) {
        auto* tc = *lnav_data.ld_view_stack.top();
        lnav_data.ld_last_user_mark[tc] = tc->get_top();
        tc->toggle_user_mark(&textview_curses::BM_USER,
                             vis_line_t(lnav_data.ld_last_user_mark[tc]));
        tc->reload_data();
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_mark_expr(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty() || lnav_data.ld_view_stack.empty()) {
        args.emplace_back("filter-expr-syms");
    } else if (args.size() < 2) {
        return ec.make_error("expecting an SQL expression");
    } else if (*lnav_data.ld_view_stack.top() != &lnav_data.ld_views[LNV_LOG]) {
        return ec.make_error(":mark-expr is only supported for the LOG view");
    } else {
        auto expr = remaining_args(cmdline, args);
        auto stmt_str = fmt::format(FMT_STRING("SELECT 1 WHERE {}"), expr);

        auto_mem<sqlite3_stmt> stmt(sqlite3_finalize);
#ifdef SQLITE_PREPARE_PERSISTENT
        auto retcode = sqlite3_prepare_v3(lnav_data.ld_db.in(),
                                          stmt_str.c_str(),
                                          stmt_str.size(),
                                          SQLITE_PREPARE_PERSISTENT,
                                          stmt.out(),
                                          nullptr);
#else
        auto retcode = sqlite3_prepare_v2(lnav_data.ld_db.in(),
                                          stmt_str.c_str(),
                                          stmt_str.size(),
                                          stmt.out(),
                                          nullptr);
#endif
        if (retcode != SQLITE_OK) {
            const char* errmsg = sqlite3_errmsg(lnav_data.ld_db);
            auto expr_al = attr_line_t(expr).with_attr_for_all(
                VC_ROLE.value(role_t::VCR_QUOTED_CODE));
            readline_sqlite_highlighter(expr_al, -1);
            auto um
                = lnav::console::user_message::error(
                      attr_line_t("invalid mark expression: ").append(expr_al))
                      .with_reason(errmsg)
                      .with_snippets(ec.ec_source);

            return Err(um);
        }

        auto& lss = lnav_data.ld_log_source;
        if (ec.ec_dry_run) {
            auto set_res = lss.set_preview_sql_filter(stmt.release());

            if (set_res.isErr()) {
                return Err(set_res.unwrapErr());
            }
            lnav_data.ld_preview_status_source.get_description().set_value(
                "Matches are highlighted in the text view");
        } else {
            auto set_res = lss.set_sql_marker(expr, stmt.release());

            if (set_res.isErr()) {
                return Err(set_res.unwrapErr());
            }
        }
    }

    return Ok(retval);
}

static std::string
com_mark_expr_prompt(exec_context& ec, const std::string& cmdline)
{
    textview_curses* tc = *lnav_data.ld_view_stack.top();

    if (tc != &lnav_data.ld_views[LNV_LOG]) {
        return "";
    }

    return fmt::format(FMT_STRING("{} {}"),
                       trim(cmdline),
                       trim(lnav_data.ld_log_source.get_sql_marker_text()));
}

static Result<std::string, lnav::console::user_message>
com_clear_mark_expr(exec_context& ec,
                    std::string cmdline,
                    std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else {
        if (!ec.ec_dry_run) {
            lnav_data.ld_log_source.set_sql_marker("", nullptr);
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_goto_mark(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("mark-type");
    } else {
        static const std::set<const bookmark_type_t*> DEFAULT_TYPES = {
            &textview_curses::BM_USER,
            &textview_curses::BM_USER_EXPR,
            &textview_curses::BM_META,
        };

        textview_curses* tc = get_textview_for_mode(lnav_data.ld_mode);
        std::set<const bookmark_type_t*> mark_types;

        if (args.size() > 1) {
            for (size_t lpc = 1; lpc < args.size(); lpc++) {
                auto bt_opt = bookmark_type_t::find_type(args[lpc]);
                if (!bt_opt) {
                    auto um
                        = lnav::console::user_message::error(
                              attr_line_t("unknown bookmark type: ")
                                  .append(args[lpc]))
                              .with_snippets(ec.ec_source)
                              .with_help(
                                  attr_line_t("available types: ")
                                      .join(bookmark_type_t::get_all_types()
                                                | lnav::itertools::map(
                                                    &bookmark_type_t::get_name)
                                                | lnav::itertools::sorted(),
                                            ", "));
                    return Err(um);
                }
                mark_types.insert(bt_opt.value());
            }
        } else {
            mark_types = DEFAULT_TYPES;
        }

        if (!ec.ec_dry_run) {
            nonstd::optional<vis_line_t> new_top;

            if (args[0] == "next-mark") {
                auto search_from_top = search_forward_from(tc);

                for (const auto& bt : mark_types) {
                    auto bt_top
                        = next_cluster(&bookmark_vector<vis_line_t>::next,
                                       bt,
                                       search_from_top);

                    if (bt_top && (!new_top || bt_top < new_top.value())) {
                        new_top = bt_top;
                    }
                }

                if (!new_top) {
                    auto um = lnav::console::user_message::info(fmt::format(
                        FMT_STRING("no more {} bookmarks after here"),
                        fmt::join(mark_types
                                      | lnav::itertools::map(
                                          &bookmark_type_t::get_name),
                                  ", ")));

                    return Err(um);
                }
            } else {
                for (const auto& bt : mark_types) {
                    auto bt_top = next_cluster(
                        &bookmark_vector<vis_line_t>::prev, bt, tc->get_top());

                    if (bt_top && (!new_top || bt_top > new_top.value())) {
                        new_top = bt_top;
                    }
                }

                if (!new_top) {
                    auto um = lnav::console::user_message::info(fmt::format(
                        FMT_STRING("no more {} bookmarks before here"),
                        fmt::join(mark_types
                                      | lnav::itertools::map(
                                          &bookmark_type_t::get_name),
                                  ", ")));

                    return Err(um);
                }
            }

            if (new_top) {
                tc->get_sub_source()->get_location_history() |
                    [new_top](auto lh) {
                        lh->loc_history_append(new_top.value());
                    };
                tc->set_selection(new_top.value());
            }
            lnav_data.ld_bottom_source.grep_error("");
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_goto_location(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        lnav_data.ld_view_stack.top() | [&args](auto tc) {
            tc->get_sub_source()->get_location_history() |
                [tc, &args](auto lh) {
                    return args[0] == "prev-location"
                        ? lh->loc_history_back(tc->get_selection())
                        : lh->loc_history_forward(tc->get_selection());
                }
                | [tc](auto new_top) { tc->set_selection(new_top); };
        };
    }

    return Ok(retval);
}

static bool
csv_needs_quoting(const std::string& str)
{
    return (str.find_first_of(",\"\r\n") != std::string::npos);
}

static std::string
csv_quote_string(const std::string& str)
{
    static const std::regex csv_column_quoter("\"");

    std::string retval = std::regex_replace(str, csv_column_quoter, "\"\"");

    retval.insert(0, 1, '\"');
    retval.append(1, '\"');

    return retval;
}

static void
csv_write_string(FILE* outfile, const std::string& str)
{
    if (csv_needs_quoting(str)) {
        std::string quoted_str = csv_quote_string(str);

        fmt::fprintf(outfile, "%s", quoted_str);
    } else {
        fmt::fprintf(outfile, "%s", str);
    }
}

static void
yajl_writer(void* context, const char* str, size_t len)
{
    FILE* file = (FILE*) context;

    fwrite(str, len, 1, file);
}

static void
json_write_row(yajl_gen handle, int row)
{
    db_label_source& dls = lnav_data.ld_db_row_source;
    yajlpp_map obj_map(handle);

    for (size_t col = 0; col < dls.dls_headers.size(); col++) {
        obj_map.gen(dls.dls_headers[col].hm_name);

        if (dls.dls_rows[row][col] == db_label_source::NULL_STR) {
            obj_map.gen();
            continue;
        }

        db_label_source::header_meta& hm = dls.dls_headers[col];

        switch (hm.hm_column_type) {
            case SQLITE_FLOAT:
            case SQLITE_INTEGER: {
                auto len = strlen(dls.dls_rows[row][col]);

                if (len == 0) {
                    obj_map.gen();
                } else {
                    yajl_gen_number(handle, dls.dls_rows[row][col], len);
                }
                break;
            }
            case SQLITE_TEXT:
                switch (hm.hm_sub_type) {
                    case 74: {
                        auto_mem<yajl_handle_t> parse_handle(yajl_free);
                        unsigned char* err;
                        json_ptr jp("");
                        json_op jo(jp);

                        jo.jo_ptr_callbacks = json_op::gen_callbacks;
                        jo.jo_ptr_data = handle;
                        parse_handle.reset(
                            yajl_alloc(&json_op::ptr_callbacks, nullptr, &jo));

                        const unsigned char* json_in
                            = (const unsigned char*) dls.dls_rows[row][col];
                        switch (yajl_parse(parse_handle.in(),
                                           json_in,
                                           strlen((const char*) json_in)))
                        {
                            case yajl_status_error:
                            case yajl_status_client_canceled: {
                                err = yajl_get_error(
                                    parse_handle.in(),
                                    0,
                                    json_in,
                                    strlen((const char*) json_in));
                                log_error("unable to parse JSON cell: %s", err);
                                obj_map.gen(dls.dls_rows[row][col]);
                                yajl_free_error(parse_handle.in(), err);
                                return;
                            }
                            default:
                                break;
                        }

                        switch (yajl_complete_parse(parse_handle.in())) {
                            case yajl_status_error:
                            case yajl_status_client_canceled: {
                                err = yajl_get_error(
                                    parse_handle.in(),
                                    0,
                                    json_in,
                                    strlen((const char*) json_in));
                                log_error("unable to parse JSON cell: %s", err);
                                obj_map.gen(dls.dls_rows[row][col]);
                                yajl_free_error(parse_handle.in(), err);
                                return;
                            }
                            default:
                                break;
                        }
                        break;
                    }
                    default:
                        obj_map.gen(dls.dls_rows[row][col]);
                        break;
                }
                break;
            default:
                obj_map.gen(dls.dls_rows[row][col]);
                break;
        }
    }
}

static Result<std::string, lnav::console::user_message>
com_save_to(exec_context& ec,
            std::string cmdline,
            std::vector<std::string>& args)
{
    FILE *outfile = nullptr, *toclose = nullptr;
    const char* mode = "";
    std::string fn, retval;
    bool to_term = false;
    int (*closer)(FILE*) = fclose;

    if (args.empty()) {
        args.emplace_back("filename");
        return Ok(std::string());
    }

    fn = trim(remaining_args(cmdline, args));

    std::vector<std::string> split_args;
    shlex lexer(fn);

    if (!lexer.split(split_args, ec.create_resolver())) {
        return ec.make_error("unable to parse arguments");
    }

    auto* tc = *lnav_data.ld_view_stack.top();
    auto opt_view_name = find_arg(split_args, "--view");
    if (opt_view_name) {
        auto opt_view_index = view_from_string(opt_view_name->c_str());

        if (!opt_view_index) {
            return ec.make_error("invalid view name: {}", *opt_view_name);
        }

        tc = &lnav_data.ld_views[*opt_view_index];
    }

    if (split_args.empty()) {
        return ec.make_error(
            "expecting file name or '-' to write to the terminal");
    }

    if (split_args.size() > 1) {
        return ec.make_error("more than one file name was matched");
    }

    if (args[0] == "append-to") {
        mode = "a";
    } else {
        mode = "w";
    }

    auto& dls = lnav_data.ld_db_row_source;
    bookmark_vector<vis_line_t> all_user_marks;

    if (args[0] == "write-csv-to" || args[0] == "write-json-to"
        || args[0] == "write-jsonlines-to" || args[0] == "write-cols-to"
        || args[0] == "write-table-to")
    {
        if (dls.dls_headers.empty()) {
            return ec.make_error(
                "no query result to write, use ';' to execute a query");
        }
    } else if (args[0] == "write-raw-to" && tc == &lnav_data.ld_views[LNV_DB]) {
    } else if (args[0] != "write-screen-to" && args[0] != "write-view-to") {
        all_user_marks = combined_user_marks(tc->get_bookmarks());
        if (all_user_marks.empty()) {
            return ec.make_error(
                "no lines marked to write, use 'm' to mark lines");
        }
    }

    if (ec.ec_dry_run) {
        outfile = tmpfile();
        toclose = outfile;
    } else if (split_args[0] == "-" || split_args[0] == "/dev/stdout") {
        auto ec_out = ec.get_output();

        if (!ec_out) {
            outfile = stdout;
            nodelay(lnav_data.ld_window, 0);
            endwin();
            struct termios curr_termios;
            tcgetattr(1, &curr_termios);
            curr_termios.c_oflag |= ONLCR | OPOST;
            tcsetattr(1, TCSANOW, &curr_termios);
            setvbuf(stdout, nullptr, _IONBF, 0);
            to_term = true;
            fprintf(outfile,
                    "\n---------------- Press any key to exit lo-fi display "
                    "----------------\n\n");
        } else {
            outfile = *ec_out;
        }
        if (outfile == stdout) {
            lnav_data.ld_stdout_used = true;
        }
    } else if (split_args[0] == "/dev/clipboard") {
        auto open_res = sysclip::open(sysclip::type_t::GENERAL);
        if (open_res.isErr()) {
            alerter::singleton().chime("cannot open clipboard");
            return ec.make_error("Unable to copy to clipboard: {}",
                                 open_res.unwrapErr());
        }
        auto holder = open_res.unwrap();
        toclose = outfile = holder.release();
        closer = holder.get_free_func<int (*)(FILE*)>();
    } else if (lnav_data.ld_flags & LNF_SECURE_MODE) {
        return ec.make_error("{} -- unavailable in secure mode", args[0]);
    } else if ((outfile = fopen(split_args[0].c_str(), mode)) == nullptr) {
        return ec.make_error("unable to open file -- {}", split_args[0]);
    } else {
        toclose = outfile;
    }

    int line_count = 0;

    if (args[0] == "write-csv-to") {
        std::vector<std::vector<const char*>>::iterator row_iter;
        std::vector<const char*>::iterator iter;
        std::vector<db_label_source::header_meta>::iterator hdr_iter;
        bool first = true;

        for (hdr_iter = dls.dls_headers.begin();
             hdr_iter != dls.dls_headers.end();
             ++hdr_iter)
        {
            if (!first) {
                fprintf(outfile, ",");
            }
            csv_write_string(outfile, hdr_iter->hm_name);
            first = false;
        }
        fprintf(outfile, "\n");

        for (row_iter = dls.dls_rows.begin(); row_iter != dls.dls_rows.end();
             ++row_iter)
        {
            if (ec.ec_dry_run && distance(dls.dls_rows.begin(), row_iter) > 10)
            {
                break;
            }

            first = true;
            for (iter = row_iter->begin(); iter != row_iter->end(); ++iter) {
                if (!first) {
                    fprintf(outfile, ",");
                }
                csv_write_string(outfile, *iter);
                first = false;
            }
            fprintf(outfile, "\n");

            line_count += 1;
        }
    } else if (args[0] == "write-cols-to" || args[0] == "write-table-to") {
        bool first = true;

        fprintf(outfile, "\u250f");
        for (const auto& hdr : dls.dls_headers) {
            auto cell_line = repeat("\u2501", hdr.hm_column_size);

            if (!first) {
                fprintf(outfile, "\u2533");
            }
            fprintf(outfile, "%s", cell_line.c_str());
            first = false;
        }
        fprintf(outfile, "\u2513\n");

        for (const auto& hdr : dls.dls_headers) {
            auto centered_hdr = center_str(hdr.hm_name, hdr.hm_column_size);

            fprintf(outfile, "\u2503");
            fprintf(outfile, "%s", centered_hdr.c_str());
        }
        fprintf(outfile, "\u2503\n");

        first = true;
        fprintf(outfile, "\u2521");
        for (const auto& hdr : dls.dls_headers) {
            auto cell_line = repeat("\u2501", hdr.hm_column_size);

            if (!first) {
                fprintf(outfile, "\u2547");
            }
            fprintf(outfile, "%s", cell_line.c_str());
            first = false;
        }
        fprintf(outfile, "\u2529\n");

        for (size_t row = 0; row < dls.text_line_count(); row++) {
            if (ec.ec_dry_run && row > 10) {
                break;
            }

            for (size_t col = 0; col < dls.dls_headers.size(); col++) {
                const auto& hdr = dls.dls_headers[col];

                fprintf(outfile, "\u2502");

                auto cell = dls.dls_rows[row][col];
                auto cell_byte_len = strlen(cell);
                auto cell_length = utf8_string_length(cell, cell_byte_len)
                                       .unwrapOr(cell_byte_len);
                auto padding = hdr.hm_column_size - cell_length;

                if (hdr.hm_column_type != SQLITE3_TEXT) {
                    fprintf(outfile, "%s", std::string(padding, ' ').c_str());
                }
                fprintf(outfile, "%s", cell);
                if (hdr.hm_column_type == SQLITE3_TEXT) {
                    fprintf(outfile, "%s", std::string(padding, ' ').c_str());
                }
            }
            fprintf(outfile, "\u2502\n");

            line_count += 1;
        }

        first = true;
        fprintf(outfile, "\u2514");
        for (const auto& hdr : dls.dls_headers) {
            auto cell_line = repeat("\u2501", hdr.hm_column_size);

            if (!first) {
                fprintf(outfile, "\u2534");
            }
            fprintf(outfile, "%s", cell_line.c_str());
            first = false;
        }
        fprintf(outfile, "\u2518\n");

    } else if (args[0] == "write-json-to") {
        yajlpp_gen gen;

        yajl_gen_config(gen, yajl_gen_beautify, 1);
        yajl_gen_config(gen, yajl_gen_print_callback, yajl_writer, outfile);

        {
            yajlpp_array root_array(gen);

            for (size_t row = 0; row < dls.dls_rows.size(); row++) {
                if (ec.ec_dry_run && row > 10) {
                    break;
                }

                json_write_row(gen, row);
                line_count += 1;
            }
        }
    } else if (args[0] == "write-jsonlines-to") {
        yajlpp_gen gen;

        yajl_gen_config(gen, yajl_gen_beautify, 0);
        yajl_gen_config(gen, yajl_gen_print_callback, yajl_writer, outfile);

        for (size_t row = 0; row < dls.dls_rows.size(); row++) {
            if (ec.ec_dry_run && row > 10) {
                break;
            }

            json_write_row(gen, row);
            yajl_gen_reset(gen, "\n");
            line_count += 1;
        }
    } else if (args[0] == "write-screen-to") {
        bool wrapped = tc->get_word_wrap();
        vis_line_t orig_top = tc->get_top();

        tc->set_word_wrap(to_term);

        vis_line_t top = tc->get_top();
        vis_line_t bottom = tc->get_bottom();
        if (lnav_data.ld_flags & LNF_HEADLESS && tc->get_inner_height() > 0_vl)
        {
            bottom = tc->get_inner_height() - 1_vl;
        }
        auto y = 0_vl;
        auto wrapped_count = 0_vl;
        std::vector<attr_line_t> rows(bottom - top + 1);
        auto dim = tc->get_dimensions();
        attr_line_t ov_al;

        auto* los = tc->get_overlay_source();
        tc->listview_value_for_rows(*tc, top, rows);
        for (const auto& al : rows) {
            while (los != nullptr
                   && los->list_value_for_overlay(
                       *tc, y, tc->get_inner_height(), top, ov_al))
            {
                write_line_to(outfile, ov_al);
                ++y;
            }
            wrapped_count += vis_line_t((al.length() - 1) / (dim.second - 2));
            write_line_to(outfile, al);

            line_count += 1;
            ++top;
            ++y;
        }
        while (los != nullptr
               && los->list_value_for_overlay(
                   *tc, y, tc->get_inner_height(), top, ov_al)
               && !ov_al.empty())
        {
            write_line_to(outfile, ov_al);
            ++y;
        }

        tc->set_word_wrap(wrapped);
        tc->set_top(orig_top);

        if (!(lnav_data.ld_flags & LNF_HEADLESS)) {
            while (y + wrapped_count < dim.first + 2_vl) {
                fmt::print(outfile, FMT_STRING("\n"));
                ++y;
            }
        }
    } else if (args[0] == "write-raw-to") {
        if (tc == &lnav_data.ld_views[LNV_DB]) {
            for (auto row_iter = dls.dls_rows.begin();
                 row_iter != dls.dls_rows.end();
                 ++row_iter)
            {
                if (ec.ec_dry_run
                    && distance(dls.dls_rows.begin(), row_iter) > 10)
                {
                    break;
                }

                for (auto& iter : *row_iter) {
                    fputs(iter, outfile);
                }
                fprintf(outfile, "\n");

                line_count += 1;
            }
        } else if (tc == &lnav_data.ld_views[LNV_LOG]) {
            nonstd::optional<std::pair<logfile*, content_line_t>> last_line;
            bookmark_vector<vis_line_t> visited;
            auto& lss = lnav_data.ld_log_source;
            std::vector<attr_line_t> rows(1);
            size_t count = 0;
            std::string line;

            for (auto iter = all_user_marks.begin();
                 iter != all_user_marks.end();
                 iter++, count++)
            {
                if (ec.ec_dry_run && count > 10) {
                    break;
                }
                auto cl = lss.at(*iter);
                auto lf = lss.find(cl);
                auto lf_iter = lf->begin() + cl;

                while (lf_iter->get_sub_offset() != 0) {
                    --lf_iter;
                }

                auto line_pair = std::make_pair(
                    lf.get(),
                    content_line_t(std::distance(lf->begin(), lf_iter)));
                if (last_line && last_line.value() == line_pair) {
                    continue;
                }
                last_line = line_pair;
                auto read_res = lf->read_raw_message(lf_iter);
                if (read_res.isErr()) {
                    log_error("unable to read message: %s",
                              read_res.unwrapErr().c_str());
                    continue;
                }
                auto sbr = read_res.unwrap();
                fprintf(outfile, "%.*s\n", (int) sbr.length(), sbr.get_data());

                line_count += 1;
            }
        }
    } else if (args[0] == "write-view-to") {
        bool wrapped = tc->get_word_wrap();
        auto tss = tc->get_sub_source();

        tc->set_word_wrap(to_term);

        for (size_t lpc = 0; lpc < tss->text_line_count(); lpc++) {
            if (ec.ec_dry_run && lpc >= 10) {
                break;
            }

            std::string line;

            tss->text_value_for_line(*tc, lpc, line, text_sub_source::RF_RAW);
            fprintf(outfile, "%s\n", line.c_str());

            line_count += 1;
        }

        tc->set_word_wrap(wrapped);
    } else {
        auto* los = tc->get_overlay_source();
        std::vector<attr_line_t> rows(1);
        attr_line_t ov_al;
        size_t count = 0;

        for (auto iter = all_user_marks.begin(); iter != all_user_marks.end();
             iter++, count++)
        {
            if (ec.ec_dry_run && count > 10) {
                break;
            }
            tc->listview_value_for_rows(*tc, *iter, rows);
            write_line_to(outfile, rows[0]);

            auto y = 1_vl;
            while (los != nullptr
                   && los->list_value_for_overlay(
                       *tc, y, tc->get_inner_height(), *iter, ov_al))
            {
                write_line_to(outfile, ov_al);
                ++y;
            }

            line_count += 1;
        }
    }

    fflush(outfile);

    if (to_term) {
        cbreak();
        getch();
        refresh();
        nodelay(lnav_data.ld_window, 1);
    }
    if (ec.ec_dry_run) {
        rewind(outfile);

        char buffer[32 * 1024];
        size_t rc = fread(buffer, 1, sizeof(buffer), outfile);

        attr_line_t al(std::string(buffer, rc));

        lnav_data.ld_preview_source.replace_with(al)
            .set_text_format(detect_text_format(al.get_string()))
            .truncate_to(10);
        lnav_data.ld_preview_status_source.get_description().set_value(
            "First lines of file: %s", split_args[0].c_str());
    } else {
        retval = fmt::format(FMT_STRING("info: Wrote {:L} rows to {}"),
                             line_count,
                             split_args[0]);
    }
    if (toclose != nullptr) {
        closer(toclose);
    }
    outfile = nullptr;

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_pipe_to(exec_context& ec,
            std::string cmdline,
            std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("filename");
        return Ok(std::string());
    }

    if (lnav_data.ld_flags & LNF_SECURE_MODE) {
        return ec.make_error("{} -- unavailable in secure mode", args[0]);
    }

    if (args.size() < 2) {
        return ec.make_error("expecting command to execute");
    }

    if (ec.ec_dry_run) {
        return Ok(std::string());
    }

    auto* tc = *lnav_data.ld_view_stack.top();
    auto bv = combined_user_marks(tc->get_bookmarks());
    bool pipe_line_to = (args[0] == "pipe-line-to");

    std::string cmd = trim(remaining_args(cmdline, args));
    auto_pipe in_pipe(STDIN_FILENO);
    auto_pipe out_pipe(STDOUT_FILENO);

    in_pipe.open();
    out_pipe.open();

    pid_t child_pid = fork();

    in_pipe.after_fork(child_pid);
    out_pipe.after_fork(child_pid);

    switch (child_pid) {
        case -1:
            return ec.make_error("unable to fork child process -- {}",
                                 strerror(errno));

        case 0: {
            const char* args[] = {
                "sh",
                "-c",
                cmd.c_str(),
                nullptr,
            };
            auto path_v = ec.ec_path_stack;
            std::string path;

            dup2(STDOUT_FILENO, STDERR_FILENO);
            path_v.emplace_back(lnav::paths::dotlnav() / "formats/default");

            if (pipe_line_to && tc == &lnav_data.ld_views[LNV_LOG]) {
                logfile_sub_source& lss = lnav_data.ld_log_source;
                log_data_helper ldh(lss);
                char tmp_str[64];

                ldh.parse_line(ec.ec_top_line, true);
                auto format = ldh.ldh_file->get_format();
                auto source_path = format->get_source_path();
                path_v.insert(
                    path_v.end(), source_path.begin(), source_path.end());

                snprintf(tmp_str, sizeof(tmp_str), "%d", (int) ec.ec_top_line);
                setenv("log_line", tmp_str, 1);
                sql_strftime(
                    tmp_str, sizeof(tmp_str), ldh.ldh_line->get_timeval());
                setenv("log_time", tmp_str, 1);
                setenv("log_path", ldh.ldh_file->get_filename().c_str(), 1);
                for (auto& ldh_line_value : ldh.ldh_line_values.lvv_values) {
                    setenv(ldh_line_value.lv_meta.lvm_name.get(),
                           ldh_line_value.to_string().c_str(),
                           1);
                }
                auto iter = ldh.ldh_parser->dp_pairs.begin();
                for (size_t lpc = 0; lpc < ldh.ldh_parser->dp_pairs.size();
                     lpc++, ++iter)
                {
                    std::string colname = ldh.ldh_parser->get_element_string(
                        iter->e_sub_elements->front());
                    colname = ldh.ldh_namer->add_column(colname).to_string();
                    std::string val = ldh.ldh_parser->get_element_string(
                        iter->e_sub_elements->back());
                    setenv(colname.c_str(), val.c_str(), 1);
                }
            }

            setenv("PATH", lnav::filesystem::build_path(path_v).c_str(), 1);
            execvp(args[0], (char* const*) args);
            _exit(1);
            break;
        }

        default:
            bookmark_vector<vis_line_t>::iterator iter;
            std::string line;

            in_pipe.read_end().close_on_exec();
            in_pipe.write_end().close_on_exec();

            lnav_data.ld_children.push_back(child_pid);

            std::future<std::string> reader;

            if (out_pipe.read_end() != -1) {
                reader = ec.ec_pipe_callback(ec, cmdline, out_pipe.read_end());
            }

            if (pipe_line_to) {
                if (tc->get_inner_height() == 0) {
                    // Nothing to do
                } else if (tc == &lnav_data.ld_views[LNV_LOG]) {
                    logfile_sub_source& lss = lnav_data.ld_log_source;
                    content_line_t cl = lss.at(tc->get_top());
                    std::shared_ptr<logfile> lf = lss.find(cl);
                    shared_buffer_ref sbr;
                    lf->read_full_message(lf->message_start(lf->begin() + cl),
                                          sbr);
                    if (write(in_pipe.write_end(), sbr.get_data(), sbr.length())
                        == -1)
                    {
                        return ec.make_error("Unable to write to pipe -- {}",
                                             strerror(errno));
                    }
                    log_perror(write(in_pipe.write_end(), "\n", 1));
                } else {
                    tc->grep_value_for_line(tc->get_top(), line);
                    if (write(in_pipe.write_end(), line.c_str(), line.size())
                        == -1)
                    {
                        return ec.make_error("Unable to write to pipe -- {}",
                                             strerror(errno));
                    }
                    log_perror(write(in_pipe.write_end(), "\n", 1));
                }
            } else {
                for (iter = bv.begin(); iter != bv.end(); iter++) {
                    tc->grep_value_for_line(*iter, line);
                    if (write(in_pipe.write_end(), line.c_str(), line.size())
                        == -1)
                    {
                        return ec.make_error("Unable to write to pipe -- {}",
                                             strerror(errno));
                    }
                    log_perror(write(in_pipe.write_end(), "\n", 1));
                }
            }

            in_pipe.write_end().reset();

            if (reader.valid()) {
                retval = reader.get();
            } else {
                retval = "";
            }
            break;
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_redirect_to(exec_context& ec,
                std::string cmdline,
                std::vector<std::string>& args)
{
    if (args.empty()) {
        args.emplace_back("filename");
        return Ok(std::string());
    }

    if (args.size() == 1) {
        if (ec.ec_dry_run) {
            return Ok(std::string("info: redirect will be cleared"));
        }

        ec.clear_output();
        return Ok(std::string("info: cleared redirect"));
    }

    std::string fn = trim(remaining_args(cmdline, args));
    std::vector<std::string> split_args;
    shlex lexer(fn);
    scoped_resolver scopes = {
        &ec.ec_local_vars.top(),
        &ec.ec_global_vars,
    };

    if (!lexer.split(split_args, scopes)) {
        return ec.make_error("unable to parse arguments");
    }
    if (split_args.size() > 1) {
        return ec.make_error("more than one file name was matched");
    }

    if (ec.ec_dry_run) {
        return Ok("info: output will be redirected to -- " + split_args[0]);
    }

    nonstd::optional<FILE*> file;

    if (split_args[0] == "-") {
        ec.clear_output();
    } else if (split_args[0] == "/dev/clipboard") {
        auto out = sysclip::open(sysclip::type_t::GENERAL);
        if (out.isErr()) {
            alerter::singleton().chime("cannot open clipboard");
            return ec.make_error("Unable to copy to clipboard: {}",
                                 out.unwrapErr());
        }

        auto holder = out.unwrap();
        ec.set_output(split_args[0],
                      holder.release(),
                      holder.get_free_func<int (*)(FILE*)>());
    } else if (lnav_data.ld_flags & LNF_SECURE_MODE) {
        return ec.make_error("{} -- unavailable in secure mode", args[0]);
    } else {
        FILE* file = fopen(split_args[0].c_str(), "w");
        if (file == nullptr) {
            return ec.make_error("unable to open file -- {}", split_args[0]);
        }

        ec.set_output(split_args[0], file, fclose);
    }

    return Ok("info: redirecting output to file -- " + split_args[0]);
}

static Result<std::string, lnav::console::user_message>
com_highlight(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("filter");
    } else if (args.size() > 1) {
        auto* tc = *lnav_data.ld_view_stack.top();
        auto& hm = tc->get_highlights();
        auto re_frag = remaining_args_frag(cmdline, args);
        args[1] = re_frag.to_string();
        if (hm.find({highlight_source_t::INTERACTIVE, args[1]}) != hm.end()) {
            return ec.make_error("highlight already exists -- {}", args[1]);
        }

        auto compile_res
            = pcrepp::shared_from_str(args[1], PCRE_CASELESS | PCRE_UTF8);

        if (compile_res.isErr()) {
            auto ce = compile_res.unwrapErr();
            auto um = lnav::console::user_message::error(
                          "invalid regular expression")
                          .with_reason(ce.ce_msg)
                          .with_snippets(ec.ec_source);
            um.um_snippets.back()
                .s_content.append("\n")
                .append(re_frag.sf_begin + ce.ce_offset, ' ')
                .append("^ "_comment)
                .append(lnav::roles::comment(ce.ce_msg));
            return Err(um);
        }
        highlighter hl(compile_res.unwrap());
        auto hl_attrs = view_colors::singleton().attrs_for_ident(args[1]);

        if (ec.ec_dry_run) {
            hl_attrs.ta_attrs |= A_BLINK;
        }

        hl.with_attrs(hl_attrs);

        if (ec.ec_dry_run) {
            hm[{highlight_source_t::PREVIEW, "preview"}] = hl;

            lnav_data.ld_preview_status_source.get_description().set_value(
                "Matches are highlighted in the view");

            retval = "";
        } else {
            hm[{highlight_source_t::INTERACTIVE, args[1]}] = hl;

            if (lnav_data.ld_rl_view != nullptr) {
                lnav_data.ld_rl_view->add_possibility(
                    ln_mode_t::COMMAND, "highlight", args[1]);
            }

            retval = "info: highlight pattern now active";
        }
        tc->reload_data();
    } else {
        return ec.make_error("expecting a regular expression to highlight");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_clear_highlight(exec_context& ec,
                    std::string cmdline,
                    std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("highlight");
    } else if (args.size() > 1 && args[1][0] != '$') {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        auto& hm = tc->get_highlights();

        args[1] = remaining_args(cmdline, args);
        auto hm_iter = hm.find({highlight_source_t::INTERACTIVE, args[1]});
        if (hm_iter == hm.end()) {
            return ec.make_error("highlight does not exist -- {}", args[1]);
        } else if (ec.ec_dry_run) {
            retval = "";
        } else {
            hm.erase(hm_iter);
            retval = "info: highlight pattern cleared";
            tc->reload_data();

            if (lnav_data.ld_rl_view != NULL) {
                lnav_data.ld_rl_view->rem_possibility(
                    ln_mode_t::COMMAND, "highlight", args[1]);
            }
        }
    } else {
        return ec.make_error("expecting highlight expression to clear");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_help(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        ensure_view(&lnav_data.ld_views[LNV_HELP]);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message> com_enable_filter(
    exec_context& ec, std::string cmdline, std::vector<std::string>& args);

static Result<std::string, lnav::console::user_message>
com_filter(exec_context& ec,
           std::string cmdline,
           std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("filter");

        return Ok(std::string());
    }

    auto tc = *lnav_data.ld_view_stack.top();
    auto tss = tc->get_sub_source();

    if (!tss->tss_supports_filtering) {
        return ec.make_error("{} view does not support filtering",
                             lnav_view_strings[tc - lnav_data.ld_views]);
    } else if (args.size() > 1) {
        auto* tss = tc->get_sub_source();
        auto& fs = tss->get_filters();
        auto re_frag = remaining_args_frag(cmdline, args);
        args[1] = re_frag.to_string();
        if (fs.get_filter(args[1]) != nullptr) {
            return com_enable_filter(ec, cmdline, args);
        }

        if (fs.full()) {
            return ec.make_error(
                "filter limit reached, try combining "
                "filters with a pipe symbol (e.g. foo|bar)");
        }

        auto compile_res
            = pcrepp::shared_from_str(args[1], PCRE_CASELESS | PCRE_UTF8);

        if (compile_res.isErr()) {
            auto ce = compile_res.unwrapErr();
            auto um = lnav::console::user_message::error(
                          "invalid regular expression")
                          .with_reason(ce.ce_msg)
                          .with_snippets(ec.ec_source);
            um.um_snippets.back()
                .s_content.append("\n")
                .append(re_frag.sf_begin + ce.ce_offset, ' ')
                .append("^ "_comment)
                .append(lnav::roles::comment(ce.ce_msg));
            return Err(um);
        }
        if (ec.ec_dry_run) {
            if (args[0] == "filter-in" && !fs.empty()) {
                lnav_data.ld_preview_status_source.get_description().set_value(
                    "Match preview for :filter-in only works if there are no "
                    "other filters");
                retval = "";
            } else {
                auto& hm = tc->get_highlights();
                highlighter hl(compile_res.unwrap());
                auto role = (args[0] == "filter-out") ? role_t::VCR_DIFF_DELETE
                                                      : role_t::VCR_DIFF_ADD;
                hl.with_role(role);
                hl.with_attrs(text_attrs{A_BLINK | A_REVERSE});

                hm[{highlight_source_t::PREVIEW, "preview"}] = hl;
                tc->reload_data();

                lnav_data.ld_preview_status_source.get_description().set_value(
                    "Matches are highlighted in %s in the text view",
                    role == role_t::VCR_DIFF_DELETE ? "red" : "green");

                retval = "";
            }
        } else {
            text_filter::type_t lt = (args[0] == "filter-out")
                ? text_filter::EXCLUDE
                : text_filter::INCLUDE;
            auto filter_index = fs.next_index();
            if (!filter_index) {
                return ec.make_error("too many filters");
            }
            auto pf = std::make_shared<pcre_filter>(
                lt, args[1], *filter_index, compile_res.unwrap());

            log_debug("%s [%d] %s",
                      args[0].c_str(),
                      pf->get_index(),
                      args[1].c_str());
            fs.add_filter(pf);
            tss->text_filters_changed();

            retval = "info: filter now active";
        }
    } else {
        return ec.make_error("expecting a regular expression to filter");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_delete_filter(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("all-filters");
    } else if (args.size() > 1) {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        text_sub_source* tss = tc->get_sub_source();
        filter_stack& fs = tss->get_filters();

        args[1] = remaining_args(cmdline, args);
        if (ec.ec_dry_run) {
            retval = "";
        } else if (fs.delete_filter(args[1])) {
            retval = "info: deleted filter";
            tss->text_filters_changed();
        } else {
            return ec.make_error("unknown filter -- {}", args[1]);
        }
    } else {
        return ec.make_error("expecting a filter to delete");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_enable_filter(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("disabled-filter");
    } else if (args.size() > 1) {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        text_sub_source* tss = tc->get_sub_source();
        filter_stack& fs = tss->get_filters();
        std::shared_ptr<text_filter> lf;

        args[1] = remaining_args(cmdline, args);
        lf = fs.get_filter(args[1]);
        if (lf == nullptr) {
            return ec.make_error("no such filter -- {}", args[1]);
        } else if (lf->is_enabled()) {
            retval = "info: filter already enabled";
        } else if (ec.ec_dry_run) {
            retval = "";
        } else {
            fs.set_filter_enabled(lf, true);
            tss->text_filters_changed();
            retval = "info: filter enabled";
        }
    } else {
        return ec.make_error("expecting disabled filter to enable");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_disable_filter(exec_context& ec,
                   std::string cmdline,
                   std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("enabled-filter");
    } else if (args.size() > 1) {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        text_sub_source* tss = tc->get_sub_source();
        filter_stack& fs = tss->get_filters();
        std::shared_ptr<text_filter> lf;

        args[1] = remaining_args(cmdline, args);
        lf = fs.get_filter(args[1]);
        if (lf == nullptr) {
            return ec.make_error("no such filter -- {}", args[1]);
        } else if (!lf->is_enabled()) {
            retval = "info: filter already disabled";
        } else if (ec.ec_dry_run) {
            retval = "";
        } else {
            fs.set_filter_enabled(lf, false);
            tss->text_filters_changed();
            retval = "info: filter disabled";
        }
    } else {
        return ec.make_error("expecting enabled filter to disable");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_filter_expr(exec_context& ec,
                std::string cmdline,
                std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("filter-expr-syms");
    } else if (args.size() > 1) {
        textview_curses* tc = *lnav_data.ld_view_stack.top();

        if (tc != &lnav_data.ld_views[LNV_LOG]) {
            return ec.make_error(
                "The :filter-expr command only works in the log view");
        }

        auto expr = remaining_args(cmdline, args);
        args[1] = fmt::format(FMT_STRING("SELECT 1 WHERE {}"), expr);

        auto_mem<sqlite3_stmt> stmt(sqlite3_finalize);
#ifdef SQLITE_PREPARE_PERSISTENT
        auto retcode = sqlite3_prepare_v3(lnav_data.ld_db.in(),
                                          args[1].c_str(),
                                          args[1].size(),
                                          SQLITE_PREPARE_PERSISTENT,
                                          stmt.out(),
                                          nullptr);
#else
        auto retcode = sqlite3_prepare_v2(lnav_data.ld_db.in(),
                                          args[1].c_str(),
                                          args[1].size(),
                                          stmt.out(),
                                          nullptr);
#endif
        if (retcode != SQLITE_OK) {
            const char* errmsg = sqlite3_errmsg(lnav_data.ld_db);
            auto expr_al = attr_line_t(expr).with_attr_for_all(
                VC_ROLE.value(role_t::VCR_QUOTED_CODE));
            readline_sqlite_highlighter(expr_al, -1);
            auto um = lnav::console::user_message::error(
                          attr_line_t("invalid filter expression: ")
                              .append(expr_al))
                          .with_reason(errmsg)
                          .with_snippets(ec.ec_source);

            return Err(um);
        }

        if (ec.ec_dry_run) {
            auto set_res = lnav_data.ld_log_source.set_preview_sql_filter(
                stmt.release());

            if (set_res.isErr()) {
                return Err(set_res.unwrapErr());
            }
            lnav_data.ld_preview_status_source.get_description().set_value(
                "Matches are highlighted in the text view");
        } else {
            lnav_data.ld_log_source.set_preview_sql_filter(nullptr);
            auto set_res
                = lnav_data.ld_log_source.set_sql_filter(expr, stmt.release());

            if (set_res.isErr()) {
                return Err(set_res.unwrapErr());
            }
        }
        lnav_data.ld_log_source.text_filters_changed();
        tc->reload_data();
    } else {
        return ec.make_error("expecting an SQL expression");
    }

    return Ok(retval);
}

static std::string
com_filter_expr_prompt(exec_context& ec, const std::string& cmdline)
{
    textview_curses* tc = *lnav_data.ld_view_stack.top();

    if (tc != &lnav_data.ld_views[LNV_LOG]) {
        return "";
    }

    return fmt::format(FMT_STRING("{} {}"),
                       trim(cmdline),
                       trim(lnav_data.ld_log_source.get_sql_filter_text()));
}

static Result<std::string, lnav::console::user_message>
com_clear_filter_expr(exec_context& ec,
                      std::string cmdline,
                      std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else {
        if (!ec.ec_dry_run) {
            lnav_data.ld_log_source.set_sql_filter("", nullptr);
            lnav_data.ld_log_source.text_filters_changed();
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_enable_word_wrap(exec_context& ec,
                     std::string cmdline,
                     std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        lnav_data.ld_views[LNV_LOG].set_word_wrap(true);
        lnav_data.ld_views[LNV_TEXT].set_word_wrap(true);
        lnav_data.ld_views[LNV_PRETTY].set_word_wrap(true);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_disable_word_wrap(exec_context& ec,
                      std::string cmdline,
                      std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        lnav_data.ld_views[LNV_LOG].set_word_wrap(false);
        lnav_data.ld_views[LNV_TEXT].set_word_wrap(false);
        lnav_data.ld_views[LNV_PRETTY].set_word_wrap(false);
    }

    return Ok(retval);
}

static std::set<std::string> custom_logline_tables;

static Result<std::string, lnav::console::user_message>
com_create_logline_table(exec_context& ec,
                         std::string cmdline,
                         std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (args.size() == 2) {
        textview_curses& log_view = lnav_data.ld_views[LNV_LOG];

        if (log_view.get_inner_height() == 0) {
            return ec.make_error("no log data available");
        } else {
            vis_line_t vl = log_view.get_top();
            content_line_t cl = lnav_data.ld_log_source.at_base(vl);
            auto ldt = std::make_shared<log_data_table>(
                lnav_data.ld_log_source,
                *lnav_data.ld_vtab_manager,
                cl,
                intern_string::lookup(args[1]));

            if (ec.ec_dry_run) {
                attr_line_t al(ldt->get_table_statement());

                lnav_data.ld_preview_status_source.get_description().set_value(
                    "The following table will be created:");
                lnav_data.ld_preview_source.replace_with(al).set_text_format(
                    text_format_t::TF_SQL);

                return Ok(std::string());
            } else {
                std::string errmsg;

                errmsg = lnav_data.ld_vtab_manager->register_vtab(ldt);
                if (errmsg.empty()) {
                    custom_logline_tables.insert(args[1]);
                    if (lnav_data.ld_rl_view != NULL) {
                        lnav_data.ld_rl_view->add_possibility(
                            ln_mode_t::COMMAND, "custom-table", args[1]);
                    }
                    retval = "info: created new log table -- " + args[1];
                } else {
                    return ec.make_error("unable to create table -- {}",
                                         errmsg);
                }
            }
        }
    } else {
        return ec.make_error("expecting a table name");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_delete_logline_table(exec_context& ec,
                         std::string cmdline,
                         std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("custom-table");
    } else if (args.size() == 2) {
        if (custom_logline_tables.find(args[1]) == custom_logline_tables.end())
        {
            return ec.make_error("unknown logline table -- {}", args[1]);
        }

        if (ec.ec_dry_run) {
            return Ok(std::string());
        }

        std::string rc = lnav_data.ld_vtab_manager->unregister_vtab(
            intern_string::lookup(args[1]));

        if (rc.empty()) {
            if (lnav_data.ld_rl_view != NULL) {
                lnav_data.ld_rl_view->rem_possibility(
                    ln_mode_t::COMMAND, "custom-table", args[1]);
            }
            retval = "info: deleted logline table";
        } else {
            return ec.make_error("{}", rc);
        }
    } else {
        return ec.make_error("expecting a table name");
    }

    return Ok(retval);
}

static std::set<std::string> custom_search_tables;

static Result<std::string, lnav::console::user_message>
com_create_search_table(exec_context& ec,
                        std::string cmdline,
                        std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (args.size() >= 2) {
        string_fragment regex_frag;
        std::string regex;

        if (args.size() >= 3) {
            regex_frag = remaining_args_frag(cmdline, args, 2);
            regex = regex_frag.to_string();
        } else {
            regex = lnav_data.ld_views[LNV_LOG].get_current_search();
        }

        auto re_res = pcrepp::shared_from_str(
            regex, log_search_table::pattern_options());

        if (re_res.isErr()) {
            auto re_err = re_res.unwrapErr();
            auto um = lnav::console::user_message::error(
                          "invalid regular expression")
                          .with_reason(re_err.ce_msg)
                          .with_snippets(ec.ec_source);
            if (args.size() >= 3) {
                um.um_snippets.back()
                    .s_content.append("\n")
                    .append(regex_frag.sf_begin + re_err.ce_offset, ' ')
                    .append("^ "_comment)
                    .append(lnav::roles::comment(re_err.ce_msg));
            }
            return Err(um);
        }

        auto re = re_res.unwrap();
        auto tab_name = intern_string::lookup(args[1]);
        auto lst = std::make_shared<log_search_table>(*re, tab_name);
        if (ec.ec_dry_run) {
            auto* tc = &lnav_data.ld_views[LNV_LOG];
            auto& hm = tc->get_highlights();
            highlighter hl(re);

            hl.with_role(role_t::VCR_INFO);
            hl.with_attrs(text_attrs{A_BLINK});

            hm[{highlight_source_t::PREVIEW, "preview"}] = hl;
            tc->reload_data();

            attr_line_t al(lst->get_table_statement());

            lnav_data.ld_preview_status_source.get_description().set_value(
                "The following table will be created:");

            lnav_data.ld_preview_source.replace_with(al).set_text_format(
                text_format_t::TF_SQL);

            return Ok(std::string());
        }

        auto tab_iter = custom_search_tables.find(args[1]);
        if (tab_iter != custom_search_tables.end()) {
            lnav_data.ld_vtab_manager->unregister_vtab(tab_name);
        }

        std::string errmsg;

        errmsg = lnav_data.ld_vtab_manager->register_vtab(lst);
        if (errmsg.empty()) {
            custom_search_tables.insert(args[1]);
            if (lnav_data.ld_rl_view != nullptr) {
                lnav_data.ld_rl_view->add_possibility(
                    ln_mode_t::COMMAND, "search-table", args[1]);
            }
            retval = "info: created new search table -- " + args[1];
        } else {
            return ec.make_error("unable to create table -- {}", errmsg);
        }
    } else {
        return ec.make_error("expecting a table name");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_delete_search_table(exec_context& ec,
                        std::string cmdline,
                        std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("search-table");
    } else if (args.size() == 2) {
        auto tab_iter = custom_search_tables.find(args[1]);
        if (tab_iter == custom_search_tables.end()) {
            return ec.make_error("unknown search table -- {}", args[1]);
        }

        if (ec.ec_dry_run) {
            return Ok(std::string());
        }

        custom_search_tables.erase(tab_iter);
        auto rc = lnav_data.ld_vtab_manager->unregister_vtab(
            intern_string::lookup(args[1]));

        if (rc.empty()) {
            if (lnav_data.ld_rl_view != NULL) {
                lnav_data.ld_rl_view->rem_possibility(
                    ln_mode_t::COMMAND, "search-table", args[1]);
            }
            retval = "info: deleted search table";
        } else {
            return ec.make_error("{}", rc);
        }
    } else {
        return ec.make_error("expecting a table name");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_session(exec_context& ec,
            std::string cmdline,
            std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (ec.ec_dry_run) {
        retval = "";
    } else if (args.size() >= 2) {
        /* XXX put these in a map */
        if (args[1] != "highlight" && args[1] != "enable-word-wrap"
            && args[1] != "disable-word-wrap" && args[1] != "filter-in"
            && args[1] != "filter-out" && args[1] != "enable-filter"
            && args[1] != "disable-filter")
        {
            return ec.make_error(
                "only the highlight, filter, and word-wrap commands are "
                "supported");
        } else if (getenv("HOME") == NULL) {
            return ec.make_error("the HOME environment variable is not set");
        } else {
            auto saved_cmd = trim(remaining_args(cmdline, args));
            auto old_file_name = lnav::paths::dotlnav() / "session";
            auto new_file_name = lnav::paths::dotlnav() / "session.tmp";

            std::ifstream session_file(old_file_name.string());
            std::ofstream new_session_file(new_file_name.string());

            if (!new_session_file) {
                return ec.make_error("cannot write to session file");
            } else {
                bool added = false;
                std::string line;

                if (session_file.is_open()) {
                    while (getline(session_file, line)) {
                        if (line == saved_cmd) {
                            added = true;
                            break;
                        }
                        new_session_file << line << std::endl;
                    }
                }
                if (!added) {
                    new_session_file << saved_cmd << std::endl;

                    log_perror(
                        rename(new_file_name.c_str(), old_file_name.c_str()));
                } else {
                    log_perror(remove(new_file_name.c_str()));
                }

                retval = "info: session file saved";
            }
        }
    } else {
        return ec.make_error("expecting a command to save to the session file");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_open(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("filename");
        return Ok(std::string());
    }

    if (lnav_data.ld_flags & LNF_SECURE_MODE) {
        return ec.make_error("{} -- unavailable in secure mode", args[0]);
    }

    if (args.size() < 2) {
        return ec.make_error("expecting file name to open");
    }

    std::vector<std::string> word_exp;
    std::string pat;
    file_collection fc;

    pat = trim(remaining_args(cmdline, args));

    std::vector<std::string> split_args;
    shlex lexer(pat);
    scoped_resolver scopes = {
        &ec.ec_local_vars.top(),
        &ec.ec_global_vars,
    };

    if (!lexer.split(split_args, scopes)) {
        return ec.make_error("unable to parse arguments");
    }

    std::vector<std::pair<std::string, file_location_t>> files_to_front;
    std::vector<std::string> closed_files;

    for (auto fn : split_args) {
        file_location_t file_loc;

        if (access(fn.c_str(), R_OK) != 0) {
            auto colon_index = fn.rfind(':');
            auto hash_index = fn.rfind('#');
            if (colon_index != std::string::npos) {
                auto top_range = scn::string_view{
                    &fn[colon_index + 1], &(*fn.cend())};
                auto scan_res = scn::scan_value<int>(top_range);

                if (scan_res) {
                    fn = fn.substr(0, colon_index);
                    file_loc = vis_line_t(scan_res.value());
                }
            } else if (hash_index != std::string::npos) {
                file_loc = fn.substr(hash_index);
                fn = fn.substr(0, hash_index);
            }
        }

        auto file_iter = lnav_data.ld_active_files.fc_files.begin();
        for (; file_iter != lnav_data.ld_active_files.fc_files.end();
             ++file_iter)
        {
            auto lf = *file_iter;

            if (lf->get_filename() == fn) {
                if (lf->get_format() != nullptr) {
                    retval = "info: log file already loaded";
                    break;
                }

                files_to_front.emplace_back(fn, file_loc);
                retval = "";
                break;
            }
        }
        if (file_iter == lnav_data.ld_active_files.fc_files.end()) {
            auto_mem<char> abspath;
            struct stat st;

            if (is_url(fn.c_str())) {
#ifndef HAVE_LIBCURL
                retval = "error: lnav was not compiled with libcurl";
#else
                if (!ec.ec_dry_run) {
                    auto ul = std::make_shared<url_loader>(fn);

                    lnav_data.ld_active_files.fc_file_names[fn].with_fd(
                        ul->copy_fd());
                    isc::to<curl_looper&, services::curl_streamer_t>().send(
                        [ul](auto& clooper) { clooper.add_request(ul); });
                    lnav_data.ld_files_to_front.emplace_back(fn, file_loc);
                    retval = "info: opened URL";
                } else {
                    retval = "";
                }
#endif
            } else if (is_glob(fn.c_str())) {
                fc.fc_file_names.emplace(fn, logfile_open_options());
                retval = "info: watching -- " + fn;
            } else if (stat(fn.c_str(), &st) == -1) {
                if (fn.find(':') != std::string::npos) {
                    fc.fc_file_names.emplace(fn, logfile_open_options());
                    retval = "info: watching -- " + fn;
                } else {
                    auto um = lnav::console::user_message::error(
                                  attr_line_t("cannot open file: ")
                                      .append(lnav::roles::file(fn)))
                                  .with_errno_reason()
                                  .with_snippets(ec.ec_source)
                                  .with_help(
                                      "make sure the file exists and is "
                                      "accessible");
                    return Err(um);
                }
            } else if (is_dev_null(st)) {
                return ec.make_error("cannot open /dev/null");
            } else if (S_ISFIFO(st.st_mode)) {
                auto_fd fifo_fd;

                if ((fifo_fd = open(fn.c_str(), O_RDONLY)) == -1) {
                    auto um = lnav::console::user_message::error(
                                  attr_line_t("cannot open FIFO: ")
                                      .append(lnav::roles::file(fn)))
                                  .with_errno_reason()
                                  .with_snippets(ec.ec_source);
                    return Err(um);
                } else if (ec.ec_dry_run) {
                    retval = "";
                } else {
                    auto fifo_piper = std::make_shared<piper_proc>(
                        std::move(fifo_fd),
                        false,
                        lnav::filesystem::open_temp_file(
                            ghc::filesystem::temp_directory_path()
                            / "lnav.fifo.XXXXXX")
                            .map([](auto pair) {
                                ghc::filesystem::remove(pair.first);

                                return pair;
                            })
                            .expect("Cannot create temporary file for FIFO")
                            .second);
                    auto fifo_out_fd = fifo_piper->get_fd();
                    auto desc = fmt::format(FMT_STRING("FIFO [{}]"),
                                            lnav_data.ld_fifo_counter++);
                    lnav_data.ld_active_files.fc_file_names[desc].with_fd(
                        std::move(fifo_out_fd));
                    lnav_data.ld_pipers.push_back(fifo_piper);
                }
            } else if ((abspath = realpath(fn.c_str(), nullptr)) == nullptr) {
                auto um = lnav::console::user_message::error(
                              attr_line_t("cannot open file: ")
                                  .append(lnav::roles::file(fn)))
                              .with_errno_reason()
                              .with_snippets(ec.ec_source)
                              .with_help(
                                  "make sure the file exists and is "
                                  "accessible");
                return Err(um);
            } else if (S_ISDIR(st.st_mode)) {
                std::string dir_wild(abspath.in());

                if (dir_wild[dir_wild.size() - 1] == '/') {
                    dir_wild.resize(dir_wild.size() - 1);
                }
                fc.fc_file_names.emplace(dir_wild + "/*",
                                         logfile_open_options());
                retval = "info: watching -- " + dir_wild;
            } else if (!S_ISREG(st.st_mode)) {
                auto um = lnav::console::user_message::error(
                              attr_line_t("cannot open file: ")
                                  .append(lnav::roles::file(fn)))
                              .with_reason("not a regular file or directory")
                              .with_snippets(ec.ec_source)
                              .with_help(
                                  "only regular files, directories, and FIFOs "
                                  "can be opened");
                return Err(um);
            } else if (access(fn.c_str(), R_OK) == -1) {
                auto um = lnav::console::user_message::error(
                              attr_line_t("cannot read file: ")
                                  .append(lnav::roles::file(fn)))
                              .with_errno_reason()
                              .with_snippets(ec.ec_source)
                              .with_help(
                                  "make sure the file exists and is "
                                  "accessible");
                return Err(um);
            } else {
                fn = abspath.in();
                fc.fc_file_names.emplace(fn, logfile_open_options());
                retval = "info: opened -- " + fn;
                files_to_front.emplace_back(fn, file_loc);

                closed_files.push_back(fn);
                if (lnav_data.ld_rl_view != nullptr) {
                    lnav_data.ld_rl_view->set_alt_value(
                        HELP_MSG_1(X, "to close the file"));
                }
            }
        }
    }

    if (ec.ec_dry_run) {
        lnav_data.ld_preview_source.clear();
        if (!fc.fc_file_names.empty()) {
            auto iter = fc.fc_file_names.begin();
            std::string fn = iter->first;
            auto_fd preview_fd;

            if (fn.find(':') != std::string::npos) {
                auto id = lnav_data.ld_preview_generation;
                lnav_data.ld_preview_status_source.get_description()
                    .set_cylon(true)
                    .set_value("Loading %s...", fn.c_str());
                lnav_data.ld_preview_source.clear();

                isc::to<tailer::looper&, services::remote_tailer_t>().send(
                    [id, fn](auto& tlooper) {
                        auto rp_opt = humanize::network::path::from_str(fn);
                        if (rp_opt) {
                            tlooper.load_preview(id, *rp_opt);
                        }
                    });
                lnav_data.ld_preview_view.set_needs_update();
            } else if (is_glob(fn.c_str())) {
                static_root_mem<glob_t, globfree> gl;

                if (glob(fn.c_str(), GLOB_NOCHECK, nullptr, gl.inout()) == 0) {
                    attr_line_t al;

                    for (size_t lpc = 0; lpc < gl->gl_pathc && lpc < 10; lpc++)
                    {
                        al.append(gl->gl_pathv[lpc]).append("\n");
                    }
                    if (gl->gl_pathc > 10) {
                        al.append(" ... ")
                            .append(lnav::roles::number(
                                std::to_string(gl->gl_pathc - 10)))
                            .append(" files not shown ...");
                    }
                    lnav_data.ld_preview_status_source.get_description()
                        .set_value("The following files will be loaded:");
                    lnav_data.ld_preview_source.replace_with(al);
                } else {
                    return ec.make_error("failed to evaluate glob -- {}", fn);
                }
            } else if ((preview_fd = open(fn.c_str(), O_RDONLY)) == -1) {
                return ec.make_error(
                    "unable to open file3: {} -- {}", fn, strerror(errno));
            } else {
                line_buffer lb;
                attr_line_t al;
                file_range range;
                std::string lines;

                lb.set_fd(preview_fd);
                for (int lpc = 0; lpc < 10; lpc++) {
                    auto load_result = lb.load_next_line(range);

                    if (load_result.isErr()) {
                        break;
                    }

                    auto li = load_result.unwrap();

                    range = li.li_file_range;
                    auto read_result = lb.read_range(range);
                    if (read_result.isErr()) {
                        break;
                    }

                    auto sbr = read_result.unwrap();
                    lines.append(sbr.get_data(), sbr.length());
                }

                lnav_data.ld_preview_source.replace_with(al.with_string(lines))
                    .set_text_format(detect_text_format(al.get_string()));
                lnav_data.ld_preview_status_source.get_description().set_value(
                    "For file: %s", fn.c_str());
            }
        }
    } else {
        lnav_data.ld_files_to_front.insert(lnav_data.ld_files_to_front.end(),
                                           files_to_front.begin(),
                                           files_to_front.end());
        for (const auto& fn : closed_files) {
            fc.fc_closed_files.erase(fn);
        }

        lnav_data.ld_active_files.merge(fc);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_close(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        nonstd::optional<ghc::filesystem::path> actual_path;
        std::string fn;

        if (tc == &lnav_data.ld_views[LNV_TEXT]) {
            textfile_sub_source& tss = lnav_data.ld_text_source;

            if (tss.empty()) {
                return ec.make_error("no text files are opened");
            } else {
                fn = tss.current_file()->get_filename();
                lnav_data.ld_active_files.request_close(tss.current_file());

                if (tss.size() == 1) {
                    lnav_data.ld_view_stack.pop_back();
                }
            }
        } else if (tc == &lnav_data.ld_views[LNV_LOG]) {
            if (tc->get_inner_height() == 0) {
                return ec.make_error("no log files loaded");
            } else {
                logfile_sub_source& lss = lnav_data.ld_log_source;
                vis_line_t vl = tc->get_top();
                content_line_t cl = lss.at(vl);
                std::shared_ptr<logfile> lf = lss.find(cl);

                actual_path = lf->get_actual_path();
                fn = lf->get_filename();
                if (!ec.ec_dry_run) {
                    lnav_data.ld_active_files.request_close(lf);
                }
            }
        } else {
            return ec.make_error(
                "close must be run in the log or text file views");
        }
        if (!fn.empty()) {
            if (ec.ec_dry_run) {
                retval = "";
            } else {
                if (is_url(fn.c_str())) {
                    isc::to<curl_looper&, services::curl_streamer_t>().send(
                        [fn](auto& clooper) { clooper.close_request(fn); });
                }
                if (actual_path) {
                    lnav_data.ld_active_files.fc_file_names.erase(
                        actual_path.value().string());
                }
                lnav_data.ld_active_files.fc_closed_files.insert(fn);
                retval = "info: closed -- " + fn;
            }
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_file_visibility(exec_context& ec,
                    std::string cmdline,
                    std::vector<std::string>& args)
{
    bool only_this_file = false;
    bool make_visible;
    std::string retval;

    if (args[0] == "show-file") {
        make_visible = true;
    } else if (args[0] == "show-only-this-file") {
        make_visible = true;
        only_this_file = true;
    } else {
        make_visible = false;
    }

    if (args.size() == 1 || only_this_file) {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        std::shared_ptr<logfile> lf;

        if (tc == &lnav_data.ld_views[LNV_TEXT]) {
            textfile_sub_source& tss = lnav_data.ld_text_source;

            if (tss.empty()) {
                return ec.make_error("no text files are opened");
            }
            lf = tss.current_file();
        } else if (tc == &lnav_data.ld_views[LNV_LOG]) {
            if (tc->get_inner_height() == 0) {
                return ec.make_error("no log files loaded");
            }
            auto& lss = lnav_data.ld_log_source;
            auto vl = tc->get_top();
            auto cl = lss.at(vl);
            lf = lss.find(cl);
        } else {
            return ec.make_error(
                ":{} must be run in the log or text file views", args[0]);
        }

        if (!ec.ec_dry_run) {
            if (only_this_file) {
                for (const auto& ld : lnav_data.ld_log_source) {
                    ld->set_visibility(false);
                }
            }
            lnav_data.ld_log_source.find_data(lf) |
                [make_visible](auto ld) { ld->set_visibility(make_visible); };
            tc->get_sub_source()->text_filters_changed();
        }
        retval = fmt::format(FMT_STRING("info: {} file -- {}"),
                             make_visible ? "showing" : "hiding",
                             lf->get_filename());
    } else {
        int text_file_count = 0, log_file_count = 0;
        auto lexer = shlex(cmdline);

        lexer.split(args, ec.create_resolver());
        args.erase(args.begin());

        for (const auto& lf : lnav_data.ld_active_files.fc_files) {
            if (lf.get() == nullptr) {
                continue;
            }

            auto ld_opt = lnav_data.ld_log_source.find_data(lf);

            if (!ld_opt || ld_opt.value()->ld_visible == make_visible) {
                continue;
            }

            auto find_iter
                = find_if(args.begin(), args.end(), [&lf](const auto& arg) {
                      return fnmatch(arg.c_str(), lf->get_filename().c_str(), 0)
                          == 0;
                  });

            if (find_iter == args.end()) {
                continue;
            }

            if (!ec.ec_dry_run) {
                ld_opt | [make_visible](auto ld) {
                    ld->set_visibility(make_visible);
                };
            }
            if (lf->get_format() != nullptr) {
                log_file_count += 1;
            } else {
                text_file_count += 1;
            }
        }
        if (!ec.ec_dry_run && log_file_count > 0) {
            lnav_data.ld_views[LNV_LOG]
                .get_sub_source()
                ->text_filters_changed();
        }
        if (!ec.ec_dry_run && text_file_count > 0) {
            lnav_data.ld_views[LNV_TEXT]
                .get_sub_source()
                ->text_filters_changed();
        }
        retval = fmt::format(
            FMT_STRING("info: {} {:L} log files and {:L} text files"),
            make_visible ? "showing" : "hiding",
            log_file_count,
            text_file_count);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_hide_file(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("visible-files");
    } else {
        return com_file_visibility(ec, cmdline, args);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_show_file(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("hidden-files");
    } else {
        return com_file_visibility(ec, cmdline, args);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_show_only_this_file(exec_context& ec,
                        std::string cmdline,
                        std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else {
        return com_file_visibility(ec, cmdline, args);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_comment(exec_context& ec,
            std::string cmdline,
            std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        return Ok(std::string());
    } else if (args.size() > 1) {
        if (ec.ec_dry_run) {
            return Ok(std::string());
        }
        auto* tc = *lnav_data.ld_view_stack.top();

        if (tc != &lnav_data.ld_views[LNV_LOG]) {
            return ec.make_error(
                "The :comment command only works in the log view");
        }
        auto& lss = lnav_data.ld_log_source;

        args[1] = trim(remaining_args(cmdline, args));
        auto unquoted = auto_buffer::alloc(args[1].size() + 1);
        auto unquoted_len = unquote_content(unquoted.in(), args[1].c_str(), args[1].size(), 0);
        unquoted.resize(unquoted_len + 1);

        tc->set_user_mark(&textview_curses::BM_META, tc->get_top(), true);

        auto& line_meta = lss.get_bookmark_metadata(tc->get_top());

        line_meta.bm_comment = unquoted.in();
        lss.set_line_meta_changed();
        lss.text_filters_changed();
        tc->reload_data();

        retval = "info: comment added to line";
    } else {
        return ec.make_error("expecting some comment text");
    }

    return Ok(retval);
}

static std::string
com_comment_prompt(exec_context& ec, const std::string& cmdline)
{
    textview_curses* tc = *lnav_data.ld_view_stack.top();

    if (tc != &lnav_data.ld_views[LNV_LOG]) {
        return "";
    }
    auto& lss = lnav_data.ld_log_source;

    auto line_meta_opt = lss.find_bookmark_metadata(tc->get_top());

    if (line_meta_opt && !line_meta_opt.value()->bm_comment.empty()) {
        auto trimmed_comment = trim(line_meta_opt.value()->bm_comment);
        auto buf = auto_buffer::alloc(trimmed_comment.size() + 16);
        quote_content(buf, trimmed_comment, 0);

        return trim(cmdline) + " " + buf.to_string();
    }

    return "";
}

static Result<std::string, lnav::console::user_message>
com_clear_comment(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        return Ok(std::string());
    } else if (ec.ec_dry_run) {
        return Ok(std::string());
    } else {
        textview_curses* tc = *lnav_data.ld_view_stack.top();

        if (tc != &lnav_data.ld_views[LNV_LOG]) {
            return ec.make_error(
                "The :clear-comment command only works in the log view");
        }
        auto& lss = lnav_data.ld_log_source;

        auto line_meta_opt = lss.find_bookmark_metadata(tc->get_top());
        if (line_meta_opt) {
            bookmark_metadata& line_meta = *(line_meta_opt.value());

            line_meta.bm_comment.clear();
            if (line_meta.empty()) {
                lss.erase_bookmark_metadata(tc->get_top());
                tc->set_user_mark(
                    &textview_curses::BM_META, tc->get_top(), false);
            }

            lss.set_line_meta_changed();
            lss.text_filters_changed();
            tc->reload_data();

            retval = "info: cleared comment";
        }
        tc->search_new_data();
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_tag(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("tag");
        return Ok(std::string());
    } else if (args.size() > 1) {
        if (ec.ec_dry_run) {
            return Ok(std::string());
        }
        textview_curses* tc = *lnav_data.ld_view_stack.top();

        if (tc != &lnav_data.ld_views[LNV_LOG]) {
            return ec.make_error("The :tag command only works in the log view");
        }
        auto& lss = lnav_data.ld_log_source;

        tc->set_user_mark(&textview_curses::BM_META, tc->get_top(), true);
        auto& line_meta = lss.get_bookmark_metadata(tc->get_top());
        for (size_t lpc = 1; lpc < args.size(); lpc++) {
            std::string tag = args[lpc];

            if (!startswith(tag, "#")) {
                tag = "#" + tag;
            }
            bookmark_metadata::KNOWN_TAGS.insert(tag);
            line_meta.add_tag(tag);
        }
        tc->search_new_data();
        lss.set_line_meta_changed();
        lss.text_filters_changed();
        tc->reload_data();

        retval = "info: tag(s) added to line";
    } else {
        return ec.make_error("expecting one or more tags");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_untag(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("line-tags");
        return Ok(std::string());
    } else if (args.size() > 1) {
        if (ec.ec_dry_run) {
            return Ok(std::string());
        }
        textview_curses* tc = *lnav_data.ld_view_stack.top();

        if (tc != &lnav_data.ld_views[LNV_LOG]) {
            return ec.make_error(
                "The :untag command only works in the log view");
        }
        auto& lss = lnav_data.ld_log_source;

        auto line_meta_opt = lss.find_bookmark_metadata(tc->get_top());
        if (line_meta_opt) {
            bookmark_metadata& line_meta = *(line_meta_opt.value());

            for (size_t lpc = 1; lpc < args.size(); lpc++) {
                std::string tag = args[lpc];

                if (!startswith(tag, "#")) {
                    tag = "#" + tag;
                }
                line_meta.remove_tag(tag);
            }
            if (line_meta.empty()) {
                tc->set_user_mark(
                    &textview_curses::BM_META, tc->get_top(), false);
            }
        }
        tc->search_new_data();
        lss.set_line_meta_changed();
        lss.text_filters_changed();
        tc->reload_data();

        retval = "info: tag(s) removed from line";
    } else {
        return ec.make_error("expecting one or more tags");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_delete_tags(exec_context& ec,
                std::string cmdline,
                std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("tag");
        return Ok(std::string());
    } else if (args.size() > 1) {
        if (ec.ec_dry_run) {
            return Ok(std::string());
        }
        textview_curses* tc = *lnav_data.ld_view_stack.top();

        if (tc != &lnav_data.ld_views[LNV_LOG]) {
            return ec.make_error(
                "The :delete-tag command only works in the log view");
        }

        auto& known_tags = bookmark_metadata::KNOWN_TAGS;
        std::vector<std::string> tags;

        for (size_t lpc = 1; lpc < args.size(); lpc++) {
            std::string tag = args[lpc];

            if (!startswith(tag, "#")) {
                tag = "#" + tag;
            }
            if (known_tags.find(tag) == known_tags.end()) {
                return ec.make_error("Unknown tag -- {}", tag);
            }

            tags.emplace_back(tag);
            known_tags.erase(tag);
        }

        auto& lss = lnav_data.ld_log_source;
        auto& vbm = tc->get_bookmarks()[&textview_curses::BM_META];

        for (auto iter = vbm.begin(); iter != vbm.end();) {
            auto line_meta_opt = lss.find_bookmark_metadata(*iter);

            if (!line_meta_opt) {
                ++iter;
                continue;
            }

            auto& line_meta = line_meta_opt.value();
            for (const auto& tag : tags) {
                line_meta->remove_tag(tag);
            }

            if (line_meta->empty()) {
                lss.erase_bookmark_metadata(*iter);
                size_t off = distance(vbm.begin(), iter);

                tc->set_user_mark(&textview_curses::BM_META, *iter, false);
                iter = next(vbm.begin(), off);
            } else {
                ++iter;
            }
        }

        retval = "info: deleted tag(s)";
    } else {
        return ec.make_error("expecting one or more tags");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_partition_name(exec_context& ec,
                   std::string cmdline,
                   std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        return Ok(std::string());
    } else if (args.size() > 1) {
        if (ec.ec_dry_run) {
            retval = "";
        } else {
            textview_curses& tc = lnav_data.ld_views[LNV_LOG];
            logfile_sub_source& lss = lnav_data.ld_log_source;

            args[1] = trim(remaining_args(cmdline, args));

            tc.set_user_mark(&textview_curses::BM_META, tc.get_top(), true);

            auto& line_meta = lss.get_bookmark_metadata(tc.get_top());

            line_meta.bm_name = args[1];
            retval = "info: name set for partition";
        }
    } else {
        return ec.make_error("expecting partition name");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_clear_partition(exec_context& ec,
                    std::string cmdline,
                    std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        return Ok(std::string());
    } else if (args.size() == 1) {
        textview_curses& tc = lnav_data.ld_views[LNV_LOG];
        logfile_sub_source& lss = lnav_data.ld_log_source;
        auto& bv = tc.get_bookmarks()[&textview_curses::BM_META];
        nonstd::optional<vis_line_t> part_start;

        if (binary_search(bv.begin(), bv.end(), tc.get_top())) {
            part_start = tc.get_top();
        } else {
            part_start = bv.prev(tc.get_top());
        }
        if (!part_start) {
            return ec.make_error("top line is not in a partition");
        }

        if (!ec.ec_dry_run) {
            auto& line_meta = lss.get_bookmark_metadata(part_start.value());

            line_meta.bm_name.clear();
            if (line_meta.empty()) {
                lss.erase_bookmark_metadata(part_start.value());
                tc.set_user_mark(
                    &textview_curses::BM_META, part_start.value(), false);
            }

            retval = "info: cleared partition name";
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_summarize(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("colname");
        return Ok(retval);
    } else if (!setup_logline_table(ec)) {
        return ec.make_error("no log data available");
    } else if (args.size() == 1) {
        return ec.make_error("no columns specified");
    } else {
        auto_mem<char, sqlite3_free> query_frag;
        std::vector<std::string> other_columns;
        std::vector<std::string> num_columns;
        const auto& top_source = ec.ec_source.back();
        sql_progress_guard progress_guard(sql_progress,
                                          sql_progress_finished,
                                          top_source.s_location,
                                          top_source.s_content);
        auto_mem<sqlite3_stmt> stmt(sqlite3_finalize);
        int retcode;
        std::string query;

        query = "SELECT ";
        for (size_t lpc = 1; lpc < args.size(); lpc++) {
            if (lpc > 1)
                query += ", ";
            query += args[lpc];
        }
        query += " FROM logline ";

        retcode = sqlite3_prepare_v2(
            lnav_data.ld_db.in(), query.c_str(), -1, stmt.out(), nullptr);
        if (retcode != SQLITE_OK) {
            const char* errmsg = sqlite3_errmsg(lnav_data.ld_db);

            return ec.make_error("{}", errmsg);
        }

        switch (sqlite3_step(stmt.in())) {
            case SQLITE_OK:
            case SQLITE_DONE: {
                return ec.make_error("no data");
            } break;
            case SQLITE_ROW:
                break;
            default: {
                const char* errmsg;

                errmsg = sqlite3_errmsg(lnav_data.ld_db);
                return ec.make_error("{}", errmsg);
            } break;
        }

        if (ec.ec_dry_run) {
            return Ok(std::string());
        }

        for (int lpc = 0; lpc < sqlite3_column_count(stmt.in()); lpc++) {
            switch (sqlite3_column_type(stmt.in(), lpc)) {
                case SQLITE_INTEGER:
                case SQLITE_FLOAT:
                    num_columns.push_back(args[lpc + 1]);
                    break;
                default:
                    other_columns.push_back(args[lpc + 1]);
                    break;
            }
        }

        query = "SELECT";
        for (auto iter = other_columns.begin(); iter != other_columns.end();
             ++iter)
        {
            if (iter != other_columns.begin()) {
                query += ",";
            }
            query_frag
                = sqlite3_mprintf(" %s as \"c_%s\", count(*) as \"count_%s\"",
                                  iter->c_str(),
                                  iter->c_str(),
                                  iter->c_str());
            query += query_frag;
        }

        if (!other_columns.empty() && !num_columns.empty()) {
            query += ", ";
        }

        for (auto iter = num_columns.begin(); iter != num_columns.end(); ++iter)
        {
            if (iter != num_columns.begin()) {
                query += ",";
            }
            query_frag = sqlite3_mprintf(
                " sum(\"%s\"), "
                " min(\"%s\"), "
                " avg(\"%s\"), "
                " median(\"%s\"), "
                " stddev(\"%s\"), "
                " max(\"%s\") ",
                iter->c_str(),
                iter->c_str(),
                iter->c_str(),
                iter->c_str(),
                iter->c_str(),
                iter->c_str());
            query += query_frag;
        }

        query
            += (" FROM logline "
                "WHERE (logline.log_part is null or "
                "startswith(logline.log_part, '.') = 0) ");

        for (auto iter = other_columns.begin(); iter != other_columns.end();
             ++iter)
        {
            if (iter == other_columns.begin()) {
                query += " GROUP BY ";
            } else {
                query += ",";
            }
            query_frag = sqlite3_mprintf(" \"c_%s\"", iter->c_str());
            query += query_frag;
        }

        for (auto iter = other_columns.begin(); iter != other_columns.end();
             ++iter)
        {
            if (iter == other_columns.begin()) {
                query += " ORDER BY ";
            } else {
                query += ",";
            }
            query_frag = sqlite3_mprintf(
                " \"count_%s\" desc, \"c_%s\" collate naturalnocase asc",
                iter->c_str(),
                iter->c_str());
            query += query_frag;
        }
        log_debug("query %s", query.c_str());

        db_label_source& dls = lnav_data.ld_db_row_source;

        dls.clear();
        retcode = sqlite3_prepare_v2(
            lnav_data.ld_db.in(), query.c_str(), -1, stmt.out(), nullptr);

        if (retcode != SQLITE_OK) {
            const char* errmsg = sqlite3_errmsg(lnav_data.ld_db);

            return ec.make_error("{}", errmsg);
        } else if (stmt == nullptr) {
            retval = "";
        } else {
            bool done = false;

            while (!done) {
                retcode = sqlite3_step(stmt.in());

                switch (retcode) {
                    case SQLITE_OK:
                    case SQLITE_DONE:
                        done = true;
                        break;

                    case SQLITE_ROW:
                        ec.ec_sql_callback(ec, stmt.in());
                        break;

                    default: {
                        const char* errmsg;

                        errmsg = sqlite3_errmsg(lnav_data.ld_db);
                        return ec.make_error("{}", errmsg);
                    }
                }
            }

            if (retcode == SQLITE_DONE) {
                lnav_data.ld_views[LNV_LOG].reload_data();
                lnav_data.ld_views[LNV_DB].reload_data();
                lnav_data.ld_views[LNV_DB].set_left(0);

                if (dls.dls_rows.size() > 0) {
                    ensure_view(&lnav_data.ld_views[LNV_DB]);
                }
            }

            lnav_data.ld_bottom_source.update_loading(0, 0);
            lnav_data.ld_status[LNS_BOTTOM].do_update();
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_add_test(exec_context& ec,
             std::string cmdline,
             std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (args.size() > 1) {
        return ec.make_error("not expecting any arguments");
    } else if (ec.ec_dry_run) {
    } else {
        textview_curses* tc = *lnav_data.ld_view_stack.top();

        bookmark_vector<vis_line_t>& bv
            = tc->get_bookmarks()[&textview_curses::BM_USER];
        bookmark_vector<vis_line_t>::iterator iter;

        for (iter = bv.begin(); iter != bv.end(); ++iter) {
            auto_mem<FILE> file(fclose);
            char path[PATH_MAX];
            std::string line;

            tc->grep_value_for_line(*iter, line);

            line.insert(0, 13, ' ');

            snprintf(path,
                     sizeof(path),
                     "%s/test/log-samples/sample-%s.txt",
                     getenv("LNAV_SRC"),
                     hasher().update(line).to_string().c_str());

            if ((file = fopen(path, "w")) == nullptr) {
                perror("fopen failed");
            } else {
                fprintf(file, "%s\n", line.c_str());
            }
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_switch_to_view(exec_context& ec,
                   std::string cmdline,
                   std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("viewname");
    } else if (args.size() > 1) {
        bool found = false;

        for (int lpc = 0; lnav_view_strings[lpc] && !found; lpc++) {
            if (strcasecmp(args[1].c_str(), lnav_view_strings[lpc]) == 0) {
                if (!ec.ec_dry_run) {
                    if (args[0] == "switch-to-view") {
                        ensure_view(&lnav_data.ld_views[lpc]);
                    } else {
                        toggle_view(&lnav_data.ld_views[lpc]);
                    }
                }
                found = true;
            }
        }

        if (!found) {
            return ec.make_error("invalid view name -- {}", args[1]);
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_toggle_filtering(exec_context& ec,
                     std::string cmdline,
                     std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        auto tc = *lnav_data.ld_view_stack.top();
        auto tss = tc->get_sub_source();

        tss->toggle_apply_filters();
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_zoom_to(exec_context& ec,
            std::string cmdline,
            std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("zoomlevel");
    } else if (ec.ec_dry_run) {
    } else if (args.size() > 1) {
        bool found = false;

        for (size_t lpc = 0; lpc < lnav_zoom_strings.size() && !found; lpc++) {
            if (strcasecmp(args[1].c_str(), lnav_zoom_strings[lpc].c_str())
                == 0)
            {
                auto& ss = *lnav_data.ld_spectro_source;
                struct timeval old_time;

                lnav_data.ld_zoom_level = lpc;

                auto& hist_view = lnav_data.ld_views[LNV_HISTOGRAM];

                if (hist_view.get_inner_height() > 0) {
                    auto old_time_opt = lnav_data.ld_hist_source2.time_for_row(
                        lnav_data.ld_views[LNV_HISTOGRAM].get_top());
                    if (old_time_opt) {
                        old_time = old_time_opt.value();
                        rebuild_hist();
                        lnav_data.ld_hist_source2.row_for_time(old_time) |
                            [](auto new_top) {
                                lnav_data.ld_views[LNV_HISTOGRAM].set_top(
                                    new_top);
                            };
                    }
                }

                auto& spectro_view = lnav_data.ld_views[LNV_SPECTRO];

                if (spectro_view.get_inner_height() > 0) {
                    auto old_time_opt
                        = lnav_data.ld_spectro_source->time_for_row(
                            lnav_data.ld_views[LNV_SPECTRO].get_selection());
                    ss.ss_granularity = ZOOM_LEVELS[lnav_data.ld_zoom_level];
                    ss.invalidate();
                    spectro_view.reload_data();
                    if (old_time_opt) {
                        lnav_data.ld_spectro_source->row_for_time(
                            old_time_opt.value())
                            | [](auto new_top) {
                                  lnav_data.ld_views[LNV_SPECTRO].set_selection(
                                      new_top);
                              };
                    }
                }

                lnav_data.ld_view_stack.set_needs_update();

                found = true;
            }
        }

        if (!found) {
            auto um = lnav::console::user_message::error(
                          attr_line_t("invalid zoom level: ")
                              .append(lnav::roles::symbol(args[1])))
                          .with_snippets(ec.ec_source)
                          .with_help(attr_line_t("available levels: ")
                                         .join(lnav_zoom_strings, ", "));
            return Err(um);
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_reset_session(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        reset_session();
        lnav_data.ld_views[LNV_LOG].reload_data();
    }

    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_load_session(exec_context& ec,
                 std::string cmdline,
                 std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        load_session();
        lnav_data.ld_views[LNV_LOG].reload_data();
    }

    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_save_session(exec_context& ec,
                 std::string cmdline,
                 std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        save_session();
    }

    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_export_session_to(exec_context& ec,
                      std::string cmdline,
                      std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("filename");
    } else if (!ec.ec_dry_run) {
        auto_mem<FILE> outfile(fclose);
        auto fn = trim(remaining_args(cmdline, args));
        auto to_term = false;

        if (fn == "-" || fn == "/dev/stdout") {
            auto ec_out = ec.get_output();

            if (!ec_out) {
                outfile = auto_mem<FILE>::leak(stdout);
                nodelay(lnav_data.ld_window, 0);
                endwin();
                struct termios curr_termios;
                tcgetattr(1, &curr_termios);
                curr_termios.c_oflag |= ONLCR | OPOST;
                tcsetattr(1, TCSANOW, &curr_termios);
                setvbuf(stdout, nullptr, _IONBF, 0);
                to_term = true;
                fprintf(
                    outfile,
                    "\n---------------- Press any key to exit lo-fi display "
                    "----------------\n\n");
            } else {
                outfile = auto_mem<FILE>::leak(ec_out.value());
            }
            if (outfile.in() == stdout) {
                lnav_data.ld_stdout_used = true;
            }
        } else if (fn == "/dev/clipboard") {
            auto open_res = sysclip::open(sysclip::type_t::GENERAL);
            if (open_res.isErr()) {
                alerter::singleton().chime("cannot open clipboard");
                return ec.make_error("Unable to copy to clipboard: {}",
                                     open_res.unwrapErr());
            }
            outfile = open_res.unwrap();
        } else if (lnav_data.ld_flags & LNF_SECURE_MODE) {
            return ec.make_error("{} -- unavailable in secure mode", args[0]);
        } else {
            if ((outfile = fopen(fn.c_str(), "we")) == nullptr) {
                return ec.make_error("unable to open file -- {}", fn);
            }
            fchmod(fileno(outfile.in()), S_IRWXU);
        }

        auto export_res = lnav::session::export_to(outfile.in());

        fflush(outfile.in());
        if (to_term) {
            cbreak();
            getch();
            refresh();
            nodelay(lnav_data.ld_window, 1);
        }
        if (export_res.isErr()) {
            return Err(export_res.unwrapErr());
        }

        retval = fmt::format(
            FMT_STRING("info: wrote session commands to -- {}"), fn);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_set_min_log_level(exec_context& ec,
                      std::string cmdline,
                      std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("levelname");
    } else if (ec.ec_dry_run) {
        retval = "";
    } else if (args.size() == 2) {
        auto& lss = lnav_data.ld_log_source;
        auto new_level = string2level(args[1].c_str(), args[1].size(), false);
        lss.set_min_log_level(new_level);

        retval = ("info: minimum log level is now -- "
                  + std::string(level_names[new_level]));
    } else {
        return ec.make_error("expecting a log level name");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_toggle_field(exec_context& ec,
                 std::string cmdline,
                 std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("colname");
    } else if (args.size() < 2) {
        return ec.make_error("Expecting a log message field name");
    } else {
        auto* tc = *lnav_data.ld_view_stack.top();

        if (tc != &lnav_data.ld_views[LNV_LOG]) {
            retval = "error: hiding fields only works in the log view";
        } else if (ec.ec_dry_run) {
            // TODO: highlight the fields to be hidden.
            retval = "";
        } else {
            logfile_sub_source& lss = lnav_data.ld_log_source;
            bool hide = args[0] == "hide-fields";
            std::vector<std::string> found_fields, missing_fields;

            for (int lpc = 1; lpc < (int) args.size(); lpc++) {
                intern_string_t name;
                std::shared_ptr<log_format> format;
                size_t dot;

                if ((dot = args[lpc].find('.')) != std::string::npos) {
                    const intern_string_t format_name
                        = intern_string::lookup(args[lpc].c_str(), dot);

                    format = log_format::find_root_format(format_name.get());
                    if (!format) {
                        return ec.make_error("unknown format -- {}",
                                             format_name.to_string());
                    }
                    name = intern_string::lookup(&(args[lpc].c_str()[dot + 1]),
                                                 args[lpc].length() - dot - 1);
                } else if (tc->get_inner_height() == 0) {
                    return ec.make_error("no log messages to hide");
                } else {
                    content_line_t cl = lss.at(tc->get_top());
                    std::shared_ptr<logfile> lf = lss.find(cl);
                    format = lf->get_format();
                    name = intern_string::lookup(args[lpc]);
                }

                if (format->hide_field(name, hide)) {
                    found_fields.push_back(args[lpc]);
                    if (hide) {
                        if (lnav_data.ld_rl_view != nullptr) {
                            lnav_data.ld_rl_view->set_alt_value(
                                HELP_MSG_1(x, "to quickly show hidden fields"));
                        }
                    }
                    tc->set_needs_update();
                } else {
                    missing_fields.push_back(args[lpc]);
                }
            }

            if (missing_fields.empty()) {
                auto visibility = hide ? "hiding" : "showing";
                retval = fmt::format(FMT_STRING("info: {} field(s) -- {}"),
                                     visibility,
                                     fmt::join(found_fields, ", "));
            } else {
                return ec.make_error("unknown field(s) -- {}",
                                     fmt::join(missing_fields, ", "));
            }
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_hide_line(exec_context& ec,
              std::string cmdline,
              std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("move-time");
    } else if (args.size() == 1) {
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        logfile_sub_source& lss = lnav_data.ld_log_source;

        if (tc == &lnav_data.ld_views[LNV_LOG]) {
            struct timeval min_time, max_time;
            bool have_min_time = lss.get_min_log_time(min_time);
            bool have_max_time = lss.get_max_log_time(max_time);
            char min_time_str[32], max_time_str[32];

            if (have_min_time) {
                sql_strftime(min_time_str, sizeof(min_time_str), min_time);
            }
            if (have_max_time) {
                sql_strftime(max_time_str, sizeof(max_time_str), max_time);
            }
            if (have_min_time && have_max_time) {
                retval
                    = fmt::format("info: hiding lines before {} and after {}",
                                  min_time_str,
                                  max_time_str);
            } else if (have_min_time) {
                retval
                    = fmt::format("info: hiding lines before {}", min_time_str);
            } else if (have_max_time) {
                retval
                    = fmt::format("info: hiding lines after {}", max_time_str);
            } else {
                retval
                    = "info: no lines hidden by time, pass an absolute or "
                      "relative time";
            }
        } else {
            return ec.make_error(
                "hiding lines by time only works in the log view");
        }
    } else if (args.size() >= 2) {
        std::string all_args = remaining_args(cmdline, args);
        textview_curses* tc = *lnav_data.ld_view_stack.top();
        logfile_sub_source& lss = lnav_data.ld_log_source;
        date_time_scanner dts;
        struct timeval tv;
        bool tv_set = false;
        auto parse_res = relative_time::from_str(all_args);

        if (parse_res.isOk()) {
            if (tc == &lnav_data.ld_views[LNV_LOG]) {
                if (tc->get_inner_height() > 0) {
                    content_line_t cl;
                    struct exttm tm;
                    vis_line_t vl;
                    logline* ll;

                    vl = tc->get_top();
                    cl = lnav_data.ld_log_source.at(vl);
                    ll = lnav_data.ld_log_source.find_line(cl);
                    ll->to_exttm(tm);
                    tv = parse_res.unwrap().adjust(tm).to_timeval();

                    tv_set = true;
                }
            } else {
                return ec.make_error(
                    "relative time values only work in the log view");
            }
        } else if (dts.convert_to_timeval(all_args, tv)) {
            if (tc == &lnav_data.ld_views[LNV_LOG]) {
                tv_set = true;
            } else {
                return ec.make_error("time values only work in the log view");
            }
        }

        if (tv_set && !ec.ec_dry_run) {
            char time_text[256];
            std::string relation;

            sql_strftime(time_text, sizeof(time_text), tv);
            if (args[0] == "hide-lines-before") {
                lss.set_min_log_time(tv);
                relation = "before";
            } else {
                lss.set_max_log_time(tv);
                relation = "after";
            }

            retval = "info: hiding lines " + relation + " " + time_text;
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_show_lines(exec_context& ec,
               std::string cmdline,
               std::vector<std::string>& args)
{
    std::string retval = "info: showing lines";

    if (ec.ec_dry_run) {
        retval = "";
    } else if (!args.empty()) {
        logfile_sub_source& lss = lnav_data.ld_log_source;
        textview_curses* tc = *lnav_data.ld_view_stack.top();

        if (tc == &lnav_data.ld_views[LNV_LOG]) {
            lss.clear_min_max_log_times();
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_hide_unmarked(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    std::string retval = "info: hid unmarked lines";

    if (args.empty()) {
    } else if (ec.ec_dry_run) {
        retval = "";
    } else {
        auto* tc = *lnav_data.ld_view_stack.top();
        const auto& bv = tc->get_bookmarks()[&textview_curses::BM_USER];
        const auto& bv_expr
            = tc->get_bookmarks()[&textview_curses::BM_USER_EXPR];

        if (bv.empty() && bv_expr.empty()) {
            return ec.make_error("no lines have been marked");
        } else {
            lnav_data.ld_log_source.set_marked_only(true);
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_show_unmarked(exec_context& ec,
                  std::string cmdline,
                  std::vector<std::string>& args)
{
    std::string retval = "info: showing unmarked lines";

    if (ec.ec_dry_run) {
        retval = "";
    } else {
        lnav_data.ld_log_source.set_marked_only(false);
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_rebuild(exec_context& ec,
            std::string cmdline,
            std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        rescan_files(true);
        rebuild_indexes_repeatedly();
    }

    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_shexec(exec_context& ec,
           std::string cmdline,
           std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        log_perror(system(cmdline.substr(args[0].size()).c_str()));
    }

    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_poll_now(exec_context& ec,
             std::string cmdline,
             std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        isc::to<curl_looper&, services::curl_streamer_t>().send_and_wait(
            [](auto& clooper) { clooper.process_all(); });
    }

    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_test_comment(exec_context& ec,
                 std::string cmdline,
                 std::vector<std::string>& args)
{
    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_redraw(exec_context& ec,
           std::string cmdline,
           std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (ec.ec_dry_run) {
    } else if (lnav_data.ld_window) {
        redrawwin(lnav_data.ld_window);
    }

    return Ok(std::string());
}

static Result<std::string, lnav::console::user_message>
com_echo(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval = "error: expecting a message";

    if (args.empty()) {
    } else if (args.size() >= 1) {
        bool lf = true;
        std::string src;

        if (args.size() > 2 && args[1] == "-n") {
            std::string::size_type index_in_cmdline = cmdline.find(args[1]);

            lf = false;
            src = cmdline.substr(index_in_cmdline + args[1].length() + 1);
        } else if (args.size() >= 2) {
            src = cmdline.substr(args[0].length() + 1);
        } else {
            src = "";
        }

        auto lexer = shlex(src);
        lexer.eval(retval, ec.create_resolver());

        auto ec_out = ec.get_output();
        if (ec.ec_dry_run) {
            lnav_data.ld_preview_status_source.get_description().set_value(
                "The text to output:");
            lnav_data.ld_preview_source.replace_with(attr_line_t(retval));
            retval = "";
        } else if (ec_out) {
            FILE* outfile = *ec_out;

            if (outfile == stdout) {
                lnav_data.ld_stdout_used = true;
            }

            fprintf(outfile, "%s", retval.c_str());
            if (lf) {
                putc('\n', outfile);
            }
            fflush(outfile);

            retval = "";
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_alt_msg(exec_context& ec,
            std::string cmdline,
            std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
    } else if (ec.ec_dry_run) {
        retval = "";
    } else if (args.size() == 1) {
        if (lnav_data.ld_rl_view != nullptr) {
            lnav_data.ld_rl_view->set_alt_value("");
        }
        retval = "";
    } else {
        std::string msg = remaining_args(cmdline, args);

        if (lnav_data.ld_rl_view != nullptr) {
            lnav_data.ld_rl_view->set_alt_value(msg);
        }

        retval = "";
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_eval(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("*");
    } else if (args.size() > 1) {
        static intern_string_t EVAL_SRC = intern_string::lookup(":eval");

        std::string all_args = remaining_args(cmdline, args);
        std::string expanded_cmd;
        shlex lexer(all_args.c_str(), all_args.size());

        log_debug("Evaluating: %s", all_args.c_str());
        if (!lexer.eval(expanded_cmd,
                        {
                            &ec.ec_local_vars.top(),
                            &ec.ec_global_vars,
                        }))
        {
            return ec.make_error("invalid arguments");
        }
        log_debug("Expanded command to evaluate: %s", expanded_cmd.c_str());

        if (expanded_cmd.empty()) {
            return ec.make_error("empty result after evaluation");
        }

        if (ec.ec_dry_run) {
            attr_line_t al(expanded_cmd);

            lnav_data.ld_preview_status_source.get_description().set_value(
                "The command to be executed:");

            lnav_data.ld_preview_source.replace_with(al);

            return Ok(std::string());
        }

        auto src_guard = ec.enter_source(EVAL_SRC, 1, expanded_cmd);
        std::string alt_msg;
        switch (expanded_cmd[0]) {
            case ':':
                return execute_command(ec, expanded_cmd.substr(1));
            case ';':
                return execute_sql(ec, expanded_cmd.substr(1), alt_msg);
            case '|':
                return execute_file(ec, expanded_cmd.substr(1));
            case '/': {
                auto search_cmd = expanded_cmd.substr(1);
                lnav_data.ld_view_stack.top() | [&search_cmd](auto tc) {
                    tc->execute_search(search_cmd);
                };
                break;
            }
            default:
                return ec.make_error(
                    "expecting argument to start with ':', ';', '/', "
                    "or '|' to signify a command, SQL query, or script to "
                    "execute");
        }
    } else {
        return ec.make_error("expecting a command or query to evaluate");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_config(exec_context& ec,
           std::string cmdline,
           std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("config-option");
    } else if (args.size() > 1) {
        static const auto INPUT_SRC = intern_string::lookup("input");

        yajlpp_parse_context ypc(INPUT_SRC, &lnav_config_handlers);
        std::vector<lnav::console::user_message> errors;
        std::string option = args[1];

        lnav_config = rollback_lnav_config;
        ypc.set_path(option)
            .with_obj(lnav_config)
            .with_error_reporter([&errors](const auto& ypc, auto msg) {
                errors.push_back(msg);
            });
        ypc.ypc_active_paths.insert(option);
        ypc.update_callbacks();

        const auto* jph = ypc.ypc_current_handler;

        if (jph == nullptr && !ypc.ypc_handler_stack.empty()) {
            jph = ypc.ypc_handler_stack.back();
        }

        if (jph != nullptr) {
            yajlpp_gen gen;
            yajlpp_gen_context ygc(gen, lnav_config_handlers);
            yajl_gen_config(gen, yajl_gen_beautify, 1);
            ygc.with_context(ypc);

            if (ypc.ypc_current_handler == nullptr) {
                ygc.gen();
            } else {
                jph->gen(ygc, gen);
            }

            auto old_value = gen.to_string_fragment().to_string();

            if (args.size() == 2 || ypc.ypc_current_handler == nullptr) {
                lnav_config = rollback_lnav_config;
                reload_config(errors);

                if (ec.ec_dry_run) {
                    attr_line_t al(old_value);

                    lnav_data.ld_preview_source.replace_with(al)
                        .set_text_format(detect_text_format(old_value))
                        .truncate_to(10);
                    lnav_data.ld_preview_status_source.get_description()
                        .set_value("Value of option: %s", option.c_str());

                    char help_text[1024];

                    snprintf(help_text,
                             sizeof(help_text),
                             ANSI_BOLD("%s") " " ANSI_UNDERLINE("%s") " -- %s",
                             jph->jph_property.c_str(),
                             jph->jph_synopsis,
                             jph->jph_description);

                    retval = help_text;
                } else {
                    retval = fmt::format(
                        FMT_STRING("{} = {}"), option, trim(old_value));
                }
            } else if (lnav_data.ld_flags & LNF_SECURE_MODE
                       && !startswith(option, "/ui/"))
            {
                return ec.make_error(":config {} -- unavailable in secure mode",
                                     option);
            } else {
                auto value = remaining_args(cmdline, args, 2);
                bool changed = false;

                if (ec.ec_dry_run) {
                    char help_text[1024];

                    snprintf(help_text,
                             sizeof(help_text),
                             ANSI_BOLD("%s %s") " -- %s",
                             jph->jph_property.c_str(),
                             jph->jph_synopsis,
                             jph->jph_description);

                    retval = help_text;
                }

                if (ypc.ypc_current_handler->jph_callbacks.yajl_string) {
                    ypc.ypc_callbacks.yajl_string(
                        &ypc,
                        (const unsigned char*) value.c_str(),
                        value.size());
                    changed = true;
                } else if (ypc.ypc_current_handler->jph_callbacks.yajl_integer)
                {
                    auto scan_res = scn::scan_value<int64_t>(value);
                    if (!scan_res || !scan_res.empty()) {
                        return ec.make_error("expecting an integer, found: {}",
                                             value);
                    }
                    ypc.ypc_callbacks.yajl_integer(&ypc, scan_res.value());
                    changed = true;
                } else if (ypc.ypc_current_handler->jph_callbacks.yajl_boolean)
                {
                    bool bvalue = false;

                    if (strcasecmp(value.c_str(), "true") == 0) {
                        bvalue = true;
                    }
                    ypc.ypc_callbacks.yajl_boolean(&ypc, bvalue);
                    changed = true;
                } else {
                    return ec.make_error("unhandled type");
                }

                if (!errors.empty()) {
                    return Err(errors[0]);
                }

                if (changed) {
                    intern_string_t path = intern_string::lookup(option);

                    lnav_config_locations[path]
                        = ec.ec_source.back().s_location;
                    reload_config(errors);

                    if (!errors.empty()) {
                        lnav_config = rollback_lnav_config;
                        reload_config(errors);
                        return Err(errors[0]);
                    }
                    if (!ec.ec_dry_run) {
                        retval = "info: changed config option -- " + option;
                        rollback_lnav_config = lnav_config;
                        if (!(lnav_data.ld_flags & LNF_SECURE_MODE)) {
                            save_config();
                        }
                    }
                }
            }
        } else {
            return ec.make_error("unknown configuration option -- {}", option);
        }
    } else {
        return ec.make_error(
            "expecting a configuration option to read or write");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_reset_config(exec_context& ec,
                 std::string cmdline,
                 std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("config-option");
    } else if (args.size() == 1) {
        return ec.make_error("expecting a configuration option to reset");
    } else {
        static const auto INPUT_SRC = intern_string::lookup("input");

        yajlpp_parse_context ypc(INPUT_SRC, &lnav_config_handlers);
        std::string option = args[1];

        while (!option.empty() && option.back() == '/') {
            option.pop_back();
        }
        lnav_config = rollback_lnav_config;
        ypc.set_path(option).with_obj(lnav_config);
        ypc.ypc_active_paths.insert(option);
        ypc.update_callbacks();

        if (option == "*"
            || (ypc.ypc_current_handler != nullptr
                || !ypc.ypc_handler_stack.empty()))
        {
            if (!ec.ec_dry_run) {
                reset_config(option);
                rollback_lnav_config = lnav_config;
                if (!(lnav_data.ld_flags & LNF_SECURE_MODE)) {
                    save_config();
                }
            }
            if (option == "*") {
                retval = "info: reset all options";
            } else {
                retval = "info: reset option -- " + option;
            }
        } else {
            return ec.make_error("unknown configuration option -- {}", option);
        }
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_spectrogram(exec_context& ec,
                std::string cmdline,
                std::vector<std::string>& args)
{
    std::string retval;

    if (args.empty()) {
        args.emplace_back("numeric-colname");
    } else if (ec.ec_dry_run) {
        retval = "";
    } else if (args.size() == 2) {
        auto colname = remaining_args(cmdline, args);
        auto& ss = *lnav_data.ld_spectro_source;
        bool found = false;

        ss.ss_granularity = ZOOM_LEVELS[lnav_data.ld_zoom_level];
        if (ss.ss_value_source != nullptr) {
            delete ss.ss_value_source;
            ss.ss_value_source = nullptr;
        }
        ss.invalidate();

        if (*lnav_data.ld_view_stack.top() == &lnav_data.ld_views[LNV_DB]) {
            auto dsvs = std::make_unique<db_spectro_value_source>(colname);

            if (dsvs->dsvs_error_msg) {
                return Err(
                    dsvs->dsvs_error_msg.value().with_snippets(ec.ec_source));
            }
            ss.ss_value_source = dsvs.release();
            found = true;
        } else {
            auto lsvs = std::make_unique<log_spectro_value_source>(
                intern_string::lookup(colname));

            if (!lsvs->lsvs_found) {
                return ec.make_error("unknown numeric message field -- {}",
                                     colname);
            }
            ss.ss_value_source = lsvs.release();
            found = true;
        }

        if (found) {
            ss.text_selection_changed(lnav_data.ld_views[LNV_SPECTRO]);
            ensure_view(&lnav_data.ld_views[LNV_SPECTRO]);

            if (lnav_data.ld_rl_view != nullptr) {
                lnav_data.ld_rl_view->set_alt_value(
                    HELP_MSG_2(z, Z, "to zoom in/out"));
            }

            retval = "info: visualizing field -- " + colname;
        }
    } else {
        return ec.make_error("expecting a message field name");
    }

    return Ok(retval);
}

static Result<std::string, lnav::console::user_message>
com_quit(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
{
    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        lnav_data.ld_looping = false;
    }
    return Ok(std::string());
}

static void
command_prompt(std::vector<std::string>& args)
{
    auto* tc = *lnav_data.ld_view_stack.top();
    auto* rlc = lnav_data.ld_rl_view;

    rlc->clear_possibilities(ln_mode_t::COMMAND, "move-args");
    if (lnav_data.ld_views[LNV_LOG].get_inner_height() > 0) {
        static const char* MOVE_TIMES[]
            = {"here", "now", "today", "yesterday", nullptr};

        logfile_sub_source& lss = lnav_data.ld_log_source;
        textview_curses& log_view = lnav_data.ld_views[LNV_LOG];
        content_line_t cl = lss.at(log_view.get_top());
        std::shared_ptr<logfile> lf = lss.find(cl);
        auto ll = lf->begin() + cl;
        log_data_helper ldh(lss);

        lnav_data.ld_exec_context.ec_top_line = tc->get_top();

        lnav_data.ld_rl_view->clear_possibilities(ln_mode_t::COMMAND,
                                                  "numeric-colname");
        lnav_data.ld_rl_view->clear_possibilities(ln_mode_t::COMMAND,
                                                  "colname");

        ldh.parse_line(log_view.get_top(), true);

        if (tc == &lnav_data.ld_views[LNV_DB]) {
            db_label_source& dls = lnav_data.ld_db_row_source;

            for (auto& dls_header : dls.dls_headers) {
                if (!dls_header.hm_graphable) {
                    continue;
                }

                lnav_data.ld_rl_view->add_possibility(
                    ln_mode_t::COMMAND, "numeric-colname", dls_header.hm_name);
            }
        } else {
            for (auto& ldh_line_value : ldh.ldh_line_values.lvv_values) {
                auto& meta = ldh_line_value.lv_meta;

                if (!meta.lvm_format) {
                    continue;
                }

                const auto* stats
                    = meta.lvm_format.value()->stats_for_value(meta.lvm_name);

                if (stats == nullptr) {
                    continue;
                }

                lnav_data.ld_rl_view->add_possibility(
                    ln_mode_t::COMMAND,
                    "numeric-colname",
                    meta.lvm_name.to_string());
            }
        }

        for (auto& cn_name : ldh.ldh_namer->cn_names) {
            lnav_data.ld_rl_view->add_possibility(
                ln_mode_t::COMMAND, "colname", cn_name.to_string());
        }
        for (const auto& iter : ldh.ldh_namer->cn_builtin_names) {
            if (iter == column_namer::BUILTIN_COL) {
                continue;
            }
            lnav_data.ld_rl_view->add_possibility(
                ln_mode_t::COMMAND, "colname", iter.to_string());
        }

        ldh.clear();

        rlc->clear_possibilities(ln_mode_t::COMMAND, "move-time");
        rlc->add_possibility(ln_mode_t::COMMAND, "move-time", MOVE_TIMES);
        rlc->add_possibility(ln_mode_t::COMMAND, "move-args", MOVE_TIMES);
        rlc->clear_possibilities(ln_mode_t::COMMAND, "line-time");
        {
            struct timeval tv = lf->get_time_offset();
            char buffer[64];

            sql_strftime(
                buffer, sizeof(buffer), ll->get_time(), ll->get_millis(), 'T');
            rlc->add_possibility(ln_mode_t::COMMAND, "line-time", buffer);
            rlc->add_possibility(ln_mode_t::COMMAND, "move-args", buffer);
            rlc->add_possibility(ln_mode_t::COMMAND, "move-time", buffer);
            sql_strftime(buffer,
                         sizeof(buffer),
                         ll->get_time() - tv.tv_sec,
                         ll->get_millis() - (tv.tv_usec / 1000),
                         'T');
            rlc->add_possibility(ln_mode_t::COMMAND, "line-time", buffer);
            rlc->add_possibility(ln_mode_t::COMMAND, "move-args", buffer);
            rlc->add_possibility(ln_mode_t::COMMAND, "move-time", buffer);
        }
    }

    rollback_lnav_config = lnav_config;
    lnav_data.ld_doc_status_source.set_title("Command Help");
    add_view_text_possibilities(lnav_data.ld_rl_view,
                                ln_mode_t::COMMAND,
                                "filter",
                                tc,
                                text_quoting::none);
    lnav_data.ld_rl_view->add_possibility(
        ln_mode_t::COMMAND, "filter", tc->get_current_search());
    add_filter_possibilities(tc);
    add_mark_possibilities();
    add_config_possibilities();
    add_env_possibilities(ln_mode_t::COMMAND);
    add_tag_possibilities();
    add_file_possibilities();
    add_recent_netlocs_possibilities();

    auto *ta = dynamic_cast<text_anchors*>(tc->get_sub_source());
    if (ta != nullptr) {
        rlc->add_possibility(ln_mode_t::COMMAND, "move-args", ta->get_anchors());
    }

    if (tc == &lnav_data.ld_views[LNV_LOG]) {
        add_filter_expr_possibilities(
            lnav_data.ld_rl_view, ln_mode_t::COMMAND, "filter-expr-syms");
    }
    lnav_data.ld_mode = ln_mode_t::COMMAND;
    lnav_data.ld_rl_view->focus(ln_mode_t::COMMAND,
                                cget(args, 2).value_or(":"),
                                cget(args, 3).value_or(""));
}

static void
script_prompt(std::vector<std::string>& args)
{
    textview_curses* tc = *lnav_data.ld_view_stack.top();
    auto& scripts = injector::get<available_scripts&>();

    lnav_data.ld_mode = ln_mode_t::EXEC;

    lnav_data.ld_exec_context.ec_top_line = tc->get_top();
    lnav_data.ld_rl_view->clear_possibilities(ln_mode_t::EXEC, "__command");
    find_format_scripts(lnav_data.ld_config_paths, scripts);
    for (const auto& iter : scripts.as_scripts) {
        lnav_data.ld_rl_view->add_possibility(
            ln_mode_t::EXEC, "__command", iter.first);
    }
    add_view_text_possibilities(
        lnav_data.ld_rl_view, ln_mode_t::EXEC, "*", tc, text_quoting::regex);
    add_env_possibilities(ln_mode_t::EXEC);
    lnav_data.ld_rl_view->focus(ln_mode_t::EXEC,
                                cget(args, 2).value_or("|"),
                                cget(args, 3).value_or(""));
    lnav_data.ld_bottom_source.set_prompt(
        "Enter a script to execute: (Press " ANSI_BOLD("CTRL+]") " to abort)");
}

static void
search_prompt(std::vector<std::string>& args)
{
    textview_curses* tc = *lnav_data.ld_view_stack.top();

    lnav_data.ld_mode = ln_mode_t::SEARCH;
    lnav_data.ld_search_start_line = tc->get_top();
    add_view_text_possibilities(
        lnav_data.ld_rl_view, ln_mode_t::SEARCH, "*", tc, text_quoting::regex);
    lnav_data.ld_rl_view->focus(ln_mode_t::SEARCH,
                                cget(args, 2).value_or("/"),
                                cget(args, 3).value_or(""));
    lnav_data.ld_doc_status_source.set_title("Syntax Help");
    rl_set_help();
    lnav_data.ld_bottom_source.set_prompt(
        "Search for:  "
        "(Press " ANSI_BOLD("CTRL+J") " to jump to a previous hit and "
        ANSI_BOLD("CTRL+]") " to abort)");
}

static void
search_filters_prompt(std::vector<std::string>& args)
{
    lnav_data.ld_mode = ln_mode_t::SEARCH_FILTERS;
    lnav_data.ld_filter_view.reload_data();
    add_view_text_possibilities(lnav_data.ld_rl_view,
                                ln_mode_t::SEARCH_FILTERS,
                                "*",
                                &lnav_data.ld_filter_view,
                                text_quoting::regex);
    lnav_data.ld_rl_view->focus(ln_mode_t::SEARCH_FILTERS,
                                cget(args, 2).value_or("/"),
                                cget(args, 3).value_or(""));
    lnav_data.ld_bottom_source.set_prompt(
        "Search for:  "
        "(Press " ANSI_BOLD("CTRL+J") " to jump to a previous hit and "
        ANSI_BOLD("CTRL+]") " to abort)");
}

static void
search_files_prompt(std::vector<std::string>& args)
{
    static const std::regex re_escape(R"(([.\^$*+?()\[\]{}\\|]))");

    lnav_data.ld_mode = ln_mode_t::SEARCH_FILES;
    for (const auto& lf : lnav_data.ld_active_files.fc_files) {
        auto path = pcrepp::quote(lf->get_unique_path());
        lnav_data.ld_rl_view->add_possibility(
            ln_mode_t::SEARCH_FILES, "*", path);
    }
    lnav_data.ld_rl_view->focus(ln_mode_t::SEARCH_FILES,
                                cget(args, 2).value_or("/"),
                                cget(args, 3).value_or(""));
    lnav_data.ld_bottom_source.set_prompt(
        "Search for:  "
        "(Press " ANSI_BOLD("CTRL+J") " to jump to a previous hit and "
        ANSI_BOLD("CTRL+]") " to abort)");
}

static void
search_spectro_details_prompt(std::vector<std::string>& args)
{
    lnav_data.ld_mode = ln_mode_t::SEARCH_SPECTRO_DETAILS;
    add_view_text_possibilities(lnav_data.ld_rl_view,
                                ln_mode_t::SEARCH_SPECTRO_DETAILS,
                                "*",
                                &lnav_data.ld_spectro_details_view,
                                text_quoting::regex);
    lnav_data.ld_rl_view->focus(ln_mode_t::SEARCH_SPECTRO_DETAILS,
                                cget(args, 2).value_or("/"),
                                cget(args, 3).value_or(""));
    lnav_data.ld_bottom_source.set_prompt(
        "Search for:  "
        "(Press " ANSI_BOLD("CTRL+J") " to jump to a previous hit and "
        ANSI_BOLD("CTRL+]") " to abort)");
}

static void
sql_prompt(std::vector<std::string>& args)
{
    textview_curses* tc = *lnav_data.ld_view_stack.top();
    textview_curses& log_view = lnav_data.ld_views[LNV_LOG];

    lnav_data.ld_exec_context.ec_top_line = tc->get_top();

    lnav_data.ld_mode = ln_mode_t::SQL;
    setup_logline_table(lnav_data.ld_exec_context);
    lnav_data.ld_rl_view->focus(ln_mode_t::SQL,
                                cget(args, 2).value_or(";"),
                                cget(args, 3).value_or(""));

    lnav_data.ld_doc_status_source.set_title("Query Help");
    rl_set_help();
    lnav_data.ld_bottom_source.update_loading(0, 0);
    lnav_data.ld_status[LNS_BOTTOM].do_update();

    auto* fos = (field_overlay_source*) log_view.get_overlay_source();
    fos->fos_contexts.top().c_show = true;
    tc->reload_data();
    lnav_data.ld_bottom_source.set_prompt(
        "Enter an SQL query: (Press " ANSI_BOLD("CTRL+]") " to abort)");
}

static void
user_prompt(std::vector<std::string>& args)
{
    textview_curses* tc = *lnav_data.ld_view_stack.top();
    lnav_data.ld_exec_context.ec_top_line = tc->get_top();

    lnav_data.ld_mode = ln_mode_t::USER;
    setup_logline_table(lnav_data.ld_exec_context);
    lnav_data.ld_rl_view->focus(ln_mode_t::USER,
                                cget(args, 2).value_or("? "),
                                cget(args, 3).value_or(""));

    lnav_data.ld_bottom_source.update_loading(0, 0);
    lnav_data.ld_status[LNS_BOTTOM].do_update();
}

static Result<std::string, lnav::console::user_message>
com_prompt(exec_context& ec,
           std::string cmdline,
           std::vector<std::string>& args)
{
    static std::map<std::string, std::function<void(std::vector<std::string>&)>>
        PROMPT_TYPES = {
            {"command", command_prompt},
            {"script", script_prompt},
            {"search", search_prompt},
            {"search-filters", search_filters_prompt},
            {"search-files", search_files_prompt},
            {"search-spectro-details", search_spectro_details_prompt},
            {"sql", sql_prompt},
            {"user", user_prompt},
        };

    if (args.empty()) {
    } else if (!ec.ec_dry_run) {
        args.clear();

        auto lexer = shlex(cmdline);
        lexer.split(args, ec.create_resolver());

        auto alt_flag = std::find(args.begin(), args.end(), "--alt");
        auto is_alt = false;
        if (alt_flag != args.end()) {
            args.erase(alt_flag);
            is_alt = true;
        }

        auto prompter = PROMPT_TYPES.find(args[1]);

        if (prompter == PROMPT_TYPES.end()) {
            return ec.make_error("Unknown prompt type: {}", args[1]);
        }

        prompter->second(args);
        lnav_data.ld_rl_view->set_alt_focus(is_alt);
    }
    return Ok(std::string());
}

readline_context::command_t STD_COMMANDS[] = {
    {"prompt",
     com_prompt,

     help_text(":prompt")
         .with_summary("Open the given prompt")
         .with_parameter(
             {"type",
              "The type of prompt -- command, script, search, sql, user"})
         .with_parameter(
             help_text(
                 "--alt",
                 "Perform the alternate action for this prompt by default")
                 .optional())
         .with_parameter(
             help_text("prompt", "The prompt to display").optional())
         .with_parameter(
             help_text("initial-value",
                       "The initial value to fill in for the prompt")
                 .optional())
         .with_example({
             "To open the command prompt with 'filter-in' already filled in",
             "command : 'filter-in '",
         })
         .with_example({
             "To ask the user a question",
             "user 'Are you sure? '",
         })},

    {"adjust-log-time",
     com_adjust_log_time,

     help_text(":adjust-log-time")
         .with_summary("Change the timestamps of the top file to be relative "
                       "to the given date")
         .with_parameter(
             help_text("timestamp",
                       "The new timestamp for the top line in the view")
                 .with_format(help_parameter_format_t::HPF_DATETIME))
         .with_example({"To set the top timestamp to a given date",
                        "2017-01-02T05:33:00"})
         .with_example({"To set the top timestamp back an hour", "-1h"})},

    {"unix-time",
     com_unix_time,

     help_text(":unix-time")
         .with_summary("Convert epoch time to a human-readable form")
         .with_parameter(help_text("seconds", "The epoch timestamp to convert")
                             .with_format(help_parameter_format_t::HPF_INTEGER))
         .with_example({"To convert the epoch time 1490191111", "1490191111"})},
    {"current-time",
     com_current_time,

     help_text(":current-time")
         .with_summary("Print the current time in human-readable form and "
                       "seconds since the epoch")},
    {"goto",
     com_goto,

     help_text(":goto")
         .with_summary("Go to the given location in the top view")
         .with_parameter(
             help_text("line#|N%|timestamp|#anchor",
                       "A line number, percent into the file, timestamp, "
                       "or an anchor in a text file"))
         .with_examples(
             {{"To go to line 22", "22"},
              {"To go to the line 75% of the way into the view", "75%"},
              {"To go to the first message on the first day of 2017",
               "2017-01-01"},
              {"To go to the Screenshots section", "#screenshots"}})
         .with_tags({"navigation"})},
    {"relative-goto",
     com_relative_goto,

     help_text(":relative-goto")
         .with_summary("Move the current view up or down by the given amount")
         .with_parameter({"line-count|N%", "The amount to move the view by."})
         .with_examples({
             {"To move 22 lines down in the view", "+22"},
             {"To move 10 percent back in the view", "-10%"},
         })
         .with_tags({"navigation"})},
    {"mark",
     com_mark,

     help_text(":mark")
         .with_summary(
             "Toggle the bookmark state for the top line in the current view")
         .with_tags({"bookmarks"})},
    {
        "mark-expr",
        com_mark_expr,

        help_text(":mark-expr")
            .with_summary("Set the bookmark expression")
            .with_parameter(help_text(
                "expr",
                "The SQL expression to evaluate for each log message.  "
                "The message values can be accessed using column names "
                "prefixed with a colon"))
            .with_opposites({"clear-mark-expr"})
            .with_tags({"bookmarks"})
            .with_example(
                {"To mark lines from 'dhclient' that mention 'eth0'",
                 ":log_procname = 'dhclient' AND :log_body LIKE '%eth0%'"}),

        com_mark_expr_prompt,
    },
    {"clear-mark-expr",
     com_clear_mark_expr,

     help_text(":clear-mark-expr")
         .with_summary("Clear the mark expression")
         .with_opposites({"mark-expr"})
         .with_tags({"bookmarks"})},
    {"next-mark",
     com_goto_mark,

     help_text(":next-mark")
         .with_summary(
             "Move to the next bookmark of the given type in the current view")
         .with_parameter(help_text("type",
                                   "The type of bookmark -- error, warning, "
                                   "search, user, file, meta")
                             .one_or_more())
         .with_example({"To go to the next error", "error"})
         .with_tags({"bookmarks", "navigation"})},
    {"prev-mark",
     com_goto_mark,

     help_text(":prev-mark")
         .with_summary("Move to the previous bookmark of the given type in the "
                       "current view")
         .with_parameter(help_text("type",
                                   "The type of bookmark -- error, warning, "
                                   "search, user, file, meta")
                             .one_or_more())
         .with_example({"To go to the previous error", "error"})
         .with_tags({"bookmarks", "navigation"})},
    {"next-location",
     com_goto_location,

     help_text(":next-location")
         .with_summary("Move to the next position in the location history")
         .with_tags({"navigation"})},
    {"prev-location",
     com_goto_location,

     help_text(":prev-location")
         .with_summary("Move to the previous position in the location history")
         .with_tags({"navigation"})},
    {"help",
     com_help,

     help_text(":help").with_summary("Open the help text view")},
    {"hide-fields",
     com_toggle_field,

     help_text(":hide-fields")
         .with_summary(
             "Hide log message fields by replacing them with an ellipsis")
         .with_parameter(
             help_text("field-name",
                       "The name of the field to hide in the format for the "
                       "top log line.  "
                       "A qualified name can be used where the field name is "
                       "prefixed "
                       "by the format name and a dot to hide any field.")
                 .one_or_more())
         .with_example(
             {"To hide the log_procname fields in all formats", "log_procname"})
         .with_example(
             {"To hide only the log_procname field in the syslog format",
              "syslog_log.log_procname"})
         .with_tags({"display"})},
    {"show-fields",
     com_toggle_field,

     help_text(":show-fields")
         .with_summary("Show log message fields that were previously hidden")
         .with_parameter(
             help_text("field-name", "The name of the field to show")
                 .one_or_more())
         .with_example({"To show all the log_procname fields in all formats",
                        "log_procname"})
         .with_opposites({"hide-fields"})
         .with_tags({"display"})},
    {"hide-lines-before",
     com_hide_line,

     help_text(":hide-lines-before")
         .with_summary("Hide lines that come before the given date")
         .with_parameter(help_text("date", "An absolute or relative date"))
         .with_examples({
             {"To hide the lines before the top line in the view", "here"},
             {"To hide the log messages before 6 AM today", "6am"},
         })
         .with_tags({"filtering"})},
    {"hide-lines-after",
     com_hide_line,

     help_text(":hide-lines-after")
         .with_summary("Hide lines that come after the given date")
         .with_parameter(help_text("date", "An absolute or relative date"))
         .with_examples({
             {"To hide the lines after the top line in the view", "here"},
             {"To hide the lines after 6 AM today", "6am"},
         })
         .with_tags({"filtering"})},
    {"show-lines-before-and-after",
     com_show_lines,

     help_text(":show-lines-before-and-after")
         .with_summary(
             "Show lines that were hidden by the 'hide-lines' commands")
         .with_opposites({"hide-lines-before", "hide-lines-after"})
         .with_tags({"filtering"})},
    {"hide-unmarked-lines",
     com_hide_unmarked,

     help_text(":hide-unmarked-lines")
         .with_summary("Hide lines that have not been bookmarked")
         .with_tags({"filtering", "bookmarks"})},
    {"show-unmarked-lines",
     com_show_unmarked,

     help_text(":show-unmarked-lines")
         .with_summary("Show lines that have not been bookmarked")
         .with_opposites({"show-unmarked-lines"})
         .with_tags({"filtering", "bookmarks"})},
    {"highlight",
     com_highlight,

     help_text(":highlight")
         .with_summary("Add coloring to log messages fragments that match the "
                       "given regular expression")
         .with_parameter(
             help_text("pattern", "The regular expression to match"))
         .with_tags({"display"})
         .with_example(
             {"To highlight numbers with three or more digits", R"(\d{3,})"})},
    {"clear-highlight",
     com_clear_highlight,

     help_text(":clear-highlight")
         .with_summary("Remove a previously set highlight regular expression")
         .with_parameter(help_text(
             "pattern",
             "The regular expression previously used with :highlight"))
         .with_tags({"display"})
         .with_opposites({"highlight"})
         .with_example(
             {"To clear the highlight with the pattern 'foobar'", "foobar"})},
    {"filter-in",
     com_filter,

     help_text(":filter-in")
         .with_summary("Only show lines that match the given regular "
                       "expression in the current view")
         .with_parameter(
             help_text("pattern", "The regular expression to match"))
         .with_tags({"filtering"})
         .with_example({"To filter out log messages that do not have the "
                        "string 'dhclient'",
                        "dhclient"})},
    {"filter-out",
     com_filter,

     help_text(":filter-out")
         .with_summary("Remove lines that match the given regular expression "
                       "in the current view")
         .with_parameter(
             help_text("pattern", "The regular expression to match"))
         .with_tags({"filtering"})
         .with_example({"To filter out log messages that contain the string "
                        "'last message repeated'",
                        "last message repeated"})},
    {"delete-filter",
     com_delete_filter,

     help_text(":delete-filter")
         .with_summary("Delete the filter created with " ANSI_BOLD(
             ":filter-in") " or " ANSI_BOLD(":filter-out"))
         .with_parameter(
             help_text("pattern", "The regular expression to match"))
         .with_opposites({"filter-in", "filter-out"})
         .with_tags({"filtering"})
         .with_example(
             {"To delete the filter with the pattern 'last message repeated'",
              "last message repeated"})},
    {
        "filter-expr",
        com_filter_expr,

        help_text(":filter-expr")
            .with_summary("Set the filter expression")
            .with_parameter(help_text(
                "expr",
                "The SQL expression to evaluate for each log message.  "
                "The message values can be accessed using column names "
                "prefixed with a colon"))
            .with_opposites({"clear-filter-expr"})
            .with_tags({"filtering"})
            .with_example({"To set a filter expression that matched syslog "
                           "messages from 'syslogd'",
                           ":log_procname = 'syslogd'"})
            .with_example(
                {"To set a filter expression that matches log messages where "
                 "'id' is followed by a number and contains the string 'foo'",
                 ":log_body REGEXP 'id\\d+' AND :log_body REGEXP 'foo'"}),

        com_filter_expr_prompt,
    },
    {"clear-filter-expr",
     com_clear_filter_expr,

     help_text(":clear-filter-expr")
         .with_summary("Clear the filter expression")
         .with_opposites({"filter-expr"})
         .with_tags({"filtering"})},
    {"append-to",
     com_save_to,

     help_text(":append-to")
         .with_summary(
             "Append marked lines in the current view to the given file")
         .with_parameter(help_text("path", "The path to the file to append to"))
         .with_tags({"io"})
         .with_example(
             {"To append marked lines to the file /tmp/interesting-lines.txt",
              "/tmp/interesting-lines.txt"})},
    {"write-to",
     com_save_to,

     help_text(":write-to")
         .with_summary("Overwrite the given file with any marked lines in the "
                       "current view")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting"})
         .with_example(
             {"To write marked lines to the file /tmp/interesting-lines.txt",
              "/tmp/interesting-lines.txt"})},
    {"write-csv-to",
     com_save_to,

     help_text(":write-csv-to")
         .with_summary("Write SQL results to the given file in CSV format")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting", "sql"})
         .with_example({"To write SQL results as CSV to /tmp/table.csv",
                        "/tmp/table.csv"})},
    {"write-json-to",
     com_save_to,

     help_text(":write-json-to")
         .with_summary("Write SQL results to the given file in JSON format")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting", "sql"})
         .with_example({"To write SQL results as JSON to /tmp/table.json",
                        "/tmp/table.json"})},
    {"write-jsonlines-to",
     com_save_to,

     help_text(":write-jsonlines-to")
         .with_summary(
             "Write SQL results to the given file in JSON Lines format")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting", "sql"})
         .with_example({"To write SQL results as JSON Lines to /tmp/table.json",
                        "/tmp/table.json"})},
    {"write-table-to",
     com_save_to,

     help_text(":write-table-to")
         .with_summary(
             "Write SQL results to the given file in a tabular format")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting", "sql"})
         .with_example({"To write SQL results as text to /tmp/table.txt",
                        "/tmp/table.txt"})},
    {"write-raw-to",
     com_save_to,

     help_text(":write-raw-to")
         .with_summary(
             "In the log view, write the original log file content "
             "of the marked messages to the file.  In the DB view, "
             "the contents of the cells are written to the output file.")
         .with_parameter(help_text("--view={log,db}",
                                   "The view to use as the source of data")
                             .optional())
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting", "sql"})
         .with_example(
             {"To write the marked lines in the log view to /tmp/table.txt",
              "/tmp/table.txt"})},
    {"write-view-to",
     com_save_to,

     help_text(":write-view-to")
         .with_summary("Write the text in the top view to the given file "
                       "without any formatting")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting", "sql"})
         .with_example(
             {"To write the top view to /tmp/table.txt", "/tmp/table.txt"})},
    {"write-screen-to",
     com_save_to,

     help_text(":write-screen-to")
         .with_summary("Write the displayed text or SQL results to the given "
                       "file without any formatting")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting", "sql"})
         .with_example({"To write only the displayed text to /tmp/table.txt",
                        "/tmp/table.txt"})},
    {"pipe-to",
     com_pipe_to,

     help_text(":pipe-to")
         .with_summary("Pipe the marked lines to the given shell command")
         .with_parameter(
             help_text("shell-cmd", "The shell command-line to execute"))
         .with_tags({"io"})
         .with_example({"To write marked lines to 'sed' for processing",
                        "sed -e s/foo/bar/g"})},
    {"pipe-line-to",
     com_pipe_to,

     help_text(":pipe-line-to")
         .with_summary("Pipe the top line to the given shell command")
         .with_parameter(
             help_text("shell-cmd", "The shell command-line to execute"))
         .with_tags({"io"})
         .with_example({"To write the top line to 'sed' for processing",
                        "sed -e 's/foo/bar/g'"})},
    {"redirect-to",
     com_redirect_to,

     help_text(":redirect-to")
         .with_summary("Redirect the output of commands that write to "
                       "stdout to the given file")
         .with_parameter(
             help_text(
                 "path",
                 "The path to the file to write."
                 "  If not specified, the current redirect will be cleared")
                 .optional())
         .with_tags({"io", "scripting"})
         .with_example({"To write the output of lnav commands to the file "
                        "/tmp/script-output.txt",
                        "/tmp/script-output.txt"})},
    {"enable-filter",
     com_enable_filter,

     help_text(":enable-filter")
         .with_summary("Enable a previously created and disabled filter")
         .with_parameter(help_text(
             "pattern", "The regular expression used in the filter command"))
         .with_tags({"filtering"})
         .with_opposites({"disable-filter"})
         .with_example({"To enable the disabled filter with the pattern 'last "
                        "message repeated'",
                        "last message repeated"})},
    {"disable-filter",
     com_disable_filter,

     help_text(":disable-filter")
         .with_summary("Disable a filter created with filter-in/filter-out")
         .with_parameter(help_text(
             "pattern", "The regular expression used in the filter command"))
         .with_tags({"filtering"})
         .with_opposites({"filter-out", "filter-in"})
         .with_example(
             {"To disable the filter with the pattern 'last message repeated'",
              "last message repeated"})},
    {"enable-word-wrap",
     com_enable_word_wrap,

     help_text(":enable-word-wrap")
         .with_summary("Enable word-wrapping for the current view")
         .with_tags({"display"})},
    {"disable-word-wrap",
     com_disable_word_wrap,

     help_text(":disable-word-wrap")
         .with_summary("Disable word-wrapping for the current view")
         .with_opposites({"enable-word-wrap"})
         .with_tags({"display"})},
    {"create-logline-table",
     com_create_logline_table,

     help_text(":create-logline-table")
         .with_summary("Create an SQL table using the top line of the log view "
                       "as a template")
         .with_parameter(help_text("table-name", "The name for the new table"))
         .with_tags({"vtables", "sql"})
         .with_example(
             {"To create a logline-style table named 'task_durations'",
              "task_durations"})},
    {"delete-logline-table",
     com_delete_logline_table,

     help_text(":delete-logline-table")
         .with_summary("Delete a table created with create-logline-table")
         .with_parameter(
             help_text("table-name", "The name of the table to delete"))
         .with_opposites({"delete-logline-table"})
         .with_tags({"vtables", "sql"})
         .with_example(
             {"To delete the logline-style table named 'task_durations'",
              "task_durations"})},
    {"create-search-table",
     com_create_search_table,

     help_text(":create-search-table")
         .with_summary("Create an SQL table based on a regex search")
         .with_parameter(
             help_text("table-name", "The name of the table to create"))
         .with_parameter(
             help_text(
                 "pattern",
                 "The regular expression used to capture the table columns.  "
                 "If not given, the current search pattern is used.")
                 .optional())
         .with_tags({"vtables", "sql"})
         .with_example(
             {"To create a table named 'task_durations' that matches log "
              "messages with the pattern 'duration=(?<duration>\\d+)'",
              R"(task_durations duration=(?<duration>\d+))"})},
    {"delete-search-table",
     com_delete_search_table,

     help_text(":delete-search-table")
         .with_summary("Create an SQL table based on a regex search")
         .with_parameter(
             help_text("table-name", "The name of the table to create"))
         .with_opposites({"create-search-table"})
         .with_tags({"vtables", "sql"})
         .with_example({"To delete the search table named 'task_durations'",
                        "task_durations"})},
    {"open",
     com_open,

     help_text(":open")
         .with_summary(
             "Open the given file(s) in lnav.  Opening files on machines "
             "accessible via SSH can be done using the syntax: "
             "[user@]host:/path/to/logs")
         .with_parameter(
             help_text{"path", "The path to the file to open"}.one_or_more())
         .with_example({"To open the file '/path/to/file'", "/path/to/file"})
         .with_example({"To open the remote file '/var/log/syslog.log'",
                        "dean@host1.example.com:/var/log/syslog.log"})},
    {"hide-file",
     com_hide_file,

     help_text(":hide-file")
         .with_summary("Hide the given file(s) and skip indexing until it "
                       "is shown again.  If no path is given, the current "
                       "file in the view is hidden")
         .with_parameter(help_text{
             "path", "A path or glob pattern that specifies the files to hide"}
                             .zero_or_more())
         .with_opposites({"show-file"})},
    {"show-file",
     com_show_file,

     help_text(":show-file")
         .with_summary("Show the given file(s) and resume indexing.")
         .with_parameter(help_text{
             "path",
             "The path or glob pattern that specifies the files to show"}
                             .zero_or_more())
         .with_opposites({"hide-file"})},
    {"show-only-this-file",
     com_show_only_this_file,

     help_text(":show-only-this-file")
         .with_summary("Show only the file for the top line in the view")
         .with_opposites({"hide-file"})},
    {"close",
     com_close,

     help_text(":close")
         .with_summary("Close the top file in the view")
         .with_opposites({"open"})},
    {
        "comment",
        com_comment,

        help_text(":comment")
            .with_summary(
                "Attach a comment to the top log line.  The comment will be "
                "displayed right below the log message it is associated with. "
                "The comment can be formatted using markdown and you can add "
                "new-lines with '\\n'.")
            .with_parameter(help_text("text", "The comment text"))
            .with_example({"To add the comment 'This is where it all went "
                           "wrong' to the top line",
                           "This is where it all went wrong"})
            .with_tags({"metadata"}),

        com_comment_prompt,
    },
    {"clear-comment",
     com_clear_comment,

     help_text(":clear-comment")
         .with_summary("Clear the comment attached to the top log line")
         .with_opposites({"comment"})
         .with_tags({"metadata"})},
    {
        "tag",
        com_tag,

        help_text(":tag")
            .with_summary("Attach tags to the top log line")
            .with_parameter(
                help_text("tag", "The tags to attach").one_or_more())
            .with_example({"To add the tags '#BUG123' and '#needs-review' to "
                           "the top line",
                           "#BUG123 #needs-review"})
            .with_tags({"metadata"}),
    },
    {"untag",
     com_untag,

     help_text(":untag")
         .with_summary("Detach tags from the top log line")
         .with_parameter(help_text("tag", "The tags to detach").one_or_more())
         .with_example({"To remove the tags '#BUG123' and '#needs-review' from "
                        "the top line",
                        "#BUG123 #needs-review"})
         .with_opposites({"tag"})
         .with_tags({"metadata"})},
    {"delete-tags",
     com_delete_tags,

     help_text(":delete-tags")
         .with_summary("Remove the given tags from all log lines")
         .with_parameter(help_text("tag", "The tags to delete").one_or_more())
         .with_example({"To remove the tags '#BUG123' and '#needs-review' from "
                        "all log lines",
                        "#BUG123 #needs-review"})
         .with_opposites({"tag"})
         .with_tags({"metadata"})},
    {"partition-name",
     com_partition_name,

     help_text(":partition-name")
         .with_summary("Mark the top line in the log view as the start of a "
                       "new partition with the given name")
         .with_parameter(help_text("name", "The name for the new partition"))
         .with_example({"To mark the top line as the start of the partition "
                        "named 'boot #1'",
                        "boot #1"})},
    {"clear-partition",
     com_clear_partition,

     help_text(":clear-partition")
         .with_summary("Clear the partition the top line is a part of")
         .with_opposites({"partition-name"})},
    {"session",
     com_session,

     help_text(":session")
         .with_summary(
             "Add the given command to the session file (~/.lnav/session)")
         .with_parameter(help_text("lnav-command", "The lnav command to save."))
         .with_example(
             {"To add the command ':highlight foobar' to the session file",
              ":highlight foobar"})},
    {"summarize",
     com_summarize,

     help_text(":summarize")
         .with_summary("Execute a SQL query that computes the characteristics "
                       "of the values in the given column")
         .with_parameter(
             help_text("column-name", "The name of the column to analyze."))
         .with_example(
             {"To get a summary of the sc_bytes column in the access_log table",
              "sc_bytes"})},
    {"switch-to-view",
     com_switch_to_view,

     help_text(":switch-to-view")
         .with_summary("Switch to the given view")
         .with_parameter(
             help_text("view-name", "The name of the view to switch to."))
         .with_example({"To switch to the 'schema' view", "schema"})},
    {"toggle-view",
     com_switch_to_view,

     help_text(":toggle-view")
         .with_summary(
             "Switch to the given view or, if it is already displayed, "
             "switch to the previous view")
         .with_parameter(help_text(
             "view-name", "The name of the view to toggle the display of."))
         .with_example({"To switch to the 'schema' view if it is not displayed "
                        "or switch back to the previous view",
                        "schema"})},
    {"toggle-filtering",
     com_toggle_filtering,

     help_text(":toggle-filtering")
         .with_summary("Toggle the filtering flag for the current view")
         .with_tags({"filtering"})},
    {"reset-session",
     com_reset_session,

     help_text(":reset-session")
         .with_summary("Reset the session state, clearing all filters, "
                       "highlights, and bookmarks")},
    {"load-session",
     com_load_session,

     help_text(":load-session").with_summary("Load the latest session state")},
    {"save-session",
     com_save_session,

     help_text(":save-session")
         .with_summary("Save the current state as a session")},
    {"export-session-to",
     com_export_session_to,

     help_text(":export-session-to")
         .with_summary("Export the current lnav state to an executable lnav "
                       "script file that contains the commands needed to "
                       "restore the current session")
         .with_parameter(help_text("path", "The path to the file to write"))
         .with_tags({"io", "scripting"})},
    {"rebuild",
     com_rebuild,
     help_text(":rebuild")
         .with_summary("Forcefully rebuild file indexes")
         .with_tags({"scripting"})},
    {"set-min-log-level",
     com_set_min_log_level,

     help_text(":set-min-log-level")
         .with_summary("Set the minimum log level to display in the log view")
         .with_parameter(help_text("log-level", "The new minimum log level"))
         .with_example(
             {"To set the minimum log level displayed to error", "error"})},
    {"redraw",
     com_redraw,

     help_text(":redraw").with_summary("Do a full redraw of the screen")},
    {"zoom-to",
     com_zoom_to,

     help_text(":zoom-to")
         .with_summary("Zoom the histogram view to the given level")
         .with_parameter(help_text("zoom-level", "The zoom level"))
         .with_example({"To set the zoom level to '1-week'", "1-week"})},
    {"echo",
     com_echo,

     help_text(":echo")
         .with_summary(
             "Echo the given message to the screen or, if :redirect-to has "
             "been called, to output file specified in the redirect.  "
             "Variable substitution is performed on the message.  Use a "
             "backslash to escape any special characters, like '$'")
         .with_parameter(
             help_text("-n",
                       "Do not print a line-feed at the end of the output")
                 .optional())
         .with_parameter(help_text("msg", "The message to display"))
         .with_tags({"io", "scripting"})
         .with_example({"To output 'Hello, World!'", "Hello, World!"})},
    {"alt-msg",
     com_alt_msg,

     help_text(":alt-msg")
         .with_summary("Display a message in the alternate command position")
         .with_parameter(help_text("msg", "The message to display"))
         .with_tags({"scripting"})
         .with_example({"To display 'Press t to switch to the text view' on "
                        "the bottom right",
                        "Press t to switch to the text view"})},
    {"eval",
     com_eval,

     help_text(":eval")
         .with_summary("Evaluate the given command/query after doing "
                       "environment variable substitution")
         .with_parameter(help_text(
             "command", "The command or query to perform substitution on."))
         .with_tags({"scripting"})
         .with_examples({{"To substitute the table name from a variable",
                          ";SELECT * FROM ${table}"}})},
    {"config",
     com_config,

     help_text(":config")
         .with_summary("Read or write a configuration option")
         .with_parameter({"option", "The path to the option to read or write"})
         .with_parameter(help_text("value",
                                   "The value to write.  If not given, the "
                                   "current value is returned")
                             .optional())
         .with_example(
             {"To read the configuration of the '/ui/clock-format' option",
              "/ui/clock-format"})
         .with_example({"To set the '/ui/dim-text' option to 'false'",
                        "/ui/dim-text false"})
         .with_tags({"configuration"})},
    {"reset-config",
     com_reset_config,

     help_text(":reset-config")
         .with_summary("Reset the configuration option to its default value")
         .with_parameter(help_text("option", "The path to the option to reset"))
         .with_example({"To reset the '/ui/clock-format' option back to the "
                        "builtin default",
                        "/ui/clock-format"})
         .with_tags({"configuration"})},
    {"spectrogram",
     com_spectrogram,

     help_text(":spectrogram")
         .with_summary("Visualize the given message field or database column "
                       "using a spectrogram")
         .with_parameter(help_text(
             "field-name", "The name of the numeric field to visualize."))
         .with_example(
             {"To visualize the sc_bytes field in the access_log format",
              "sc_bytes"})},
    {"quit",
     com_quit,

     help_text(":quit").with_summary("Quit lnav")}};

static std::unordered_map<char const*, std::vector<char const*>> aliases = {
    {"quit", {"q", "q!"}},
    {"write-table-to", {"write-cols-to"}},
};

void
init_lnav_commands(readline_context::command_map_t& cmd_map)
{
    for (auto& cmd : STD_COMMANDS) {
        cmd.c_help.index_tags();
        cmd_map[cmd.c_name] = &cmd;

        auto itr = aliases.find(cmd.c_name);
        if (itr != aliases.end()) {
            for (char const* alias : itr->second) {
                cmd_map[alias] = &cmd;
            }
        }
    }

    if (getenv("LNAV_SRC") != nullptr) {
        static readline_context::command_t add_test(com_add_test);

        cmd_map["add-test"] = &add_test;
    }
    if (getenv("lnav_test") != nullptr) {
        static readline_context::command_t shexec(com_shexec),
            poll_now(com_poll_now), test_comment(com_test_comment);

        cmd_map["shexec"] = &shexec;
        cmd_map["poll-now"] = &poll_now;
        cmd_map["test-comment"] = &test_comment;
    }
}
