windowpp 0.1.1

package/framework/src/FileSystem/Linux/savefile.cpp

@@ -0,0 +1,333 @@
+// ============================================================================
+//  FileSystem/Linux/savefile.cpp
+//  Handles:  fs:writeFile, fs:writeBinaryFile, fs:appendFile,
+//            fs:copyFile, fs:moveFile, fs:deleteFile,
+//            fs:createDir, fs:removeDir
+// ============================================================================
+
+#include <fcntl.h>
+#include <spawn.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <fstream>
+#include <filesystem>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../filesystem_handler.h"
+
+extern char **environ;
+
+namespace wpp::fs {
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static std::vector<uint8_t> base64Decode(const std::string& b64) {
+    static const int kDec[256] = {
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
+        52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
+        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+        15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
+        -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+        41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+    };
+    std::vector<uint8_t> out;
+    out.reserve(b64.size() * 3 / 4);
+    uint32_t buf = 0;
+    int bits = 0;
+    for (unsigned char c : b64) {
+        if (c == '=') break;
+        int v = kDec[c];
+        if (v < 0) continue;
+        buf = (buf << 6) | static_cast<uint32_t>(v);
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out.push_back(static_cast<uint8_t>((buf >> bits) & 0xFF));
+        }
+    }
+    return out;
+}
+
+static void writeData(const std::string& path,
+                      const void* data, size_t size, bool append) {
+    int flags = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
+    int fd = open(path.c_str(), flags, 0644);
+    if (fd < 0)
+        throw std::runtime_error("Cannot open '" + path + "' for writing: " +
+                                 std::string(strerror(errno)));
+    ssize_t n = write(fd, data, size);
+    close(fd);
+    if (n < 0 || static_cast<size_t>(n) != size)
+        throw std::runtime_error("Write failed for '" + path + "'");
+}
+
+static void launchDetached(const std::vector<std::string>& args) {
+    if (args.empty()) {
+        throw std::runtime_error("launchDetached failed: no command provided");
+    }
+
+    std::vector<char*> argv;
+    argv.reserve(args.size() + 1);
+    for (const auto& arg : args) {
+        argv.push_back(const_cast<char*>(arg.c_str()));
+    }
+    argv.push_back(nullptr);
+
+    pid_t pid = 0;
+    const int rc = posix_spawnp(&pid, argv[0], nullptr, nullptr, argv.data(), environ);
+    if (rc != 0) {
+        throw std::runtime_error("Failed to launch '" + args[0] + "': " + std::string(strerror(rc)));
+    }
+}
+
+static bool tryLaunchDetached(const std::vector<std::string>& args) {
+    if (args.empty()) return false;
+
+    std::vector<char*> argv;
+    argv.reserve(args.size() + 1);
+    for (const auto& arg : args) {
+        argv.push_back(const_cast<char*>(arg.c_str()));
+    }
+    argv.push_back(nullptr);
+
+    pid_t pid = 0;
+    const int rc = posix_spawnp(&pid, argv[0], nullptr, nullptr, argv.data(), environ);
+    return rc == 0;
+}
+
+static std::string trim(std::string value) {
+    const auto first = value.find_first_not_of(" \t\r\n");
+    if (first == std::string::npos) return {};
+    const auto last = value.find_last_not_of(" \t\r\n");
+    return value.substr(first, last - first + 1);
+}
+
+static bool parseDesktopEntry(const std::string& path, ApplicationEntry& out) {
+    std::ifstream file(path);
+    if (!file.is_open()) {
+        return false;
+    }
+
+    bool in_desktop_entry = false;
+    bool hidden = false;
+    bool no_display = false;
+    bool is_application = false;
+    std::string name;
+
+    std::string line;
+    while (std::getline(file, line)) {
+        line = trim(line);
+        if (line.empty() || line[0] == '#') continue;
+        if (line.front() == '[' && line.back() == ']') {
+            in_desktop_entry = (line == "[Desktop Entry]");
+            continue;
+        }
+        if (!in_desktop_entry) continue;
+
+        const auto equals = line.find('=');
+        if (equals == std::string::npos) continue;
+
+        const std::string key = trim(line.substr(0, equals));
+        const std::string value = trim(line.substr(equals + 1));
+        if (key == "Name" && name.empty()) {
+            name = value;
+        } else if (key == "Hidden") {
+            hidden = value == "true" || value == "1";
+        } else if (key == "NoDisplay") {
+            no_display = value == "true" || value == "1";
+        } else if (key == "Type") {
+            is_application = value == "Application";
+        }
+    }
+
+    if (!is_application || hidden || no_display) {
+        return false;
+    }
+
+    const std::filesystem::path fs_path(path);
+    out = ApplicationEntry{
+        fs_path.filename().string(),
+        name.empty() ? fs_path.stem().string() : name,
+        path,
+        path,
+    };
+    return true;
+}
+
+// ─── fs:writeFile ─────────────────────────────────────────────────────────────
+
+void handleWriteFile(const std::string& path, const std::string& text) {
+    writeData(path, text.data(), text.size(), false);
+}
+
+// ─── fs:writeBinaryFile ───────────────────────────────────────────────────────
+
+void handleWriteBinaryFile(const std::string& path, const std::string& b64) {
+    auto bytes = base64Decode(b64);
+    writeData(path, bytes.data(), bytes.size(), false);
+}
+
+// ─── fs:appendFile ────────────────────────────────────────────────────────────
+
+void handleAppendFile(const std::string& path, const std::string& text) {
+    writeData(path, text.data(), text.size(), true);
+}
+
+// ─── fs:copyFile ─────────────────────────────────────────────────────────────
+
+void handleCopyFile(const std::string& src, const std::string& dest) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    fs::copy_file(src, dest, fs::copy_options::overwrite_existing, ec);
+    if (ec) throw std::runtime_error("copyFile failed: " + ec.message());
+}
+
+// ─── fs:moveFile ─────────────────────────────────────────────────────────────
+
+void handleMoveFile(const std::string& src, const std::string& dest) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    fs::rename(src, dest, ec);
+    if (ec) throw std::runtime_error("moveFile failed: " + ec.message());
+}
+
+// ─── fs:deleteFile ────────────────────────────────────────────────────────────
+
+void handleDeleteFile(const std::string& path) {
+    if (unlink(path.c_str()) != 0)
+        throw std::runtime_error("deleteFile failed for '" + path + "': " +
+                                 std::string(strerror(errno)));
+}
+
+// ─── fs:createDir ────────────────────────────────────────────────────────────
+
+void handleCreateDir(const std::string& path, bool recursive) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    if (recursive)
+        fs::create_directories(path, ec);
+    else
+        fs::create_directory(path, ec);
+    if (ec) throw std::runtime_error("createDir failed: " + ec.message());
+}
+
+// ─── fs:removeDir ────────────────────────────────────────────────────────────
+
+void handleRemoveDir(const std::string& path, bool recursive) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    if (recursive)
+        fs::remove_all(path, ec);
+    else
+        fs::remove(path, ec);
+    if (ec) throw std::runtime_error("removeDir failed: " + ec.message());
+}
+
+void handleOpenPath(const std::string& path) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    if (!fs::exists(path, ec) || ec) {
+        throw std::runtime_error("openPath failed: path does not exist: " + path);
+    }
+
+    launchDetached({"xdg-open", path});
+}
+
+void handleRevealPath(const std::string& path) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    fs::path target(path);
+    if (!fs::exists(target, ec) || ec) {
+        throw std::runtime_error("revealPath failed: path does not exist: " + path);
+    }
+
+    if (fs::is_directory(target, ec)) {
+        launchDetached({"xdg-open", path});
+        return;
+    }
+
+    const fs::path parent = target.parent_path();
+    launchDetached({"xdg-open", parent.empty() ? std::string(".") : parent.string()});
+}
+
+std::vector<ApplicationEntry> handleListApplications() {
+    namespace fs = std::filesystem;
+
+    std::vector<fs::path> roots = {
+        "/usr/share/applications",
+        "/usr/local/share/applications",
+        "/var/lib/flatpak/exports/share/applications",
+    };
+    if (const char* home = std::getenv("HOME")) {
+        roots.emplace_back(std::string(home) + "/.local/share/applications");
+        roots.emplace_back(std::string(home) + "/.local/share/flatpak/exports/share/applications");
+    }
+
+    std::vector<ApplicationEntry> apps;
+    std::set<std::string> seen;
+    for (const auto& root : roots) {
+        std::error_code ec;
+        if (!fs::exists(root, ec) || ec) {
+            continue;
+        }
+
+        fs::recursive_directory_iterator it(root, fs::directory_options::skip_permission_denied, ec);
+        fs::recursive_directory_iterator end;
+        for (; it != end; it.increment(ec)) {
+            if (ec) {
+                ec.clear();
+                continue;
+            }
+
+            const auto& entry = *it;
+            if (!entry.is_regular_file(ec) || ec) {
+                ec.clear();
+                continue;
+            }
+            if (entry.path().extension() != ".desktop") {
+                continue;
+            }
+
+            ApplicationEntry app;
+            const std::string path = entry.path().string();
+            if (!parseDesktopEntry(path, app)) {
+                continue;
+            }
+            if (!seen.insert(app.id).second) {
+                continue;
+            }
+            apps.push_back(std::move(app));
+        }
+    }
+
+    return apps;
+}
+
+void handleLaunchApplication(const std::string& target) {
+    const std::string desktop_id = std::filesystem::path(target).filename().string();
+    if (tryLaunchDetached({"gio", "launch", target})) {
+        return;
+    }
+    if (tryLaunchDetached({"gtk-launch", desktop_id})) {
+        return;
+    }
+    launchDetached({"xdg-open", target});
+}
+
+} // namespace wpp::fs

