Fix/launcher focus bugs (#457)

* fix(launcher): focus search bar from Settings + show weekday in calculator

When a sibling window from the same app (Settings, Extension Store, etc.)
was the key window, opening the launcher panel via the hotkey left the
search input unfocused — mainWindow.focus() alone can't take key status
from a regular activated window in the same app. Detect that case and
activate the launcher with app.focus({ steal: true }); this only steals
from our own window so selection-capture behavior is unaffected.

Calculator date results now include the day of the week. SoulverCore's
stringValue strips the year and never includes a weekday (e.g.
"24 may 2026" → "May 24"), so the Swift bridge now returns the underlying
Foundation.Date as an iso field and the renderer reformats date answers
with toLocaleDateString({ weekday, day, month, year }) → "Sunday, 24 May 2026".

* fix(launcher): keep success toast visible for full 3s after no-view command

The inline toast raised by showHUD inside the launcher footer (e.g.
"Your Mac is now caffeinated" after running Caffeinate) was disappearing
almost immediately. Root cause: NoViewRunner unmounts the ExtensionView
~600 ms after the command finishes, and ExtensionView's unmount cleanup
called Toast.dismissActive() unconditionally — overriding the toast's
own 3000 ms auto-hide. dismissActive now only hides Animated (loading)
toasts, which have no timer and must be cleaned up so they don't
linger; Success/Failure toasts keep their auto-hide timer.

Also fix a related race in the bottom-left memoryStatusWindow badge: the
200 ms fade-out finalization setTimeout in hideMemoryStatusBar wasn't
tracked, so a fresh showMemoryStatusBar arriving during the fade
couldn't cancel it — the orphan win.hide() then yanked the new badge
off-screen. The finalize timeout is now stored, cleared by subsequent
hide() calls, and gated on the current renderSeq so a show during the
fade reliably keeps the window visible.

Author: shobhit99

src/main/main.ts

@@ -2450,6 +2450,7 @@ let promptRendererReady = false;
 let pendingPromptWindowShown: { mode: string; selectedTextSnapshot: string } | null = null;
 let memoryStatusWindow: InstanceType<typeof BrowserWindow> | null = null;
 let memoryStatusHideTimer: NodeJS.Timeout | null = null;
+let memoryStatusFadeFinalizeTimer: NodeJS.Timeout | null = null;
 let memoryStatusRenderSeq = 0;
 let memoryStatusHideTimerSeq = 0;
 let confettiWindow: InstanceType<typeof BrowserWindow> | null = null;
@@ -2651,7 +2652,16 @@ function hideMemoryStatusBar(): void {
       win.webContents.executeJavaScript('window.__scFadeOut && window.__scFadeOut()').catch(() => {});
     }
   } catch {}
