fix: proper opening of the mac app on bookmarklet

src/main/main.ts

@@ -19,6 +19,8 @@ let activePreviewPostId: string | null = null;
 let appInitialized = false;
 let blogmarkQueue: string[] = [];
 let blogmarkQueueProcessing = false;
+let pendingBlogmarkCreatedEvents: unknown[] = [];
+let rendererReady = false;
 const PREVIEW_SERVER_PORT = 4123;
 const BLOG_PREVIEW_POST_MENU_ID = APP_MENU_ITEM_IDS.previewPost;
 const BLOGMARK_PROTOCOL = 'bds';
@@ -201,6 +203,7 @@ protocol.registerSchemesAsPrivileged([
 ]);
 
 function createWindow(): void {
+  rendererReady = false;
   const isMac = process.platform === 'darwin';
   const initialWindowState = resolveInitialWindowState();
   mainWindow = new BrowserWindow({
@@ -376,8 +379,22 @@ async function processBlogmarkDeepLink(rawDeepLink: string): Promise<void> {
     categories: preferredCategory ? [preferredCategory] : [],
   });
 
-  if (mainWindow && !mainWindow.isDestroyed()) {
+  if (mainWindow && !mainWindow.isDestroyed() && rendererReady) {
     mainWindow.webContents.send('blogmark:created', createdPost);
+  } else {
+    pendingBlogmarkCreatedEvents.push(createdPost);
+  }
+}
+
+function flushPendingBlogmarkCreatedEvents(): void {
+  if (!rendererReady || !mainWindow || mainWindow.isDestroyed() || pendingBlogmarkCreatedEvents.length === 0) {
+    return;
+  }
+
+  const queuedEvents = pendingBlogmarkCreatedEvents;
+  pendingBlogmarkCreatedEvents = [];
+  for (const payload of queuedEvents) {
+    mainWindow.webContents.send('blogmark:created', payload);
   }
 }
 
@@ -708,6 +725,12 @@ async function initialize(): Promise<void> {
     activePreviewPostId = typeof postId === 'string' && postId.length > 0 ? postId : null;
     setPreviewPostMenuEnabled(Boolean(activePreviewPostId));
   });
+
+  ipcMain.handle('app:rendererReady', async () => {
+    rendererReady = true;
+    flushPendingBlogmarkCreatedEvents();
+    return true;
+  });
   
   // Initialize and register chat handlers
   initializeChatHandlers(() => mainWindow);

src/main/preload.ts

@@ -147,6 +147,7 @@ export const electronAPI: ElectronAPI = {
     readProjectMetadata: (folderPath: string) => ipcRenderer.invoke('app:readProjectMetadata', folderPath),
     getBlogmarkBookmarklet: () => ipcRenderer.invoke('app:getBlogmarkBookmarklet'),
     copyToClipboard: (text: string) => ipcRenderer.invoke('app:copyToClipboard', text),
+    notifyRendererReady: () => ipcRenderer.invoke('app:rendererReady'),
     setPreviewPostTarget: (postId: string | null) => ipcRenderer.invoke('app:setPreviewPostTarget', postId),
     triggerMenuAction: (action: string) => ipcRenderer.invoke('app:triggerMenuAction', action),
   },

src/main/shared/electronApi.ts

@@ -567,6 +567,7 @@ export interface ElectronAPI {
     readProjectMetadata: (folderPath: string) => Promise<{ name?: string; description?: string; publicUrl?: string; mainLanguage?: string } | null>;
     getBlogmarkBookmarklet: () => Promise<string>;
     copyToClipboard: (text: string) => Promise<boolean>;
+    notifyRendererReady: () => Promise<boolean>;
     setPreviewPostTarget: (postId: string | null) => Promise<void>;
     triggerMenuAction: (action: string) => Promise<void>;
   };

src/renderer/App.tsx

@@ -1,10 +1,12 @@
-import React, { useEffect } from 'react';
+import React, { useEffect, useRef } from 'react';
 import { ActivityBar, Sidebar, Editor, StatusBar, Panel, TabBar, ToastContainer, showToast, ResizablePanel, WindowTitleBar } from './components';
 import { useAppStore, PostData, MediaData, TaskProgress } from './store';
 import { loadTabsForProject, saveTabsForProject } from './utils';
-import { openEntityTab, openSingletonToolTab } from './navigation/tabPolicy';
+import { openSingletonToolTab } from './navigation/tabPolicy';
 import { persistSiteValidationReport } from './navigation/siteValidationPersistence';
 import { executeActivityClick } from './navigation/activityExecution';
+import { handleBlogmarkCreatedEvent } from './navigation/blogmarkHandling';
+import { createDeferredEventGate } from './navigation/deferredEventGate';
 import { createAndFocusPost } from './navigation/postCreation';
 import { ensureRendererPicoThemeStylesheet, getRendererPicoTheme } from './utils/picoTheme';
 import { useI18n } from './i18n';
@@ -33,6 +35,25 @@ const App: React.FC = () => {
     openTab,
     restoreTabState,
   } = useAppStore();
+  const blogmarkEventGateRef = useRef(createDeferredEventGate<PostData>());
+
+  const processBlogmarkCreated = (created: PostData) => {
+    addPost(created);
+    const state = useAppStore.getState();
+    handleBlogmarkCreatedEvent(
+      {
+        activeView: state.activeView,
+        sidebarVisible: state.sidebarVisible,
+      },
+      created,
+      {
+        setActiveView: state.setActiveView,
+        toggleSidebar: state.toggleSidebar,
+        setSelectedPost: state.setSelectedPost,
+        openTab: state.openTab,
+      },
+    );
+  };
 
   // Load initial data
   useEffect(() => {
@@ -80,6 +101,9 @@ const App: React.FC = () => {
         console.error('Failed to load initial data:', error);
       } finally {
         setLoading(false);
+        setTimeout(() => {
+          blogmarkEventGateRef.current.markReady(processBlogmarkCreated);
+        }, 0);
       }
     };
 
@@ -216,28 +240,12 @@ const App: React.FC = () => {
 
     unsubscribers.push(
       window.electronAPI?.on('blogmark:created', (post: unknown) => {
-        const created = post as { id?: string } | null;
+        const created = post as PostData;
         if (!created?.id) {
           return;
         }
 
-        const state = useAppStore.getState();
-        executeActivityClick(
-          {
-            activeView: state.activeView,
-            sidebarVisible: state.sidebarVisible,
-            tabs: state.tabs,
-            activeTabId: state.activeTabId,
-          },
-          'posts',
-          {
-            setActiveView: state.setActiveView,
-            toggleSidebar: state.toggleSidebar,
-          },
-        );
-
-        state.setSelectedPost(created.id);
-        openEntityTab(state.openTab, 'post', created.id, 'preview');
+        blogmarkEventGateRef.current.push(created, processBlogmarkCreated);
       }) || (() => {})
     );
 
@@ -475,6 +483,10 @@ const App: React.FC = () => {
       }) || (() => {})
     );
 
+    void window.electronAPI?.app.notifyRendererReady?.().catch((error) => {
+      console.error('Failed to notify renderer readiness:', error);
+    });
+
     return () => {
       unsubscribers.forEach(unsub => unsub());
     };

src/renderer/navigation/blogmarkHandling.ts

@@ -0,0 +1,40 @@
+import { openEntityTab } from './tabPolicy';
+import type { SidebarView } from './sidebarViewRegistry';
+
+interface BlogmarkStateSnapshot {
+  activeView: SidebarView;
+  sidebarVisible: boolean;
+}
+
+interface BlogmarkCreatedPayload {
+  id?: string;
+}
+
+interface BlogmarkHandlers {
+  setActiveView: (view: SidebarView) => void;
+  toggleSidebar: () => void;
+  setSelectedPost: (id: string) => void;
+  openTab: (tab: { type: 'post'; id: string; isTransient: boolean }) => void;
+}
+
+export function handleBlogmarkCreatedEvent(
+  snapshot: BlogmarkStateSnapshot,
+  payload: BlogmarkCreatedPayload | null | undefined,
+  handlers: BlogmarkHandlers,
+): void {
+  const postId = typeof payload?.id === 'string' ? payload.id : '';
+  if (!postId) {
+    return;
+  }
+
+  if (snapshot.activeView !== 'posts') {
+    handlers.setActiveView('posts');
+  }
+
+  if (!snapshot.sidebarVisible) {
+    handlers.toggleSidebar();
+  }
+
+  handlers.setSelectedPost(postId);
+  openEntityTab(handlers.openTab, 'post', postId, 'preview');
+}

src/renderer/navigation/deferredEventGate.ts

@@ -0,0 +1,35 @@
+export interface DeferredEventGate<T> {
+  push: (event: T, consume: (event: T) => void) => void;
+  markReady: (consume: (event: T) => void) => void;
+  isReady: () => boolean;
+}
+
+export function createDeferredEventGate<T>(): DeferredEventGate<T> {
+  let ready = false;
+  let queue: T[] = [];
+
+  return {
+    push: (event, consume) => {
+      if (ready) {
+        consume(event);
+        return;
+      }
+
+      queue.push(event);
+    },
+    markReady: (consume) => {
+      if (ready) {
+        return;
+      }
+
+      ready = true;
+      const queuedEvents = queue;
+      queue = [];
+
+      for (const event of queuedEvents) {
+        consume(event);
+      }
+    },
+    isReady: () => ready,
+  };
+}