Merge pull request #5004 from RSSNext/release/mobile/0.5.2

release(mobile): Release v0.5.2

Author: DIYgod

apps/desktop/changelog/1.7.0.md

@@ -0,0 +1,18 @@
+# What's new in v1.7.0
+
+## Improvements
+
+- Removed the connection status indicator from the desktop app
+
+## No longer broken
+
+- Fixed duplicate desktop auth session cookies
+- Fixed session refresh after cookie updates
+- Fixed returning through the Discover route
+- Fixed desktop download link
+- Fixed MAS review state detection from OTA versions
+- Extended API request timeouts
+
+## Thanks
+
+Special thanks to volunteer contributor @cuikaipeng for their valuable contribution

apps/desktop/layer/main/src/lib/auth-cookies.test.ts

@@ -1,5 +1,5 @@
 import type { Session } from "electron"
-import { describe, expect, it, vi } from "vitest"
+import { beforeEach, describe, expect, it, vi } from "vitest"
 
 import {
   buildManagedAuthCookieHeader,
@@ -10,6 +10,10 @@ import {
 } from "./auth-cookies"
 
 describe("auth cookies", () => {
+  beforeEach(() => {
+    vi.useRealTimers()
+  })
+
   it("builds a cookie header from managed auth cookies only", () => {
     const header = buildManagedAuthCookieHeader([
       { name: "__Secure-better-auth.session_token", value: "session-token" },
@@ -104,6 +108,53 @@ describe("auth cookies", () => {
     expect(remove).not.toHaveBeenCalled()
   })
 
+  it("persists session token cookies across app restarts when the server sends Max-Age", async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date("2026-05-12T00:00:00.000Z"))
+
+    const set = vi.fn().mockImplementation(async () => {})
+    const remove = vi.fn().mockImplementation(async () => {})
+    const get = vi.fn().mockResolvedValue([])
+
+    await persistManagedAuthCookiesFromSetCookieHeader({
+      apiURL: "https://api.folo.is",
+      session: {
+        cookies: { get, set, remove },
+      } as unknown as Session,
+      setCookieHeader:
+        "__Secure-better-auth.session_token=session-token; Max-Age=2592000; Path=/; HttpOnly; Secure; SameSite=None",
+    })
+
+    expect(set).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "__Secure-better-auth.session_token",
+        value: "session-token",
+        expirationDate: 1_781_136_000,
+      }),
+    )
+  })
+
+  it("keeps rememberMe=false session token cookies session-scoped", async () => {
+    const set = vi.fn().mockImplementation(async () => {})
+    const remove = vi.fn().mockImplementation(async () => {})
+    const get = vi.fn().mockResolvedValue([])
+
+    await persistManagedAuthCookiesFromSetCookieHeader({
+      apiURL: "https://api.folo.is",
+      session: {
+        cookies: { get, set, remove },
+      } as unknown as Session,
+      setCookieHeader:
+        "__Secure-better-auth.session_token=session-token; Path=/; HttpOnly; Secure; SameSite=None",
+    })
+
+    expect(set).toHaveBeenCalledWith(
+      expect.not.objectContaining({
+        expirationDate: expect.any(Number),
+      }),
+    )
+  })
+
   it("removes stale duplicate session token cookies while keeping the secure host-only cookie", async () => {
     const remove = vi.fn().mockImplementation(async () => {})
     const get = vi.fn().mockResolvedValue([

apps/desktop/layer/main/src/lib/auth-cookies.ts

@@ -224,6 +224,18 @@ const shouldRemoveCookie = (cookie: ParsedSetCookie) => {
   return false
 }
 
+const getCookieExpirationDate = (cookie: ParsedSetCookie) => {
+  if (cookie.expirationDate !== undefined) {
+    return cookie.expirationDate
+  }
+
+  if (cookie.maxAge !== undefined && cookie.maxAge > 0) {
+    return Math.floor(Date.now() / 1000) + cookie.maxAge
+  }
+
+  return
+}
+
 export const getManagedAuthCookieNames = () => {
   return [...MANAGED_AUTH_COOKIE_NAMES]
 }
@@ -368,6 +380,7 @@ export const persistManagedAuthCookiesFromSetCookieHeader = async ({
       continue
     }
 
+    const expirationDate = getCookieExpirationDate(cookie)
     const details: CookiesSetDetails = {
       url: apiURL,
       name: cookie.name,
@@ -377,7 +390,7 @@ export const persistManagedAuthCookiesFromSetCookieHeader = async ({
       secure: cookie.secure,
       ...(cookie.sameSite ? { sameSite: cookie.sameSite } : {}),
       ...(cookie.domain ? { domain: cookie.domain } : {}),
-      ...(cookie.expirationDate ? { expirationDate: cookie.expirationDate } : {}),
+      ...(expirationDate ? { expirationDate } : {}),
     }
 
     await session.cookies.set(details)

apps/desktop/layer/main/src/lib/tray.test.ts

@@ -0,0 +1,131 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const mocks = vi.hoisted(() => {
+  const env = {
+    isMacOS: false,
+    isMAS: false,
+    isWindows: false,
+  }
+
+  return {
+    app: {
+      getName: vi.fn(() => "Folo"),
+      quit: vi.fn(),
+    },
+    buildFromTemplate: vi.fn((template) => ({ template })),
+    env,
+    getBadgeCount: vi.fn(() => 0),
+    getTrayIconPath: vi.fn(() => "/icon.png"),
+    logger: {
+      info: vi.fn(),
+    },
+    nativeImage: {
+      createFromPath: vi.fn(() => {
+        const image = {
+          resize: vi.fn(() => image),
+          setTemplateImage: vi.fn(),
+        }
+        return image
+      }),
+    },
+    store: {
+      get: vi.fn(() => true),
+      set: vi.fn(),
+    },
+    trayInstances: [] as Array<{
+      destroy: ReturnType<typeof vi.fn>
+      on: ReturnType<typeof vi.fn>
+      setContextMenu: ReturnType<typeof vi.fn>
+      setToolTip: ReturnType<typeof vi.fn>
+    }>,
+    Tray: class {
+      constructor() {
+        const tray = {
+          destroy: vi.fn(),
+          on: vi.fn(),
+          setContextMenu: vi.fn(),
+          setToolTip: vi.fn(),
+        }
+        mocks.trayInstances.push(tray)
+        return tray
+      }
+    },
+  }
+})
+
+vi.mock("electron", () => ({
+  app: {
+    getName: mocks.app.getName,
+    getBadgeCount: mocks.getBadgeCount,
+    quit: mocks.app.quit,
+    setBadgeCount: vi.fn(),
+  },
+  Menu: {
+    buildFromTemplate: mocks.buildFromTemplate,
+  },
+  nativeImage: mocks.nativeImage,
+  Tray: mocks.Tray,
+}))
+
+vi.mock("~/env", () => mocks.env)
+
+vi.mock("~/helper", () => ({
+  getTrayIconPath: mocks.getTrayIconPath,
+}))
+
+vi.mock("~/logger", () => ({
+  logger: mocks.logger,
+  revealLogFile: vi.fn(),
+}))
+
+vi.mock("~/manager/window", () => ({
+  WindowManager: {
+    getMainWindowOrCreate: vi.fn(() => ({
+      isMinimized: vi.fn(() => false),
+      show: vi.fn(),
+      webContents: {
+        reload: vi.fn(),
+        toggleDevTools: vi.fn(),
+      },
+    })),
+  },
+}))
+
+vi.mock("~/updater", () => ({
+  checkForAppUpdates: vi.fn(),
+}))
+
+vi.mock("./i18n", () => ({
+  t: vi.fn((key: string, options?: { name?: string }) =>
+    options?.name ? `${key} ${options.name}` : key,
+  ),
+}))
+
+vi.mock("./store", () => ({
+  store: mocks.store,
+}))
+
+describe("tray", () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.clearAllMocks()
+
+    mocks.env.isMacOS = false
+    mocks.env.isMAS = false
+    mocks.env.isWindows = false
+    mocks.getBadgeCount.mockReturnValue(0)
+    mocks.store.get.mockReturnValue(true)
+    mocks.trayInstances.length = 0
+  })
+
+  it("refreshes the existing tray menu instead of recreating the native tray", async () => {
+    const { registerAppTray } = await import("./tray")
+
+    registerAppTray()
+    registerAppTray()
+
+    expect(mocks.trayInstances).toHaveLength(1)
+    expect(mocks.trayInstances[0]!.destroy).not.toHaveBeenCalled()
+    expect(mocks.trayInstances[0]!.setContextMenu).toHaveBeenCalledTimes(2)
+  })
+})

apps/desktop/layer/main/src/lib/tray.ts

@@ -75,10 +75,19 @@ const getTrayContextMenu = () => {
     },
   ])
 }
+
+const refreshTrayContextMenu = () => {
+  if (!tray) return
+
+  tray.setContextMenu(getTrayContextMenu())
+  tray.setToolTip(app.getName())
+}
+
 export const registerAppTray = () => {
   if (!getTrayConfig()) return
   if (tray) {
-    destroyAppTray()
+    refreshTrayContextMenu()
+    return
   }
 
   const icon = nativeImage.createFromPath(getTrayIconPath())
@@ -87,10 +96,9 @@ export const registerAppTray = () => {
   trayIcon.setTemplateImage(true)
   tray = new Tray(trayIcon)
 
-  tray.setContextMenu(getTrayContextMenu())
-  tray.setToolTip(app.getName())
+  refreshTrayContextMenu()
   tray.on("mouse-enter", () => {
-    tray?.setContextMenu(getTrayContextMenu())
+    refreshTrayContextMenu()
   })
   if (isWindows) {
     tray.on("click", showWindow)

apps/desktop/layer/renderer/src/components/ui/markdown/renderers/BlockImage.test.tsx

@@ -0,0 +1,105 @@
+import * as React from "react"
+import { act } from "react"
+import type { Root } from "react-dom/client"
+import { createRoot } from "react-dom/client"
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest"
+
+import { MarkdownRenderActionContext } from "../context"
+import { MarkdownBlockImage } from "./BlockImage"
+
+const { mediaMock, getWrappedElementSizeMock } = vi.hoisted(() => ({
+  mediaMock: vi.fn(
+    ({
+      blurhash: _blurhash,
+      mediaContainerClassName: _mediaContainerClassName,
+      popper: _popper,
+      proxy: _proxy,
+      showFallback: _showFallback,
+      type: _type,
+      ...props
+    }: React.ImgHTMLAttributes<HTMLImageElement> & Record<string, unknown>) => (
+      <img alt="" data-testid="media" {...props} />
+    ),
+  ),
+  getWrappedElementSizeMock: vi.fn(() => ({ h: 0, w: 640 })),
+}))
+
+vi.mock("../../media/Media", () => ({
+  Media: mediaMock,
+}))
+
+vi.mock("~/providers/wrapped-element-provider", () => ({
+  useWrappedElementSize: getWrappedElementSizeMock,
+}))
+
+const renderComponent = async (element: React.ReactNode) => {
+  const container = document.createElement("div")
+  document.body.append(container)
+
+  const root = createRoot(container)
+
+  await act(async () => {
+    root.render(element)
+  })
+
+  return { container, root }
+}
+
+describe("MarkdownBlockImage", () => {
+  let root: Root | null = null
+  let container: HTMLElement | null = null
+
+  beforeAll(() => {
+    ;(globalThis as typeof globalThis & { React: typeof React }).React = React
+    ;(
+      globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT: boolean }
+    ).IS_REACT_ACT_ENVIRONMENT = true
+  })
+
+  afterEach(async () => {
+    if (root) {
+      await act(async () => {
+        root?.unmount()
+      })
+    }
+
+    container?.remove()
+    root = null
+    container = null
+    vi.clearAllMocks()
+  })
+
+  test("passes image context menu events with the resolved image URL", async () => {
+    const onImageContextMenu = vi.fn()
+
+    ;({ container, root } = await renderComponent(
+      <MarkdownRenderActionContext
+        value={{
+          ensureAndRenderTimeStamp: () => false,
+          isAudio: () => false,
+          onImageContextMenu,
+          transformUrl: (url) => (url ? new URL(url, "https://example.com/post").href : url),
+        }}
+      >
+        <MarkdownBlockImage src="./image.png" width={700} height={400} />
+      </MarkdownRenderActionContext>,
+    ))
+
+    const image = container?.querySelector('[data-testid="media"]')
+    const event = new MouseEvent("contextmenu", {
+      bubbles: true,
+      cancelable: true,
+      clientX: 12,
+      clientY: 34,
+    })
+
+    await act(async () => {
+      image?.dispatchEvent(event)
+    })
+
+    expect(onImageContextMenu).toHaveBeenCalledWith(
+      expect.objectContaining({ clientX: 12, clientY: 34 }),
+      "https://example.com/image.png",
+    )
+  })
+})