Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Add SWR preview session state and resubscribe handling

Julius Marminge3c7862edd70e
diff --git a/apps/web/src/browser/HostedBrowserWebview.tsx b/apps/web/src/browser/HostedBrowserWebview.tsx
index e158d7eba..276a9090a 100644
--- a/apps/web/src/browser/HostedBrowserWebview.tsx
+++ b/apps/web/src/browser/HostedBrowserWebview.tsx
@@ -1,8 +1,8 @@
"use client";
-import type { DesktopPreviewWebviewConfig, ScopedThreadRef } from "@t3tools/contracts";
+import type { ScopedThreadRef } from "@t3tools/contracts";
import { useShallow } from "zustand/react/shallow";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useRef } from "react";
import { previewBridge } from "~/components/preview/previewBridge";
import { usePreviewBridge } from "~/components/preview/usePreviewBridge";
@@ -10,6 +10,7 @@ import { usePreviewBridge } from "~/components/preview/usePreviewBridge";
import { useBrowserRecordingStore } from "./browserRecording";
import { useBrowserSurfaceStore } from "./browserSurfaceStore";
import { acquireDesktopTab } from "./desktopTabLifetime";
+import { usePreviewWebviewConfig } from "./previewWebviewConfigState";
interface ElectronWebview extends HTMLElement {
src: string;
@@ -31,7 +32,7 @@ export function HostedBrowserWebview(props: {
readonly initialUrl: string | null;
}) {
const { threadRef, tabId, initialUrl } = props;
- const [config, setConfig] = useState<DesktopPreviewWebviewConfig | null>(null);
+ const config = usePreviewWebviewConfig(threadRef.environmentId);
const initialSrcRef = useRef(initialUrl ?? "about:blank");
const webviewRef = useRef<ElectronWebview | null>(null);
const presentation = useBrowserSurfaceStore(useShallow((state) => state.byTabId[tabId] ?? null));
@@ -41,19 +42,6 @@ export function HostedBrowserWebview(props: {
useEffect(() => acquireDesktopTab(tabId), [tabId]);
- useEffect(() => {
- let cancelled = false;
- void previewBridge
- ?.getPreviewConfig(threadRef.environmentId)
- .then((next) => {
- if (!cancelled) setConfig(next);
- })
- .catch(() => undefined);
- return () => {
- cancelled = true;
- };
- }, [threadRef.environmentId]);
-
const setWebviewRef = useCallback((node: HTMLElement | null) => {
webviewRef.current = node as ElectronWebview | null;
if (node && !node.hasAttribute("allowpopups")) node.setAttribute("allowpopups", "true");
diff --git a/apps/web/src/browser/previewWebviewConfigState.ts b/apps/web/src/browser/previewWebviewConfigState.ts
new file mode 100644
index 000000000..99a8388ec
--- /dev/null
+++ b/apps/web/src/browser/previewWebviewConfigState.ts
@@ -0,0 +1,48 @@
+import { useAtomValue } from "@effect/atom-react";
+import type { DesktopPreviewWebviewConfig, EnvironmentId } from "@t3tools/contracts";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+
+import { previewBridge } from "~/components/preview/previewBridge";
+
+const PREVIEW_CONFIG_STALE_TIME_MS = 5 * 60_000;
+const PREVIEW_CONFIG_IDLE_TTL_MS = 10 * 60_000;
+
+class PreviewWebviewConfigError extends Data.TaggedError("PreviewWebviewConfigError")<{
+ readonly message: string;
+ readonly cause?: unknown;
+}> {}
+
+const previewWebviewConfigAtom = Atom.family((environmentId: EnvironmentId) =>
+ Atom.make(
+ Effect.tryPromise({
+ try: () => {
+ if (!previewBridge) {
+ throw new Error("Desktop preview bridge is unavailable.");
+ }
+ return previewBridge.getPreviewConfig(environmentId);
+ },
+ catch: (cause) =>
+ new PreviewWebviewConfigError({
+ message: "Could not load desktop preview configuration.",
+ cause,
+ }),
+ }),
+ ).pipe(
+ Atom.swr({
+ staleTime: PREVIEW_CONFIG_STALE_TIME_MS,
+ revalidateOnMount: true,
+ }),
+ Atom.setIdleTTL(PREVIEW_CONFIG_IDLE_TTL_MS),
+ Atom.withLabel(`preview:webview-config:${environmentId}`),
+ ),
+);
+
+export function usePreviewWebviewConfig(
+ environmentId: EnvironmentId,
+): DesktopPreviewWebviewConfig | null {
+ const result = useAtomValue(previewWebviewConfigAtom(environmentId));
+ return Option.getOrNull(AsyncResult.value(result));
+}
diff --git a/apps/web/src/components/preview/previewSessionState.ts b/apps/web/src/components/preview/previewSessionState.ts
new file mode 100644
index 000000000..3d27a7654
--- /dev/null
+++ b/apps/web/src/components/preview/previewSessionState.ts
@@ -0,0 +1,71 @@
+import { useAtomValue } from "@effect/atom-react";
+import { parseScopedThreadKey, scopedThreadKey } from "@t3tools/client-runtime";
+import type { PreviewListResult, ScopedThreadRef } from "@t3tools/contracts";
+import * as Cause from "effect/Cause";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+
+import { ensureEnvironmentApi } from "~/environmentApi";
+import { appAtomRegistry } from "~/rpc/atomRegistry";
+
+const PREVIEW_SESSION_STALE_TIME_MS = 5_000;
+const PREVIEW_SESSION_IDLE_TTL_MS = 5 * 60_000;
+
+class PreviewSessionQueryError extends Data.TaggedError("PreviewSessionQueryError")<{
+ readonly message: string;
+ readonly cause?: unknown;
+}> {}
+
+const previewSessionListAtom = Atom.family((threadKey: string) =>
+ Atom.make(
+ Effect.tryPromise({
+ try: () => {
+ const threadRef = parseScopedThreadKey(threadKey);
+ if (!threadRef) {
+ throw new Error(`Invalid scoped thread key: ${threadKey}`);
+ }
+ return ensureEnvironmentApi(threadRef.environmentId).preview.list({
+ threadId: threadRef.threadId,
+ });
+ },
+ catch: (cause) =>
+ new PreviewSessionQueryError({
+ message: "Could not load preview sessions.",
+ cause,
+ }),
+ }),
+ ).pipe(
+ Atom.swr({
+ staleTime: PREVIEW_SESSION_STALE_TIME_MS,
+ revalidateOnMount: true,
+ }),
+ Atom.setIdleTTL(PREVIEW_SESSION_IDLE_TTL_MS),
+ Atom.withLabel(`preview:sessions:${threadKey}`),
+ ),
+);
+
+export interface PreviewSessionQueryState {
+ readonly data: PreviewListResult | null;
+ readonly error: string | null;
+ readonly isPending: boolean;
+}
+
+export function refreshPreviewSessionState(threadRef: ScopedThreadRef): void {
+ appAtomRegistry.refresh(previewSessionListAtom(scopedThreadKey(threadRef)));
+}
+
+export function usePreviewSessionState(threadRef: ScopedThreadRef): PreviewSessionQueryState {
+ const result = useAtomValue(previewSessionListAtom(scopedThreadKey(threadRef)));
+ let error: string | null = null;
+ if (result._tag === "Failure") {
+ const cause = Cause.squash(result.cause);
+ error = cause instanceof Error ? cause.message : "Could not load preview sessions.";
+ }
+ return {
+ data: Option.getOrNull(AsyncResult.value(result)),
+ error,
+ isPending: result.waiting,
+ };
+}
diff --git a/apps/web/src/components/preview/usePreviewSession.ts b/apps/web/src/components/preview/usePreviewSession.ts
index 1a4446bd3..8e4cd95c9 100644
--- a/apps/web/src/components/preview/usePreviewSession.ts
+++ b/apps/web/src/components/preview/usePreviewSession.ts
@@ -4,9 +4,12 @@ import { scopedThreadKey } from "@t3tools/client-runtime";
import type { ScopedThreadRef } from "@t3tools/contracts";
import { useEffect } from "react";
-import { ensureEnvironmentApi } from "~/environmentApi";
+import { ensureEnvironmentApi, readEnvironmentApi } from "~/environmentApi";
+import { readEnvironmentConnection, subscribeEnvironmentConnections } from "~/environments/runtime";
import { usePreviewStateStore } from "~/previewStateStore";
+import { refreshPreviewSessionState, usePreviewSessionState } from "./previewSessionState";
+
/**
* Subscribes to the server's per-thread preview events and replays the
* latest snapshot on mount.
@@ -16,52 +19,82 @@ import { usePreviewStateStore } from "~/previewStateStore";
* `preview.open` so subsequent events land on a real session.
*/
export function usePreviewSession(threadRef: ScopedThreadRef): void {
+ const query = usePreviewSessionState(threadRef);
const applyServerSnapshot = usePreviewStateStore((state) => state.applyServerSnapshot);
const applyServerEvent = usePreviewStateStore((state) => state.applyServerEvent);
useEffect(() => {
- if (typeof window === "undefined") return;
- const api = ensureEnvironmentApi(threadRef.environmentId);
+ if (!query.data) return;
const threadIdValue = threadRef.threadId;
let cancelled = false;
+ if (query.data.sessions.length > 0) {
+ for (const snapshot of query.data.sessions) applyServerSnapshot(threadRef, snapshot);
+ return;
+ }
+ if (query.isPending) return;
+
+ // Server has no sessions — try to recover what the renderer remembers
+ // from before the disconnect.
+ const localSnapshot =
+ usePreviewStateStore.getState().byThreadKey[scopedThreadKey(threadRef)]?.snapshot;
+ const recoverableUrl =
+ localSnapshot && localSnapshot.navStatus._tag !== "Idle" ? localSnapshot.navStatus.url : null;
+ if (!recoverableUrl) {
+ applyServerSnapshot(threadRef, null);
+ return;
+ }
+ const api = ensureEnvironmentApi(threadRef.environmentId);
void api.preview
- .list({ threadId: threadIdValue })
- .then((result) => {
+ .open({ threadId: threadIdValue, url: recoverableUrl })
+ .then((snapshot) => {
if (cancelled) return;
- // Pick the most recent session. Server returns sessions sorted by
- // `updatedAt` ascending, so the last one is freshest.
- const serverSnapshot = result.sessions.at(-1) ?? null;
- if (serverSnapshot) {
- for (const snapshot of result.sessions) applyServerSnapshot(threadRef, snapshot);
- return;
- }
- // Server has no sessions — try to recover what the renderer
- // remembers from before the disconnect.
- const localSnapshot =
- usePreviewStateStore.getState().byThreadKey[scopedThreadKey(threadRef)]?.snapshot;
- const recoverableUrl =
- localSnapshot && localSnapshot.navStatus._tag !== "Idle"
- ? localSnapshot.navStatus.url
- : null;
- if (recoverableUrl) {
- void api.preview
- .open({ threadId: threadIdValue, url: recoverableUrl })
- .catch(() => undefined);
- } else {
- applyServerSnapshot(threadRef, null);
- }
+ applyServerSnapshot(threadRef, snapshot);
+ refreshPreviewSessionState(threadRef);
})
.catch(() => undefined);
- const unsubscribe = api.preview.onEvent((event) => {
- if (event.threadId !== threadIdValue) return;
- applyServerEvent(threadRef, event);
- });
-
return () => {
cancelled = true;
- unsubscribe();
};
- }, [applyServerEvent, applyServerSnapshot, threadRef]);
+ }, [applyServerSnapshot, query.data, query.isPending, threadRef]);
+
+ useEffect(() => {
+ if (typeof window === "undefined") return;
+ let clientIdentity: object | null = null;
+ let unsubscribeEvents: () => void = () => undefined;
+
+ const attach = () => {
+ const connection = readEnvironmentConnection(threadRef.environmentId);
+ const api = readEnvironmentApi(threadRef.environmentId);
+ const nextIdentity = connection?.client ?? api ?? null;
+ if (nextIdentity === clientIdentity) return;
+
+ unsubscribeEvents();
+ unsubscribeEvents = () => undefined;
+ clientIdentity = nextIdentity;
+ if (!api) return;
+
+ refreshPreviewSessionState(threadRef);
+ unsubscribeEvents = api.preview.onEvent(
+ (event) => {
+ if (event.threadId !== threadRef.threadId) return;
+ applyServerEvent(threadRef, event);
+ if (event.type === "opened" || event.type === "closed") {
+ refreshPreviewSessionState(threadRef);
+ }
+ },
+ {
+ onResubscribe: () => refreshPreviewSessionState(threadRef),
+ },
+ );
+ };
+
+ const unsubscribeConnections = subscribeEnvironmentConnections(attach);
+ attach();
+ return () => {
+ unsubscribeConnections();
+ unsubscribeEvents();
+ };
+ }, [applyServerEvent, threadRef]);
}
diff --git a/apps/web/src/environmentApi.ts b/apps/web/src/environmentApi.ts
index 2c2166d50..4bb3c3654 100644
--- a/apps/web/src/environmentApi.ts
+++ b/apps/web/src/environmentApi.ts
@@ -72,7 +72,7 @@ export function createEnvironmentApi(rpcClient: WsRpcClient): EnvironmentApi {
reportOwner: (owner) => rpcClient.preview.automation.reportOwner(owner as never),
clearOwner: (input) => rpcClient.preview.automation.clearOwner(input as never),
},
- onEvent: (callback) => rpcClient.preview.onEvent(callback),
+ onEvent: (callback, options) => rpcClient.preview.onEvent(callback, options),
subscribePorts: (callback, options) => rpcClient.preview.subscribePorts(callback, options),
},
};
diff --git a/apps/web/src/previewStateStore.test.ts b/apps/web/src/previewStateStore.test.ts
index 3adb954cb..b2df246f2 100644
--- a/apps/web/src/previewStateStore.test.ts
+++ b/apps/web/src/previewStateStore.test.ts
@@ -262,6 +262,31 @@ describe("previewStateStore (single-tab)", () => {
expect(state.snapshot).toBeNull();
});
+ it("does not replace a streamed snapshot with older SWR data", () => {
+ const store = usePreviewStateStore.getState();
+ store.applyServerSnapshot(
+ ref,
+ makeSnapshot({
+ navStatus: { _tag: "Success", url: "http://localhost:5173/new", title: "New" },
+ updatedAt: "2026-01-01T00:00:02.000Z",
+ }),
+ );
+ store.applyServerSnapshot(
+ ref,
+ makeSnapshot({
+ navStatus: { _tag: "Success", url: "http://localhost:5173/old", title: "Old" },
+ updatedAt: "2026-01-01T00:00:01.000Z",
+ }),
+ );
+
+ const state = selectThreadPreviewState(usePreviewStateStore.getState().byThreadKey, ref);
+ expect(state.snapshot?.navStatus).toEqual({
+ _tag: "Success",
+ url: "http://localhost:5173/new",
+ title: "New",
+ });
+ });
+
it("rememberUrl dedupes and caps at limit", () => {
const store = usePreviewStateStore.getState();
for (let i = 0; i < __testing.RECENT_URL_LIMIT + 5; i += 1) {
diff --git a/apps/web/src/previewStateStore.ts b/apps/web/src/previewStateStore.ts
index d6cacda3a..75cb45db4 100644
--- a/apps/web/src/previewStateStore.ts
+++ b/apps/web/src/previewStateStore.ts
@@ -189,6 +189,10 @@ export const usePreviewStateStore = create<PreviewStateStoreState>()((set) => ({
desktopByTabId: {},
};
}
+ const existing = current.sessions[snapshot.tabId];
+ if (existing && existing.updatedAt > snapshot.updatedAt) {
+ return current;
+ }
const recentlySeenUrls =
snapshot && snapshot.navStatus._tag !== "Idle"
? dedupeRecentUrls(current.recentlySeenUrls, snapshot.navStatus.url)
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index 1739a27e5..463879e9a 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -1190,7 +1190,10 @@ export interface EnvironmentApi {
reportOwner: (owner: PreviewAutomationOwner) => Promise<void>;
clearOwner: (input: { clientId: string }) => Promise<void>;
};
- onEvent: (callback: (event: PreviewEvent) => void) => () => void;
+ onEvent: (
+ callback: (event: PreviewEvent) => void,
+ options?: { onResubscribe?: () => void },
+ ) => () => void;
subscribePorts: (
callback: (servers: DiscoveredLocalServerList) => void,
options?: { onResubscribe?: () => void },