windowpp 0.1.1

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

@@ -0,0 +1,264 @@
+// ============================================================================
+//  FileSystem/MacOS/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 <unistd.h>
+#include <stdio.h>   // rename
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <cerrno>
+#include <cstring>
+#include <cstdlib>
+#include <set>
+#include <algorithm>
+#include <filesystem>
+#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 std::string toLowerAscii(std::string value) {
+    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
+        return static_cast<char>(std::tolower(c));
+    });
+    return value;
+}
+
+// ─── 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({"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({"open", path});
+        return;
+    }
+
+    launchDetached({"open", "-R", path});
+}
+
+std::vector<ApplicationEntry> handleListApplications() {
+    namespace fs = std::filesystem;
+
+    std::vector<fs::path> roots = {
+        "/Applications",
+        "/System/Applications",
+        "/System/Applications/Utilities",
+    };
+    if (const char* home = std::getenv("HOME")) {
+        roots.emplace_back(std::string(home) + "/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_directory(ec) || ec) {
+                ec.clear();
+                continue;
+            }
+
+            if (toLowerAscii(entry.path().extension().string()) != ".app") {
+                continue;
+            }
+
+            it.disable_recursion_pending();
+            const std::string path = entry.path().string();
+            if (!seen.insert(path).second) {
+                continue;
+            }
+
+            apps.push_back(ApplicationEntry{
+                path,
+                entry.path().stem().string(),
+                path,
+                path,
+            });
+        }
+    }
+
+    return apps;
+}
+
+void handleLaunchApplication(const std::string& target) {
+    launchDetached({"open", target});
+}
+
+} // namespace wpp::fs

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

