camofox-browser 2.1.1 → 2.4.3

package/dist/src/routes/openclaw.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,9 +43,12 @@ const express_1 = require("express");
 const errors_1 = require("../middleware/errors");
 const logging_1 = require("../middleware/logging");
 const auth_1 = require("../middleware/auth");
+const structured_extractor_1 = require("../services/structured-extractor");
 const config_1 = require("../utils/config");
 const browser_1 = require("../services/browser");
 const context_pool_1 = require("../services/context-pool");
+const lifecycle_controller_1 = require("../services/lifecycle-controller");
+const download_1 = require("../services/download");
 const session_1 = require("../services/session");
 const tab_1 = require("../services/tab");
 const CONFIG = (0, config_1.loadConfig)();
@@ -26,6 +62,15 @@ const PKG_VERSION = (() => {
     return pkg.version;
 })();
 const router = (0, express_1.Router)();
+function getRouteErrorStatus(err) {
+    if (typeof err === 'object' && err !== null && 'statusCode' in err && typeof err.statusCode === 'number') {
+        return err.statusCode;
+    }
+    if (typeof err === 'object' && err !== null && 'status' in err && typeof err.status === 'number') {
+        return err.status;
+    }
+    return 500;
+}
 function isLoadState(value) {
     return value === 'load' || value === 'domcontentloaded' || value === 'networkidle';
 }
