windowpp 0.1.1

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

@@ -0,0 +1,290 @@
+// ============================================================================
+//  FileSystem/Windows/savefile.cpp
+//  Handles:  fs:writeFile, fs:writeBinaryFile, fs:appendFile,
+//            fs:copyFile, fs:moveFile, fs:deleteFile,
+//            fs:createDir, fs:removeDir
+// ============================================================================
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <shellapi.h>
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#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 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;
+}
+
+static void writeBytes(const std::string& path,
+                       const void* data, size_t size, bool append) {
+    std::wstring wpath = toWide(path);
+    DWORD access = GENERIC_WRITE;
+    DWORD creation = append ? OPEN_ALWAYS : CREATE_ALWAYS;
+
+    HANDLE hFile = CreateFileW(wpath.c_str(), access, 0, nullptr,
+                               creation, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (hFile == INVALID_HANDLE_VALUE) {
+        DWORD err = GetLastError();
+        throw std::runtime_error("Cannot open '" + path + "' for writing (Win32 error " +
+                                 std::to_string(err) + ")");
+    }
+    if (append) {
+        if (SetFilePointer(hFile, 0, nullptr, FILE_END) == INVALID_SET_FILE_POINTER) {
+            CloseHandle(hFile);
+            throw std::runtime_error("Seek to end failed for '" + path + "'");
+        }
+    }
+    DWORD written = 0;
+    if (!WriteFile(hFile, data, static_cast<DWORD>(size), &written, nullptr) ||
+        written != static_cast<DWORD>(size)) {
+        CloseHandle(hFile);
+        throw std::runtime_error("Write failed for '" + path + "'");
+    }
+    CloseHandle(hFile);
+}
+
+static std::vector<uint8_t> base64Decode(const std::string& b64) {
+    static const int kDecTable[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 = kDecTable[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;
+}
+
+// ─── fs:writeFile ─────────────────────────────────────────────────────────────
+
+void handleWriteFile(const std::string& path, const std::string& text) {
+    writeBytes(path, text.data(), text.size(), /*append=*/false);
+}
+
+// ─── fs:writeBinaryFile ───────────────────────────────────────────────────────
+
+void handleWriteBinaryFile(const std::string& path, const std::string& b64) {
+    auto bytes = base64Decode(b64);
+    writeBytes(path, bytes.data(), bytes.size(), /*append=*/false);
+}
+
+// ─── fs:appendFile ────────────────────────────────────────────────────────────
+
+void handleAppendFile(const std::string& path, const std::string& text) {
+    writeBytes(path, text.data(), text.size(), /*append=*/true);
+}
+
+// ─── fs:copyFile ─────────────────────────────────────────────────────────────
+
+void handleCopyFile(const std::string& src, const std::string& dest) {
+    if (!CopyFileW(toWide(src).c_str(), toWide(dest).c_str(), /*bFailIfExists=*/FALSE)) {
+        DWORD err = GetLastError();
+        throw std::runtime_error("CopyFile failed: " + std::to_string(err));
+    }
+}
+
+// ─── fs:moveFile ─────────────────────────────────────────────────────────────
+
+void handleMoveFile(const std::string& src, const std::string& dest) {
+    if (!MoveFileExW(toWide(src).c_str(), toWide(dest).c_str(),
+                     MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED)) {
+        DWORD err = GetLastError();
+        throw std::runtime_error("MoveFile failed: " + std::to_string(err));
+    }
+}
+
+// ─── fs:deleteFile ────────────────────────────────────────────────────────────
+
+void handleDeleteFile(const std::string& path) {
+    if (!DeleteFileW(toWide(path).c_str())) {
+        DWORD err = GetLastError();
+        throw std::runtime_error("DeleteFile failed: " + std::to_string(err));
+    }
+}
+
+// ─── fs:createDir ────────────────────────────────────────────────────────────
+
+void handleCreateDir(const std::string& path, bool recursive) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    if (recursive) {
+        fs::create_directories(fs::path(toWide(path)), ec);
+    } else {
+        fs::create_directory(fs::path(toWide(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(fs::path(toWide(path)), ec);
+    } else {
+        fs::remove(fs::path(toWide(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(fs::path(toWide(path)), ec) || ec) {
+        throw std::runtime_error("openPath failed: path does not exist: " + path);
+    }
+
+    const auto result = reinterpret_cast<intptr_t>(
+        ShellExecuteW(nullptr, L"open", toWide(path).c_str(), nullptr, nullptr, SW_SHOWNORMAL));
+    if (result <= 32) {
+        throw std::runtime_error("openPath failed for '" + path + "' (ShellExecute error " +
+                                 std::to_string(result) + ")");
+    }
+}
+
+void handleRevealPath(const std::string& path) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    fs::path target = fs::path(toWide(path));
+    if (!fs::exists(target, ec) || ec) {
+        throw std::runtime_error("revealPath failed: path does not exist: " + path);
+    }
+
+    if (fs::is_directory(target, ec)) {
+        handleOpenPath(path);
+        return;
+    }
+
+    const std::wstring params = L"/select,\"" + target.wstring() + L"\"";
+    const auto result = reinterpret_cast<intptr_t>(
+        ShellExecuteW(nullptr, L"open", L"explorer.exe", params.c_str(), nullptr, SW_SHOWNORMAL));
+    if (result <= 32) {
+        throw std::runtime_error("revealPath failed for '" + path + "' (ShellExecute error " +
+                                 std::to_string(result) + ")");
+    }
+}
+
+std::vector<ApplicationEntry> handleListApplications() {
+    namespace fs = std::filesystem;
+
+    std::vector<fs::path> roots;
+    if (const wchar_t* appdata = _wgetenv(L"APPDATA")) {
+        roots.emplace_back(std::wstring(appdata) + L"\\Microsoft\\Windows\\Start Menu\\Programs");
+    }
+    if (const wchar_t* program_data = _wgetenv(L"ProgramData")) {
+        roots.emplace_back(std::wstring(program_data) + L"\\Microsoft\\Windows\\Start Menu\\Programs");
+    }
+
+    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;
+            }
+
+            const std::string extension = toLowerAscii(entry.path().extension().u8string());
+            if (extension != ".lnk" && extension != ".url" && extension != ".appref-ms" && extension != ".exe") {
+                continue;
+            }
+
+            const std::string path = entry.path().u8string();
+            const std::string dedupe_key = toLowerAscii(path);
+            if (!seen.insert(dedupe_key).second) {
+                continue;
+            }
+
+            apps.push_back(ApplicationEntry{
+                path,
+                entry.path().stem().u8string(),
+                path,
+                path,
+            });
+        }
+    }
+
+    return apps;
+}
+
+void handleLaunchApplication(const std::string& target) {
+    handleOpenPath(target);
+}
+
+} // namespace wpp::fs

package/framework/src/FileSystem/file_index_service.cpp

@@ -0,0 +1,262 @@
+#include "file_index_service.h"
+
+#include "filesystem_handler.h"
+
+#include <nlohmann/json.hpp>
+
+#include <filesystem>
+#include <functional>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+namespace wpp::fs {
+
+namespace {
+
+using NativeJson = nlohmann::json;
+
+std::string normalize_path(const std::string& value) {
+    return std::filesystem::path(value).lexically_normal().u8string();
+}
+
+bool is_hidden_entry(const std::filesystem::directory_entry& entry) {
+    const auto filename = entry.path().filename().u8string();
+    if (!filename.empty() && filename[0] == '.') {
+        return true;
+    }
+
+#ifdef _WIN32
+    const DWORD attributes = GetFileAttributesW(entry.path().c_str());
+    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_HIDDEN) != 0;
+#else
+    return false;
+#endif
+}
+
+int64_t path_modified_ms(const std::string& path) {
+    try {
+        const auto stat = handleStat(path);
+        return stat.modifiedMs;
+    } catch (...) {
+        return -1;
+    }
+}
+
+NativeJson entry_to_json(const IndexedPathEntry& entry) {
+    return NativeJson{
+        {"path", entry.path},
+        {"name", entry.name},
+        {"isDir", entry.isDir},
+        {"isHidden", entry.isHidden},
+    };
+}
+
+IndexedPathEntry entry_from_json(const NativeJson& value) {
+    IndexedPathEntry entry;
+    entry.path = value.value("path", "");
+    entry.name = value.value("name", "");
+    entry.isDir = value.value("isDir", false);
+    entry.isHidden = value.value("isHidden", false);
+    return entry;
+}
+
+} // namespace
+
+FileIndexService& FileIndexService::instance() {
+    static FileIndexService service;
+    return service;
+}
+
+void FileIndexService::configure_cache_root(const std::string& cache_root) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    cache_root_ = cache_root;
+    if (!cache_root_.empty()) {
+        std::error_code ec;
+        std::filesystem::create_directories(std::filesystem::u8path(cache_root_), ec);
+    }
+}
+
+std::vector<IndexedPathEntry> FileIndexService::get_or_build_root_index(const std::string& root,
+                                                                        std::atomic<bool>* cancelled,
+                                                                        uint64_t& scanned_entries) {
+    scanned_entries = 0;
+    auto state = get_state(root);
+
+    std::lock_guard<std::mutex> lock(state->mutex);
+    if (!state->loaded && load_from_disk(state)) {
+        state->loaded = true;
+    }
+
+    const int64_t current_root_modified = path_modified_ms(state->root);
+    if (state->loaded && state->rootModifiedMs >= 0 && current_root_modified == state->rootModifiedMs) {
+        scanned_entries = static_cast<uint64_t>(state->entries.size());
+        return state->entries;
+    }
+
+    int64_t built_root_modified = current_root_modified;
+    auto rebuilt = build_root_index(state->root, cancelled, scanned_entries, built_root_modified);
+    if (cancelled && cancelled->load()) {
+        return {};
+    }
+
+    state->entries = std::move(rebuilt);
+    state->rootModifiedMs = built_root_modified;
+    state->loaded = true;
+    save_to_disk(*state);
+    return state->entries;
+}
+
+std::shared_ptr<FileIndexService::RootIndex> FileIndexService::get_state(const std::string& root) {
+    const std::string normalized = normalize_root(root);
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = indexes_.find(normalized);
+    if (it != indexes_.end()) {
+        return it->second;
+    }
+
+    auto state = std::make_shared<RootIndex>();
+    state->root = normalized;
+    indexes_.emplace(normalized, state);
+    return state;
+}
+
+std::vector<IndexedPathEntry> FileIndexService::build_root_index(const std::string& root,
+                                                                 std::atomic<bool>* cancelled,
+                                                                 uint64_t& scanned_entries,
+                                                                 int64_t& root_modified_ms) const {
+    std::vector<IndexedPathEntry> entries;
+    root_modified_ms = path_modified_ms(root);
+
+    std::error_code ec;
+    std::filesystem::path root_path(root);
+    if (std::filesystem::is_regular_file(root_path, ec)) {
+        entries.push_back(IndexedPathEntry{
+            normalize_path(root),
+            root_path.filename().u8string(),
+            false,
+            false,
+        });
+        scanned_entries = 1;
+        return entries;
+    }
+
+    if (ec || !std::filesystem::is_directory(root_path, ec)) {
+        return entries;
+    }
+
+    std::vector<std::filesystem::path> pending_dirs;
+    pending_dirs.push_back(root_path);
+
+    while (!pending_dirs.empty()) {
+        if (cancelled && cancelled->load()) {
+            return {};
+        }
+
+        std::filesystem::path dir = std::move(pending_dirs.back());
+        pending_dirs.pop_back();
+
+        auto it = std::filesystem::directory_iterator(
+            dir,
+            std::filesystem::directory_options::skip_permission_denied,
+            ec);
+        if (ec) {
+            continue;
+        }
+
+        for (const auto& entry : it) {
+            if (cancelled && cancelled->load()) {
+                return {};
+            }
+
+            ++scanned_entries;
+            const bool hidden = is_hidden_entry(entry);
+            const bool is_directory = entry.is_directory(ec);
+            ec.clear();
+
+            entries.push_back(IndexedPathEntry{
+                normalize_path(entry.path().u8string()),
+                entry.path().filename().u8string(),
+                is_directory,
+                hidden,
+            });
+
+            if (is_directory) {
+                pending_dirs.push_back(entry.path());
+            }
+        }
+    }
+
+    return entries;
+}
+
+bool FileIndexService::load_from_disk(const std::shared_ptr<RootIndex>& state) {
+    const std::string cache_file = cache_file_for_root(state->root);
+    if (cache_file.empty() || !handleExists(cache_file)) {
+        return false;
+    }
+
+    try {
+        const auto parsed = NativeJson::parse(handleReadFile(cache_file));
+        if (parsed.value("version", 0) != 1) {
+            return false;
+        }
+
+        if (parsed.value("root", std::string()) != state->root) {
+            return false;
+        }
+
+        state->rootModifiedMs = parsed.value("rootModifiedMs", -1LL);
+        state->entries.clear();
+        for (const auto& entry : parsed.value("entries", NativeJson::array())) {
+            state->entries.push_back(entry_from_json(entry));
+        }
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+void FileIndexService::save_to_disk(const RootIndex& state) const {
+    const std::string cache_file = cache_file_for_root(state.root);
+    if (cache_file.empty()) {
+        return;
+    }
+
+    NativeJson entries = NativeJson::array();
+    for (const auto& entry : state.entries) {
+        entries.push_back(entry_to_json(entry));
+    }
+
+    NativeJson payload{
+        {"version", 1},
+        {"root", state.root},
+        {"rootModifiedMs", state.rootModifiedMs},
+        {"entries", std::move(entries)},
+    };
+
+    const auto parent = std::filesystem::u8path(cache_file).parent_path();
+    if (!parent.empty()) {
+        std::error_code ec;
+        std::filesystem::create_directories(parent, ec);
+    }
+
+    handleWriteFile(cache_file, payload.dump());
+}
+
+std::string FileIndexService::normalize_root(const std::string& root) const {
+    return normalize_path(root);
+}
+
+std::string FileIndexService::cache_file_for_root(const std::string& root) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (cache_root_.empty()) {
+        return {};
+    }
+
+    const size_t digest = std::hash<std::string>{}(root);
+    return (std::filesystem::u8path(cache_root_) / (std::to_string(digest) + ".json")).u8string();
+}
+
+} // namespace wpp::fs

package/framework/src/FileSystem/file_index_service.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace wpp::fs {
+
+struct IndexedPathEntry {
+    std::string path;
+    std::string name;
+    bool isDir = false;
+    bool isHidden = false;
+};
+
+class FileIndexService {
+public:
+    static FileIndexService& instance();
+
+    void configure_cache_root(const std::string& cache_root);
+
+    std::vector<IndexedPathEntry> get_or_build_root_index(const std::string& root,
+                                                          std::atomic<bool>* cancelled,
+                                                          uint64_t& scanned_entries);
+
+private:
+    struct RootIndex {
+        std::string root;
+        int64_t rootModifiedMs = -1;
+        std::vector<IndexedPathEntry> entries;
+        bool loaded = false;
+        std::mutex mutex;
+    };
+
+    mutable std::mutex mutex_;
+    std::string cache_root_;
+    std::unordered_map<std::string, std::shared_ptr<RootIndex>> indexes_;
+
+    FileIndexService() = default;
+
+    std::shared_ptr<RootIndex> get_state(const std::string& root);
+    std::vector<IndexedPathEntry> build_root_index(const std::string& root,
+                                                   std::atomic<bool>* cancelled,
+                                                   uint64_t& scanned_entries,
+                                                   int64_t& root_modified_ms) const;
+    bool load_from_disk(const std::shared_ptr<RootIndex>& state);
+    void save_to_disk(const RootIndex& state) const;
+    std::string normalize_root(const std::string& root) const;
+    std::string cache_file_for_root(const std::string& root) const;
+};
+
+} // namespace wpp::fs