@@ -0,0 +1,195 @@
+// ============================================================================
+//  FileSystem/Windows/filesearch.cpp
+//  Handles:  fs:exists, fs:stat, fs:readDir, fs:searchFiles
+// ============================================================================
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+
+#include <filesystem>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+// PathMatchSpecW is in shlwapi
+#pragma comment(lib, "shlwapi.lib")
+#include <shlwapi.h>
+
+#include "../filesystem_handler.h"
+
+namespace wpp::fs {
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static std::wstring toWide(const std::string& utf8) {
+    if (utf8.empty()) return {};
+    int len = MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, nullptr, 0);
+    std::wstring ws(len, L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, ws.data(), len);
+    if (!ws.empty() && ws.back() == L'\0') ws.pop_back();
+    return ws;
+}
+
+static std::string toUtf8(const std::wstring& ws) {
+    if (ws.empty()) return {};
+    int len = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), -1,
+                                  nullptr, 0, nullptr, nullptr);
+    std::string s(len, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), -1,
+                        s.data(), len, nullptr, nullptr);
+    if (!s.empty() && s.back() == '\0') s.pop_back();
+    return s;
+}
+
+static int64_t filetimeToUnixMs(const FILETIME& ft) {
+    // FILETIME: 100-ns intervals since 1601-01-01
+    uint64_t ticks = (static_cast<uint64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+    // Offset from 1601-01-01 to 1970-01-01 in 100-ns intervals
+    constexpr uint64_t kEpochOffset = 116444736000000000ULL;
+    if (ticks < kEpochOffset) return 0;
+    return static_cast<int64_t>((ticks - kEpochOffset) / 10000);
+}
+
+// ─── fs:exists ───────────────────────────────────────────────────────────────
+
+bool handleExists(const std::string& path) {
+    DWORD attr = GetFileAttributesW(toWide(path).c_str());
+    return attr != INVALID_FILE_ATTRIBUTES;
+}
+
+// ─── fs:stat ─────────────────────────────────────────────────────────────────
+
+FileStat handleStat(const std::string& path) {
+    std::wstring wpath = toWide(path);
+    WIN32_FILE_ATTRIBUTE_DATA info{};
+    if (!GetFileAttributesExW(wpath.c_str(), GetFileExInfoStandard, &info)) {
+        DWORD err = GetLastError();
+        throw std::runtime_error("stat failed for '" + path +
+                                 "' (Win32 error " + std::to_string(err) + ")");
+    }
+
+    // Extract file name
+    auto fsPath = std::filesystem::path(wpath);
+    std::string name = toUtf8(fsPath.filename().wstring());
+
+    uint64_t size =
+        (static_cast<uint64_t>(info.nFileSizeHigh) << 32) | info.nFileSizeLow;
+    bool isDir  = (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+    bool isLink = (info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
+
+    return FileStat{
+        path,
+        name,
+        static_cast<int64_t>(size),
+        isDir,
+        isLink,
+        filetimeToUnixMs(info.ftLastWriteTime),
+        filetimeToUnixMs(info.ftCreationTime),
+        -1  // mode not available on Windows
+    };
+}
+
+// ─── fs:readDir ──────────────────────────────────────────────────────────────
+
+std::vector<DirEntry> handleReadDir(const std::string& path) {
+    std::wstring wpattern = toWide(path) + L"\\*";
+    WIN32_FIND_DATAW ffd{};
+    HANDLE hFind = FindFirstFileW(wpattern.c_str(), &ffd);
+    if (hFind == INVALID_HANDLE_VALUE) {
+        DWORD err = GetLastError();
+        if (err == ERROR_FILE_NOT_FOUND) return {};
+        throw std::runtime_error("readDir failed for '" + path +
+                                 "' (Win32 error " + std::to_string(err) + ")");
+    }
+
+    std::vector<DirEntry> entries;
+    do {
+        std::wstring wname = ffd.cFileName;
+        if (wname == L"." || wname == L"..") continue;
+        bool isDir  = (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+        bool isLink = (ffd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
+        std::string name = toUtf8(wname);
+        entries.push_back(DirEntry{name, path + "\\" + name, isDir, isLink});
+    } while (FindNextFileW(hFind, &ffd));
+    FindClose(hFind);
+    return entries;
+}
+
+std::vector<std::string> handleListRoots() {
+    DWORD length = GetLogicalDriveStringsW(0, nullptr);
+    if (length == 0) {
+        return {};
+    }
+
+    std::wstring buffer(length, L'\0');
+    GetLogicalDriveStringsW(length, buffer.data());
+
+    std::vector<std::string> roots;
+    const wchar_t* current = buffer.c_str();
+    while (*current) {
+        roots.push_back(toUtf8(current));
+        current += wcslen(current) + 1;
+    }
+    return roots;
+}
+
+// ─── fs:searchFiles ──────────────────────────────────────────────────────────
+
+static void searchRecursive(const std::wstring& dir,
+                             const std::wstring& wpattern,
+                             bool recursive,
+                             bool includeHidden,
+                             bool includeDirectories,
+                             size_t maxResults,
+                             std::vector<std::string>& results) {
+    if (maxResults > 0 && results.size() >= maxResults) return;
+
+    std::wstring query = dir + L"\\*";
+    WIN32_FIND_DATAW ffd{};
+    HANDLE hFind = FindFirstFileW(query.c_str(), &ffd);
+    if (hFind == INVALID_HANDLE_VALUE) return;
+
+    do {
+        if (maxResults > 0 && results.size() >= maxResults) break;
+
+        std::wstring wname = ffd.cFileName;
+        if (wname == L"." || wname == L"..") continue;
+
+        bool hidden = (!wname.empty() && wname[0] == L'.') ||
+                      (ffd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0;
+        if (hidden && !includeHidden) continue;
+
+        bool isDir = (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+        std::wstring fullW = dir + L"\\" + wname;
+
+        if (isDir) {
+            if (includeDirectories && PathMatchSpecW(wname.c_str(), wpattern.c_str())) {
+                results.push_back(toUtf8(fullW));
+            }
+            if (recursive) {
+                searchRecursive(fullW, wpattern, recursive,
+                                includeHidden, includeDirectories, maxResults, results);
+            }
+        } else {
+            // Match filename against glob pattern
+            if (PathMatchSpecW(wname.c_str(), wpattern.c_str())) {
+                results.push_back(toUtf8(fullW));
+            }
+        }
+    } while (FindNextFileW(hFind, &ffd));
+    FindClose(hFind);
+}
+
+std::vector<std::string> handleSearchFiles(const std::string& dir,
+                                           const SearchOptions& opts) {
+    std::wstring wdir     = toWide(dir);
+    std::wstring wpattern = toWide(opts.pattern.empty() ? "*" : opts.pattern);
+    std::vector<std::string> results;
+    searchRecursive(wdir, wpattern, opts.recursive, opts.includeHidden,
+                    opts.includeDirectories,
+                    opts.maxResults, results);
+    return results;
+}
+
+} // namespace wpp::fs

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

@@ -0,0 +1,122 @@
+// ============================================================================
+//  FileSystem/Windows/readfile.cpp
+//  Handles:  fs:readFile, fs:readBinaryFile
+// ============================================================================
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <stdexcept>
+
+#include "../filesystem_handler.h"
+
+namespace wpp::fs {
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static std::wstring toWide(const std::string& utf8) {
+    if (utf8.empty()) return {};
+    int len = MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, nullptr, 0);
+    std::wstring ws(len, L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, ws.data(), len);
+    // Remove the null terminator added by MultiByteToWideChar
+    if (!ws.empty() && ws.back() == L'\0') ws.pop_back();
+    return ws;
+}
+
+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;
+}
+
+// ─── fs:readFile ─────────────────────────────────────────────────────────────
+
+std::string handleReadFile(const std::string& path) {
+    std::wstring wpath = toWide(path);
+    HANDLE hFile = CreateFileW(
+        wpath.c_str(), GENERIC_READ, FILE_SHARE_READ,
+        nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+
+    if (hFile == INVALID_HANDLE_VALUE) {
+        DWORD err = GetLastError();
+        throw std::runtime_error("Cannot open file '" + path +
+                                 "' (Win32 error " + std::to_string(err) + ")");
+    }
+
+    LARGE_INTEGER fileSize{};
+    if (!GetFileSizeEx(hFile, &fileSize)) {
+        CloseHandle(hFile);
+        throw std::runtime_error("Cannot get size of '" + path + "'");
+    }
+
+    std::string text(static_cast<size_t>(fileSize.QuadPart), '\0');
+    DWORD bytesRead = 0;
+    if (!ReadFile(hFile, text.data(), static_cast<DWORD>(text.size()),
+                  &bytesRead, nullptr)) {
+        CloseHandle(hFile);
+        throw std::runtime_error("Read failed for '" + path + "'");
+    }
+    CloseHandle(hFile);
+    text.resize(bytesRead);
+    return text;
+}
+
+// ─── fs:readBinaryFile ───────────────────────────────────────────────────────
+
+// Returns the file bytes as a Base64-encoded string.
+std::string handleReadBinaryFile(const std::string& path) {
+    std::wstring wpath = toWide(path);
+    HANDLE hFile = CreateFileW(
+        wpath.c_str(), GENERIC_READ, FILE_SHARE_READ,
+        nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+
+    if (hFile == INVALID_HANDLE_VALUE) {
+        DWORD err = GetLastError();
+        throw std::runtime_error("Cannot open file '" + path +
+                                 "' (Win32 error " + std::to_string(err) + ")");
+    }
+
+    LARGE_INTEGER fileSize{};
+    if (!GetFileSizeEx(hFile, &fileSize)) {
+        CloseHandle(hFile);
+        throw std::runtime_error("Cannot get size of '" + path + "'");
+    }
+
+    std::vector<uint8_t> bytes(static_cast<size_t>(fileSize.QuadPart));
+    DWORD bytesRead = 0;
+    if (!ReadFile(hFile, bytes.data(), static_cast<DWORD>(bytes.size()),
+                  &bytesRead, nullptr)) {
+        CloseHandle(hFile);
+        throw std::runtime_error("Read failed for '" + path + "'");
+    }
+    CloseHandle(hFile);
+    bytes.resize(bytesRead);
+    return base64Encode(bytes);
+}
+
+} // namespace wpp::fs