@@ -61,32 +106,137 @@ router.get('/', async (_req, res) => {
 });
 // POST /tabs/open - Open tab (alias for POST /tabs, OpenClaw format)
 router.post('/tabs/open', async (req, res) => {
+    let profileUserId;
+    let profileSessionKey;
+    let createdSessionProfile = false;
+    let createdSessionProfileSignature;
+    let createdDefaultSessionProfileClaim = false;
+    let releaseSessionProfileCreate;
     try {
-        const { url, userId, listItemId = 'default' } = req.body;
+        if (CONFIG.apiKey && !(0, auth_1.isAuthorizedWithApiKey)(req, CONFIG.apiKey)) {
+            return res.status(403).json({ error: 'Forbidden' });
+        }
+        const { url, userId, listItemId = 'default', proxyProfile, proxy, geoMode } = req.body;
         if (!userId) {
             return res.status(400).json({ error: 'userId is required' });
         }
         if (!url) {
             return res.status(400).json({ error: 'url is required' });
         }
-        const urlErr = (0, tab_1.validateUrl)(url);
+        profileUserId = userId;
+        profileSessionKey = listItemId;
+        // Establish/check session profile if proxy/geo fields provided
+        let resolvedSessionProfile;
+        if (proxyProfile || proxy || geoMode) {
+            const { resolveSessionProfileInput, getConfiguredServerProxy, loadProxyProfiles } = await Promise.resolve().then(() => __importStar(require('../utils/proxy-profiles')));
+            const profileInput = {
+                proxy: proxy,
+                proxyProfile,
+                geoMode: geoMode,
+            };
+            const deps = {
+                serverProxy: getConfiguredServerProxy(CONFIG.proxy),
+                proxyProfiles: loadProxyProfiles(CONFIG.proxyProfilesFile),
+            };
+            try {
+                const resolvedProfileBase = resolveSessionProfileInput(profileInput, deps);
+                resolvedSessionProfile = { ...resolvedProfileBase, sessionKey: listItemId };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return res.status(400).json({ error: message });
+            }
+        }
+        const urlErr = await (0, tab_1.validateNavigationUrl)(url, {
+            allowPrivateNetworkTargets: CONFIG.allowPrivateNetworkTargets,
+        });
         if (urlErr)
             return res.status(400).json({ error: urlErr });
-        const sessionMapKey = (0, session_1.getSessionMapKey)(userId, null);
-        const session = await (0, session_1.getSession)(userId);
+        const canonical = (0, session_1.getCanonicalProfile)(userId);
+        if (!canonical) {
+            (0, logging_1.log)('warn', 'openclaw tab open rejected: no canonical profile', { userId: String(userId) });
+            return res.status(409).json({
+                error: 'No canonical profile',
+                message: 'Cannot open tabs via this endpoint without an established canonical profile. Use core POST /tabs first.',
+            });
+        }
+        if (resolvedSessionProfile) {
+            while (true) {
+                await (0, session_1.waitForSessionProfileCreate)(userId, listItemId);
+                const existingProfile = (0, session_1.getEstablishedSessionProfile)(userId, listItemId);
+                if (existingProfile) {
+                    if (existingProfile.signature !== resolvedSessionProfile.signature) {
+                        return res.status(409).json({ error: 'Session profile conflict' });
+                    }
+                    break;
+                }
+                if ((0, session_1.hasDefaultSessionProfileRuntime)(userId, listItemId)) {
+                    return res.status(409).json({ error: 'Session profile conflict' });
+                }
+                const mutex = (0, session_1.acquireSessionProfileCreateMutex)(userId, listItemId, resolvedSessionProfile.signature);
+                if (mutex.acquired) {
+                    releaseSessionProfileCreate = mutex.release;
+                    try {
+                        (0, session_1.establishSessionProfile)(userId, listItemId, resolvedSessionProfile);
+                        createdSessionProfile = true;
+                        createdSessionProfileSignature = resolvedSessionProfile.signature;
+                    }
+                    catch (err) {
+                        releaseSessionProfileCreate(false);
+                        releaseSessionProfileCreate = undefined;
+                        const message = err instanceof Error ? err.message : String(err);
+                        if (message === 'Session profile conflict') {
+                            return res.status(409).json({ error: 'Session profile conflict' });
+                        }
+                        return res.status(400).json({ error: message });
+                    }
+                    break;
+                }
+                await mutex.wait;
+            }
+        }
+        else {
+            await (0, session_1.waitForSessionProfileCreate)(userId, listItemId);
+            if (!(0, session_1.getEstablishedSessionProfile)(userId, listItemId)) {
+                createdDefaultSessionProfileClaim = (0, session_1.claimDefaultSessionProfileRuntime)(userId, listItemId);
+            }
+        }
+        const establishedProfile = (0, session_1.getEstablishedSessionProfile)(userId, listItemId);
+        const sessionMapKey = establishedProfile
+            ? (0, session_1.getSessionMapKey)(userId, listItemId, establishedProfile.signature)
+            : (0, session_1.getSessionMapKey)(userId, canonical.resolvedOverrides);
+        const session = await (0, session_1.getSession)(userId, canonical.resolvedOverrides, listItemId);
         const totalTabs = (0, session_1.countTotalTabsForSessions)([[sessionMapKey, session]]);
         if (totalTabs >= session_1.MAX_TABS_PER_SESSION) {
+            if (createdSessionProfile && createdSessionProfileSignature) {
+                await (0, session_1.rollbackSessionProfileRuntime)(userId, listItemId, createdSessionProfileSignature);
+            }
+            if (createdDefaultSessionProfileClaim) {
+                (0, session_1.clearDefaultSessionProfileClaim)(userId, listItemId);
+                createdDefaultSessionProfileClaim = false;
+            }
+            releaseSessionProfileCreate?.(false);
+            releaseSessionProfileCreate = undefined;
             return res.status(429).json({ error: 'Maximum tabs per session reached' });
         }
         const group = (0, session_1.getTabGroup)(session, listItemId);
         const page = await session.context.newPage();
         const tabId = node_crypto_1.default.randomUUID();
-        const tabState = (0, tab_1.createTabState)(page);
+        const tabState = await (0, tab_1.createTabState)(page);
         group.set(tabId, tabState);
         (0, session_1.indexTab)(tabId, sessionMapKey);
-        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+        (0, download_1.registerDownloadListener)(tabId, String(userId), page);
+        await (0, tab_1.navigateWithSafetyGuard)(page, url, {
+            allowPrivateNetworkTargets: CONFIG.allowPrivateNetworkTargets,
+            waitUntil: 'domcontentloaded',
+            timeout: 30000,
+        });
         tabState.visitedUrls.add(url);
         (0, logging_1.log)('info', 'openclaw tab opened', { reqId: req.reqId, tabId, url: page.url() });
+        lifecycle_controller_1.lifecycleController.recordInteractiveActivity();
+        releaseSessionProfileCreate?.(true);
+        releaseSessionProfileCreate = undefined;
+        createdSessionProfile = false;
         return res.json({
             ok: true,
             targetId: tabId,
@@ -96,9 +246,22 @@ router.post('/tabs/open', async (req, res) => {
         });
     }
     catch (err) {
+        if (createdSessionProfile && profileUserId && profileSessionKey) {
+            if (createdSessionProfileSignature) {
+                await (0, session_1.rollbackSessionProfileRuntime)(profileUserId, profileSessionKey, createdSessionProfileSignature);
+            }
+            else {
+                (0, session_1.clearSessionProfile)(profileUserId, profileSessionKey);
+            }
+        }
+        if (createdDefaultSessionProfileClaim && profileUserId && profileSessionKey) {
+            (0, session_1.clearDefaultSessionProfileClaim)(profileUserId, profileSessionKey);
+        }
+        releaseSessionProfileCreate?.(false);
+        releaseSessionProfileCreate = undefined;
         const message = err instanceof Error ? err.message : String(err);
         (0, logging_1.log)('error', 'openclaw tab open failed', { reqId: req.reqId, error: message });
-        return res.status(500).json({ error: (0, errors_1.safeError)(err) });
+        return res.status(getRouteErrorStatus(err)).json({ error: (0, errors_1.safeError)(err) });
     }
 });
 // POST /start - Start browser (OpenClaw expects this)
@@ -128,16 +291,16 @@ router.post('/stop', async (req, res) => {
 // POST /navigate - Navigate (OpenClaw format with targetId in body)
 router.post('/navigate', async (req, res) => {
     try {
-        const { targetId, url, userId } = req.body;
+        if (CONFIG.apiKey && !(0, auth_1.isAuthorizedWithApiKey)(req, CONFIG.apiKey)) {
+            return res.status(403).json({ error: 'Forbidden' });
+        }
+        const { targetId, url, macro, query, userId } = req.body;
         if (!userId) {
             return res.status(400).json({ error: 'userId is required' });
         }
-        if (!url) {
-            return res.status(400).json({ error: 'url is required' });
+        if (!url && !macro) {
+            return res.status(400).json({ error: 'url or macro required' });
         }
-        const urlErr = (0, tab_1.validateUrl)(url);
-        if (urlErr)
-            return res.status(400).json({ error: urlErr });
         const found = (0, session_1.findTabById)(String(targetId), userId);
         if (!found) {
             return res.status(404).json({ error: 'Tab not found' });
@@ -145,17 +308,36 @@ router.post('/navigate', async (req, res) => {
         const { tabState } = found;
         tabState.toolCalls++;
         const result = await (0, session_1.withUserLimit)(String(userId), CONFIG.maxConcurrentPerUser, () => (0, tab_1.withTimeout)((0, tab_1.withTabLock)(String(targetId), async () => {
-            await tabState.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-            tabState.visitedUrls.add(url);
+            let targetUrl = url;
+            if (macro) {
+                const { expandMacro } = await Promise.resolve().then(() => __importStar(require('../utils/macros')));
+                targetUrl = expandMacro(macro, query) || url;
+            }
+            if (!targetUrl)
+                return { status: 400, body: { error: 'url or macro required' } };
+            const urlErr = await (0, tab_1.validateNavigationUrl)(targetUrl, {
+                allowPrivateNetworkTargets: CONFIG.allowPrivateNetworkTargets,
+            });
+            if (urlErr)
+                return { status: 400, body: { error: urlErr } };
+            await (0, tab_1.navigateWithSafetyGuard)(tabState.page, targetUrl, {
+                allowPrivateNetworkTargets: CONFIG.allowPrivateNetworkTargets,
+                waitUntil: 'domcontentloaded',
+                timeout: 30000,
+            });
+            tabState.visitedUrls.add(targetUrl);
             tabState.refs = await (0, tab_1.buildRefs)(tabState.page);
-            return { ok: true, targetId, url: tabState.page.url() };
+            return { status: 200, body: { ok: true, targetId, url: tabState.page.url() } };
         }), CONFIG.handlerTimeoutMs, 'openclaw-navigate'));
-        return res.json(result);
+        if (result.status !== 200)
+            return res.status(result.status).json(result.body);
+        lifecycle_controller_1.lifecycleController.recordInteractiveActivity();
+        return res.json(result.body);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         (0, logging_1.log)('error', 'openclaw navigate failed', { reqId: req.reqId, error: message });
-        return res.status(500).json({ error: (0, errors_1.safeError)(err) });
+        return res.status(getRouteErrorStatus(err)).json({ error: (0, errors_1.safeError)(err) });
     }
 });
 // GET /snapshot - Snapshot (OpenClaw format with query params)
@@ -171,25 +353,29 @@ router.get('/snapshot', async (req, res) => {
         }
         const { tabState } = found;
         tabState.toolCalls++;
-        const result = await (0, tab_1.withTimeout)((0, tab_1.snapshotTab)(tabState), CONFIG.handlerTimeoutMs, 'openclaw-snapshot');
+        const rawOffset = Number(req.query.offset);
+        const offset = Number.isFinite(rawOffset) && rawOffset > 0 ? Math.floor(rawOffset) : 0;
+        const raw = await (0, session_1.withUserLimit)(String(userId), CONFIG.maxConcurrentPerUser, () => (0, tab_1.withTimeout)((0, tab_1.snapshotTab)(tabState), CONFIG.handlerTimeoutMs, 'openclaw-snapshot'));
+        const payload = (0, tab_1.buildSnapshotPayload)(raw, offset);
         return res.json({
             ok: true,
             format: 'aria',
             targetId,
-            url: result.url,
-            snapshot: result.snapshot,
-            refsCount: result.refsCount,
+            ...payload,
         });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         (0, logging_1.log)('error', 'openclaw snapshot failed', { reqId: req.reqId, error: message });
-        return res.status(500).json({ error: (0, errors_1.safeError)(err) });
+        return res.status(getRouteErrorStatus(err)).json({ error: (0, errors_1.safeError)(err) });
     }
 });
 // POST /act - Combined action endpoint (OpenClaw format)
 router.post('/act', async (req, res) => {
     try {
+        if (CONFIG.apiKey && !(0, auth_1.isAuthorizedWithApiKey)(req, CONFIG.apiKey)) {
+            return res.status(403).json({ error: 'Forbidden' });
+        }
         const body = req.body;
         const kind = typeof body.kind === 'string' ? body.kind : undefined;
         const targetId = typeof body.targetId === 'string' ? body.targetId : undefined;
@@ -235,16 +421,17 @@ router.post('/act', async (req, res) => {
                             }
                         }
                     };
-                    if (ref) {
-                        const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
-                        if (!locator)
-                            throw new Error(`Unknown ref: ${ref}`);
-                        await doClick(locator);
-                    }
-                    else {
-                        await doClick(String(selector));
-                    }
-                    await tabState.page.waitForTimeout(500);
+                    await (0, tab_1.withBlockedNavigationTracking)(tabState.page, async () => {
+                        if (ref) {
+                            const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
+                            if (!locator)
+                                throw new Error(`Unknown ref: ${ref}`);
+                            await doClick(locator);
+                        }
+                        else {
+                            await doClick(String(selector));
+                        }
+                    });
                     tabState.refs = await (0, tab_1.buildRefs)(tabState.page);
                     return { ok: true, targetId, url: tabState.page.url() };
                 }
@@ -257,20 +444,22 @@ router.post('/act', async (req, res) => {
                     if (typeof text !== 'string' || text.length === 0) {
                         throw new Error('text is required');
                     }
-                    if (ref) {
-                        const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
-                        if (!locator)
-                            throw new Error(`Unknown ref: ${ref}`);
-                        await (0, tab_1.smartFill)(locator, tabState.page, text);
-                        if (submit)
-                            await tabState.page.keyboard.press('Enter');
-                    }
-                    else {
-                        const locator = tabState.page.locator(String(selector));
-                        await (0, tab_1.smartFill)(locator, tabState.page, text);
-                        if (submit)
-                            await tabState.page.keyboard.press('Enter');
-                    }
+                    await (0, tab_1.withBlockedNavigationTracking)(tabState.page, async () => {
+                        if (ref) {
+                            const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
+                            if (!locator)
+                                throw new Error(`Unknown ref: ${ref}`);
+                            await (0, tab_1.smartFill)(locator, tabState.page, text);
+                            if (submit)
+                                await tabState.page.keyboard.press('Enter');
+                        }
+                        else {
+                            const locator = tabState.page.locator(String(selector));
+                            await (0, tab_1.smartFill)(locator, tabState.page, text);
+                            if (submit)
+                                await tabState.page.keyboard.press('Enter');
+                        }
+                    });
                     return { ok: true, targetId };
                 }
                 case 'select': {
@@ -282,15 +471,17 @@ router.post('/act', async (req, res) => {
                     if (typeof value !== 'string') {
                         throw new Error('value is required');
                     }
-                    if (ref) {
-                        const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
-                        if (!locator)
-                            throw new Error(`Unknown ref: ${ref}`);
-                        await locator.selectOption(value);
-                    }
-                    else {
-                        await tabState.page.locator(String(selector)).selectOption(value);
-                    }
+                    await (0, tab_1.withBlockedNavigationTracking)(tabState.page, async () => {
+                        if (ref) {
+                            const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
+                            if (!locator)
+                                throw new Error(`Unknown ref: ${ref}`);
+                            await locator.selectOption(value);
+                        }
+                        else {
+                            await tabState.page.locator(String(selector)).selectOption(value);
+                        }
+                    });
                     return { ok: true, targetId };
                 }
                 case 'press': {
@@ -298,7 +489,9 @@ router.post('/act', async (req, res) => {
                     const { key } = params;
                     if (!key)
                         throw new Error('key is required');
-                    await tabState.page.keyboard.press(key);
+                    await (0, tab_1.withBlockedNavigationTracking)(tabState.page, async () => {
+                        await tabState.page.keyboard.press(key);
+                    });
                     return { ok: true, targetId };
                 }
                 case 'scroll':
@@ -307,17 +500,20 @@ router.post('/act', async (req, res) => {
                     const ref = params.ref;
                     const direction = params.direction ?? 'down';
                     const amount = params.amount ?? 500;
-                    if (ref) {
-                        const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
-                        if (!locator)
-                            throw new Error(`Unknown ref: ${ref}`);
-                        await locator.scrollIntoViewIfNeeded({ timeout: 5000 });
-                    }
-                    else {
-                        const delta = direction === 'up' ? -amount : amount;
-                        await tabState.page.mouse.wheel(0, delta);
-                    }
-                    await tabState.page.waitForTimeout(300);
+                    await (0, tab_1.withBlockedNavigationTracking)(tabState.page, async () => {
+                        if (ref) {
+                            const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
+                            if (!locator)
+                                throw new Error(`Unknown ref: ${ref}`);
+                            await locator.scrollIntoViewIfNeeded({ timeout: 5000 });
+                        }
+                        else {
+                            const isHorizontal = direction === 'left' || direction === 'right';
+                            const delta = direction === 'up' || direction === 'left' ? -amount : amount;
+                            await tabState.page.mouse.wheel(isHorizontal ? delta : 0, isHorizontal ? 0 : delta);
+                        }
+                        await tabState.page.waitForTimeout(300);
+                    });
                     return { ok: true, targetId };
                 }
                 case 'hover': {
@@ -325,15 +521,17 @@ router.post('/act', async (req, res) => {
                     const { ref, selector } = params;
                     if (!ref && !selector)
                         throw new Error('ref or selector required');
-                    if (ref) {
-                        const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
-                        if (!locator)
-                            throw new Error(`Unknown ref: ${ref}`);
-                        await locator.hover({ timeout: 5000 });
-                    }
-                    else {
-                        await tabState.page.locator(String(selector)).hover({ timeout: 5000 });
-                    }
+                    await (0, tab_1.withBlockedNavigationTracking)(tabState.page, async () => {
+                        if (ref) {
+                            const locator = await (0, tab_1.refToLocator)(tabState.page, ref, tabState.refs);
+                            if (!locator)
+                                throw new Error(`Unknown ref: ${ref}`);
+                            await locator.hover({ timeout: 5000 });
+                        }
+                        else {
+                            await tabState.page.locator(String(selector)).hover({ timeout: 5000 });
+                        }
+                    });
                     return { ok: true, targetId };
                 }
                 case 'wait': {
@@ -341,17 +539,38 @@ router.post('/act', async (req, res) => {
                     const { timeMs, text } = params;
                     const loadStateUnknown = params.loadState;
                     const loadState = typeof loadStateUnknown === 'string' && isLoadState(loadStateUnknown) ? loadStateUnknown : undefined;
-                    if (timeMs) {
-                        await tabState.page.waitForTimeout(timeMs);
-                    }
-                    else if (text) {
-                        await tabState.page.waitForSelector(`text=${text}`, { timeout: 30000 });
-                    }
-                    else if (loadState) {
-                        await tabState.page.waitForLoadState(loadState, { timeout: 30000 });
-                    }
+                    await (0, tab_1.withBlockedNavigationTracking)(tabState.page, async () => {
+                        try {
+                            if (timeMs) {
+                                await tabState.page.waitForTimeout(timeMs);
+                            }
+                            else if (text) {
+                                await tabState.page.waitForSelector(`text=${text}`, { timeout: 30000 });
+                            }
+                            else if (loadState) {
+                                await tabState.page.waitForLoadState(loadState, { timeout: 30000 });
+                            }
+                        }
+                        catch (err) {
+                            await (0, tab_1.flushBlockedNavigationError)(tabState.page);
+                            throw err;
+                        }
+                    });
                     return { ok: true, targetId, url: tabState.page.url() };
                 }
+                case 'extractStructured': {
+                    const params = body;
+                    if (!params.schema || typeof params.schema !== 'object' || Array.isArray(params.schema)) {
+                        throw new structured_extractor_1.StructuredExtractSchemaError('schema must be an object');
+                    }
+                    const payload = await (0, structured_extractor_1.extractStructuredData)(tabState.page, params.schema);
+                    return {
+                        ok: true,
+                        targetId,
+                        data: payload.data,
+                        metadata: payload.metadata,
+                    };
+                }
                 case 'close': {
                     await (0, tab_1.safePageClose)(tabState.page);
                     found.group.delete(String(targetId));
@@ -365,16 +584,24 @@ router.post('/act', async (req, res) => {
                     throw new Error(`Unsupported action kind: ${kind}`);
             }
         }), CONFIG.handlerTimeoutMs, 'act'));
+        lifecycle_controller_1.lifecycleController.recordInteractiveActivity();
         return res.json(result);
     }
     catch (err) {
+        if (err instanceof structured_extractor_1.StructuredExtractSchemaError) {
+            return res.status(err.statusCode).json({ error: err.message });
+        }
+        if (err instanceof structured_extractor_1.StructuredExtractRuntimeError) {
+            return res.status(err.statusCode).json({
+                error: 'Structured extraction failed',
+                fieldPath: err.fieldPath,
+                reason: err.reason,
+            });
+        }
         const message = err instanceof Error ? err.message : String(err);
-        const statusCode = err?.statusCode;
         const kindFromBody = typeof req.body.kind === 'string' ? req.body.kind : undefined;
         (0, logging_1.log)('error', 'act failed', { reqId: req.reqId, kind: kindFromBody, error: message });
-        if (statusCode === 400)
-            return res.status(400).json({ error: message });
-        return res.status(500).json({ error: (0, errors_1.safeError)(err) });
+        return res.status(getRouteErrorStatus(err)).json({ error: (0, errors_1.safeError)(err) });
     }
 });
 exports.default = router;