sparkbun 0.2.5 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sparkbun",
-	"version": "0.2.5",
+	"version": "0.2.6",
 	"description": "Build fast, lightweight, cross-platform desktop apps with TypeScript and Bun.",
 	"license": "MIT",
 	"author": "SparkBun Contributors",

package/src/bun/core/BrowserWindow.ts

@@ -29,6 +29,12 @@ export type WindowOptionsType<T = undefined> = {
 	preload: string | null;
 	viewsRoot: string | null;
 	renderer: "native" | "cef";
+	// Storage partition for the webview's cookies/localStorage/cache/IndexedDB.
+	// A value starting with "persist:" is written to disk; any other non-empty
+	// value is ephemeral — in-memory only, gone when the process exits — which
+	// is what incognito-style/diskless sessions want. Omitted/null falls back to
+	// "persist:default" (on-disk).
+	partition?: string;
 	rpc?: T;
 	styleMask?: {};
 	// titleBarStyle options:
@@ -105,6 +111,7 @@ export class BrowserWindow<T extends RPCWithTransport = AnyRPC> {
 	html: string | null = null;
 	preload: string | null = null;
 	viewsRoot: string | null = null;
+	partition: string | null = null;
 	renderer: "native" | "cef" = "native";
 	transparent: boolean = false;
 	passthrough: boolean = false;
@@ -139,6 +146,7 @@ export class BrowserWindow<T extends RPCWithTransport = AnyRPC> {
 		this.html = options.html || null;
 		this.preload = options.preload || null;
 		this.viewsRoot = options.viewsRoot || null;
+		this.partition = options.partition ?? null;
 		this.renderer = options.renderer || defaultOptions.renderer;
 		this.transparent = options.transparent ?? false;
 		this.passthrough = options.passthrough ?? false;
@@ -223,6 +231,7 @@ export class BrowserWindow<T extends RPCWithTransport = AnyRPC> {
 			html: this.html,
 			preload: this.preload,
 			viewsRoot: this.viewsRoot,
+			partition: this.partition,
 			// frame: this.frame,
 			renderer: this.renderer,
 			frame: {

package/src/native/linux/nativeWrapper.cpp

@@ -11208,55 +11208,66 @@ static std::map<std::string, WebKitWebsiteDataManager*> g_partitionDataManagers;
 static WebKitWebsiteDataManager* getDataManagerForPartition(const char* partitionIdentifier) {
     std::string partition = partitionIdentifier ? partitionIdentifier : "";
 
+    // Prefer the data manager owned by the live webview context for this
+    // partition. getContextForPartition() builds each webview's context around
+    // its own WebKitWebsiteDataManager; creating a separate manager here — even
+    // one pointing at the same on-disk directory — clears a different instance
+    // and leaves the running webview's storage untouched, which made
+    // clearStorageData()/cookies.clear() appear to do nothing. Resolving through
+    // the context keeps clears on the exact store the page reads and writes.
+    if (partition.empty()) {
+        WebKitWebContext* context = webkit_web_context_get_default();
+        return webkit_web_context_get_website_data_manager(context);
+    }
+
+    auto ctxIt = g_partitionContexts.find(partition);
+    if (ctxIt != g_partitionContexts.end() && ctxIt->second) {
+        return webkit_web_context_get_website_data_manager(ctxIt->second);
+    }
+
+    // No live context for this partition yet — fall back to a standalone manager
+    // (cached) so cookie/storage APIs still work before a webview is created.
     auto it = g_partitionDataManagers.find(partition);
     if (it != g_partitionDataManagers.end()) {
         return it->second;
     }
 
     WebKitWebsiteDataManager* dataManager = nullptr;
+    bool isPersistent = partition.substr(0, 8) == "persist:";
 
-    if (partition.empty()) {
-        // Default: use default context's data manager
-        WebKitWebContext* context = webkit_web_context_get_default();
-        dataManager = webkit_web_context_get_website_data_manager(context);
-    } else {
-        bool isPersistent = partition.substr(0, 8) == "persist:";
+    if (isPersistent) {
+        std::string partitionName = partition.substr(8);
 
-        if (isPersistent) {
-            std::string partitionName = partition.substr(8);
+        // Build paths with identifier/channel structure (consistent with CLI and updater)
+        char* home = getenv("HOME");
+        std::string homeStr = home ? std::string(home) : "/tmp";
+        std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
+        std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
 
-            // Build paths with identifier/channel structure (consistent with CLI and updater)
-            char* home = getenv("HOME");
-            std::string homeStr = home ? std::string(home) : "/tmp";
-            std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
-            std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
+        g_mkdir_with_parents(dataPath.c_str(), 0755);
+        g_mkdir_with_parents(cachePath.c_str(), 0755);
 
-            g_mkdir_with_parents(dataPath.c_str(), 0755);
-            g_mkdir_with_parents(cachePath.c_str(), 0755);
+        dataManager = webkit_website_data_manager_new(
+            "base-data-directory", dataPath.c_str(),
+            "base-cache-directory", cachePath.c_str(),
+            NULL
+        );
 
-            dataManager = webkit_website_data_manager_new(
-                "base-data-directory", dataPath.c_str(),
-                "base-cache-directory", cachePath.c_str(),
-                NULL
+        // Enable persistent cookie storage (SQLite-backed)
+        WebKitCookieManager* cookieManager = webkit_website_data_manager_get_cookie_manager(dataManager);
+        if (cookieManager) {
+            std::string cookiePath = dataPath + "/cookies.sqlite";
+            webkit_cookie_manager_set_persistent_storage(
+                cookieManager,
+                cookiePath.c_str(),
+                WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE
             );
-
-            // Enable persistent cookie storage (SQLite-backed)
-            WebKitCookieManager* cookieManager = webkit_website_data_manager_get_cookie_manager(dataManager);
-            if (cookieManager) {
-                std::string cookiePath = dataPath + "/cookies.sqlite";
-                webkit_cookie_manager_set_persistent_storage(
-                    cookieManager,
-                    cookiePath.c_str(),
-                    WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE
-                );
-            }
-        } else {
-            dataManager = webkit_website_data_manager_new_ephemeral();
         }
-
-        g_partitionDataManagers[partition] = dataManager;
+    } else {
+        dataManager = webkit_website_data_manager_new_ephemeral();
     }
 
+    g_partitionDataManagers[partition] = dataManager;
     return dataManager;
 }
 
@@ -11651,11 +11662,44 @@ SPARKBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdentifier, const
 // Clear all cookies (WebKit2GTK)
 // Clear all cookies (WebKit2GTK) - STUB implementation to prevent crashes
 SPARKBUN_EXPORT void sessionClearCookies(const char* partitionIdentifier) {
-    // Stub implementation: do nothing and return immediately
-    // This prevents crashes from complex WebKit async patterns during tests
-    // while maintaining API compatibility
-    (void)partitionIdentifier; // Suppress unused parameter warning
-    return;
+    // Copy argument before dispatching to main thread
+    std::string partitionStr = partitionIdentifier ? partitionIdentifier : "";
+
+    // Clear cookies via the website data manager rather than per-cookie
+    // get/delete. This reuses the same dispatch + GMainLoop pattern as
+    // sessionClearStorageData (which is stable) instead of the async cookie
+    // enumeration that previously crashed and led to this being stubbed out.
+    dispatch_sync_main_void([partitionStr]() {
+        WebKitWebsiteDataManager* dataManager = getDataManagerForPartition(partitionStr.c_str());
+        if (!dataManager) {
+            return;
+        }
+
+        GMainLoop* loop = g_main_loop_new(NULL, FALSE);
+
+        webkit_website_data_manager_clear(dataManager, WEBKIT_WEBSITE_DATA_COOKIES, 0, nullptr,
+            [](GObject* source, GAsyncResult* result, gpointer user_data) {
+                GMainLoop* loop = static_cast<GMainLoop*>(user_data);
+                GError* error = nullptr;
+                webkit_website_data_manager_clear_finish(WEBKIT_WEBSITE_DATA_MANAGER(source), result, &error);
+                if (error) {
+                    g_error_free(error);
+                }
+                g_main_loop_quit(loop);
+            }, loop);
+
+        GSource* timeout = g_timeout_source_new(10000);
+        g_source_set_callback(timeout, [](gpointer data) -> gboolean {
+            g_main_loop_quit(static_cast<GMainLoop*>(data));
+            return G_SOURCE_REMOVE;
+        }, loop, nullptr);
+        g_source_attach(timeout, g_main_loop_get_context(loop));
+
+        g_main_loop_run(loop);
+        g_source_destroy(timeout);
+        g_source_unref(timeout);
+        g_main_loop_unref(loop);
+    });
 }
 
 // Clear storage data (WebKit2GTK)