fix: mini window on mac

features/stepDefinitions/wiki.ts

@@ -318,18 +318,10 @@ async function clearGitTestData() {
  * @param description - Human-readable description of what we're waiting for (comes first for readability)
  * @param marker - The test-id marker to look for in logs
  *
- * This searches in both TidGi- and wiki- log files with appropriate timeouts
+ * This searches in TidGi- log files by default
  */
 Then('I wait for {string} log marker {string}', async function(this: ApplicationWorld, description: string, marker: string) {
-  // Determine timeout and log prefix based on operation type
-  const isGitOperation = marker.includes('git-') || marker.includes('revert');
-  const isWikiRestart = marker.includes('MAIN_WIKI_RESTARTED');
-  const isWorkspaceOperation = marker.includes('WORKSPACE_');
-  const isTidgiMiniWindowOperation = marker.includes('TIDGI_MINI_WINDOW');
-  const isRevert = marker.includes('revert');
-  const timeout = isRevert ? 30000 : (isWikiRestart ? 25000 : (isGitOperation ? 25000 : 15000));
-  const logPrefix = (isGitOperation || isWikiRestart || isWorkspaceOperation || isTidgiMiniWindowOperation) ? 'TidGi-' : undefined;
-  await waitForLogMarker(marker, `Log marker "${marker}" not found. Expected: ${description}`, timeout, logPrefix);
+  await waitForLogMarker(marker, `Log marker "${marker}" not found. Expected: ${description}`, 10000, 'TidGi-');
 });
 
 /**
@@ -341,6 +333,34 @@ Then('I wait for SSE and watch-fs to be ready', async function(this: Application
   await waitForLogMarker('[test-id-SSE_READY]', 'SSE backend did not become ready within timeout', 20000);
 });
 
+/**
+ * Remove log lines containing specific text from all TidGi- log files.
+ * This is useful when you need to wait for a log marker that may have appeared earlier in the scenario,
+ * and you want to ensure you're waiting for a new occurrence of that marker.
+ * @param marker - The text pattern to remove from log files
+ */
+When('I clear log lines containing {string}', async function(this: ApplicationWorld, marker: string) {
+  const logDirectory = path.join(process.cwd(), 'userData-test', 'logs');
+  if (!fs.existsSync(logDirectory)) return;
+
+  const today = new Date().toISOString().split('T')[0];
+  const logFiles = fs.readdirSync(logDirectory).filter(f => 
+    (f.startsWith('TidGi-') || f === `TidGi-${today}.log`) && f.endsWith('.log')
+  );
+
+  for (const logFile of logFiles) {
+    const logPath = path.join(logDirectory, logFile);
+    try {
+      const content = fs.readFileSync(logPath, 'utf-8');
+      const lines = content.split('\n');
+      const filteredLines = lines.filter(line => !line.includes(marker));
+      fs.writeFileSync(logPath, filteredLines.join('\n'), 'utf-8');
+    } catch {
+      // Ignore errors if file is locked or doesn't exist
+    }
+  }
+});
+
 /**
  * Convenience steps for waiting for tiddler operations detected by watch-fs
  * These use dynamic markers that include the tiddler name

features/tidgiMiniWindowWorkspace.feature

@@ -10,6 +10,14 @@ Feature: TidGi Mini Window Workspace Switching
     Then I launch the TidGi application
     And I wait for the page to load completely
     Then I switch to "main" window
+    # Wait for git init to complete (early sync point, ~1s after app start)
+    Then I wait for "git init complete" log marker "[test-id-git-init-complete]"
+    # Wait for wiki worker to start (~3s after git-init-complete)
+    Then I wait for "wiki worker started" log marker "[test-id-WIKI_WORKER_STARTED]"
+    # Wait for view to finish loading (~4s after wiki worker started)
+    Then I wait for "view load url done" log marker "[test-id-VIEW_LOAD_URL_DONE]"
+    # Wait for all workspace views to be initialized
+    Then I wait for "all workspace views initialized" log marker "[test-id-ALL_WORKSPACE_VIEW_INITIALIZED]"
 
   Scenario: TidGi mini window syncs with main window switching to agent workspace
     # Switch main window to agent workspace
@@ -50,12 +58,17 @@ Feature: TidGi Mini Window Workspace Switching
     And I wait for 0.2 seconds
     Then I switch to "preferences" window
     When I press the key combination "CommandOrControl+Shift+M"
+    And I wait for 1 seconds
     And I confirm the "tidgiMiniWindow" window not visible
     # Get the first wiki workspace ID and select it
     And I select "wiki" from MUI Select with test id "tidgi-mini-window-fixed-workspace-select"
     And I wait for 0.2 seconds
+    # Clear previous occurrences of the log marker before waiting for a new one
+    And I clear log lines containing "[test-id-TIDGI_MINI_WINDOW_SHOWN]"
     # Open tidgi mini window again - should show wiki workspace with browser view
     When I press the key combination "CommandOrControl+Shift+M"
+    # Wait for the view to be loaded and window to be shown
+    Then I wait for "tidgi mini window shown" log marker "[test-id-TIDGI_MINI_WINDOW_SHOWN]"
     And I confirm the "tidgiMiniWindow" window visible
     And I confirm the "tidgiMiniWindow" window browser view is positioned within visible window bounds
     Then I switch to "tidgiMiniWindow" window

src/main.ts

@@ -145,6 +145,7 @@ const commonInit = async (): Promise<void> => {
   await workspaceService.initializeDefaultPageWorkspaces();
   // perform wiki startup and git sync for each workspace
   await workspaceViewService.initializeAllWorkspaceView();
+  logger.info('[test-id-ALL_WORKSPACE_VIEW_INITIALIZED] All workspace views initialized');
 
   // Process any pending deep link after workspaces are initialized
   await deepLinkService.processPendingDeepLink();

src/services/view/index.ts

@@ -361,6 +361,7 @@ export class View implements IViewService {
       logger.debug('await loadURL done', {
         function: 'loadUrlForView',
       });
+      logger.info('[test-id-VIEW_LOAD_URL_DONE] View loadURL completed', { workspaceId: workspace.id, urlToLoad });
       const unregisterContextMenu = await this.menuService.initContextMenuForWindowWebContents(view.webContents);
       view.webContents.on('destroyed', () => {
         unregisterContextMenu();

src/services/wiki/index.ts

@@ -692,8 +692,9 @@ export class Wiki implements IWikiService {
           function: 'startWiki',
         });
         await this.startWiki(id, userName);
-        logger.debug('done', {
+        logger.info('[test-id-WIKI_WORKER_STARTED] Wiki worker started successfully', {
           function: 'startWiki',
+          workspaceId: id,
         });
       } catch (error) {
         logger.warn('startWiki failed', { function: 'startWiki', error });

src/services/windows/handleAttachToTidgiMiniWindow.ts

@@ -96,15 +96,16 @@ export async function handleAttachToTidgiMiniWindow(
       });
     }
   });
-  tidgiMiniWindow.on('hide', async () => {
-    // on mac, calling `tidgiMiniWindow.app.hide()` with main window open will bring background main window up, which we don't want. We want to bring previous other app up. So close main window first.
-    if (isMac) {
-      const mainWindow = windowService.get(WindowNames.main);
-      if (mainWindow?.isVisible() === true) {
-        await windowService.hide(WindowNames.main);
-      }
-    }
-  });
+  // This will close main and preference window when mini window closed, thus make it impossible to test keyboard shortcut to open mini window again, make e2e test fail on mac. So commented out.
+  // tidgiMiniWindow.on('hide', async () => {
+  //   // on mac, calling `tidgiMiniWindow.app.hide()` with main window open will bring background main window up, which we don't want. We want to bring previous other app up. So close main window first.
+  //   if (isMac) {
+  //     const mainWindow = windowService.get(WindowNames.main);
+  //     if (mainWindow?.isVisible() === true) {
+  //       await windowService.hide(WindowNames.main);
+  //     }
+  //   }
+  // });
   // https://github.com/maxogden/menubar/issues/120
   tidgiMiniWindow.on('after-hide', () => {
     if (isMac) {

src/services/windows/index.ts

@@ -414,6 +414,7 @@ export class Window implements IWindowService {
 
           // Use menuBar.showWindow() instead of direct window.show() for proper tidgi mini window behavior
           void this.tidgiMiniWindowMenubar.showWindow();
+          logger.info('[test-id-TIDGI_MINI_WINDOW_SHOWN] TidGi mini window showWindow called', { function: 'openTidgiMiniWindow' });
         }
         return;
       }