windowpp 0.1.1

package/framework/src/FileSystem/filesystem_bridge.h

@@ -0,0 +1,243 @@
+// ============================================================================
+//  FileSystem/filesystem_bridge.h
+//  Wires all fs:* IPC calls from the frontend into the native handlers.
+//
+//  Usage — call once per window after creation, inside your window-config
+//  on_message callback or wherever you dispatch webview messages:
+//
+//    #include "FileSystem/filesystem_bridge.h"
+//
+//    // eval_fn executes a JavaScript string in the webview.
+//    // On Win32 you can use:  webview->ExecuteScript(wide(js));
+//    // On macOS / Linux you can use: webview->send_message(js)  — the
+//    //   send_message implementations on those platforms call evaluateJavaScript /
+//    //   webkit_web_view_run_javascript which eval the string directly.
+//    // The simplest one-liner for any platform that has send_message == eval:
+//    //   auto eval = [wv](const std::string& js){ wv->send_message(js); };
+//
+//    wpp::fs::FsBridge bridge([wv](const std::string& js){ wv->send_message(js); });
+//
+//    config.webview.on_message = [&bridge](const std::string& raw){
+//        bridge.dispatch(raw);
+//    };
+//
+// ============================================================================
+
+#pragma once
+
+#include <functional>
+#include <utility>
+#include <stdexcept>
+#include <string>
+
+#include "filesystem_handler.h"
+#include "filesystem_json.h"
+#include "filesystem_search_service.h"
+
+namespace wpp::fs {
+
+// eval_fn(js) — executes `js` as JavaScript in the target webview.
+using EvalFn = std::function<void(const std::string& js)>;
+using DispatchFn = std::function<void(std::function<void()>)>;
+
+class FsBridge {
+public:
+    explicit FsBridge(EvalFn eval_fn,
+                      DispatchFn dispatch_fn = {},
+                      std::string search_cache_root = {})
+        : eval_(std::move(eval_fn)), dispatch_(std::move(dispatch_fn)) {
+        if (!search_cache_root.empty()) {
+            FileSearchService::instance().configure_cache_root(search_cache_root);
+        }
+    }
+
+    // Call this from WebViewConfig::on_message for every incoming message.
+    // Non-fs:* messages are silently ignored so multiple bridges can share
+    // the same on_message callback.
+    void dispatch(const std::string& raw) {
+        std::string id, method;
+        std::vector<JsonValue> params;
+
+        // Parse envelope
+        try {
+            auto env = JsonValue::parse(raw);
+            id     = env["id"].as_string();
+            method = env["method"].as_string();
+            params = env["params"].as_array();
+        } catch (...) {
+            return; // Malformed message — ignore
+        }
+
+        // Only handle fs:* methods
+        if (method.size() < 3 || method.compare(0, 3, "fs:") != 0) return;
+
+        // Helper: send success response — calls window.__response__(id, result)
+        auto reply_ok = [this, &id](const std::string& json_result) {
+            eval_("window.__response__(" + JsonValue::to_js_argument(id) + "," + json_result + ")");
+        };
+
+        // Helper: send error response
+        auto reply_err = [this, &id](const std::string& msg) {
+            eval_(
+                "window.__response__(" + JsonValue::to_js_argument(id) + ",null," +
+                JsonValue::to_js_argument(msg) + ")");
+        };
+
+        auto send_stream_event = [this](const std::string& search_id,
+                                        const std::string& event_name,
+                                        const std::string& json_payload) {
+            std::string script = "window.__wpp_fs_stream__ && window.__wpp_fs_stream__(" +
+                                 JsonValue::to_js_argument(search_id) + "," +
+                                 JsonValue::to_js_argument(event_name) + "," +
+                                 json_payload + ")";
+            if (dispatch_) {
+                dispatch_([eval = eval_, script = std::move(script)]() {
+                    eval(script);
+                });
+            } else {
+                eval_(script);
+            }
+        };
+
+        // ── Dispatch ────────────────────────────────────────────────────────
+        try {
+            if (method == "fs:readFile") {
+                reply_ok(JsonValue::quote(handleReadFile(params[0].as_string())));
+
+            } else if (method == "fs:readBinaryFile") {
+                reply_ok(JsonValue::quote(handleReadBinaryFile(params[0].as_string())));
+
+            } else if (method == "fs:writeFile") {
+                handleWriteFile(params[0].as_string(), params[1].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:writeBinaryFile") {
+                handleWriteBinaryFile(params[0].as_string(), params[1].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:appendFile") {
+                handleAppendFile(params[0].as_string(), params[1].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:copyFile") {
+                handleCopyFile(params[0].as_string(), params[1].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:moveFile") {
+                handleMoveFile(params[0].as_string(), params[1].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:deleteFile") {
+                handleDeleteFile(params[0].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:exists") {
+                reply_ok(handleExists(params[0].as_string()) ? "true" : "false");
+
+            } else if (method == "fs:stat") {
+                reply_ok(statToJson(handleStat(params[0].as_string())));
+
+            } else if (method == "fs:readDir") {
+                reply_ok(dirEntriesToJson(handleReadDir(params[0].as_string())));
+
+            } else if (method == "fs:listRoots") {
+                reply_ok(stringArrayToJson(handleListRoots()));
+
+            } else if (method == "fs:createDir") {
+                bool recursive = params.size() > 1 && params[1].as_bool();
+                handleCreateDir(params[0].as_string(), recursive);
+                reply_ok("null");
+
+            } else if (method == "fs:removeDir") {
+                bool recursive = params.size() > 1 && params[1].as_bool();
+                handleRemoveDir(params[0].as_string(), recursive);
+                reply_ok("null");
+
+            } else if (method == "fs:openPath") {
+                handleOpenPath(params[0].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:revealPath") {
+                handleRevealPath(params[0].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:listApplications") {
+                reply_ok(applicationEntriesToJson(handleListApplications()));
+
+            } else if (method == "fs:launchApplication") {
+                handleLaunchApplication(params[0].as_string());
+                reply_ok("null");
+
+            } else if (method == "fs:searchFiles") {
+                SearchOptions opts;
+                if (params.size() > 1) {
+                    auto& o        = params[1];
+                    opts.pattern       = o.get_string("pattern", "*");
+                    opts.recursive     = o.get_bool("recursive", false);
+                    opts.includeHidden = o.get_bool("includeHidden", false);
+                    opts.includeDirectories = o.get_bool("includeDirectories", false);
+                    opts.maxResults    = o.get_size_t("maxResults", 0);
+                }
+                reply_ok(stringArrayToJson(handleSearchFiles(params[0].as_string(), opts)));
+
+            } else if (method == "fs:searchFilesStreamStart") {
+                std::vector<std::string> roots;
+                if (!params.empty()) {
+                    try {
+                        for (const auto& value : params[0].as_array()) {
+                            roots.push_back(value.as_string());
+                        }
+                    } catch (...) {
+                        roots.push_back(params[0].as_string());
+                    }
+                }
+
+                SearchOptions opts;
+                if (params.size() > 1) {
+                    auto& o = params[1];
+                    opts.pattern = o.get_string("pattern", "*");
+                    opts.recursive = o.get_bool("recursive", false);
+                    opts.includeHidden = o.get_bool("includeHidden", false);
+                    opts.includeDirectories = o.get_bool("includeDirectories", false);
+                    opts.maxResults = o.get_size_t("maxResults", 0);
+                }
+                std::string requested_search_id;
+                if (params.size() > 2) {
+                    requested_search_id = params[2].as_string();
+                }
+
+                if (roots.empty()) {
+                    throw std::runtime_error("No search roots provided");
+                }
+
+                const std::string search_id = FileSearchService::instance().start(
+                    roots,
+                    opts,
+                    [send_stream_event](const std::string& stream_id, std::vector<std::string> batch) {
+                        send_stream_event(stream_id, "batch", stringArrayToJson(batch));
+                    },
+                    [send_stream_event](const std::string& stream_id, const StreamSearchSummary& summary) {
+                        send_stream_event(stream_id, "done", searchSummaryToJson(summary));
+                    },
+                    requested_search_id);
+
+                reply_ok(JsonValue::dump_value(search_id));
+
+            } else if (method == "fs:searchFilesStreamCancel") {
+                FileSearchService::instance().cancel(params[0].as_string());
+                reply_ok("null");
+            }
+
+        } catch (const std::exception& e) {
+            reply_err(e.what());
+        } catch (...) {
+            reply_err("Unknown error in fs bridge");
+        }
+    }
+
+private:
+    EvalFn eval_;
+    DispatchFn dispatch_;
+};
+
+} // namespace wpp::fs

package/framework/src/FileSystem/filesystem_handler.h

@@ -0,0 +1,93 @@
+// ============================================================================
+//  FileSystem/filesystem_handler.h
+//  Shared types and function declarations used by every platform
+//  implementation.  Include this in each platform *.cpp.
+// ============================================================================
+
+#pragma once
+
+#include <functional>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace wpp::fs {
+
+// ─── Shared types (mirror the TypeScript interfaces) ─────────────────────────
+
+struct FileStat {
+    std::string path;
+    std::string name;
+    int64_t     size;        // bytes
+    bool        isDir;
+    bool        isSymlink;
+    int64_t     modifiedMs;  // ms since Unix epoch
+    int64_t     createdMs;   // ms since Unix epoch; -1 if unsupported
+    int         mode;        // POSIX permission bits; -1 on Windows
+};
+
+struct DirEntry {
+    std::string name;
+    std::string path;
+    bool        isDir;
+    bool        isSymlink;
+};
+
+struct ApplicationEntry {
+    std::string id;
+    std::string name;
+    std::string path;
+    std::string launchTarget;
+};
+
+struct SearchOptions {
+    std::string pattern;        // glob, e.g. "*.cpp" — empty → "*"
+    bool        recursive      = false;
+    bool        includeHidden  = false;
+    bool        includeDirectories = false;
+    size_t      maxResults     = 0;  // 0 = unlimited
+};
+
+struct StreamSearchSummary {
+    uint64_t    scannedEntries = 0;
+    uint64_t    matchedEntries = 0;
+    bool        cancelled      = false;
+    bool        truncated      = false;
+    std::string error;
+};
+
+using StreamBatchCallback = std::function<void(const std::string& searchId,
+                                               std::vector<std::string> batch)>;
+using StreamDoneCallback = std::function<void(const std::string& searchId,
+                                              const StreamSearchSummary& summary)>;
+
+// ─── Per-operation handler declarations ─────────────────────────────────────
+//  Each platform provides exactly these functions in its own .cpp files.
+
+// readfile.cpp
+std::string              handleReadFile(const std::string& path);
+std::string              handleReadBinaryFile(const std::string& path); // → Base64
+
+// savefile.cpp
+void handleWriteFile      (const std::string& path, const std::string& text);
+void handleWriteBinaryFile(const std::string& path, const std::string& b64);
+void handleAppendFile     (const std::string& path, const std::string& text);
+void handleCopyFile       (const std::string& src,  const std::string& dest);
+void handleMoveFile       (const std::string& src,  const std::string& dest);
+void handleDeleteFile     (const std::string& path);
+void handleCreateDir      (const std::string& path, bool recursive);
+void handleRemoveDir      (const std::string& path, bool recursive);
+void handleOpenPath       (const std::string& path);
+void handleRevealPath     (const std::string& path);
+std::vector<ApplicationEntry> handleListApplications();
+void handleLaunchApplication(const std::string& target);
+
+// filesearch.cpp
+bool                     handleExists    (const std::string& path);
+FileStat                 handleStat      (const std::string& path);
+std::vector<DirEntry>    handleReadDir   (const std::string& path);
+std::vector<std::string> handleListRoots ();
+std::vector<std::string> handleSearchFiles(const std::string& dir,
+                                           const SearchOptions& opts);
+
+} // namespace wpp::fs

package/framework/src/FileSystem/filesystem_json.h

@@ -0,0 +1,241 @@
+// ============================================================================
+//  FileSystem/filesystem_json.h
+//  nlohmann/json-backed helpers for the native bridge layer.
+// ============================================================================
+
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "filesystem_handler.h"
+
+namespace wpp::fs {
+
+class JsonValue {
+public:
+    using NativeJson = nlohmann::json;
+
+    JsonValue() = default;
+    explicit JsonValue(NativeJson value) : value_(std::move(value)) {}
+
+    static JsonValue parse(const std::string& s) {
+        return JsonValue(NativeJson::parse(s));
+    }
+
+    std::string as_string() const {
+        if (value_.is_string()) {
+            return value_.get<std::string>();
+        }
+        throw std::runtime_error("JsonValue: not a string");
+    }
+
+    bool as_bool() const {
+        if (value_.is_boolean()) {
+            return value_.get<bool>();
+        }
+        if (value_.is_number_integer() || value_.is_number_unsigned()) {
+            return value_.get<int64_t>() != 0;
+        }
+        throw std::runtime_error("JsonValue: not a bool");
+    }
+
+    int64_t as_int() const {
+        if (value_.is_number_integer() || value_.is_number_unsigned()) {
+            return value_.get<int64_t>();
+        }
+        if (value_.is_number_float()) {
+            return static_cast<int64_t>(value_.get<double>());
+        }
+        throw std::runtime_error("JsonValue: not a number");
+    }
+
+    double as_double() const {
+        if (value_.is_number_float()) {
+            return value_.get<double>();
+        }
+        if (value_.is_number_integer() || value_.is_number_unsigned()) {
+            return static_cast<double>(value_.get<int64_t>());
+        }
+        throw std::runtime_error("JsonValue: not a number");
+    }
+
+    std::vector<JsonValue> as_array() const {
+        if (value_.is_null()) {
+            return {};
+        }
+        if (!value_.is_array()) {
+            throw std::runtime_error("JsonValue: not an array");
+        }
+
+        std::vector<JsonValue> values;
+        values.reserve(value_.size());
+        for (const auto& item : value_) {
+            values.emplace_back(item);
+        }
+        return values;
+    }
+
+    JsonValue operator[](const std::string& key) const {
+        if (value_.is_object()) {
+            auto it = value_.find(key);
+            if (it != value_.end()) {
+                return JsonValue(*it);
+            }
+        }
+        return JsonValue();
+    }
+
+    JsonValue operator[](size_t idx) const {
+        if (!value_.is_array() || idx >= value_.size()) {
+            throw std::out_of_range("JsonValue: array index out of range");
+        }
+        return JsonValue(value_.at(idx));
+    }
+
+    std::string get_string(const std::string& key, const std::string& def) const {
+        if (!value_.is_object()) {
+            return def;
+        }
+        auto it = value_.find(key);
+        if (it != value_.end() && it->is_string()) {
+            return it->get<std::string>();
+        }
+        return def;
+    }
+
+    bool get_bool(const std::string& key, bool def) const {
+        if (!value_.is_object()) {
+            return def;
+        }
+        auto it = value_.find(key);
+        if (it != value_.end() && it->is_boolean()) {
+            return it->get<bool>();
+        }
+        return def;
+    }
+
+    int64_t get_int(const std::string& key, int64_t def) const {
+        if (!value_.is_object()) {
+            return def;
+        }
+        auto it = value_.find(key);
+        if (it == value_.end()) {
+            return def;
+        }
+        if (it->is_number_integer() || it->is_number_unsigned()) {
+            return it->get<int64_t>();
+        }
+        if (it->is_number_float()) {
+            return static_cast<int64_t>(it->get<double>());
+        }
+        return def;
+    }
+
+    size_t get_size_t(const std::string& key, size_t def) const {
+        const int64_t value = get_int(key, static_cast<int64_t>(def));
+        if (value < 0) {
+            return def;
+        }
+        return static_cast<size_t>(value);
+    }
+
+    static std::string quote(const std::string& s) {
+        return NativeJson(s).dump();
+    }
+
+    static std::string to_js_argument(const std::string& value) {
+        return NativeJson(value).dump();
+    }
+
+    static std::string to_js_argument(const char* value) {
+        return NativeJson(value).dump();
+    }
+
+    static std::string to_js_argument(bool value) {
+        return NativeJson(value).dump();
+    }
+
+    static std::string to_js_argument(std::nullptr_t) {
+        return "null";
+    }
+
+    template <typename T>
+    static std::string to_js_argument(const T& value) {
+        return NativeJson(value).dump();
+    }
+
+    template <typename T>
+    static std::string dump_value(const T& value) {
+        return NativeJson(value).dump();
+    }
+
+private:
+    NativeJson value_ = nullptr;
+};
+
+template <typename Entry>
+inline std::string dirEntriesToJson(const std::vector<Entry>& entries,
+                                    bool Entry::*is_dir,
+                                    bool Entry::*is_symlink) {
+    auto json = nlohmann::json::array();
+    for (const auto& entry : entries) {
+        json.push_back({
+            {"name", entry.name},
+            {"path", entry.path},
+            {"isDir", entry.*is_dir},
+            {"isSymlink", entry.*is_symlink},
+        });
+    }
+    return json.dump();
+}
+
+inline std::string dirEntriesToJson(const std::vector<DirEntry>& entries) {
+    return dirEntriesToJson(entries, &DirEntry::isDir, &DirEntry::isSymlink);
+}
+
+inline std::string statToJson(const FileStat& stat) {
+    return nlohmann::json({
+        {"path", stat.path},
+        {"name", stat.name},
+        {"size", stat.size},
+        {"isDir", stat.isDir},
+        {"isSymlink", stat.isSymlink},
+        {"modifiedMs", stat.modifiedMs},
+        {"createdMs", stat.createdMs},
+        {"mode", stat.mode},
+    }).dump();
+}
+
+inline std::string applicationEntriesToJson(const std::vector<ApplicationEntry>& entries) {
+    auto json = nlohmann::json::array();
+    for (const auto& entry : entries) {
+        json.push_back({
+            {"id", entry.id},
+            {"name", entry.name},
+            {"path", entry.path},
+            {"launchTarget", entry.launchTarget},
+        });
+    }
+    return json.dump();
+}
+
+inline std::string stringArrayToJson(const std::vector<std::string>& values) {
+    return nlohmann::json(values).dump();
+}
+
+inline std::string searchSummaryToJson(const StreamSearchSummary& summary) {
+    return nlohmann::json({
+        {"scannedEntries", summary.scannedEntries},
+        {"matchedEntries", summary.matchedEntries},
+        {"cancelled", summary.cancelled},
+        {"truncated", summary.truncated},
+        {"error", summary.error},
+    }).dump();
+}
+
+} // namespace wpp::fs