feat(cloud): a box reports its agent status so the sidebar can show it

apps/api/src/app/api/cloud-workspaces/[workspaceId]/agent-status/route.ts

@@ -0,0 +1,38 @@
+import { ACTIVE_AGENT_STATUSES } from "@superset/shared/agent-status";
+import { reportSandboxAgentStatus } from "@superset/trpc/lib/sandbox";
+import { z } from "zod";
+
+const bodySchema = z.object({
+	status: z.enum(ACTIVE_AGENT_STATUSES).nullable(),
+	at: z.number().int().positive(),
+});
+
+export async function POST(
+	request: Request,
+	{ params }: { params: Promise<{ workspaceId: string }> },
+): Promise<Response> {
+	const { workspaceId } = await params;
+	const presented = request.headers
+		.get("authorization")
+		?.replace(/^Bearer\s+/i, "");
+	if (!presented || !/^[0-9a-f-]{36}$/i.test(workspaceId)) {
+		return Response.json({ error: "unauthorized" }, { status: 401 });
+	}
+	const parsed = bodySchema.safeParse(await request.json().catch(() => null));
+	if (!parsed.success) {
+		return Response.json({ error: "invalid body" }, { status: 400 });
+	}
+	const outcome = await reportSandboxAgentStatus({
+		workspaceId,
+		presentedSecret: presented,
+		status: parsed.data.status,
+		at: parsed.data.at,
+	});
+	if (outcome === "unauthorized") {
+		return Response.json({ error: "unauthorized" }, { status: 401 });
+	}
+	if (outcome === "unknown") {
+		return Response.json({ error: "unknown workspace" }, { status: 404 });
+	}
+	return Response.json({ ok: true });
+}

apps/desktop/src/renderer/hooks/host-service/useTerminalAgentStatuses/deriveTerminalAgentStatus.ts

@@ -1,3 +1,4 @@
+import { agentStatusFromEvent } from "@superset/shared/agent-status";
 import type { PaneStatus } from "shared/tabs-types";
 
 /**
@@ -14,11 +15,9 @@ export function deriveTerminalAgentStatus({
 	lastEventAt: number;
 	lastSeenAt: number | undefined;
 }): PaneStatus {
-	if (lastEventType === "Start") return "working";
-	if (lastEventType === "PermissionRequest") return "permission";
-	if (lastEventType === "Failed") return "failed";
-	if (lastEventType === "Stop") {
+	const status = agentStatusFromEvent(lastEventType);
+	if (status === "review") {
 		return lastEventAt > (lastSeenAt ?? 0) ? "review" : "idle";
 	}
-	return "idle";
+	return status ?? "idle";
 }

apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/DashboardSidebar.tsx

@@ -18,12 +18,14 @@ import {
 	useStarNagCard,
 } from "renderer/components/SidebarCardSlot";
 import { UpdatesPill } from "renderer/components/UpdatesPill";
+import { useCloudWorkspaces } from "renderer/hooks/useCloudWorkspaces";
 import { useV2UserPreferences } from "renderer/hooks/useV2UserPreferences";
 import { useHotkeyDisplay } from "renderer/hotkeys";
 import { OrganizationDropdown } from "renderer/routes/_authenticated/_dashboard/components/TopBar/components/OrganizationDropdown";
 import { useDashboardSidebarState } from "renderer/routes/_authenticated/hooks/useDashboardSidebarState";
 import { useLocalHostService } from "renderer/routes/_authenticated/providers/LocalHostServiceProvider";
 import { useSidebarSectionsCollapseStore } from "renderer/stores/sidebar-sections-collapse";
+import { useV2NotificationStore } from "renderer/stores/v2-notifications";
 import { DashboardSidebarBulkActions } from "./components/DashboardSidebarBulkActions";
 import { DashboardSidebarBulkDeleteMount } from "./components/DashboardSidebarBulkDeleteMount";
 import { DashboardSidebarCloudSection } from "./components/DashboardSidebarCloudSection";
@@ -271,6 +273,20 @@ export function DashboardSidebar({
 	// the status provider fans out bindings queries and event subscriptions for
 	// these once, instead of per row. Deliberately unfiltered so subscriptions
 	// don't churn per keystroke.
+	const { workspaces: cloudWorkspaces } = useCloudWorkspaces();
+	const pruneWorkspaceSeen = useV2NotificationStore(
+		(state) => state.pruneWorkspaceSeen,
+	);
+	useEffect(() => {
+		if (!cloudWorkspaces) return;
+		const live = new Set(cloudWorkspaces.map((cloud) => cloud.id));
+		for (const id of Object.keys(
+			useV2NotificationStore.getState().workspaceSeenAt,
+		)) {
+			if (!live.has(id)) pruneWorkspaceSeen(id);
+		}
+	}, [cloudWorkspaces, pruneWorkspaceSeen]);
+
 	const statusWorkspaces = useMemo<SidebarStatusWorkspaceRef[]>(() => {
 		const byId = new Map<string, SidebarStatusWorkspaceRef>();
 		for (const workspace of pinnedWorkspaces) {
@@ -284,8 +300,16 @@ export function DashboardSidebar({
 				byId.set(workspace.id, { id: workspace.id, hostId: workspace.hostId });
 			}
 		}
+		for (const cloud of cloudWorkspaces ?? []) {
+			byId.set(cloud.id, {
+				id: cloud.id,
+				hostId: cloud.id,
+				reportedStatus: cloud.agentStatus ?? null,
+				reportedAt: cloud.agentStatusAt?.getTime() ?? null,
+			});
+		}
 		return [...byId.values()];
-	}, [pinnedWorkspaces, sessionWorkspaces, orderedGroups]);
+	}, [pinnedWorkspaces, sessionWorkspaces, orderedGroups, cloudWorkspaces]);
 
 	const activeV2Project = useMemo(() => {
 		if (!activeV2WorkspaceId) return null;

apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/providers/DashboardSidebarWorkspaceStatusProvider/DashboardSidebarWorkspaceStatusProvider.tsx

@@ -1,3 +1,4 @@
+import type { ActiveAgentStatus } from "@superset/shared/agent-status";
 import { useQueries, useQueryClient } from "@tanstack/react-query";
 import {
 	createContext,
@@ -41,6 +42,8 @@ export interface SidebarWorkspaceStatusEntry {
 	statuses: ReadonlyMap<string, PaneStatus>;
 	/** Populated only for the active workspace — the only row that shows it. */
 	diffStats: DiffStats | null;
