Home /Modules/sleela-terminal/slsh.cpp

slsh.cpp

sleela-terminal/slsh.cpp · 829 line(s) · c

// SleelaTerminal(TM) shell -- L6 CLI / REPL driver (slsh).
// Original SLeeLa work (see NOTICE).
//
// Usage:
//   slsh                 interactive read-eval-print loop
//   slsh -c "script"     run the script string
//   slsh FILE            run the script file

#include "core.hpp"
#include "lexer.hpp"
#include "parser.hpp"
#include "executor.hpp"
#include "m5.hpp"

#include <algorithm>
#include <cerrno>
#include <csignal>
#include <ctime>
#include <chrono>
#include <cctype>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <termios.h>
#include <thread>
#include <unistd.h>
#include <vector>

namespace {

using namespace sleela::sh;

pid_t g_shell_pid = 0;
volatile sig_atomic_t g_interrupted = 0;

void sharpQuitSignalHandler(int) {
    if (g_shell_pid != 0 && ::getpid() != g_shell_pid) {
        ::kill(::getpid(), SIGKILL);
    }
}

void interruptSignalHandler(int) {
    g_interrupted = 1;
}

void configureTerminalKeys() {
    struct termios tio;
    if (::tcgetattr(STDIN_FILENO, &tio) != 0) return;
    tio.c_cc[VQUIT] = 0x18; // Ctrl+X -> SIGQUIT
    ::tcsetattr(STDIN_FILENO, TCSANOW, &tio);
}

class RawMode {
public:
    RawMode() {
        if (::tcgetattr(STDIN_FILENO, &saved_) != 0) return;
        termios raw = saved_;
        raw.c_lflag &= static_cast<tcflag_t>(~(ICANON | ECHO));
        raw.c_iflag &= static_cast<tcflag_t>(~(IXON | ICRNL));
        raw.c_oflag |= OPOST;
        raw.c_cc[VMIN] = 1;
        raw.c_cc[VTIME] = 0;
        active_ = (::tcsetattr(STDIN_FILENO, TCSANOW, &raw) == 0);
    }

    ~RawMode() { restore(); }

    void restore() {
        if (active_) {
            ::tcsetattr(STDIN_FILENO, TCSANOW, &saved_);
            active_ = false;
        }
    }