package/framework/src/FileSystem/MacOS/filesearch.cpp

@@ -0,0 +1,149 @@
+// ============================================================================
+//  FileSystem/MacOS/filesearch.cpp
+//  Handles:  fs:exists, fs:stat, fs:readDir, fs:searchFiles
+// ============================================================================
+
+#include <dirent.h>
+#include <fnmatch.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../filesystem_handler.h"
+
+namespace wpp::fs {
+
+// ─── fs:exists ───────────────────────────────────────────────────────────────
+
+bool handleExists(const std::string& path) {
+    struct stat st{};
+    return stat(path.c_str(), &st) == 0;
+}
+
+// ─── fs:stat ─────────────────────────────────────────────────────────────────
+
+FileStat handleStat(const std::string& path) {
+    struct stat st{};
+    if (::stat(path.c_str(), &st) != 0)
+        throw std::runtime_error("stat failed for '" + path + "': " +
+                                 std::string(strerror(errno)));
+
+    // Extract file name from path
+    std::string name = path;
+    auto slash = path.rfind('/');
+    if (slash != std::string::npos) name = path.substr(slash + 1);
+
+    bool isDir  = S_ISDIR(st.st_mode);
+    bool isLink = S_ISLNK(st.st_mode);
+
+    // macOS: st_birthtimespec holds creation time
+    int64_t createdMs = static_cast<int64_t>(st.st_birthtimespec.tv_sec) * 1000 +
+                        st.st_birthtimespec.tv_nsec / 1000000;
+    int64_t modifiedMs = static_cast<int64_t>(st.st_mtimespec.tv_sec) * 1000 +
+                         st.st_mtimespec.tv_nsec / 1000000;
+
+    return FileStat{
+        path,
+        name,
+        static_cast<int64_t>(st.st_size),
+        isDir,
+        isLink,
+        modifiedMs,
+        createdMs,
+        static_cast<int>(st.st_mode & 0777)
+    };
+}
+
+// ─── fs:readDir ──────────────────────────────────────────────────────────────
+
+std::vector<DirEntry> handleReadDir(const std::string& path) {
+    DIR* dir = opendir(path.c_str());
+    if (!dir)
+        throw std::runtime_error("readDir failed for '" + path + "': " +
+                                 std::string(strerror(errno)));
+
+    std::vector<DirEntry> entries;
+    struct dirent* ent;
+    while ((ent = readdir(dir)) != nullptr) {
+        std::string name = ent->d_name;
+        if (name == "." || name == "..") continue;
+        std::string full = path + "/" + name;
+        bool isDir  = ent->d_type == DT_DIR;
+        bool isLink = ent->d_type == DT_LNK;
+        if (ent->d_type == DT_UNKNOWN) {
+            struct stat st{};
+            ::stat(full.c_str(), &st);
+            isDir  = S_ISDIR(st.st_mode);
+            isLink = S_ISLNK(st.st_mode);
+        }
+        entries.push_back(DirEntry{name, full, isDir, isLink});
+    }
+    closedir(dir);
+    return entries;
+}
+
+std::vector<std::string> handleListRoots() {
+    return {"/"};
+}
+
+// ─── fs:searchFiles ──────────────────────────────────────────────────────────
+
+static void searchRecursive(const std::string& dir,
+                             const std::string& pattern,
+                             bool recursive,
+                             bool includeHidden,
+                             bool includeDirectories,
+                             size_t maxResults,
+                             std::vector<std::string>& results) {
+    if (maxResults > 0 && results.size() >= maxResults) return;
+
+    DIR* d = opendir(dir.c_str());
+    if (!d) return;
+
+    struct dirent* ent;
+    while ((ent = readdir(d)) != nullptr) {
+        if (maxResults > 0 && results.size() >= maxResults) break;
+        std::string name = ent->d_name;
+        if (name == "." || name == "..") continue;
+        bool hidden = (!name.empty() && name[0] == '.');
+        if (hidden && !includeHidden) continue;
+
+        std::string full = dir + "/" + name;
+        bool isDir = ent->d_type == DT_DIR;
+        if (ent->d_type == DT_UNKNOWN) {
+            struct stat st{};
+            ::stat(full.c_str(), &st);
+            isDir = S_ISDIR(st.st_mode);
+        }
+
+        if (isDir) {
+            if (includeDirectories && fnmatch(pattern.c_str(), name.c_str(), FNM_CASEFOLD) == 0)
+                results.push_back(full);
+            if (recursive) {
+                searchRecursive(full, pattern, recursive,
+                                includeHidden, includeDirectories, maxResults, results);
+            }
+        } else {
+            if (fnmatch(pattern.c_str(), name.c_str(), FNM_CASEFOLD) == 0)
+                results.push_back(full);
+        }
+    }
+    closedir(d);
+}
+
+std::vector<std::string> handleSearchFiles(const std::string& dir,
+                                           const SearchOptions& opts) {
+    std::string pat = opts.pattern.empty() ? "*" : opts.pattern;
+    std::vector<std::string> results;
+    searchRecursive(dir, pat, opts.recursive, opts.includeHidden,
+                    opts.includeDirectories,
+                    opts.maxResults, results);
+    return results;
+}
+
+} // namespace wpp::fs

