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.
"use client";
import { isTagged } from "../tagged";
import { Predicate } from "effect";
import { usePreviewCapture } from "./usePreviewCapture";
import { scopedThreadKey } from "@akeru/client-runtime/environment";
import { squashAtomCommandFailure } from "@akeru/client-runtime/state/runtime";
import {
FILL_PREVIEW_VIEWPORT,
type PreviewAnnotationPayload,
type PreviewViewportSetting,
type ScopedThreadRef,
} from "@akeru/contracts";
import { normalizePreviewUrl } from "@akeru/shared/preview";
import { useCallback, useEffect, useRef, useState } from "react";
import { resolveDiscoveredServerUrl } from "~/browser/browserTargetResolver";
import {
BROWSER_HISTORY_MAX_ENTRIES_PER_PROJECT,
recordVisitForThread,
removeUrlForThread,
setTitleForThreadUrl,
useThreadRecentHistory,
} from "~/browserHistoryStore";
import { type ComposerImageAttachment, useComposerDraftStore } from "~/composerDraftStore";
import { previewAnnotationScreenshotFile } from "~/lib/previewAnnotation";
import { ensureLocalApi } from "~/localApi";
import {
rememberPreviewUrl,
updatePreviewServerSnapshot,
useThreadPreviewState,
} from "~/previewStateStore";
import { useEnvironmentHttpBaseUrl } from "~/state/environments";
import { previewEnvironment } from "~/state/preview";
import { useAtomCommand } from "~/state/use-atom-command";
import { browserResponsiveViewportForToggle, useBrowserDefaults } from "~/browser/browserDefaults";
import {
findActiveBrowserRecordingRuntimeTabId,
useActiveBrowserRecordingTabIds,
} from "~/browser/browserRecording";
import { BrowserSurfaceSlot } from "~/browser/BrowserSurfaceSlot";
import { useBrowserSurfaceStore } from "~/browser/browserSurfaceStore";
import {
commitBrowserViewportChange,
subscribeBrowserViewportChange,
} from "~/browser/browserViewportActions";
import { previewRuntimeTabId } from "~/browser/previewRuntimeTabId";
import { toastManager } from "~/components/ui/toast";
import { AgentBrowserCursor } from "./AgentBrowserCursor";
import { openPreviewSession } from "./openPreviewSession";
import { subscribePreviewAction } from "./previewActionBus";
import { previewBridge } from "./previewBridge";
import { PreviewChromeRow } from "./PreviewChromeRow";
import { PreviewEmptyState } from "./PreviewEmptyState";
import { shouldShowPreviewEmptyState } from "./previewEmptyStateLogic";
import { PreviewMoreMenu } from "./PreviewMoreMenu";
import { PreviewUnreachable } from "./PreviewUnreachable";
import { usePreviewSession } from "./usePreviewSession";
import { ZoomIndicator } from "./ZoomIndicator";
interface Props {
threadRef: ScopedThreadRef;
tabId?: string | null;
configuredUrls?: ReadonlyArray<string> | undefined;
visible: boolean;
onSendAnnotation?: (
annotation: PreviewAnnotationPayload,
image: ComposerImageAttachment | null,
) => void;
}
const localApi = typeof window === "undefined" ? null : ensureLocalApi();
/**
* Single-tab preview surface: chrome row on top, one webview below, empty
* state when no session exists for the thread.
*/
export function PreviewView({
threadRef,
tabId: requestedTabId,
configuredUrls,
visible,
onSendAnnotation,
}: Props) {
const [focusUrlNonce, setFocusUrlNonce] = useState<number | undefined>(undefined);
const [pickActive, setPickActive] = useState(false);
const activeRecordingTabIds = useActiveBrowserRecordingTabIds();
const pickActiveRef = useRef(false);
const isMountedRef = useRef(true);
// Kept in sync so the title effect can depend on the stable thread key
// instead of the thread object, which is recreated on every update.
const threadRefRef = useRef(threadRef);
threadRefRef.current = threadRef;
const previewState = useThreadPreviewState(threadRef);
const recentHistoryEntries = useThreadRecentHistory(
threadRef,
BROWSER_HISTORY_MAX_ENTRIES_PER_PROJECT,
);
const addPreviewAnnotation = useComposerDraftStore((store) => store.addPreviewAnnotation);
const addImage = useComposerDraftStore((store) => store.addImage);
const environmentHttpBaseUrl = useEnvironmentHttpBaseUrl(threadRef.environmentId);
const environmentHostname = environmentHttpBaseUrl
? new URL(environmentHttpBaseUrl).hostname
: null;
const open = useAtomCommand(previewEnvironment.open);
const resize = useAtomCommand(previewEnvironment.resize, "preview viewport resize");
usePreviewSession(threadRef);
useEffect(() => {
isMountedRef.current = true;
return () => {
isMountedRef.current = false;
};
}, []);
const tabId = requestedTabId ?? previewState.activeTabId;
const runtimeTabId = tabId
? previewRuntimeTabId(threadRef, previewState.serverEpoch, tabId)
: null;
const recordingRuntimeTabId =
tabId && runtimeTabId
? activeRecordingTabIds.has(runtimeTabId)
? runtimeTabId
: findActiveBrowserRecordingRuntimeTabId(threadRef, tabId)
: null;
const snapshot = tabId ? (previewState.sessions[tabId] ?? null) : null;
const desktopOverlay = tabId ? (previewState.desktopByTabId[tabId] ?? null) : null;
const navStatus = snapshot?.navStatus ?? { _tag: "Idle" as const };
const url = isTagged(navStatus, "Idle") ? "" : navStatus.url;
const loading = desktopOverlay?.loading ?? isTagged(navStatus, "Loading");
const canGoBack = desktopOverlay?.canGoBack ?? snapshot?.canGoBack ?? false;
const canGoForward = desktopOverlay?.canGoForward ?? snapshot?.canGoForward ?? false;
const refreshDisabled = isTagged(navStatus, "Idle");
const isUnreachable = isTagged(navStatus, "LoadFailed");
const showEmptyState = shouldShowPreviewEmptyState(snapshot);
const controller = desktopOverlay?.controller ?? "none";
const viewport = snapshot?.viewport ?? FILL_PREVIEW_VIEWPORT;
const browserDefaults = useBrowserDefaults();
const panelRect = useBrowserSurfaceStore((state) =>
runtimeTabId ? (state.byTabId[runtimeTabId]?.rect ?? null) : null,
);
const navUrl = isTagged(navStatus, "Success") ? navStatus.url : null;
const navTitle = isTagged(navStatus, "Success") ? navStatus.title : null;
const latestHistoryUrl = recentHistoryEntries[0]?.url;
const threadKey = scopedThreadKey(threadRef);
useEffect(() => {
if (!navUrl || !navTitle || !latestHistoryUrl) return;
// Agent-driven pages only enrich an existing requested URL.
setTitleForThreadUrl(threadRefRef.current, navUrl, navTitle, environmentHostname);
// threadKey stands in for threadRef, whose identity churns on every thread update.
}, [environmentHostname, latestHistoryUrl, navTitle, navUrl, threadKey]);
const navigateToResolvedUrl = useCallback(
async (resolvedUrl: string) => {
if (runtimeTabId && previewBridge) {
// The bridge mirrors the resolved URL back to the server.
await previewBridge.navigate(runtimeTabId, resolvedUrl);
rememberPreviewUrl(threadRef, resolvedUrl);
return true;
}
const result = await openPreviewSession({ openPreview: open, threadRef, url: resolvedUrl });
return isTagged(result, "Success");
},
[open, runtimeTabId, threadRef],
);
const handleSubmitUrl = useCallback(
async (next: string) => {
try {
const normalized = normalizePreviewUrl(next);
if (await navigateToResolvedUrl(normalized)) {
recordVisitForThread(threadRef, normalized);
}
} catch {
// Server-side `failed` event renders the unreachable view.
}
},
[navigateToResolvedUrl, threadRef],
);
const handleOpenServerUrl = useCallback(
async (next: string) => {
try {
const resolved = resolveDiscoveredServerUrl(threadRef.environmentId, next);
if (await navigateToResolvedUrl(resolved)) {
recordVisitForThread(threadRef, next);
}
} catch {
// Server-side `failed` event renders the unreachable view.
}
},
[navigateToResolvedUrl, threadRef],
);
const handleRefresh = useCallback(() => {
if (previewBridge && runtimeTabId) void previewBridge.refresh(runtimeTabId);
}, [runtimeTabId]);
const handleZoomIn = useCallback(() => {
if (previewBridge && runtimeTabId) void previewBridge.zoomIn(runtimeTabId);
}, [runtimeTabId]);
const handleZoomOut = useCallback(() => {
if (previewBridge && runtimeTabId) void previewBridge.zoomOut(runtimeTabId);
}, [runtimeTabId]);
const handleResetZoom = useCallback(() => {
if (previewBridge && runtimeTabId) void previewBridge.resetZoom(runtimeTabId);
}, [runtimeTabId]);
const handleViewportChange = useCallback(
async (nextViewport: PreviewViewportSetting) => {
if (!tabId) return;
const result = await resize({
environmentId: threadRef.environmentId,
input: {
threadId: threadRef.threadId,
tabId,
viewport: nextViewport,
},
});
if (isTagged(result, "Failure")) {
const error = squashAtomCommandFailure(result);
toastManager.add({
type: "error",
title: "Unable to resize browser viewport",
description: error instanceof Error ? error.message : "An error occurred.",
});
throw error;
}
updatePreviewServerSnapshot(threadRef, result.value);
},
[resize, tabId, threadRef],
);
const handleToggleDeviceToolbar = () => {
if (!runtimeTabId) return;
if (!isTagged(viewport, "fill")) {
void commitBrowserViewportChange(runtimeTabId, FILL_PREVIEW_VIEWPORT).catch(() => undefined);
return;
}
void commitBrowserViewportChange(
runtimeTabId,
browserResponsiveViewportForToggle({
defaults: browserDefaults,
panelRect,
zoomFactor: desktopOverlay?.zoomFactor,
}),
).catch(() => undefined);
};
useEffect(() => {
if (!runtimeTabId) return;
return subscribeBrowserViewportChange(runtimeTabId, handleViewportChange);
}, [handleViewportChange, runtimeTabId]);
const handleBack = useCallback(() => {
if (previewBridge && runtimeTabId) void previewBridge.goBack(runtimeTabId);
}, [runtimeTabId]);
const handleForward = useCallback(() => {
if (previewBridge && runtimeTabId) void previewBridge.goForward(runtimeTabId);
}, [runtimeTabId]);
const handleOpenInBrowser = useCallback(() => {
if (!localApi || !url) return;
void localApi.shell.openExternal(url).catch(() => undefined);
}, [url]);
const handleNativePictureInPicture = useCallback(() => {
if (!previewBridge || !runtimeTabId) return;
const operation = desktopOverlay?.pictureInPicture
? previewBridge.pictureInPicture.close
: previewBridge.pictureInPicture.open;
void operation(runtimeTabId).catch((error) => {
toastManager.add({
type: "error",
title: "Unable to update popped-out preview",
description: error instanceof Error ? error.message : "An error occurred.",
});
});
}, [desktopOverlay?.pictureInPicture, runtimeTabId]);
const handleCapture = usePreviewCapture({
recordingRuntimeTabId,
runtimeTabId,
tabId,
threadRef,
});
const handlePickElement = useCallback(() => {
if (!previewBridge || !runtimeTabId) return;
if (pickActiveRef.current) {
void previewBridge.cancelPickElement(runtimeTabId).catch(() => undefined);
return;
}
// Snapshot whatever the user was focused on (typically the chat
// composer textarea or the chrome-row pick button) BEFORE main steals
// focus into the guest webContents. We restore it when the pick
// resolves so the user's typing context isn't lost — otherwise after
// every pick they'd have to click back into the textarea.
const previouslyFocused = typeof document !== "undefined" ? document.activeElement : null;
pickActiveRef.current = true;
setPickActive(true);
void (async () => {
try {
const result = await previewBridge.pickElement(runtimeTabId);
if (!result) return;
const { annotation, submission } = result;
addPreviewAnnotation(threadRef, annotation);
let screenshotFile: File | null = null;
try {
screenshotFile = await previewAnnotationScreenshotFile(annotation);
} catch {
// The structured annotation is still sendable when converting its
// optional screenshot into a composer attachment fails.
}
const image =
screenshotFile && annotation.screenshot
? ({
type: "image",
id: annotation.id,
name: screenshotFile.name,
mimeType: screenshotFile.type,
sizeBytes: screenshotFile.size,
previewUrl: annotation.screenshot.dataUrl,
file: screenshotFile,
} satisfies ComposerImageAttachment)
: null;
if (image) {
addImage(threadRef, image);
}
if (submission === "send") {
onSendAnnotation?.(annotation, image);
}
} catch {
// Picker failed (e.g. webview navigated). Treat as silent cancel.
} finally {
pickActiveRef.current = false;
// Avoid `setState on unmounted component` if the panel/thread closed
// while the pick was in flight.
if (isMountedRef.current) setPickActive(false);
// Best-effort: restore focus to whatever the user had before the
// pick stole it into the guest webContents. Skip if the previously-
// focused element was unmounted or is no longer focusable.
if (
previouslyFocused &&
previouslyFocused.isConnected &&
"focus" in previouslyFocused &&
Predicate.isFunction(previouslyFocused.focus)
) {
try {
previouslyFocused.focus({ preventScroll: true });
} catch {
// Some elements throw on .focus() (detached iframes, etc.).
}
}
}
})();
}, [addImage, addPreviewAnnotation, onSendAnnotation, runtimeTabId, threadRef]);
// If the active tab changes mid-pick (close, thread switch, hot restart),
// tell main to tear down the in-flight session AND reset our local toggle
// state so the button doesn't get stuck pressed against a stale tab id.
useEffect(() => {
return () => {
if (!pickActiveRef.current) return;
pickActiveRef.current = false;
if (previewBridge && runtimeTabId) {
void previewBridge.cancelPickElement(runtimeTabId).catch(() => undefined);
}
if (isMountedRef.current) setPickActive(false);
};
}, [runtimeTabId]);
// Subscribe only while visible; `toggle-panel` is owned by ChatView's
// URL-aware handler regardless of whether the panel is currently mounted.
useEffect(() => {
if (!visible) return;
return subscribePreviewAction((action) => {
switch (action) {
case "refresh":
handleRefresh();
return;
case "focus-url":
setFocusUrlNonce((value) => (value ?? 0) + 1);
return;
case "zoom-in":
handleZoomIn();
return;
case "zoom-out":
handleZoomOut();
return;
case "reset-zoom":
handleResetZoom();
return;
case "toggle-panel":
return;
}
});
}, [handleRefresh, handleResetZoom, handleZoomIn, handleZoomOut, visible]);
return (
<div
className="flex min-h-0 flex-1 flex-col bg-background"
data-thread-key={scopedThreadKey(threadRef)}
>
<PreviewChromeRow
url={url}
loading={loading}
canGoBack={canGoBack}
canGoForward={canGoForward}
refreshDisabled={refreshDisabled}
focusUrlNonce={focusUrlNonce}
onBack={handleBack}
onForward={handleForward}
onRefresh={handleRefresh}
onSubmit={(next) => void handleSubmitUrl(next)}
onOpenInBrowser={tabId ? handleOpenInBrowser : undefined}
onCapture={previewBridge && tabId ? handleCapture : undefined}
captureDisabled={!desktopOverlay || isUnreachable}
recording={recordingRuntimeTabId !== null}
onPickElement={previewBridge && tabId ? handlePickElement : undefined}
pickActive={pickActive}
// Disable when there's no tab (nothing to pick on) OR the page
// failed to load (a React overlay covers the webview, so the
// user wouldn't be able to actually click anything underneath).
pickDisabled={!tabId || isUnreachable}
pickDisabledReason={
isUnreachable ? "Page didn't load — pick unavailable until the page renders" : undefined
}
trailingActions={
previewBridge ? (
<PreviewMoreMenu
tabId={runtimeTabId}
hasWebContents={desktopOverlay?.hasWebContents ?? false}
zoomFactor={desktopOverlay?.zoomFactor ?? 1}
colorScheme={desktopOverlay?.colorScheme ?? "system"}
deviceToolbarVisible={!isTagged(viewport, "fill")}
onToggleDeviceToolbar={handleToggleDeviceToolbar}
nativePictureInPicture={desktopOverlay?.pictureInPicture ?? false}
onNativePictureInPicture={handleNativePictureInPicture}
/>
) : null
}
/>
<div className="relative min-h-0 flex-1 overflow-hidden">
{runtimeTabId && snapshot && !showEmptyState ? (
<BrowserSurfaceSlot
key={runtimeTabId}
tabId={runtimeTabId}
visible={visible && !isUnreachable}
interactive={visible && !isUnreachable}
className="absolute inset-0 h-full w-full"
/>
) : null}
{showEmptyState ? (
<PreviewEmptyState
threadRef={threadRef}
environmentId={threadRef.environmentId}
configuredUrls={configuredUrls}
recentEntries={recentHistoryEntries}
onRemoveRecent={(url) => removeUrlForThread(threadRef, url)}
onOpenUrl={(next) => void handleOpenServerUrl(next)}
/>
) : null}
{snapshot && desktopOverlay ? (
<ZoomIndicator zoomFactor={desktopOverlay.zoomFactor} />
) : null}
{runtimeTabId && desktopOverlay && !showEmptyState && !isUnreachable ? (
<AgentBrowserCursor
tabId={runtimeTabId}
zoomFactor={desktopOverlay.zoomFactor}
controller={controller}
/>
) : null}
{controller !== "none" ? (
<div className="pointer-events-none absolute left-3 top-3 z-40 rounded-full border border-border/70 bg-background/90 px-2.5 py-1 text-11px font-medium shadow-sm backdrop-blur">
{controller === "agent" ? "Bot controlling browser" : "Human control"}
</div>
) : null}
{isTagged(navStatus, "LoadFailed") ? (
<div className="absolute inset-0 z-10 bg-background">
<PreviewUnreachable
url={navStatus.url}
code={navStatus.code}
description={navStatus.description}
onReload={handleRefresh}
/>
</div>
) : null}
</div>
</div>
);
}