+	/** When the host reported `status`, for mark-seen; null when derived from bindings. */
+	reportedAt: number | null;
 }
 
 const EMPTY_ENTRY: SidebarWorkspaceStatusEntry = {
@@ -49,6 +52,7 @@ const EMPTY_ENTRY: SidebarWorkspaceStatusEntry = {
 	bindings: new Map(),
 	statuses: new Map(),
 	diffStats: null,
+	reportedAt: null,
 };
 
 /**
@@ -115,6 +119,10 @@ const StatusStoreContext = createContext<SidebarWorkspaceStatusStore | null>(
 export interface SidebarStatusWorkspaceRef {
 	id: string;
 	hostId: string;
+	/** Null means idle or never reported. */
+	reportedStatus?: ActiveAgentStatus | null;
+	/** The reporting host's clock, epoch ms. */
+	reportedAt?: number | null;
 }
 
 interface WorkspaceStatusTarget {
@@ -140,6 +148,7 @@ function entriesEqual(
 	return (
 		left.status === right.status &&
 		left.isUnread === right.isUnread &&
+		left.reportedAt === right.reportedAt &&
 		(left.diffStats === right.diffStats ||
 			(left.diffStats !== null &&
 				right.diffStats !== null &&
@@ -171,6 +180,26 @@ export function DashboardSidebarWorkspaceStatusProvider({
 	const [store] = useState(() => new SidebarWorkspaceStatusStore());
 	const queryClient = useQueryClient();
 	const { cache: hostWorkspacesCache } = useHostWorkspaces();
+	// Off the fingerprinted targets: a change here must not re-run the subscriptions.
+	const reportedByWorkspaceId = useMemo(
+		() =>
+			new Map(
+				workspaces.map(
+					(workspace) =>
+						[
+							workspace.id,
+							{
+								status: workspace.reportedStatus ?? null,
+								at: workspace.reportedAt ?? null,
+							},
+						] as const,
+				),
+			),
+		[workspaces],
+	);
+	const workspaceSeenAt = useV2NotificationStore(
+		(state) => state.workspaceSeenAt,
+	);
 
 	const computedTargets = useMemo<WorkspaceStatusTarget[]>(
 		() =>
@@ -326,16 +355,32 @@ export function DashboardSidebarWorkspaceStatusProvider({
 					break;
 				}
 			}
+			const report =
+				target.hostUrl === null
+					? reportedByWorkspaceId.get(target.workspaceId)
+					: undefined;
+			const reported =
+				report?.status === "review" &&
+				report.at !== null &&
+				(workspaceSeenAt[target.workspaceId] ?? 0) >= report.at
+					? null
+					: (report?.status ?? null);
 			const candidate: SidebarWorkspaceStatusEntry = {
 				status: getHighestPriorityStatus([
 					hasManualUnread ? "review" : undefined,
+					reported ?? undefined,
 					...statuses.values(),
 				]),
-				isUnread: hasManualUnread || hasAttentionTerminal,
+				isUnread:
+					hasManualUnread ||
+					hasAttentionTerminal ||
+					reported === "review" ||
+					reported === "failed",
 				bindings,
 				statuses,
 				diffStats:
 					target.workspaceId === activeWorkspaceId ? activeDiffStats : null,
+				reportedAt: report?.at ?? null,
 			};
 			const previousEntry = previous.get(target.workspaceId);
 			next.set(
@@ -354,6 +399,8 @@ export function DashboardSidebarWorkspaceStatusProvider({
 		terminalSeenAt,
 		activeWorkspaceId,
 		activeDiffStats,
+		reportedByWorkspaceId,
+		workspaceSeenAt,
 	]);
 
 	store.replaceEntries(entries);
@@ -407,10 +454,17 @@ export function useMarkSidebarWorkspaceTerminalsSeen(
 	const markTerminalSeen = useV2NotificationStore(
 		(state) => state.markTerminalSeen,
 	);
+	const markWorkspaceSeen = useV2NotificationStore(
+		(state) => state.markWorkspaceSeen,
+	);
 	return useCallback(() => {
 		// Host-clock only: "seen through the binding's last event".
-		for (const binding of store.get(workspaceId).bindings.values()) {
+		const entry = store.get(workspaceId);
+		for (const binding of entry.bindings.values()) {
 			markTerminalSeen(binding.terminalId, binding.lastEventAt);
 		}
-	}, [store, workspaceId, markTerminalSeen]);
+		if (entry.reportedAt !== null) {
+			markWorkspaceSeen(workspaceId, entry.reportedAt);
+		}
+	}, [store, workspaceId, markTerminalSeen, markWorkspaceSeen]);
 }

apps/desktop/src/renderer/routes/_authenticated/components/RealtimeNudges/RealtimeNudges.tsx

@@ -2,6 +2,7 @@ import {
 	parseRealtimeNudgeMessage,
 	REALTIME_NUDGE_KINDS,
 	type RealtimeNudgeKind,
+	type RealtimeUpdate,
 	realtimeNudgesPath,
 } from "@superset/shared/realtime";
 import { createRelaySocket } from "@superset/workspace-client";
@@ -13,18 +14,19 @@ import { cloudTrpc } from "renderer/lib/cloud-trpc";
 
 /**
  * One socket per window to the realtime Worker. The API sends a nudge after
- * it writes hosts or cloud workspaces, and this refetches the matching
- * queries, which is why neither polls. A reopen refetches
- * everything once, since nudges sent while the socket was down are gone.
- * Rendered inside the providers: the subscription needs the active
- * organization.
+ * it writes hosts or cloud workspaces: a kind refetches the matching query,
+ * a patch is applied to the cache without one, which is why neither polls.
+ * A reopen refetches everything once, since nudges sent while the socket
+ * was down are gone. Rendered inside the providers: the subscription needs
+ * the active organization.
  */
 export function RealtimeNudges() {
 	const organizationId = useActiveOrganizationId();
 	const utils = cloudTrpc.useUtils();
 
 	useEffect(() => {
 		if (!organizationId) return;
+
 		// A hidden window marks the query stale and refetches on focus, the way
 		// its polls used to pause in the background.
 		const invalidate = (kinds: readonly RealtimeNudgeKind[]) => {
@@ -42,6 +44,23 @@ export function RealtimeNudges() {
 				}
 			}
 		};
+
+		const patch = (updates: readonly RealtimeUpdate[]) => {
+			if (updates.length === 0) return;
+			utils.cloudWorkspace.list.setData({ organizationId }, (rows) =>
+				rows?.map((row) => {
+					const update = updates.find((u) => u.workspaceId === row.id);
+					return update
+						? {
+								...row,
+								agentStatus: update.agentStatus,
+								agentStatusAt: new Date(update.agentStatusAt),
+							}
+						: row;
+				}),
+			);
+		};
+
 		const socket = createRelaySocket({
 			buildUrl: () =>
 				`${env.REALTIME_URL}${realtimeNudgesPath(organizationId)}`,
@@ -58,7 +77,9 @@ export function RealtimeNudges() {
 		});
 		socket.addEventListener("message", (event) => {
 			const message = parseRealtimeNudgeMessage(event.data);
-			if (message) invalidate(message.kinds);
+			if (!message) return;
+			patch(message.updates);
+			invalidate(message.kinds);
 		});
 		return () => socket.close(1000, "unsubscribed");
 	}, [organizationId, utils]);

apps/desktop/src/renderer/stores/v2-notifications/store.ts

@@ -32,10 +32,18 @@ export interface V2NotificationState {
 	 * and, with the monotonic guard, poison the comparison.
 	 */
 	terminalSeenAt: Record<string, number>;
+	/**
+	 * workspaceId → the reported status timestamp the user has seen, for
+	 * hosts that report a status instead of exposing bindings. Same clock
+	 * rule as terminalSeenAt: the reporting host's, never the renderer's.
+	 */
+	workspaceSeenAt: Record<string, number>;
 	setManualUnread: (workspaceId: string) => void;
 	clearManualUnread: (workspaceId: string) => void;
 	markTerminalSeen: (terminalId: string, at: number) => void;
 	pruneTerminalSeen: (terminalId: string) => void;
+	markWorkspaceSeen: (workspaceId: string, at: number) => void;
+	pruneWorkspaceSeen: (workspaceId: string) => void;
 }
 
 export const useV2NotificationStore = create<V2NotificationState>()(
@@ -44,6 +52,7 @@ export const useV2NotificationStore = create<V2NotificationState>()(
 			(set) => ({
 				manualUnread: {},
 				terminalSeenAt: {},
+				workspaceSeenAt: {},
 				setManualUnread: (workspaceId) => {
 					set((state) => ({
 						manualUnread: { ...state.manualUnread, [workspaceId]: true },
@@ -75,13 +84,31 @@ export const useV2NotificationStore = create<V2NotificationState>()(
 						return { terminalSeenAt };
 					});
 				},
+				markWorkspaceSeen: (workspaceId, at) => {
+					set((state) => {
+						const prev = state.workspaceSeenAt[workspaceId];
+						if (prev !== undefined && prev >= at) return state;
+						return {
+							workspaceSeenAt: { ...state.workspaceSeenAt, [workspaceId]: at },
+						};
+					});
+				},
+				pruneWorkspaceSeen: (workspaceId) => {
+					set((state) => {
+						if (!(workspaceId in state.workspaceSeenAt)) return state;
+						const { [workspaceId]: _removed, ...workspaceSeenAt } =
+							state.workspaceSeenAt;
+						return { workspaceSeenAt };
+					});
+				},
 			}),
 			{
 				name: "v2-notifications-v1",
 				version: 2,
 				partialize: (state) => ({
 					manualUnread: state.manualUnread,
 					terminalSeenAt: state.terminalSeenAt,
+					workspaceSeenAt: state.workspaceSeenAt,
 				}),
 				migrate: migrateV2NotificationState,
 			},
@@ -92,7 +119,7 @@ export const useV2NotificationStore = create<V2NotificationState>()(
 
 type PersistedV2NotificationState = Pick<
 	V2NotificationState,
-	"manualUnread" | "terminalSeenAt"
+	"manualUnread" | "terminalSeenAt" | "workspaceSeenAt"
 >;
 
 /**
@@ -111,6 +138,7 @@ export function migrateV2NotificationState(
 		return {
 			manualUnread: state?.manualUnread ?? {},
 			terminalSeenAt: state?.terminalSeenAt ?? {},
+			workspaceSeenAt: state?.workspaceSeenAt ?? {},
 		};
 	}
 	const legacy = persisted as
@@ -128,7 +156,7 @@ export function migrateV2NotificationState(
 			manualUnread[entry.workspaceId] = true;
 		}
 	}
-	return { manualUnread, terminalSeenAt: {} };
+	return { manualUnread, terminalSeenAt: {}, workspaceSeenAt: {} };
 }
 
 export function getV2NotificationSourceKey(