    bool active() const { return active_; }

private:
    termios saved_{};
    bool active_ = false;
};

void writeBytes(const std::string& s) {
    std::size_t off = 0;
    while (off < s.size()) {
        const ssize_t n = ::write(STDOUT_FILENO, s.data() + off, s.size() - off);
        if (n <= 0) return;
        off += static_cast<std::size_t>(n);
    }
}

std::string colourPrompt(const std::string& prompt) {
    // Colour the conventional username@computername: prompt without changing
    // the plain prompt stored by Environment or reported by the prompt command.
    const std::size_t at = prompt.find('@');
    const std::size_t colon = prompt.find(':', at == std::string::npos ? 0 : at + 1);
    if (at == std::string::npos || colon == std::string::npos ||
        colon + 1 >= prompt.size() || prompt[colon + 1] != ' ') {
        return prompt;
    }
    return "\033[1;32m" + prompt.substr(0, at) + "\033[0m@" +
           "\033[1;34m" + prompt.substr(at + 1, colon - at - 1) +
           "\033[0m:\033[0m ";
}

void redrawLine(const std::string& prompt, const std::string& line, std::size_t cursor) {
    writeBytes("\r\x1b[2K" + prompt + line + "\x1b[K");
    const std::size_t right = line.size() - cursor;
    if (right > 0) writeBytes("\x1b[" + std::to_string(right) + "D");
}

bool readByte(char& c) {
    for (;;) {
        const ssize_t n = ::read(STDIN_FILENO, &c, 1);
        if (n == 1) return true;
        if (n < 0 && errno == EINTR) continue;
        return false;
    }
}

// Read one input line. `eof` is set to true when the input stream is closed
// (non-tty EOF, Ctrl+D on an empty line, or a read failure) so the caller can
// terminate the REPL instead of spinning on repeated empty results. A Ctrl+C
// cancel is NOT end-of-input: it returns an empty line with eof left false.
// Tab completion for the interactive line editor. Command-position completion
// combines shell builtins with executable files found on PATH; other positions
// complete filesystem entries, including directory traversal.
struct CompletionCandidate {
    std::string text;
    bool is_directory = false;
};

bool startsWith(const std::string& value, const std::string& prefix) {
    return value.size() >= prefix.size() && value.compare(0, prefix.size(), prefix) == 0;
}

std::string escapeCompletion(const std::string& value) {
    std::string escaped;
    for (char c : value) {
        if (c == ' ' || c == '\t' || c == '\\' || c == '$' || c == '&' ||
            c == '(' || c == ')' || c == '[' || c == ']' || c == '{' ||
            c == '}' || c == ';' || c == '|' || c == '<' || c == '>' ||
            c == '*' || c == '?' || c == '\'' || c == '"') escaped.push_back('\\');
        escaped.push_back(c);
    }
    return escaped;
}

std::vector<CompletionCandidate> completionCandidates(const std::string& line,
                                                       std::size_t cursor,
                                                       std::size_t token_start) {
    const std::string token = line.substr(token_start, cursor - token_start);
    const std::string before_token = line.substr(0, token_start);
    const std::size_t separator = before_token.find_last_of(";|&\n");
    const std::string command_prefix = separator == std::string::npos
        ? before_token : before_token.substr(separator + 1);
    const bool command_position =
        command_prefix.find_first_not_of(" \t") == std::string::npos &&
        token.find('/') == std::string::npos;
    std::vector<std::string> names;
    if (command_position) {
        static const std::vector<std::string> builtins = {
            ":", "[", "bg", "break", "cd", "continue", "echo", "eval", "exec",
            "exit", "export", "false", "fg", "getopts", "help", "jobs", "pwd",
            "read", "return", "set", "shift", "test", "times", "trap", "true",
            "type", "umask", "unalias", "unset", "wait", "footerbar", "prompt",
            "soros", "select"
        };
        for (const auto& name : builtins)
            if (startsWith(name, token)) names.push_back(name);

        const char* path_env = std::getenv("PATH");
        std::istringstream paths(path_env ? path_env : "");
        std::string path_entry;
        while (std::getline(paths, path_entry, ':')) {
            if (path_entry.empty()) path_entry = ".";
            std::error_code ec;
            for (std::filesystem::directory_iterator it(path_entry, ec), end;
                 !ec && it != end; it.increment(ec)) {
                const std::string name = it->path().filename().string();
                if (!startsWith(name, token) || name.empty() || name[0] == '.') continue;
                std::error_code type_ec;
                if (::access(it->path().c_str(), X_OK) == 0 &&
                    !std::filesystem::is_directory(it->path(), type_ec)) names.push_back(name);
            }
        }
    } else {
        const std::size_t slash = token.find_last_of('/');
        const std::string directory_part = slash == std::string::npos ? "" : token.substr(0, slash + 1);
        const std::string base = slash == std::string::npos ? token : token.substr(slash + 1);
        const std::filesystem::path directory = directory_part.empty()
            ? std::filesystem::path(".") : std::filesystem::path(directory_part);
        std::error_code ec;
        for (std::filesystem::directory_iterator it(directory, ec), end;
             !ec && it != end; it.increment(ec)) {
            const std::string name = it->path().filename().string();
            if (!startsWith(name, base)) continue;
            if ((base.empty() || base[0] != '.') && !name.empty() && name[0] == '.') continue;
            std::error_code type_ec;
            const bool is_dir = std::filesystem::is_directory(it->path(), type_ec);
            names.push_back(directory_part + name + (is_dir ? "/" : ""));
        }
    }
    std::sort(names.begin(), names.end());
    names.erase(std::unique(names.begin(), names.end()), names.end());
    std::vector<CompletionCandidate> found;
    for (const auto& name : names) {
        std::error_code ec;
        found.push_back({name, std::filesystem::is_directory(std::filesystem::path(name), ec)});
    }
    return found;
}

void applyTabCompletion(std::string& line, std::size_t& cursor, const std::string& prompt) {
    std::size_t token_start = cursor;
    while (token_start > 0) {
        const char c = line[token_start - 1];
        if (c == ' ' || c == '\t' || c == ';' || c == '|' || c == '&' ||
            c == '(' || c == ')' || c == '<' || c == '>') break;
        --token_start;
    }
    const std::string prefix = line.substr(token_start, cursor - token_start);
    if (prefix.empty()) return;
    const auto matches = completionCandidates(line, cursor, token_start);
    if (matches.empty()) return;

    std::string replacement;
    std::string suffix;
    if (matches.size() == 1) {
        replacement = matches.front().text;
        if (matches.front().is_directory) {
            if (replacement.empty() || replacement.back() != '/') suffix = "/";
        } else suffix = " ";
    } else {
        replacement = matches.front().text;
        for (std::size_t i = 1; i < matches.size(); ++i) {
            std::size_t n = 0;
            while (n < replacement.size() && n < matches[i].text.size() &&
                   replacement[n] == matches[i].text[n]) ++n;
            replacement.resize(n);
        }
        if (replacement.size() <= prefix.size()) {
            writeBytes("\r\n");
            for (std::size_t i = 0; i < matches.size(); ++i) {
                writeBytes(matches[i].text);
                writeBytes((i + 1) % 4 == 0 || i + 1 == matches.size() ? "\r\n" : "\t");
            }
            redrawLine(prompt, line, cursor);
            return;
        }
    }
    replacement = escapeCompletion(replacement) + suffix;
    line.replace(token_start, cursor - token_start, replacement);
    cursor = token_start + replacement.size();
    redrawLine(prompt, line, cursor);
}

std::string readInteractiveLine(const std::string& prompt,
                                std::vector<std::string>& history,
                                bool& eof) {
    eof = false;
    RawMode raw;
    if (!raw.active()) {
        std::string line;
        std::cout << prompt << std::flush;
        if (!std::getline(std::cin, line)) { eof = true; return {}; }
        return line;
    }

    std::string line;
    std::size_t cursor = 0;
    std::size_t history_index = history.size();
    bool have_history_buffer = false;
    std::string saved_line;

    // Paint the complete prompt through the same positioning path used for edits.
    // With an empty input line, cursor == line.size() == 0, so the insertion
    // point is deterministically just after the prompt's trailing colon/space.
    redrawLine(prompt, line, cursor);
    for (;;) {
        char c = 0;
        if (!readByte(c)) { eof = true; return {}; }

        if (c == '\t') { // Tab: command or filesystem completion.
            applyTabCompletion(line, cursor, prompt);
            continue;
        }

        if (c == '\n' || c == '\r') {
            writeBytes("\r\n");
            return line;
        }

        if (c == 0x03) { // Ctrl+C: cancel the current input line (not EOF).
            writeBytes("^C\r\n");
            return {};
        }

        if (c == 0x04) { // Ctrl+D: exit on an empty input line.
            if (line.empty()) {
                writeBytes("\r\n");
                eof = true;
                return {};
            }
            continue;
        }

        if (c == 0x01) { // Home / Ctrl+A
            cursor = 0;
            redrawLine(prompt, line, cursor);
            continue;
        }

        if (c == 0x05) { // End / Ctrl+E
            cursor = line.size();
            redrawLine(prompt, line, cursor);
            continue;
        }

        if (c == 0x7f || c == 0x08) { // Backspace
            if (cursor > 0) {
                line.erase(cursor - 1, 1);
                --cursor;
                redrawLine(prompt, line, cursor);
            }
            continue;
        }

        if (c == 0x0c) { // Ctrl+L
            writeBytes("\x1b[2J\x1b[H");
            redrawLine(prompt, line, cursor);
            continue;
        }

        if (c == '\x1b') {
            char a = 0, b = 0;
            if (!readByte(a)) { eof = true; return {}; }
            if (a != '[' && a != 'O') continue;
            if (!readByte(b)) { eof = true; return {}; }

            if (b == 'A') { // Up: history previous
                if (!history.empty() && history_index > 0) {
                    if (!have_history_buffer) {
                        saved_line = line;
                        have_history_buffer = true;
                    }
                    --history_index;
                    line = history[history_index];
                    cursor = line.size();
                    redrawLine(prompt, line, cursor);
                }
                continue;
            }
            if (b == 'B') { // Down: history next
                if (have_history_buffer) {
                    if (history_index + 1 < history.size()) {
                        ++history_index;
                        line = history[history_index];
                    } else {
                        history_index = history.size();
                        line = saved_line;
                        have_history_buffer = false;
                    }
                    cursor = line.size();
                    redrawLine(prompt, line, cursor);
                }
                continue;
            }
            if (b == 'C') { // Right
                if (cursor < line.size()) ++cursor;
                redrawLine(prompt, line, cursor);
                continue;
            }
            if (b == 'D') { // Left
                if (cursor > 0) --cursor;
                redrawLine(prompt, line, cursor);
                continue;
            }
            if (b == 'H') { // Home
                cursor = 0;
                redrawLine(prompt, line, cursor);
                continue;
            }
            if (b == 'F') { // End
                cursor = line.size();
                redrawLine(prompt, line, cursor);
                continue;
            }

            if (b == '3') { // Delete: ESC [ 3 ~
                char tilde = 0;
                if (readByte(tilde) && tilde == '~' && cursor < line.size()) {
                    line.erase(cursor, 1);
                    redrawLine(prompt, line, cursor);
                }
                continue;
            }
            continue;
        }

        if (static_cast<unsigned char>(c) >= 0x20) {
            line.insert(cursor, 1, c);
            ++cursor;
            redrawLine(prompt, line, cursor);
        }
    }
}

std::string trimTrailingWhitespace(std::string value) {
    while (!value.empty() && (value.back() == ' ' || value.back() == '\t')) value.pop_back();
    return value;
}

bool runPromptCommand(const std::string& line, Environment& env) {
    if (line == "prompt") {
        // Print exactly what the REPL uses, including the trailing space.
        std::cout << "[prompt] " << env.prompt() << "\n";
        std::cout.flush();
        env.setLastStatus(0);
        return true;
    }

    const std::string prefix = "prompt set ";
    if (line.compare(0, prefix.size(), prefix) != 0) return false;

    const std::string args = line.substr(prefix.size());
    const std::size_t split = args.find_first_of(" \t");
    if (split == std::string::npos) {
        std::cerr << "prompt: usage: prompt set originalprompt newprompt\n";
        env.setLastStatus(2);
        return true;
    }

    const std::string original = args.substr(0, split);
    std::size_t new_start = split;
    while (new_start < args.size() && (args[new_start] == ' ' || args[new_start] == '\t')) ++new_start;
    const std::string replacement = args.substr(new_start);

    if (replacement.empty()) {
        std::cerr << "prompt: usage: prompt set originalprompt newprompt\n";
        env.setLastStatus(2);
        return true;
    }

    if (trimTrailingWhitespace(env.prompt()) != trimTrailingWhitespace(original)) {
        std::cerr << "prompt: current prompt does not match '" << original << "'\n";
        env.setLastStatus(1);
        return true;
    }

    env.setPrompt(replacement);
    env.setLastStatus(0);
    return true;
}


const std::vector<std::string>& footerbarTopicCatalog() {
    static const std::vector<std::string> topics = {
        "academia",
        "agriculture",
        "ai-research",
        "anatomy",
        "anthropology",
        "archaeology",
        "astronomy",
        "astrophysics",
        "artificial-intelligence",
        "behavioral-science",
        "biochemistry",
        "biodiversity",
        "bioinformatics",
        "biology",
        "biomedical-engineering",
        "biophysics",
        "biotechnology",
        "botany",
        "business",
        "cancer-research",
        "chemistry",
        "climate-science",
        "cognitive-science",
        "computational-biology",
        "computer-science",
        "conservation",
        "data-science",
        "dentistry",
        "developmental-biology",
        "drug-discovery",
        "ecology",
        "economics",
        "education",
        "electrical-engineering",
        "energy",
        "engineering",
        "environmental-science",
        "epidemiology",
        "ethics",
        "evolution",
        "finance",
        "food-science",
        "forensic-science",
        "genetics",
        "geochemistry",
        "geography",
        "geology",
        "global-health",
        "health-policy",
        "history",
        "immunology",
        "infectious-disease",
        "information-security",
        "materials-science",
        "mathematics",
        "mechanical-engineering",
        "medicine",
        "microbiology",
        "molecular-biology",
        "nanotechnology",
        "neuroscience",
        "nuclear-physics",
        "nutrition",
        "oceanography",
        "oncology",
        "optics",
        "paleontology",
        "pharmacology",
        "pharmacy",
        "philosophy",
        "physics",
        "physiology",
        "plant-science",
        "political-science",
        "psychology",
        "public-health",
        "quantum-computing",
        "quantum-physics",
        "robotics",
        "science-policy",
        "software-engineering",
        "statistics",
        "sustainability",
        "systems-biology",
        "toxicology",
        "veterinary-medicine",
        "virology",
        "volcanology",
        "water-resources",
        "wildlife",
        "anxiety-research",
        "clinical-trials",
        "digital-health",
        "medical-devices",
        "mental-health",
        "pharmacogenomics",
        "regenerative-medicine",
        "stem-cells",
        "surgery",
        "vaccinology"
    };
    return topics;
}

std::filesystem::path footerbarTopicsPath() {
    const char *xdg = std::getenv("XDG_CONFIG_HOME");
    const char *home = std::getenv("HOME");
    std::filesystem::path base = (xdg && *xdg) ? xdg :
        ((home && *home) ? (std::filesystem::path(home) / ".config").string() : ".config");
    return base / "sleela" / "footerbar-topics.conf";
}

std::string lowerTopic(std::string value) {
    std::transform(value.begin(), value.end(), value.begin(),
        [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return value;
}

bool runFooterbarCommand(const std::string& line, Environment& env) {
    if (line != "footerbar" && line.rfind("footerbar ", 0) != 0) return false;
    std::istringstream input(line);
    std::string command, arg;
    input >> command;
    std::vector<std::string> requested;
    while (input >> arg) requested.push_back(lowerTopic(arg));
    const auto &catalog = footerbarTopicCatalog();
    const auto path = footerbarTopicsPath();
    std::vector<std::string> current;
    {
        std::ifstream in(path);
        while (in >> arg) current.push_back(lowerTopic(arg));
    }
    if (requested.empty() || requested.front() == "status") {
        std::cout << "footerbar topics:";
        if (current.empty()) std::cout << " (none; feed inactive)";
        for (const auto &topic : current) std::cout << " " << topic;
        std::cout << "\nUse: footerbar chemistry pharmacology\n"
                     "Use 'footerbar list' to show the 100 supported topics, or 'footerbar clear' to disable.\n";
        env.setLastStatus(0);
        return true;
    }
    if (requested.size() == 1 && requested[0] == "list") {
        for (std::size_t i = 0; i < catalog.size(); ++i)
            std::cout << catalog[i] << ((i + 1) % 5 == 0 ? "\n" : "\t");
        if (catalog.size() % 5 != 0) std::cout << "\n";
        env.setLastStatus(0);
        return true;
    }
    if (requested.size() == 1 && requested[0] == "clear") {
        std::error_code ec;
        std::filesystem::remove(path, ec);
        std::cout << "footerbar: topic feed disabled\n";
        env.setLastStatus(0);
        return true;
    }
    std::vector<std::string> selected;
    for (const auto &topic : requested) {
        if (std::find(catalog.begin(), catalog.end(), topic) == catalog.end()) {
            std::cerr << "footerbar: unsupported topic '" << topic
                      << "'; use 'footerbar list' to see supported topics\n";
            env.setLastStatus(2);
            return true;
        }
        if (std::find(selected.begin(), selected.end(), topic) == selected.end()) selected.push_back(topic);
    }
    std::error_code ec;
    std::filesystem::create_directories(path.parent_path(), ec);
    if (ec) {
        std::cerr << "footerbar: cannot create config directory: " << ec.message() << "\n";
        env.setLastStatus(1);
        return true;
    }
    std::ofstream out(path, std::ios::trunc);
    if (!out) {
        std::cerr << "footerbar: cannot write " << path << "\n";
        env.setLastStatus(1);
        return true;
    }
    for (const auto &topic : selected) out << topic << "\n";
    std::cout << "footerbar: RSS topic feed enabled for";
    for (const auto &topic : selected) std::cout << " " << topic;
    std::cout << "\n";
    env.setLastStatus(0);
    return true;
}

bool runSorosTimeCommand(const std::string& line, Environment& env) {
    if (line != "soros time") return false;

    constexpr int kSorosBaseYear = 2026;
    constexpr int kSorosBaseTimestamp = 2407;
    constexpr int kGreatMysteryTimestamp = 2607;

    const std::time_t now = std::time(nullptr);
    const std::tm* local = std::localtime(&now);
    if (local == nullptr) {
        std::cerr << "soros time: unable to determine the terminal's local year\n";
        env.setLastStatus(1);
        return true;
    }

    const int civil_year = local->tm_year + 1900;
    const int soros_timestamp = kSorosBaseTimestamp + (civil_year - kSorosBaseYear);

    std::cout << "[soros time] " << soros_timestamp
              << " (civil year " << civil_year << ")\n";
    std::cout << "[soros time] 2026 = 2407; each year after 2026 adds one.\n";
    std::cout << "[soros time] Own National Time: 2407 (2026).\n";
    std::cout << "[soros time] Great Mystery marker: " << kGreatMysteryTimestamp << "+.\n";
    std::cout.flush();
    env.setLastStatus(0);
    return true;
}

int runNormalScript(const std::string& src, Environment& env) {
    std::vector<Token> toks;
    LexError lerr;
    if (!lex(src, toks, lerr)) {
        std::cerr << "slsh: lex error at " << lerr.line << ":" << lerr.col
                  << ": " << lerr.message << "\n";
        return 2;
    }
    ParseError perr;
    NodePtr ast = parse(toks, perr);
    if (!ast) {
        std::cerr << "slsh: parse error at " << perr.line << ":" << perr.col
                  << ": " << perr.message << "\n";
        return 2;
    }
    int status = execute(*ast, env);
    if (env.shouldExit()) return env.exitCode();
    return status;
}

int runScript(const std::string& src, Environment& env) {
    if (runPromptCommand(src, env)) return env.lastStatus();
    if (runFooterbarCommand(src, env)) return env.lastStatus();
    if (runSorosTimeCommand(src, env)) return env.lastStatus();

    int status = 0;
    const M5Runner runner = [](const std::string& nested, Environment& e) {
        return runScript(nested, e);
    };
    if (runM5(src, env, runner, status)) return status;
    return runNormalScript(src, env);
}

void printCommandSummary(const std::string& command) {
    const std::time_t now = std::time(nullptr);
    std::tm local{};
    char timestamp[64] = "unknown local time";
    if (::localtime_r(&now, &local) != nullptr) {
        std::strftime(timestamp, sizeof timestamp, "%Y-%m-%d %H:%M:%S %Z", &local);
    }
    // VTE ANSI background is a text-cell rectangle, not a separate GTK panel.
    // The workspace/terminal base colours remain unchanged.
    std::cout << "\033[48;2;112;91;69m\033[38;2;252;248;240m  "
              << command << "   \xC2\xB7   " << timestamp
              << "  \033[0m\n" << std::flush;
}

int repl(Environment& env) {
    std::vector<std::string> history;
    const std::string startup_banner = "SleelaTerminal(TM) slsh -- original SLeeLa shell. Type 'exit' to leave.";
    const std::string initial_prompt = colourPrompt(env.prompt());
    // Count visible prompt columns, excluding ANSI colour/control sequences.
    std::size_t prompt_columns = 0;
    bool in_escape = false;
    bool in_csi = false;
    for (unsigned char ch : initial_prompt) {
        if (!in_escape && ch == 0x1b) {
            in_escape = true;
            continue;
        }
        if (in_escape) {
            if (!in_csi && ch == '[') {
                in_csi = true;
                continue;
            }
            if (in_csi && ch >= 0x40 && ch <= 0x7e) {
                in_escape = false;
                in_csi = false;
            } else if (!in_csi) {
                in_escape = false;
            }
            continue;
        }
        ++prompt_columns;
    }
    std::cout << startup_banner << '\n' << std::flush;

    // Fade the one-line welcome banner after five seconds without blocking the
    // REPL. Each fade frame repaints only row 1 and saves/restores the live cursor.
    // Deleting row 1 promotes the prompt row; put the cursor after the prompt,
    // not at column 1, so the empty input line starts in the normal position.
    std::thread([startup_banner, prompt_columns]() {
        std::this_thread::sleep_for(std::chrono::seconds(5));
        static const char *const fade_colours[] = {
            "\033[38;5;250m", "\033[38;5;244m",
            "\033[38;5;238m", "\033[38;5;232m"
        };
        for (const char *colour : fade_colours) {
            const std::string frame = std::string("\033[s\033[1;1H\033[2K")
                + colour + startup_banner + "\033[0m\033[u";
            (void)::write(STDOUT_FILENO, frame.data(), frame.size());
            std::this_thread::sleep_for(std::chrono::milliseconds(180));
        }
        const std::string clear_and_promote =
            "\033[1;1H\033[2K\033[1;1H\033[M\033[1;1H";
        (void)::write(STDOUT_FILENO, clear_and_promote.data(), clear_and_promote.size());
        if (prompt_columns > 0) {
            const std::string move_to_input =
                "\033[" + std::to_string(prompt_columns) + "C";
            (void)::write(STDOUT_FILENO, move_to_input.data(), move_to_input.size());
        }
    }).detach();

    for (;;) {
        bool eof = false;
        const std::string line = readInteractiveLine(colourPrompt(env.prompt()), history, eof);
        if (g_interrupted) {
            g_interrupted = 0;
            continue;
        }
        if (eof) return env.exitCode();
        if (line.empty()) continue;

        if (history.empty() || history.back() != line) history.push_back(line);
        printCommandSummary(line);
        runScript(line, env);
        if (env.shouldExit()) return env.exitCode();
    }
}

} // namespace

int main(int argc, char** argv) {
    g_shell_pid = ::getpid();
    ::signal(SIGQUIT, sharpQuitSignalHandler);
    ::signal(SIGINT, interruptSignalHandler);
    configureTerminalKeys();

    sleela::sh::Environment env;

    if (argc >= 3 && std::string(argv[1]) == "-c") {
        std::string script = argv[2];
        for (int i = 3; i < argc; ++i) { script += ' '; script += argv[i]; }
        return runScript(script, env);
    }

    if (argc >= 2) {
        std::ifstream f(argv[1]);
        if (!f) { std::cerr << "slsh: cannot open " << argv[1] << "\n"; return 1; }
        std::ostringstream ss; ss << f.rdbuf();
        return runScript(ss.str(), env);
    }

    // No script argument: if stdin is a terminal, run the interactive REPL;
    // otherwise stdin is a pipe/file, so read it in full and run it as a
    // non-interactive script -- no banner, no prompts -- matching standard
    // shell behaviour (`echo cmd | slsh`).
    if (::isatty(STDIN_FILENO)) {
        return repl(env);
    }

    std::ostringstream ss; ss << std::cin.rdbuf();
    return runScript(ss.str(), env);
}