package/framework/src/FileSystem/MacOS/readfile.cpp

@@ -0,0 +1,80 @@
+// ============================================================================
+//  FileSystem/MacOS/readfile.cpp
+//  Handles:  fs:readFile, fs:readBinaryFile
+// ============================================================================
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../filesystem_handler.h"
+
+namespace wpp::fs {
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static const std::string kB64Chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static std::string base64Encode(const std::vector<uint8_t>& bytes) {
+    std::string out;
+    out.reserve(((bytes.size() + 2) / 3) * 4);
+    size_t i = 0;
+    for (; i + 2 < bytes.size(); i += 3) {
+        uint32_t v = (bytes[i] << 16) | (bytes[i+1] << 8) | bytes[i+2];
+        out += kB64Chars[(v >> 18) & 0x3F];
+        out += kB64Chars[(v >> 12) & 0x3F];
+        out += kB64Chars[(v >>  6) & 0x3F];
+        out += kB64Chars[(v      ) & 0x3F];
+    }
+    if (i < bytes.size()) {
+        uint32_t v = bytes[i] << 16;
+        if (i + 1 < bytes.size()) v |= bytes[i+1] << 8;
+        out += kB64Chars[(v >> 18) & 0x3F];
+        out += kB64Chars[(v >> 12) & 0x3F];
+        out += (i + 1 < bytes.size()) ? kB64Chars[(v >> 6) & 0x3F] : '=';
+        out += '=';
+    }
+    return out;
+}
+
+static std::vector<uint8_t> readAllBytes(const std::string& path) {
+    int fd = open(path.c_str(), O_RDONLY);
+    if (fd < 0) {
+        throw std::runtime_error("Cannot open '" + path + "': " +
+                                 std::string(strerror(errno)));
+    }
+    struct stat st{};
+    if (fstat(fd, &st) < 0) {
+        close(fd);
+        throw std::runtime_error("stat failed for '" + path + "'");
+    }
+    std::vector<uint8_t> buf(static_cast<size_t>(st.st_size));
+    ssize_t n = read(fd, buf.data(), buf.size());
+    close(fd);
+    if (n < 0)
+        throw std::runtime_error("Read failed for '" + path + "'");
+    buf.resize(static_cast<size_t>(n));
+    return buf;
+}
+
+// ─── fs:readFile ─────────────────────────────────────────────────────────────
+
+std::string handleReadFile(const std::string& path) {
+    auto bytes = readAllBytes(path);
+    return std::string(bytes.begin(), bytes.end());
+}
+
+// ─── fs:readBinaryFile ───────────────────────────────────────────────────────
+
+std::string handleReadBinaryFile(const std::string& path) {
+    return base64Encode(readAllBytes(path));
+}
+
+} // namespace wpp::fs