-  setTimeout(() => {
+  // Track the fade-out finalization timeout so a fresh showMemoryStatusBar
+  // arriving during the 200 ms fade can cancel it. Without this, the
+  // win.hide() below fires unconditionally and yanks the freshly-shown
+  // badge off-screen ~200 ms after the new show — making rapid
+  // processing → success transitions appear to flash for only a moment.
+  if (memoryStatusFadeFinalizeTimer) clearTimeout(memoryStatusFadeFinalizeTimer);
+  const finalizeSeq = memoryStatusRenderSeq;
+  memoryStatusFadeFinalizeTimer = setTimeout(() => {
+    memoryStatusFadeFinalizeTimer = null;
+    if (finalizeSeq !== memoryStatusRenderSeq) return;
     if (!win.isDestroyed()) {
       try { win.hide(); } catch {}
     }
@@ -8885,7 +8895,28 @@ async function showWindow(options?: { systemCommandId?: string }): Promise<void>
     } catch {}
   }
 
-  const shouldActivateLauncherWindow = process.platform !== 'darwin' || launcherMode === 'onboarding';
+  // When a sibling window from our own app (Settings, Extension Store, Notes,
+  // Canvas, etc.) is currently the key window, the launcher panel's
+  // mainWindow.focus() alone is not enough to take key status away from a
+  // regular activated window in the same app — so the search input never
+  // actually receives keystrokes. Detect that case and fully activate the
+  // launcher window via app.focus({ steal: true }). This only steals focus
+  // from our own sibling window, not from another app, so the selection
+  // snapshot behavior (which only matters when another app is frontmost)
+  // is unaffected.
+  const ownAppSiblingWindowFocused =
+    process.platform === 'darwin' &&
+    BrowserWindow.getAllWindows().some(
+      (win: InstanceType<typeof BrowserWindow>) =>
+        win !== mainWindow &&
+        !win.isDestroyed() &&
+        win.isVisible() &&
+        win.isFocused()
+    );
+  const shouldActivateLauncherWindow =
+    process.platform !== 'darwin' ||
+    launcherMode === 'onboarding' ||
+    ownAppSiblingWindowFocused;
   let selectionSnapshotPromise: Promise<string> | null = null;
 
   // Capture the frontmost app BEFORE showing our window.

src/main/preload.ts

@@ -43,6 +43,7 @@ const electronAPI = {
     value: string | null;
     raw: number | null;
     type: string;
+    iso: string | null;
     error: string | null;
   }> => ipcRenderer.invoke('calculator-evaluate', expression),
 

src/main/soulver-calculator.ts

@@ -19,6 +19,7 @@ export interface SoulverResponse {
   value: string | null;
   raw: number | null;
   type: string;
+  iso: string | null;
   error: string | null;
 }
 
@@ -108,7 +109,7 @@ function ensureChild(): ChildProcessWithoutNullStreams {
 export function evaluate(expr: string): Promise<SoulverResponse> {
   const trimmed = expr.trim();
   if (!trimmed) {
-    return Promise.resolve({ id: 0, value: null, raw: null, type: 'unknown', error: 'empty' });
+    return Promise.resolve({ id: 0, value: null, raw: null, type: 'unknown', iso: null, error: 'empty' });
   }
 
   return new Promise<SoulverResponse>((resolve, reject) => {

src/native/soulver-calculator/Sources/main.swift

@@ -6,6 +6,7 @@ import SoulverCore
 // Request:  {"id": <number>, "expr": "<string>"}
 // Response: {"id": <number>, "value": "<string>", "raw": <number|null>,
 //            "type": "<math|unit|currency|percentage|date|duration|string|unknown>",
+//            "iso": "<ISO8601 string|null>",
 //            "error": "<string|null>"}
 //
 // One long-lived process per launcher. Requests arrive one per line.
@@ -54,9 +55,31 @@ struct Response: Encodable {
     let value: String?
     let raw: Double?
     let type: String
+    let iso: String?
     let error: String?
 }
 
+// ISO8601 formatter (UTC) used for the optional date payload sent to JS.
+let iso8601Formatter: ISO8601DateFormatter = {
+    let f = ISO8601DateFormatter()
+    f.formatOptions = [.withInternetDateTime]
+    return f
+}()
+
+// Extract the underlying Foundation.Date from date-typed EvaluationResults so
+// the renderer can format with a weekday/year even though SoulverCore's
+// stringValue may omit them (e.g. "May 24" for "24 may 2026").
+func isoDate(from eval: EvaluationResult) -> String? {
+    switch eval {
+    case .date(let stamp):
+        return iso8601Formatter.string(from: stamp.date)
+    case .datespan(let span):
+        return iso8601Formatter.string(from: span.startDate)
+    default:
+        return nil
+    }
+}
+
 let encoder = JSONEncoder()
 let decoder = JSONDecoder()
 let stdoutHandle = FileHandle.standardOutput
@@ -123,6 +146,7 @@ func evaluate(_ expr: String, id: Int) -> Response {
 
     if result.isEmptyResult || result.isFailedResult {
         return Response(id: id, value: nil, raw: nil, type: "unknown",
+                        iso: nil,
                         error: result.isFailedResult ? "failed" : "empty")
     }
 
@@ -131,6 +155,7 @@ func evaluate(_ expr: String, id: Int) -> Response {
         value: result.stringValue,
         raw: rawDouble(from: result.evaluationResult),
         type: classify(result),
+        iso: isoDate(from: result.evaluationResult),
         error: nil
     )
 }

src/renderer/src/raycast-api/index.tsx

@@ -873,11 +873,22 @@ export class Toast {
     return Promise.resolve();
   }
 
-  /** Dismiss any active toast — called when leaving an extension view. */
+  /**
+   * Dismiss any active toast — called when leaving an extension view.
+   *
+   * Only Animated (loading) toasts are dismissed: they have no auto-hide
+   * timer of their own, so if the extension view unmounts mid-load they
+   * would otherwise linger forever. Success/Failure toasts (the kind
+   * showHUD raises after a no-view command finishes) already auto-hide
+   * after 3 s — dismissing them on view unmount would cut their visible
+   * lifetime down to the ~600 ms NoViewRunner close delay, making
+   * "Your Mac is now caffeinated" flash and disappear.
+   */
   static dismissActive() {
-    if (Toast._activeToast) {
-      void Toast._activeToast.hide();
-    }
+    const active = Toast._activeToast;
+    if (!active) return;
+    if (active._style !== ToastStyle.Animated) return;
+    void active.hide();
   }
 }
 

src/renderer/src/smart-calculator.ts

@@ -80,11 +80,27 @@ export async function tryCalculateAsync(query: string): Promise<CalcResult | nul
     if (!kind) return null;
 
     const labels = KIND_LABELS[kind];
+    // For date results, SoulverCore's stringValue omits the year and weekday
+    // (e.g. "24 may 2026" → "May 24"). Use the iso payload added to the
+    // bridge response to format the resolved date with weekday + year so the
+    // user can see what day of the week the input falls on.
+    let resultValue = response.value;
+    if (kind === 'date' && typeof response.iso === 'string' && response.iso) {
+      const parsed = new Date(response.iso);
+      if (!Number.isNaN(parsed.getTime())) {
+        resultValue = parsed.toLocaleDateString(undefined, {
+          weekday: 'long',
+          day: 'numeric',
+          month: 'long',
+          year: 'numeric',
+        });
+      }
+    }
     return {
       kind,
       input: trimmed,
       inputLabel: labels.input,
-      result: response.value,
+      result: resultValue,
       resultLabel: labels.result,
     };
   } catch {

src/renderer/types/electron.d.ts

@@ -801,6 +801,7 @@ export interface SoulverResponse {
   value: string | null;
   raw: number | null;
   type: string;
+  iso: string | null;
   error: string | null;
 }