Skip to content

The open-source app everyone uses to manage agents at work

Merge public-gh/master into fix/hmr-websocket-reverse-proxy

dottab5efd8b435e5
diff --cc ui/index.html
index d982aa0ac2,1bb9152e1e..70a8550ead
--- a/ui/index.html
+++ b/ui/index.html
@@@ -4,7 -4,7 +4,8 @@@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
<meta name="theme-color" content="#18181b" />
+ <meta name="mobile-web-app-capable" content="yes" />
+ <meta name="apple-mobile-web-app-capable" content="yes" />
<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
<meta name="apple-mobile-web-app-title" content="Paperclip" />
<title>Paperclip</title>
diff --cc ui/src/context/LiveUpdatesProvider.test.ts
index 0000000000,3a66cec463..0bbbaabcec
mode 000000,100644..100644
--- a/ui/src/context/LiveUpdatesProvider.test.ts
+++ b/ui/src/context/LiveUpdatesProvider.test.ts
@@@ -1,0 -1,119 +1,171 @@@
+ // @vitest-environment node
+
-import { describe, expect, it } from "vitest";
++import { describe, expect, it, vi } from "vitest";
+ import { __liveUpdatesTestUtils } from "./LiveUpdatesProvider";
+ import { queryKeys } from "../lib/queryKeys";
+
+ describe("LiveUpdatesProvider issue invalidation", () => {
+ it("refreshes touched inbox queries for issue activity", () => {
+ const invalidations: unknown[] = [];
+ const queryClient = {
+ invalidateQueries: (input: unknown) => {
+ invalidations.push(input);
+ },
+ getQueryData: () => undefined,
+ };
+
+ __liveUpdatesTestUtils.invalidateActivityQueries(
+ queryClient as never,
+ "company-1",
+ {
+ entityType: "issue",
+ entityId: "issue-1",
+ details: null,
+ },
+ );
+
+ expect(invalidations).toContainEqual({
+ queryKey: queryKeys.issues.listMineByMe("company-1"),
+ });
+ expect(invalidations).toContainEqual({
+ queryKey: queryKeys.issues.listTouchedByMe("company-1"),
+ });
+ expect(invalidations).toContainEqual({
+ queryKey: queryKeys.issues.listUnreadTouchedByMe("company-1"),
+ });
+ });
+ });
+
+ describe("LiveUpdatesProvider visible issue toast suppression", () => {
+ it("suppresses activity toasts for the issue page currently in view", () => {
+ const queryClient = {
+ getQueryData: (key: unknown) => {
+ if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
+ return {
+ id: "issue-1",
+ identifier: "PAP-759",
+ assigneeAgentId: "agent-1",
+ };
+ }
+ return undefined;
+ },
+ };
+
+ expect(
+ __liveUpdatesTestUtils.shouldSuppressActivityToastForVisibleIssue(
+ queryClient as never,
+ "/PAP/issues/PAP-759",
+ {
+ entityType: "issue",
+ entityId: "issue-1",
+ details: { identifier: "PAP-759" },
+ },
+ { isForegrounded: true },
+ ),
+ ).toBe(true);
+
+ expect(
+ __liveUpdatesTestUtils.shouldSuppressActivityToastForVisibleIssue(
+ queryClient as never,
+ "/PAP/issues/PAP-759",
+ {
+ entityType: "issue",
+ entityId: "issue-2",
+ details: { identifier: "PAP-760" },
+ },
+ { isForegrounded: true },
+ ),
+ ).toBe(false);
+ });
+
+ it("suppresses run and agent status toasts for the assignee of the visible issue", () => {
+ const queryClient = {
+ getQueryData: (key: unknown) => {
+ if (JSON.stringify(key) === JSON.stringify(queryKeys.issues.detail("PAP-759"))) {
+ return {
+ id: "issue-1",
+ identifier: "PAP-759",
+ assigneeAgentId: "agent-1",
+ };
+ }
+ return undefined;
+ },
+ };
+
+ expect(
+ __liveUpdatesTestUtils.shouldSuppressRunStatusToastForVisibleIssue(
+ queryClient as never,
+ "/PAP/issues/PAP-759",
+ {
+ runId: "run-1",
+ agentId: "agent-1",
+ },
+ { isForegrounded: true },
+ ),
+ ).toBe(true);
+
+ expect(
+ __liveUpdatesTestUtils.shouldSuppressAgentStatusToastForVisibleIssue(
+ queryClient as never,
+ "/PAP/issues/PAP-759",
+ {
+ agentId: "agent-1",
+ status: "running",
+ },
+ { isForegrounded: true },
+ ),
+ ).toBe(true);
+ });
+ });
++
++describe("LiveUpdatesProvider socket helpers", () => {
++ it("waits for the selected company object to catch up before connecting", () => {
++ expect(__liveUpdatesTestUtils.resolveLiveCompanyId("company-1", null)).toBeNull();
++ expect(__liveUpdatesTestUtils.resolveLiveCompanyId("company-1", "company-2")).toBeNull();
++ expect(__liveUpdatesTestUtils.resolveLiveCompanyId("company-1", "company-1")).toBe("company-1");
++ });
++
++ it("defers close until onopen for sockets that are still connecting", () => {
++ const socket = {
++ readyState: 0,
++ onopen: (() => undefined) as (() => void) | null,
++ onmessage: (() => undefined) as (() => void) | null,
++ onerror: (() => undefined) as (() => void) | null,
++ onclose: (() => undefined) as (() => void) | null,
++ close: vi.fn(),
++ };
++
++ __liveUpdatesTestUtils.closeSocketQuietly(socket as never, "provider_unmount");
++
++ expect(socket.close).not.toHaveBeenCalled();
++ expect(socket.onmessage).toBeNull();
++ expect(socket.onclose).toBeNull();
++ expect(socket.onopen).toBeTypeOf("function");
++ expect(socket.onerror).toBeTypeOf("function");
++
++ socket.onopen?.();
++
++ expect(socket.close).toHaveBeenCalledWith(1000, "provider_unmount");
++ expect(socket.onopen).toBeNull();
++ expect(socket.onerror).toBeNull();
++ });
++
++ it("closes open sockets immediately without leaving handlers behind", () => {
++ const socket = {
++ readyState: 1,
++ onopen: (() => undefined) as (() => void) | null,
++ onmessage: (() => undefined) as (() => void) | null,
++ onerror: (() => undefined) as (() => void) | null,
++ onclose: (() => undefined) as (() => void) | null,
++ close: vi.fn(),
++ };
++
++ __liveUpdatesTestUtils.closeSocketQuietly(socket as never, "stale_connection");
++
++ expect(socket.close).toHaveBeenCalledWith(1000, "stale_connection");
++ expect(socket.onopen).toBeNull();
++ expect(socket.onmessage).toBeNull();
++ expect(socket.onerror).toBeNull();
++ expect(socket.onclose).toBeNull();
++ });
++});
diff --cc ui/src/context/LiveUpdatesProvider.tsx
index 69fdc61fc1,ec593b3bfd..b4f8338832
--- a/ui/src/context/LiveUpdatesProvider.tsx
+++ b/ui/src/context/LiveUpdatesProvider.tsx
@@@ -10,6 -14,6 +14,17 @@@ import { useLocation } from "../lib/rou
const TOAST_COOLDOWN_WINDOW_MS = 10_000;
const TOAST_COOLDOWN_MAX = 3;
const RECONNECT_SUPPRESS_MS = 2000;
++const SOCKET_CONNECTING = 0;
++const SOCKET_OPEN = 1;
++
++type LiveUpdatesSocketLike = {
++ readyState: number;
++ onopen: ((this: WebSocket, ev: Event) => unknown) | null;
++ onmessage: ((this: WebSocket, ev: MessageEvent) => unknown) | null;
++ onerror: ((this: WebSocket, ev: Event) => unknown) | null;
++ onclose: ((this: WebSocket, ev: CloseEvent) => unknown) | null;
++ close: (code?: number, reason?: string) => void;
++};
function readString(value: unknown): string | null {
return typeof value === "string" && value.length > 0 ? value : null;
@@@ -510,34 -652,33 +663,88 @@@ function handleLiveEvent
}
}
++function resolveLiveCompanyId(
++ selectedCompanyId: string | null,
++ selectedCompanyLiveId: string | null,
++): string | null {
++ return selectedCompanyId && selectedCompanyId === selectedCompanyLiveId
++ ? selectedCompanyId
++ : null;
++}
++
++function resetSocketHandlers(target: LiveUpdatesSocketLike) {
++ target.onopen = null;
++ target.onmessage = null;
++ target.onerror = null;
++ target.onclose = null;
++}
++
++function closeSocketQuietly(target: LiveUpdatesSocketLike | null, reason: string) {
++ if (!target) return;
++
++ if (target.readyState === SOCKET_CONNECTING) {
++ // Let the handshake complete and then close. Calling close() while the
++ // socket is still CONNECTING is what triggers the noisy browser error.
++ target.onopen = () => {
++ resetSocketHandlers(target);
++ target.close(1000, reason);
++ };
++ target.onmessage = null;
++ target.onerror = () => undefined;
++ target.onclose = null;
++ return;
++ }
++
++ resetSocketHandlers(target);
++
++ if (target.readyState === SOCKET_OPEN) {
++ target.close(1000, reason);
++ }
++}
++
+ export const __liveUpdatesTestUtils = {
++ closeSocketQuietly,
+ invalidateActivityQueries,
++ resolveLiveCompanyId,
+ shouldSuppressActivityToastForVisibleIssue,
+ shouldSuppressRunStatusToastForVisibleIssue,
+ shouldSuppressAgentStatusToastForVisibleIssue,
+ };
+
export function LiveUpdatesProvider({ children }: { children: ReactNode }) {
- const { selectedCompanyId } = useCompany();
+ const { selectedCompanyId, selectedCompany } = useCompany();
const queryClient = useQueryClient();
const { pushToast } = useToast();
+ const location = useLocation();
const gateRef = useRef<ToastGate>({ cooldownHits: new Map(), suppressUntil: 0 });
+ const pathnameRef = useRef(location.pathname);
- const { data: session } = useQuery({
+ const { data: session, status: sessionStatus } = useQuery({
queryKey: queryKeys.auth.session,
queryFn: () => authApi.getSession(),
retry: false,
});
const currentUserId = session?.user?.id ?? session?.session?.userId ?? null;
+ const socketAuthKey = session?.session?.id ?? currentUserId ?? "signed_out";
- const liveCompanyId = selectedCompany?.id === selectedCompanyId ? selectedCompanyId : null;
++ const liveCompanyId = resolveLiveCompanyId(selectedCompanyId, selectedCompany?.id ?? null);
+ const canConnectSocket = sessionStatus === "success" && session !== null && liveCompanyId !== null;
+ const currentActorRef = useRef<{ userId: string | null; agentId: string | null }>({
+ userId: currentUserId,
+ agentId: null,
+ });
+ useEffect(() => {
+ pathnameRef.current = location.pathname;
+ }, [location.pathname]);
+
useEffect(() => {
- if (!selectedCompanyId) return;
+ currentActorRef.current = {
+ userId: currentUserId,
+ agentId: null,
+ };
+ }, [currentUserId]);
+
+ useEffect(() => {
+ if (!canConnectSocket || !liveCompanyId) return;
let closed = false;
let reconnectAttempt = 0;
@@@ -615,9 -721,9 +792,9 @@@
try {
const parsed = JSON.parse(raw) as LiveEvent;
- handleLiveEvent(queryClient, liveCompanyId, parsed, pushToast, gateRef.current, {
- handleLiveEvent(queryClient, selectedCompanyId, pathnameRef.current, parsed, pushToast, gateRef.current, {
- userId: currentUserId,
- agentId: null,
++ handleLiveEvent(queryClient, liveCompanyId, pathnameRef.current, parsed, pushToast, gateRef.current, {
+ userId: currentActorRef.current.userId,
+ agentId: currentActorRef.current.agentId,
});
} catch {
// Ignore non-JSON payloads.