Skip to content

Supercharge your AI agents with data from the web and beyond. Building the library for superintelligence. 🔥

Reland "feat(api): record saved browser profiles from the browser service (#4730)" (#4733)

Gergő Móricz783e9ccb06f7
diff --git a/apps/api/src/__tests__/snips/v2/browser-profiles.test.ts b/apps/api/src/__tests__/snips/v2/browser-profiles.test.ts
new file mode 100644
index 000000000..9787ce65a
--- /dev/null
+++ b/apps/api/src/__tests__/snips/v2/browser-profiles.test.ts
@@ -0,0 +1,235 @@
+import request from "supertest";
+import { and, eq, inArray } from "drizzle-orm";
+import { v7 as uuidv7 } from "uuid";
+import { config } from "../../../config";
+import { describeIf, TEST_API_URL, TEST_PRODUCTION } from "../lib";
+import { idmux, Identity } from "./lib";
+import { db } from "../../../db/connection";
+import * as schema from "../../../db/schema";
+import { browserProfileStorageId } from "../../../lib/browser-profiles";
+
+const WEBHOOK_SECRET = config.BROWSER_SERVICE_WEBHOOK_SECRET;
+
+// The browser service reports each successful profile save to the same webhook
+// as session.ended. These tests stand in for it, against a session row shaped
+// like the one the API writes when a session is created with a profile.
+describeIf(TEST_PRODUCTION && !!WEBHOOK_SECRET)(
+ "Browser profile registry (profile.saved webhook)",
+ () => {
+ let identity: Identity;
+ const sessionIds: string[] = [];
+ const profileNames: string[] = [];
+
+ beforeAll(async () => {
+ identity = await idmux({ name: "browser-profiles", credits: 100 });
+ });
+
+ afterAll(async () => {
+ if (profileNames.length > 0) {
+ await db
+ .delete(schema.browser_profiles)
+ .where(
+ and(
+ eq(schema.browser_profiles.team_id, identity.teamId),
+ inArray(schema.browser_profiles.name, profileNames),
+ ),
+ );
+ }
+ if (sessionIds.length > 0) {
+ await db
+ .delete(schema.browser_sessions)
+ .where(inArray(schema.browser_sessions.id, sessionIds));
+ }
+ });
+
+ const newProfileName = () => {
+ const name = `snips-${uuidv7()}`;
+ profileNames.push(name);
+ return name;
+ };
+
+ // Returns the browser-service session id the webhook addresses.
+ const createSession = async (profileName: string | null) => {
+ const id = uuidv7();
+ const browserId = `snips-${id}`;
+ await db.insert(schema.browser_sessions).values({
+ id,
+ team_id: identity.teamId,
+ browser_id: browserId,
+ workspace_id: "",
+ context_id: "",
+ cdp_url: "wss://example.invalid/cdp",
+ cdp_path: "https://example.invalid/view",
+ stream_web_view: false,
+ status: "destroyed",
+ ttl_total: 60,
+ should_bill: false,
+ profile_name: profileName,
+ });
+ sessionIds.push(id);
+ return browserId;
+ };
+
+ const profileSaved = (
+ browserId: string,
+ profileId: string,
+ savedAt: string,
+ sizeBytes?: number,
+ ) => ({
+ eventId: uuidv7(),
+ eventType: "profile.saved",
+ sessionId: browserId,
+ profileId,
+ savedAt,
+ ...(sizeBytes !== undefined ? { sizeBytes } : {}),
+ attempt: 0,
+ });
+
+ // A null secret omits the header.
+ const send = (body: object, secret: string | null = WEBHOOK_SECRET!) => {
+ const req = request(TEST_API_URL).post("/v2/browser/webhook/destroyed");
+ if (secret !== null) req.set("x-browser-service-secret", secret);
+ return req.send(body);
+ };
+
+ const profileRow = async (name: string) => {
+ const [row] = await db
+ .select()
+ .from(schema.browser_profiles)
+ .where(
+ and(
+ eq(schema.browser_profiles.team_id, identity.teamId),
+ eq(schema.browser_profiles.name, name),
+ ),
+ );
+ return row;
+ };
+
+ it("records a saved profile under the session's team", async () => {
+ const name = newProfileName();
+ const browserId = await createSession(name);
+
+ const res = await send(
+ profileSaved(
+ browserId,
+ browserProfileStorageId(identity.teamId, name),
+ "2026-09-22T10:00:00.000Z",
+ 4096,
+ ),
+ );
+ expect(res.statusCode).toBe(200);
+
+ const row = await profileRow(name);
+ expect(row).toBeDefined();
+ expect(new Date(row!.saved_at).toISOString()).toBe(
+ "2026-09-22T10:00:00.000Z",
+ );
+ expect(row!.size_bytes).toBe(4096);
+ });
+
+ it("keeps the newest save when deliveries arrive out of order", async () => {
+ const name = newProfileName();
+ const profileId = browserProfileStorageId(identity.teamId, name);
+ const first = await createSession(name);
+ const second = await createSession(name);
+
+ const newer = await send(
+ profileSaved(second, profileId, "2026-09-22T12:00:00.000Z", 9000),
+ );
+ expect(newer.statusCode).toBe(200);
+ // An older save's retry lands after the newer one.
+ const older = await send(
+ profileSaved(first, profileId, "2026-09-22T11:00:00.000Z", 1000),
+ );
+ expect(older.statusCode).toBe(200);
+
+ const row = await profileRow(name);
+ expect(new Date(row!.saved_at).toISOString()).toBe(
+ "2026-09-22T12:00:00.000Z",
+ );
+ expect(row!.size_bytes).toBe(9000);
+ });
+
+ it("keeps the last known size when a newer save reports none", async () => {
+ const name = newProfileName();
+ const profileId = browserProfileStorageId(identity.teamId, name);
+ const first = await createSession(name);
+ const second = await createSession(name);
+
+ expect(
+ (
+ await send(
+ profileSaved(first, profileId, "2026-09-22T11:00:00.000Z", 1000),
+ )
+ ).statusCode,
+ ).toBe(200);
+ expect(
+ (
+ await send(
+ profileSaved(second, profileId, "2026-09-22T12:00:00.000Z"),
+ )
+ ).statusCode,
+ ).toBe(200);
+
+ const row = await profileRow(name);
+ expect(new Date(row!.saved_at).toISOString()).toBe(
+ "2026-09-22T12:00:00.000Z",
+ );
+ expect(row!.size_bytes).toBe(1000);
+ });
+
+ it("rejects a save whose profile id does not match the session", async () => {
+ const name = newProfileName();
+ const browserId = await createSession(name);
+
+ const res = await send(
+ profileSaved(
+ browserId,
+ browserProfileStorageId(identity.teamId, `${name}-other`),
+ "2026-09-22T10:00:00.000Z",
+ ),
+ );
+ expect(res.statusCode).toBe(409);
+ expect(await profileRow(name)).toBeUndefined();
+ });
+
+ it("ignores saves for unknown sessions and sessions without a profile", async () => {
+ const name = newProfileName();
+ const profileId = browserProfileStorageId(identity.teamId, name);
+
+ const unknown = await send(
+ profileSaved(
+ `snips-unknown-${uuidv7()}`,
+ profileId,
+ "2026-09-22T10:00:00.000Z",
+ ),
+ );
+ expect(unknown.statusCode).toBe(200);
+
+ const withoutProfile = await createSession(null);
+ const noProfile = await send(
+ profileSaved(withoutProfile, profileId, "2026-09-22T10:00:00.000Z"),
+ );
+ expect(noProfile.statusCode).toBe(200);
+
+ expect(await profileRow(name)).toBeUndefined();
+ });
+
+ it("rejects malformed events and requests without the secret", async () => {
+ const name = newProfileName();
+ const browserId = await createSession(name);
+ const event = profileSaved(
+ browserId,
+ browserProfileStorageId(identity.teamId, name),
+ "2026-09-22T10:00:00.000Z",
+ );
+
+ expect((await send({ ...event, savedAt: "yesterday" })).statusCode).toBe(
+ 400,
+ );
+ expect((await send(event, null)).statusCode).toBe(401);
+ expect((await send(event, "wrong-secret")).statusCode).toBe(401);
+ expect(await profileRow(name)).toBeUndefined();
+ });
+ },
+);
diff --git a/apps/api/src/controllers/v2/browser.ts b/apps/api/src/controllers/v2/browser.ts
index de8542735..c4f0b896e 100644
--- a/apps/api/src/controllers/v2/browser.ts
+++ b/apps/api/src/controllers/v2/browser.ts
@@ -1,4 +1,3 @@
-import { createHash } from "crypto";
import { v7 as uuidv7 } from "uuid";
import { Request, Response } from "express";
import { z } from "zod";
@@ -16,6 +15,7 @@ import {
invalidateActiveBrowserSessionCount,
didBrowserSessionUsePrompt,
clearBrowserSessionPromptFlag,
+ upsertBrowserProfile,
} from "../../lib/browser-sessions";
import {
getCombinedTeamActiveCount,
@@ -38,6 +38,11 @@ import { autumnService } from "../../services/autumn/autumn.service";
import { orgIdForTeam } from "../../lib/team-org";
import { isAgentInteropSecretValid } from "../../lib/agent-interop";
import { recordRequestCredits } from "../../lib/request-credits-store";
+import {
+ browserProfileStorageId,
+ profileSavedEventSchema,
+ resolveProfileSave,
+} from "../../lib/browser-profiles";
import {
getSafeMode,
SAFE_MODE_BROWSER_UNSUPPORTED_MESSAGE,
@@ -332,12 +337,8 @@ export async function browserCreateController(
// Build persistentStorage from profile if provided
let persistentStorage: { uniqueId: string; write: boolean } | undefined;
if (profile) {
- const teamHash = createHash("sha256")
- .update(req.auth.team_id)
- .digest("hex")
- .slice(0, 16);
persistentStorage = {
- uniqueId: `${teamHash}_${profile.name}`,
+ uniqueId: browserProfileStorageId(req.auth.team_id, profile.name),
write: profile.saveChanges !== false,
};
}
@@ -425,6 +426,7 @@ export async function browserCreateController(
ttl_total: ttl,
ttl_without_activity: activityTtl ?? null,
credits_used: null,
+ profile_name: profile?.name ?? null,
});
} catch (err) {
// If we can't persist, tear down the browser session
@@ -792,6 +794,66 @@ export async function browserListController(
});
}
+// Records that a session's persistent profile now has saved state, so the
+// profile can be listed. Retried by the browser service on any non-2xx.
+async function handleProfileSavedWebhook(
+ req: Request,
+ res: Response,
+ logger: typeof _logger,
+) {
+ const parsed = profileSavedEventSchema.safeParse(req.body);
+ if (!parsed.success) {
+ logger.warn("Malformed profile.saved webhook", { error: parsed.error });
+ return res.status(400).json({ error: "Invalid profile.saved event" });
+ }
+ const event = parsed.data;
+ const browserId = event.sessionId;
+
+ const session = await getBrowserSessionByBrowserId(browserId);
+ if (!session) {
+ logger.warn("No session found for profile.saved webhook", {
+ browserId,
+ eventId: event.eventId,
+ });
+ return res.status(200).json({ ok: true });
+ }
+
+ const resolution = resolveProfileSave(session, event);
+ if (resolution.action === "ignore") {
+ logger.info("Not recording saved profile", {
+ browserId,
+ sessionId: session.id,
+ reason: resolution.reason,
+ });
+ return res.status(200).json({ ok: true });
+ }
+ if (resolution.action === "reject") {
+ logger.error("profile.saved webhook does not match the session's profile", {
+ browserId,
+ sessionId: session.id,
+ teamId: session.team_id,
+ profileId: event.profileId,
+ });
+ return res
+ .status(409)
+ .json({ error: "Profile does not match the session" });
+ }
+
+ await upsertBrowserProfile({
+ teamId: resolution.teamId,
+ name: resolution.name,
+ savedAt: event.savedAt,
+ sizeBytes: event.sizeBytes,
+ });
+ logger.info("Recorded saved browser profile", {
+ browserId,
+ sessionId: session.id,
+ teamId: resolution.teamId,
+ eventId: event.eventId,
+ });
+ return res.status(200).json({ ok: true });
+}
+
export async function browserWebhookDestroyedController(
req: Request,
res: Response,
@@ -811,6 +873,12 @@ export async function browserWebhookDestroyedController(
return res.status(401).json({ error: "Unauthorized" });
}
+ // The browser service posts every outbox event here. session.ended (the
+ // original event, sent without a check on eventType) bills below.
+ if (req.body?.eventType === "profile.saved") {
+ return handleProfileSavedWebhook(req, res, logger);
+ }
+
const { sessionId, sessionDurationMs } = req.body as {
sessionId?: string;
sessionDurationMs?: number;
diff --git a/apps/api/src/controllers/v2/scrape-browser.ts b/apps/api/src/controllers/v2/scrape-browser.ts
index 5096c4087..16b346f5a 100644
--- a/apps/api/src/controllers/v2/scrape-browser.ts
+++ b/apps/api/src/controllers/v2/scrape-browser.ts
@@ -1,4 +1,3 @@
-import { createHash } from "crypto";
import { v7 as uuidv7 } from "uuid";
import { Response } from "express";
import { z } from "zod";
@@ -73,6 +72,7 @@ import { getScrapeJobAccess } from "../../lib/operational-job-access";
import { readScrapeJobState } from "../../lib/job-state-store";
import { scrapeQueue } from "../../services/worker/nuq-router";
import { recordJobStorePostgresFallback } from "../../lib/job-store-fallback";
+import { browserProfileStorageId } from "../../lib/browser-profiles";
// ---------------------------------------------------------------------------
// Schemas
@@ -712,12 +712,8 @@ async function createSessionForScrape(
let persistentStorage: { uniqueId: string; write: boolean } | undefined;
if (profile) {
- const teamHash = createHash("sha256")
- .update(req.auth.team_id)
- .digest("hex")
- .slice(0, 16);
persistentStorage = {
- uniqueId: `${teamHash}_${profile.name}`,
+ uniqueId: browserProfileStorageId(req.auth.team_id, profile.name),
write: profile.saveChanges !== false,
};
}
@@ -920,6 +916,7 @@ async function createSessionForScrape(
ttl_total: ttl,
ttl_without_activity: activityTtl ?? null,
credits_used: null,
+ profile_name: profile?.name ?? null,
});
invalidateActiveBrowserSessionCount(req.auth.team_id).catch(() => {});
diff --git a/apps/api/src/db/schema/public.ts b/apps/api/src/db/schema/public.ts
index badc57f6b..774bd1273 100644
--- a/apps/api/src/db/schema/public.ts
+++ b/apps/api/src/db/schema/public.ts
@@ -16,6 +16,7 @@ import {
check,
foreignKey,
index,
+ primaryKey,
unique,
} from "drizzle-orm/pg-core";
@@ -143,8 +144,25 @@ export const browser_sessions = pgTable("browser_sessions", {
credits_used: integer("credits_used"),
cdp_interactive_path: text("cdp_interactive_path"),
scrape_id: uuid("scrape_id"),
+ // The persistent profile the session was created with, if any.
+ profile_name: text("profile_name"),
});
+// Index of saved persistent browser profiles (see browser_profiles migration).
+// Contents live in browser-service object storage; a row is upserted when the
+// browser service reports a successful save.
+export const browser_profiles = pgTable(
+ "browser_profiles",
+ {
+ team_id: uuid("team_id").notNull(),
+ name: text("name").notNull(),
+ created_at: ts("created_at").notNull().defaultNow(),
+ saved_at: ts("saved_at").notNull(),
+ size_bytes: bigintNum("size_bytes"),
+ },
+ table => [primaryKey({ columns: [table.team_id, table.name] })],
+);
+
export const crawls = pgTable("crawls", {
id: uuid("id").notNull(),
request_id: uuid("request_id").notNull(),
diff --git a/apps/api/src/lib/browser-profiles.test.ts b/apps/api/src/lib/browser-profiles.test.ts
new file mode 100644
index 000000000..5bea8b479
--- /dev/null
+++ b/apps/api/src/lib/browser-profiles.test.ts
@@ -0,0 +1,113 @@
+import {
+ browserProfileStorageId,
+ profileSavedEventSchema,
+ resolveProfileSave,
+} from "./browser-profiles";
+
+const TEAM = "00000000-0000-4000-8000-000000000001";
+const OTHER_TEAM = "00000000-0000-4000-8000-000000000002";
+
+describe("browserProfileStorageId", () => {
+ it("prefixes the name with the first 16 hex chars of sha256(teamId)", () => {
+ expect(browserProfileStorageId(TEAM, "my-profile")).toBe(
+ "11e594f481958c10_my-profile",
+ );
+ expect(browserProfileStorageId(OTHER_TEAM, "my-profile")).toBe(
+ "e79acd97ac880866_my-profile",
+ );
+ });
+
+ it("keeps the name verbatim, underscores included", () => {
+ expect(browserProfileStorageId(TEAM, "a_b c")).toBe(
+ "11e594f481958c10_a_b c",
+ );
+ });
+});
+
+describe("profileSavedEventSchema", () => {
+ const event = {
+ eventId: "a4f5c6a0-4c1f-4a7f-9d0b-3e0f1d2c3b4a",
+ eventType: "profile.saved",
+ sessionId: "bs_123",
+ profileId: "11e594f481958c10_my-profile",
+ savedAt: "2026-09-22T19:30:00.000Z",
+ sizeBytes: 48213,
+ attempt: 2,
+ };
+
+ it("accepts the event the browser service sends", () => {
+ expect(profileSavedEventSchema.parse(event)).toMatchObject({
+ sessionId: "bs_123",
+ profileId: "11e594f481958c10_my-profile",
+ savedAt: "2026-09-22T19:30:00.000Z",
+ sizeBytes: 48213,
+ });
+ });
+
+ it("accepts an event without a size", () => {
+ const { sizeBytes: _, ...withoutSize } = event;
+ expect(profileSavedEventSchema.safeParse(withoutSize).success).toBe(true);
+ });
+
+ it.each([
+ ["another event type", { eventType: "session.ended" }],
+ ["a missing savedAt", { savedAt: undefined }],
+ ["a savedAt that is not a timestamp", { savedAt: "yesterday" }],
+ ["a negative size", { sizeBytes: -1 }],
+ ["a fractional size", { sizeBytes: 1.5 }],
+ ["an empty profile id", { profileId: "" }],
+ ])("rejects %s", (_, override) => {
+ expect(
+ profileSavedEventSchema.safeParse({ ...event, ...override }).success,
+ ).toBe(false);
+ });
+});
+
+describe("resolveProfileSave", () => {
+ const profileId = browserProfileStorageId(TEAM, "my-profile");
+
+ it("upserts under the session's own team and profile name", () => {
+ expect(
+ resolveProfileSave(
+ { team_id: TEAM, profile_name: "my-profile" },
+ { profileId },
+ ),
+ ).toEqual({ action: "upsert", teamId: TEAM, name: "my-profile" });
+ });
+
+ it("ignores sessions that recorded no profile name", () => {
+ for (const profile_name of [null, undefined]) {
+ expect(
+ resolveProfileSave({ team_id: TEAM, profile_name }, { profileId }),
+ ).toEqual({ action: "ignore", reason: "no_profile_name" });
+ }
+ });
+
+ it("ignores keyless callers, which have no team to list under", () => {
+ const keylessTeam = "preview_keyless_203.0.113.7";
+ expect(
+ resolveProfileSave(
+ { team_id: keylessTeam, profile_name: "my-profile" },
+ { profileId: browserProfileStorageId(keylessTeam, "my-profile") },
+ ),
+ ).toEqual({ action: "ignore", reason: "not_a_team" });
+ });
+
+ it("rejects a storage id that belongs to another team", () => {
+ expect(
+ resolveProfileSave(
+ { team_id: TEAM, profile_name: "my-profile" },
+ { profileId: browserProfileStorageId(OTHER_TEAM, "my-profile") },
+ ),
+ ).toEqual({ action: "reject", reason: "profile_mismatch" });
+ });
+
+ it("rejects a storage id for a different profile name", () => {
+ expect(
+ resolveProfileSave(
+ { team_id: TEAM, profile_name: "my-profile" },
+ { profileId: browserProfileStorageId(TEAM, "other-profile") },
+ ),
+ ).toEqual({ action: "reject", reason: "profile_mismatch" });
+ });
+});
diff --git a/apps/api/src/lib/browser-profiles.ts b/apps/api/src/lib/browser-profiles.ts
new file mode 100644
index 000000000..f6fa0991b
--- /dev/null
+++ b/apps/api/src/lib/browser-profiles.ts
@@ -0,0 +1,67 @@
+// Pure helpers for persistent browser profiles, kept free of the DB so the
+// scrape engine can import the storage id. The table writes live in
+// browser-sessions.ts.
+import { createHash } from "crypto";
+import { z } from "zod";
+
+/**
+ * The id a profile's saved state is stored under in the browser service: the
+ * first 16 hex chars of sha256(teamId), then the profile name. /scrape, browser
+ * sessions and interact sessions must all derive it the same way, or they read
+ * and write different profiles.
+ */
+export function browserProfileStorageId(teamId: string, name: string): string {
+ const teamHash = createHash("sha256")
+ .update(teamId)
+ .digest("hex")
+ .slice(0, 16);
+ return `${teamHash}_${name}`;
+}
+
+// Sent by the browser service's webhook outbox after it uploads a session's
+// profile. It names the browser-service session and the storage id only.
+export const profileSavedEventSchema = z.object({
+ eventType: z.literal("profile.saved"),
+ eventId: z.string().min(1),
+ sessionId: z.string().min(1),
+ profileId: z.string().min(1),
+ savedAt: z.iso.datetime({ offset: true }),
+ sizeBytes: z.number().int().nonnegative().optional(),
+});
+
+type ProfileSavedEvent = z.infer<typeof profileSavedEventSchema>;
+
+type ProfileSaveResolution =
+ | { action: "upsert"; teamId: string; name: string }
+ | { action: "ignore"; reason: "no_profile_name" | "not_a_team" }
+ | { action: "reject"; reason: "profile_mismatch" };
+
+/**
+ * Decides what a reported save means for the session it came from. The team
+ * and profile name come from our own session row, never from the event, and
+ * the event's storage id must be the one that row derives.
+ */
+export function resolveProfileSave(
+ session: { team_id: string; profile_name?: string | null },
+ event: Pick<ProfileSavedEvent, "profileId">,
+): ProfileSaveResolution {
+ // Sessions created before profile_name was recorded.
+ if (!session.profile_name) {
+ return { action: "ignore", reason: "no_profile_name" };
+ }
+ // Keyless callers (preview_keyless_<ip>) have no teams row to list under.
+ if (!z.uuid().safeParse(session.team_id).success) {
+ return { action: "ignore", reason: "not_a_team" };
+ }
+ if (
+ browserProfileStorageId(session.team_id, session.profile_name) !==
+ event.profileId
+ ) {
+ return { action: "reject", reason: "profile_mismatch" };
+ }
+ return {
+ action: "upsert",
+ teamId: session.team_id,
+ name: session.profile_name,
+ };
+}
diff --git a/apps/api/src/lib/browser-sessions.ts b/apps/api/src/lib/browser-sessions.ts
index c49ca50e6..8ffebe725 100644
--- a/apps/api/src/lib/browser-sessions.ts
+++ b/apps/api/src/lib/browser-sessions.ts
@@ -1,4 +1,4 @@
-import { and, desc, eq } from "drizzle-orm";
+import { and, desc, eq, sql } from "drizzle-orm";
import { deleteKey, getValue, setValue } from "../services/redis";
import { db } from "../db/connection";
import * as schema from "../db/schema";
@@ -29,6 +29,7 @@ interface BrowserSessionRow {
ttl_total: number;
ttl_without_activity: number | null;
credits_used: number | null;
+ profile_name?: string | null; // persistent profile the session was created with
created_at: string; // ISO timestamp
updated_at: string; // ISO timestamp
}
@@ -282,6 +283,35 @@ export async function updateBrowserSessionCreditsUsed(
}
}
+// Records a successful save of a persistent profile. Throws on failure so the
+// browser service's webhook outbox retries the event.
+export async function upsertBrowserProfile(input: {
+ teamId: string;
+ name: string;
+ savedAt: string;
+ sizeBytes: number | undefined;
+}): Promise<void> {
+ const profiles = schema.browser_profiles;
+ await db
+ .insert(profiles)
+ .values({
+ team_id: input.teamId,
+ name: input.name,
+ saved_at: input.savedAt,
+ size_bytes: input.sizeBytes ?? null,
+ })
+ .onConflictDoUpdate({
+ target: [profiles.team_id, profiles.name],
+ // Retried deliveries can arrive out of order, so an older save never
+ // replaces a newer one. A save that reported no size keeps the last
+ // known size rather than erasing it.
+ set: {
+ saved_at: sql`GREATEST(${profiles.saved_at}, excluded.saved_at)`,
+ size_bytes: sql`CASE WHEN excluded.saved_at >= ${profiles.saved_at} THEN COALESCE(excluded.size_bytes, ${profiles.size_bytes}) ELSE ${profiles.size_bytes} END`,
+ },
+ });
+}
+
// ---------------------------------------------------------------------------
// Prompt usage tracking (Redis)
// ---------------------------------------------------------------------------
diff --git a/apps/api/src/scraper/scrapeURL/engines/fire-engine/index.ts b/apps/api/src/scraper/scrapeURL/engines/fire-engine/index.ts
index 79ea24b0f..3a2fe1cb7 100644
--- a/apps/api/src/scraper/scrapeURL/engines/fire-engine/index.ts
+++ b/apps/api/src/scraper/scrapeURL/engines/fire-engine/index.ts
@@ -58,7 +58,7 @@ import { withSpan, setSpanAttributes } from "../../../../lib/otel-tracer";
import { getBrandingScript } from "./brandingScript";
import { abTestFireEngine } from "../../../../services/ab-test";
import { scheduleABComparison } from "../../../../services/ab-test-comparison";
-import { createHash } from "node:crypto";
+import { browserProfileStorageId } from "../../../../lib/browser-profiles";
/** Default wait (ms) before running the branding script when user did not set waitFor. Lets the page settle so DOM/images are ready and reduces JS errors. */
const BRANDING_DEFAULT_WAIT_MS = 2000;
@@ -491,7 +491,10 @@ export async function scrapeURLWithFireEngineChromeCDP(
...(forceNonRender ? { forceNonRender: true } : {}),
persistentStorage: meta.options.profile
? {
- uniqueId: `${createHash("sha256").update(meta.internalOptions.teamId).digest("hex").slice(0, 16)}_${meta.options.profile.name}`,
+ uniqueId: browserProfileStorageId(
+ meta.internalOptions.teamId,
+ meta.options.profile.name,
+ ),
}
: undefined,
...safeModeParams(meta.internalOptions.safeMode),