Skip to content

Supercharge your AI agents with data from the web and beyond. Building the library for superintelligence. πŸ”₯

Nick:

Nicolasd3d100a41eaf
diff --git a/apps/api/requests/v2/browser.requests.http b/apps/api/requests/v2/browser.requests.http
index 5dde2b379..1f4ce9d42 100644
--- a/apps/api/requests/v2/browser.requests.http
+++ b/apps/api/requests/v2/browser.requests.http
@@ -1,4 +1,4 @@
-s# Pick your baseUrl here:
+# Pick your baseUrl here:
@baseUrl = http://localhost:3002
# @baseUrl = https://api.firecrawl.dev
@@ -30,38 +30,68 @@ content-type: application/json
"streamWebView": true
}
-### Execute Code (Python) β€” replace BROWSER_ID with actual browserId
-@browserId = REPLACE_WITH_BROWSER_ID
+### List Browser Sessions (all)
+GET {{baseUrl}}/v2/browser HTTP/1.1
+Authorization: Bearer {{$dotenv TEST_API_KEY}}
+
+### List Browser Sessions (active only)
+GET {{baseUrl}}/v2/browser?status=active HTTP/1.1
+Authorization: Bearer {{$dotenv TEST_API_KEY}}
+
+### Execute Code (Python) β€” replace sessionId with actual id from create response
+@sessionId = REPLACE_WITH_SESSION_ID_FROM_CREATE_RESPONSE
POST {{baseUrl}}/v2/browser/execute HTTP/1.1
Authorization: Bearer {{$dotenv TEST_API_KEY}}
content-type: application/json
{
- "browserId": "{{browserId}}",
- "code": "await page.goto(\"https://docs.firecrawl.dev\")\nprint(await page.title())",
+ "id": "{{sessionId}}",
+ "code": "await page.goto(\"https://example.com\")\nprint(await page.title())",
"language": "python"
}
-### Execute Code (JS) β€” replace BROWSER_ID with actual browserId
+### Execute Code (JS) β€” replace sessionId with actual id
POST {{baseUrl}}/v2/browser/execute HTTP/1.1
Authorization: Bearer {{$dotenv TEST_API_KEY}}
content-type: application/json
{
- "browserId": "{{browserId}}",
+ "id": "{{sessionId}}",
"code": "await page.goto('https://example.com');\nconst title = await page.title();\nconsole.log(title);",
"language": "js"
}
-### Delete Browser Session β€” replace BROWSER_ID with actual browserId
+### Execute Code β€” screenshot to base64
+POST {{baseUrl}}/v2/browser/execute HTTP/1.1
+Authorization: Bearer {{$dotenv TEST_API_KEY}}
+content-type: application/json
+
+{
+ "id": "{{sessionId}}",
+ "code": "await page.goto(\"https://example.com\")\nscreenshot = await page.screenshot()\nimport base64\nprint(base64.b64encode(screenshot).decode()[:100])",
+ "language": "python"
+}
+
+### Execute Code β€” extract page content
+POST {{baseUrl}}/v2/browser/execute HTTP/1.1
+Authorization: Bearer {{$dotenv TEST_API_KEY}}
+content-type: application/json
+
+{
+ "id": "{{sessionId}}",
+ "code": "await page.goto(\"https://news.ycombinator.com\")\ntitles = await page.query_selector_all(\".titleline > a\")\nfor t in titles[:5]:\n print(await t.inner_text())",
+ "language": "python"
+}
+
+### Delete Browser Session β€” replace sessionId with actual id
DELETE {{baseUrl}}/v2/browser HTTP/1.1
Authorization: Bearer {{$dotenv TEST_API_KEY}}
content-type: application/json
{
- "browserId": "{{browserId}}"
+ "id": "{{sessionId}}"
}
### WebSocket β€” webview stream (use a WS client, e.g. wscat)
-# wscat -c "ws://localhost:3002/v2/browser/{{browserId}}" -H "Authorization: Bearer YOUR_API_KEY"
+# wscat -c "ws://localhost:3002/v2/browser/{{sessionId}}" -H "Authorization: Bearer YOUR_API_KEY"
diff --git a/apps/api/src/__tests__/snips/v2/browser.test.ts b/apps/api/src/__tests__/snips/v2/browser.test.ts
deleted file mode 100644
index d46841181..000000000
--- a/apps/api/src/__tests__/snips/v2/browser.test.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-import { describeIf, HAS_FIRE_ENGINE, TEST_SELF_HOST } from "../lib";
-import { scrapeTimeout, idmux, Identity, TEST_API_URL } from "./lib";
-import request from "./lib";
-import {
- BrowserCreateRequest,
- BrowserCreateResponse,
- BrowserExecuteRequest,
- BrowserExecuteResponse,
- BrowserDeleteRequest,
- BrowserDeleteResponse,
-} from "../../../controllers/v2/browser";
-
-let identity: Identity;
-
-beforeAll(async () => {
- identity = await idmux({
- name: "browser",
- concurrency: 10,
- credits: 100000,
- });
-}, 10000);
-
-// Browser feature requires fire-engine and sandbox β€” skip in self-hosted
-describeIf(!TEST_SELF_HOST && HAS_FIRE_ENGINE)("Browser API", () => {
- // ---------------------------------------------------------------
- // Helpers
- // ---------------------------------------------------------------
-
- async function browserCreateRaw(body: Partial<BrowserCreateRequest>) {
- return await request(TEST_API_URL)
- .post("/v2/browser")
- .set("Authorization", `Bearer ${identity.apiKey}`)
- .set("Content-Type", "application/json")
- .send(body);
- }
-
- async function browserExecuteRaw(body: BrowserExecuteRequest) {
- return await request(TEST_API_URL)
- .post("/v2/browser/execute")
- .set("Authorization", `Bearer ${identity.apiKey}`)
- .set("Content-Type", "application/json")
- .send(body);
- }
-
- async function browserDeleteRaw(body: BrowserDeleteRequest) {
- return await request(TEST_API_URL)
- .delete("/v2/browser")
- .set("Authorization", `Bearer ${identity.apiKey}`)
- .set("Content-Type", "application/json")
- .send(body);
- }
-
- // ---------------------------------------------------------------
- // Tests
- // ---------------------------------------------------------------
-
- it(
- "creates a browser session, executes code, then deletes it (happy path)",
- async () => {
- // 1. Create session
- const createRes = await browserCreateRaw({});
- expect(createRes.statusCode).toBe(200);
- expect(createRes.body.success).toBe(true);
- expect(typeof createRes.body.browserId).toBe("string");
- expect(typeof createRes.body.cdpUrl).toBe("string");
-
- const { browserId } = createRes.body as BrowserCreateResponse;
-
- // 2. Execute code β€” navigate to example.com and get the title
- const execRes = await browserExecuteRaw({
- browserId: browserId!,
- code: `
-await page.goto("https://example.com")
-print(await page.title())
-`,
- language: "python",
- });
-
- expect(execRes.statusCode).toBe(200);
- expect(execRes.body.success).toBe(true);
- expect(typeof execRes.body.result).toBe("string");
- expect(execRes.body.result).toContain("Example Domain");
-
- // 3. Delete session
- const deleteRes = await browserDeleteRaw({
- browserId: browserId!,
- });
- expect(deleteRes.statusCode).toBe(200);
- expect(deleteRes.body.success).toBe(true);
- },
- scrapeTimeout * 2,
- );
-
- it(
- "returns 404 when executing code on a non-existent session",
- async () => {
- const execRes = await browserExecuteRaw({
- browserId: "00000000-0000-7000-8000-000000000000",
- code: "print('hello')",
- language: "python",
- });
-
- expect(execRes.statusCode).toBe(404);
- expect(execRes.body.success).toBe(false);
- },
- scrapeTimeout,
- );
-
- it(
- "returns 404 when deleting a non-existent session",
- async () => {
- const deleteRes = await browserDeleteRaw({
- browserId: "00000000-0000-7000-8000-000000000000",
- });
-
- expect(deleteRes.statusCode).toBe(404);
- expect(deleteRes.body.success).toBe(false);
- },
- scrapeTimeout,
- );
-
- it("rejects unauthenticated requests", async () => {
- const res = await request(TEST_API_URL)
- .post("/v2/browser")
- .set("Content-Type", "application/json")
- .send({});
-
- expect(res.statusCode).toBe(401);
- expect(res.body.success).toBe(false);
- });
-});
diff --git a/apps/api/src/controllers/v2/browser.ts b/apps/api/src/controllers/v2/browser.ts
index 5e642084c..ccbf194e8 100644
--- a/apps/api/src/controllers/v2/browser.ts
+++ b/apps/api/src/controllers/v2/browser.ts
@@ -8,7 +8,16 @@ import {
Workspace,
CodeContext,
Execution,
+ SandboxClient,
} from "../../lib/sandbox-client";
+import {
+ insertBrowserSession,
+ getBrowserSession,
+ listBrowserSessions,
+ updateBrowserSessionActivity,
+ updateBrowserSessionStatus,
+ BrowserSessionRow,
+} from "../../lib/browser-sessions";
import { RequestWithAuth } from "./types";
// ---------------------------------------------------------------------------
@@ -21,84 +30,58 @@ const browserCreateRequestSchema = z.object({
streamWebView: z.boolean().default(false),
});
-export type BrowserCreateRequest = z.infer<typeof browserCreateRequestSchema>;
+type BrowserCreateRequest = z.infer<typeof browserCreateRequestSchema>;
-export interface BrowserCreateResponse {
+interface BrowserCreateResponse {
success: boolean;
- browserId?: string;
+ id?: string;
cdpUrl?: string;
error?: string;
}
const browserExecuteRequestSchema = z.object({
- browserId: z.string(),
+ id: z.string(),
code: z.string().min(1).max(100_000),
language: z.enum(["python", "js"]).default("python"),
});
-export type BrowserExecuteRequest = z.infer<typeof browserExecuteRequestSchema>;
+type BrowserExecuteRequest = z.infer<typeof browserExecuteRequestSchema>;
-export interface BrowserExecuteResponse {
+interface BrowserExecuteResponse {
success: boolean;
result?: string;
error?: string;
}
const browserDeleteRequestSchema = z.object({
- browserId: z.string(),
+ id: z.string(),
});
-export type BrowserDeleteRequest = z.infer<typeof browserDeleteRequestSchema>;
+type BrowserDeleteRequest = z.infer<typeof browserDeleteRequestSchema>;
-export interface BrowserDeleteResponse {
+interface BrowserDeleteResponse {
success: boolean;
error?: string;
}
-// ---------------------------------------------------------------------------
-// In-memory session store
-// ---------------------------------------------------------------------------
-
-interface BrowserSession {
- browserId: string;
- teamId: string;
- workspace: Workspace;
- context: CodeContext;
- cdpUrl: string;
- cdpPath: string;
- streamWebView: boolean;
- createdAt: number;
- lastActivity: number;
- ttlTotal: number;
- ttlWithoutActivity?: number;
- destroyed: boolean;
+interface BrowserListResponse {
+ success: boolean;
+ sessions?: Array<{
+ id: string;
+ status: string;
+ cdpUrl: string;
+ streamWebView: boolean;
+ createdAt: string;
+ lastActivity: string;
+ }>;
+ error?: string;
}
-const sessions = new Map<string, BrowserSession>();
-
-/** Periodic cleanup of expired sessions */
-// setInterval(() => {
-// const now = Date.now();
-// for (const [id, session] of sessions) {
-// if (session.destroyed) {
-// sessions.delete(id);
-// continue;
-// }
-// const totalExpired = now - session.createdAt > session.ttlTotal * 1000;
-// const activityExpired =
-// session.ttlWithoutActivity !== undefined &&
-// now - session.lastActivity > session.ttlWithoutActivity * 1000;
-// if (totalExpired || activityExpired) {
-// destroySession(session).catch(() => {});
-// }
-// }
-// }, 15_000);
-
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
-function getSandboxClient() {
+function getSandboxClient(): SandboxClient {
return createSandboxClient({
baseUrl: config.SANDBOX_API_URL!,
podUrlTemplate: config.SANDBOX_POD_URL_TEMPLATE,
@@ -110,76 +93,68 @@ function getSandboxClient() {
* Extract the printable output from a sandbox Execution result.
*/
function executionToString(exec: Execution): string {
- const parts: string[] = [];
return exec.text ?? "";
+}
- // // Collect stdout log lines
- // if (exec.logs.stdout.length > 0) {
- // parts.push(exec.logs.stdout.join("\n"));
- // }
-
- // // Collect stderr log lines
- // if (exec.logs.stderr.length > 0) {
- // parts.push(exec.logs.stderr.join("\n"));
- // }
-
- // // Collect result text
- // if (exec.text) {
- // parts.push(exec.text);
- // }
-
- // for (const r of exec.results) {
- // if (r.text) {
- // parts.push(r.text);
- // }
- // }
-
- // // Collect error info
- // if (exec.error) {
- // parts.push(
- // `${exec.error.name}: ${exec.error.value}${exec.error.traceback ? "\n" + exec.error.traceback : ""}`,
- // );
- // }
-
- // return parts.join("\n");
+/**
+ * Reconstruct a CodeContext from stored IDs so we can run code against
+ * a session that was persisted in Supabase (not held in memory).
+ */
+function reconstructContext(
+ client: SandboxClient,
+ row: BrowserSessionRow,
+): CodeContext {
+ return new CodeContext(client, row.workspace_id, row.context_id);
}
-async function destroySession(session: BrowserSession) {
- if (session.destroyed) return;
- session.destroyed = true;
+/**
+ * Reconstruct a Workspace from stored IDs.
+ */
+function reconstructWorkspace(
+ client: SandboxClient,
+ row: BrowserSessionRow,
+): Workspace {
+ return new Workspace(client, row.workspace_id);
+}
+/**
+ * Destroy the underlying browser resources (CDP, sandbox workspace) for a
+ * session row and mark it as destroyed in Supabase.
+ */
+async function destroySession(row: BrowserSessionRow): Promise<void> {
const logger = _logger.child({
- browserId: session.browserId,
+ sessionId: row.id,
+ browserId: row.browser_id,
module: "browser",
});
try {
- // Tell the sandbox to close the browser
- await session.context.runCode("await browser.close()").catch(() => {}); // best-effort
+ const client = getSandboxClient();
+ const ctx = reconstructContext(client, row);
+ const workspace = reconstructWorkspace(client, row);
+
+ // Best-effort: tell the sandbox to close the browser
+ await ctx.runCode("await browser.close()").catch(() => {});
// Tear down the CDP session on fire-engine
if (config.FIRE_ENGINE_BETA_URL) {
await fetch(
- `${config.FIRE_ENGINE_BETA_URL}/cdp-session/${session.browserId}`,
+ `${config.FIRE_ENGINE_BETA_URL}/cdp-session/${row.browser_id}`,
{ method: "DELETE" },
).catch(() => {});
}
// Destroy the sandbox workspace
- await session.workspace.destroy().catch(() => {});
+ await workspace.destroy().catch(() => {});
logger.info("Browser session destroyed");
} catch (err) {
logger.warn("Error while destroying browser session", { error: err });
} finally {
- sessions.delete(session.browserId);
+ await updateBrowserSessionStatus(row.id, "destroyed");
}
}
-function getSession(browserId: string): BrowserSession | undefined {
- return sessions.get(browserId);
-}
-
// ---------------------------------------------------------------------------
// Controllers
// ---------------------------------------------------------------------------
@@ -196,9 +171,9 @@ export async function browserCreateController(
});
}
- const browserId = uuidv7();
+ const sessionId = uuidv7();
const logger = _logger.child({
- browserId,
+ sessionId,
teamId: req.auth.team_id,
module: "api/v2",
method: "browserCreateController",
@@ -266,7 +241,6 @@ export async function browserCreateController(
await ctx.enableBrowser(cdpPath);
// 4. Initialize Playwright inside the sandbox
- // TODO: fix - setup session reuse for context and page
const initExec = await ctx.runCode(`
from playwright.async_api import async_playwright
@@ -294,32 +268,47 @@ page = await context.new_page()
// Build the user-facing CDP URL
const cdpUrl = `${config.CDP_PROXY_URL}${cdpPath}`;
- // 5. Store the session
- const session: BrowserSession = {
- browserId: feBrowserId,
- teamId: req.auth.team_id,
- workspace,
- context: ctx,
- cdpUrl,
- cdpPath,
- streamWebView,
- createdAt: Date.now(),
- lastActivity: Date.now(),
- ttlTotal,
- ttlWithoutActivity,
- destroyed: false,
- };
-
- sessions.set(feBrowserId, session);
+ // 5. Persist session in Supabase
+ try {
+ await insertBrowserSession({
+ id: sessionId,
+ team_id: req.auth.team_id,
+ browser_id: feBrowserId,
+ workspace_id: workspace.id,
+ context_id: ctx.id,
+ cdp_url: cdpUrl,
+ cdp_path: cdpPath,
+ stream_web_view: streamWebView,
+ status: "active",
+ ttl_total: ttlTotal,
+ ttl_without_activity: ttlWithoutActivity ?? null,
+ });
+ } catch (err) {
+ // If we can't persist, tear everything down
+ logger.error("Failed to persist browser session, cleaning up", {
+ error: err,
+ });
+ await workspace.destroy().catch(() => {});
+ if (config.FIRE_ENGINE_BETA_URL) {
+ await fetch(`${config.FIRE_ENGINE_BETA_URL}/cdp-session/${feBrowserId}`, {
+ method: "DELETE",
+ }).catch(() => {});
+ }
+ return res.status(500).json({
+ success: false,
+ error: "Failed to persist browser session.",
+ });
+ }
logger.info("Browser session created", {
+ sessionId,
browserId: feBrowserId,
cdpUrl,
});
return res.status(200).json({
success: true,
- browserId: feBrowserId,
+ id: sessionId,
cdpUrl,
});
}
@@ -338,16 +327,17 @@ export async function browserExecuteController(
req.body = browserExecuteRequestSchema.parse(req.body);
- const { browserId, code, language } = req.body;
+ const { id, code, language } = req.body;
const logger = _logger.child({
- browserId,
+ sessionId: id,
teamId: req.auth.team_id,
module: "api/v2",
method: "browserExecuteController",
});
- const session = sessions.get(browserId);
+ // Look up session from Supabase
+ const session = await getBrowserSession(id);
if (!session) {
return res.status(404).json({
@@ -356,45 +346,38 @@ export async function browserExecuteController(
});
}
- if (session.teamId !== req.auth.team_id) {
+ if (session.team_id !== req.auth.team_id) {
return res.status(403).json({
success: false,
error: "Forbidden.",
});
}
- if (session.destroyed) {
+ if (session.status === "destroyed") {
return res.status(410).json({
success: false,
error: "Browser session has been destroyed.",
});
}
- session.lastActivity = Date.now();
+ // Update activity timestamp (fire-and-forget)
+ updateBrowserSessionActivity(id).catch(() => {});
logger.info("Executing code in browser session", { language });
- // The sandbox currently only accepts Python via runCode.
- // For JS, we could wrap it differently in the future.
- console.log(`[browser-execute] Running code for session ${browserId}:`, code);
- const exec = await session.context.runCode(code);
+ // Reconstruct the code context from stored IDs
+ const client = getSandboxClient();
+ const ctx = reconstructContext(client, session);
+
+ const exec = await ctx.runCode(code);
const output = executionToString(exec);
- console.log(
- `[browser-execute] Execution result for session ${browserId}:`,
- JSON.stringify(
- {
- text: exec.text,
- results: exec.results,
- logs: exec.logs,
- error: exec.error,
- outputLength: output.length,
- },
- null,
- 2,
- ),
- );
+ logger.debug("Execution result", {
+ text: exec.text,
+ hasError: !!exec.error,
+ outputLength: output.length,
+ });
if (exec.error) {
return res.status(200).json({
@@ -424,16 +407,16 @@ export async function browserDeleteController(
req.body = browserDeleteRequestSchema.parse(req.body);
- const { browserId } = req.body;
+ const { id } = req.body;
const logger = _logger.child({
- browserId,
+ sessionId: id,
teamId: req.auth.team_id,
module: "api/v2",
method: "browserDeleteController",
});
- const session = sessions.get(browserId);
+ const session = await getBrowserSession(id);
if (!session) {
return res.status(404).json({
@@ -442,7 +425,7 @@ export async function browserDeleteController(
});
}
- if (session.teamId !== req.auth.team_id) {
+ if (session.team_id !== req.auth.team_id) {
return res.status(403).json({
success: false,
error: "Forbidden.",
@@ -457,3 +440,45 @@ export async function browserDeleteController(
success: true,
});
}
+
+export async function browserListController(
+ req: RequestWithAuth<{}, BrowserListResponse>,
+ res: Response<BrowserListResponse>,
+) {
+ if (!req.acuc?.flags?.browserBeta) {
+ return res.status(403).json({
+ success: false,
+ error:
+ "Browser is currently in beta. Please contact [email protected] to request access.",
+ });
+ }
+
+ const logger = _logger.child({
+ teamId: req.auth.team_id,
+ module: "api/v2",
+ method: "browserListController",
+ });
+
+ logger.info("Listing browser sessions");
+
+ const statusFilter = (req.query as Record<string, string>).status as
+ | "active"
+ | "destroyed"
+ | undefined;
+
+ const rows = await listBrowserSessions(req.auth.team_id, {
+ status: statusFilter,
+ });
+
+ return res.status(200).json({
+ success: true,
+ sessions: rows.map(r => ({
+ id: r.id,
+ status: r.status,
+ cdpUrl: r.cdp_url,
+ streamWebView: r.stream_web_view,
+ createdAt: r.created_at,
+ lastActivity: r.updated_at,
+ })),
+ });
+}
diff --git a/apps/api/src/lib/browser-sessions.ts b/apps/api/src/lib/browser-sessions.ts
new file mode 100644
index 000000000..3c7cf11c0
--- /dev/null
+++ b/apps/api/src/lib/browser-sessions.ts
@@ -0,0 +1,120 @@
+import { supabase_service } from "../services/supabase";
+import { logger as _logger } from "./logger";
+
+const logger = _logger.child({ module: "browser-sessions" });
+
+type BrowserSessionStatus = "active" | "destroyed" | "error";
+
+export interface BrowserSessionRow {
+ id: string;
+ team_id: string;
+ browser_id: string;
+ workspace_id: string;
+ context_id: string;
+ cdp_url: string;
+ cdp_path: string;
+ stream_web_view: boolean;
+ status: BrowserSessionStatus;
+ ttl_total: number;
+ ttl_without_activity: number | null;
+ created_at: string; // ISO timestamp
+ updated_at: string; // ISO timestamp
+}
+
+const TABLE = "browser_sessions";
+
+// ---------------------------------------------------------------------------
+// CRUD helpers
+// ---------------------------------------------------------------------------
+
+export async function insertBrowserSession(
+ row: Omit<BrowserSessionRow, "created_at" | "updated_at">,
+): Promise<BrowserSessionRow> {
+ const now = new Date().toISOString();
+ const full: BrowserSessionRow = {
+ ...row,
+ created_at: now,
+ updated_at: now,
+ };
+
+ const { data, error } = await supabase_service
+ .from(TABLE)
+ .insert(full)
+ .select()
+ .single();
+
+ if (error) {
+ logger.error("Failed to insert browser session", { error, id: row.id });
+ throw new Error(`Failed to insert browser session: ${error.message}`);
+ }
+
+ return data as BrowserSessionRow;
+}
+
+export async function getBrowserSession(
+ id: string,
+): Promise<BrowserSessionRow | null> {
+ const { data, error } = await supabase_service
+ .from(TABLE)
+ .select("*")
+ .eq("id", id)
+ .single();
+
+ if (error) {
+ // PGRST116 = no rows found
+ if (error.code === "PGRST116") return null;
+ logger.error("Failed to get browser session", { error, id });
+ throw new Error(`Failed to get browser session: ${error.message}`);
+ }
+
+ return data as BrowserSessionRow;
+}
+
+export async function listBrowserSessions(
+ teamId: string,
+ opts?: { status?: BrowserSessionStatus },
+): Promise<BrowserSessionRow[]> {
+ let query = supabase_service
+ .from(TABLE)
+ .select("*")
+ .eq("team_id", teamId)
+ .order("created_at", { ascending: false });
+
+ if (opts?.status) {
+ query = query.eq("status", opts.status);
+ }
+
+ const { data, error } = await query;
+
+ if (error) {
+ logger.error("Failed to list browser sessions", { error, teamId });
+ throw new Error(`Failed to list browser sessions: ${error.message}`);
+ }
+
+ return (data ?? []) as BrowserSessionRow[];
+}
+
+export async function updateBrowserSessionActivity(id: string): Promise<void> {
+ const { error } = await supabase_service
+ .from(TABLE)
+ .update({ last_activity: new Date().toISOString() })
+ .eq("id", id);
+
+ if (error) {
+ logger.warn("Failed to update browser session activity", { error, id });
+ }
+}
+
+export async function updateBrowserSessionStatus(
+ id: string,
+ status: BrowserSessionStatus,
+): Promise<void> {
+ const { error } = await supabase_service
+ .from(TABLE)
+ .update({ status })
+ .eq("id", id);
+
+ if (error) {
+ logger.warn("Failed to update browser session status", { error, id });
+ }
+}
diff --git a/apps/api/src/routes/v2.ts b/apps/api/src/routes/v2.ts
index ff58228d2..5b692113b 100644
--- a/apps/api/src/routes/v2.ts
+++ b/apps/api/src/routes/v2.ts
@@ -47,6 +47,7 @@ import {
browserCreateController,
browserExecuteController,
browserDeleteController,
+ browserListController,
} from "../controllers/v2/browser";
expressWs(express());
@@ -374,10 +375,16 @@ v2Router.post(
"/browser",
authMiddleware(RateLimiterMode.Browser),
countryCheck,
- checkCreditsMiddleware(5),
+ checkCreditsMiddleware(15),
wrap(browserCreateController),
);
+v2Router.get(
+ "/browser",
+ authMiddleware(RateLimiterMode.Browser),
+ wrap(browserListController),
+);
+
v2Router.post(
"/browser/execute",
authMiddleware(RateLimiterMode.Browser),
diff --git a/apps/api/src/services/rate-limiter.ts b/apps/api/src/services/rate-limiter.ts
index 95d422a11..55a848e90 100644
--- a/apps/api/src/services/rate-limiter.ts
+++ b/apps/api/src/services/rate-limiter.ts
@@ -27,7 +27,7 @@ const fallbackRateLimits: AuthCreditUsageChunk["rate_limits"] = {
crawlStatus: 25000,
extractAgentPreview: 10,
scrapeAgentPreview: 10,
- browser: 5,
+ browser: 25,
};
export function getRateLimiter(