@snutils/snu 0.2.11 → 0.3.0

package/dist/server/dispatcher.js

@@ -33,8 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StandaloneDispatcher = exports.HELPER_CONNECT_GUIDANCE = void 0;
+exports.StandaloneDispatcher = exports.HELPER_CONNECT_GUIDANCE = exports.BROWSER_ACTIONS = void 0;
 exports.resolveMappedFileName = resolveMappedFileName;
+const authProbe_js_1 = require("./authProbe.js");
+const scopeDiscovery_js_1 = require("./scopeDiscovery.js");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -46,6 +48,27 @@ const canonical_js_1 = require("./canonical.js");
 const types_js_1 = require("../types.js");
 const scopeResolver_js_1 = require("./scopeResolver.js");
 const FOLDERRECORDTABLES = ['sp_widget', 'sp_header_footer', 'sys_ui_page'];
+// Helper tab action names this host sends for the browser-relayed commands.
+// The helper tab dispatches on the exact string and drops an unknown action
+// without answering, so a wrong name here only ever surfaces as E_TIMEOUT
+// 70 seconds later (take_screenshot shipped as 'agentTakeScreenshot' and never
+// worked in standalone mode). Keep in step with the dispatch chain in the
+// extension's scriptsync.js; browserRelay.test.ts pins these values.
+exports.BROWSER_ACTIONS = {
+    get_form_state: 'agentGetFormState',
+    set_field: 'agentSetField',
+    run_ui_action: 'agentRunUiAction',
+    navigate: 'agentNavigate',
+    take_screenshot: 'takeScreenshot',
+    switch_context: 'switchContext',
+};
+const SWITCH_CONTEXT_TYPES = ['updateset', 'application', 'domain'];
+const SWITCH_CONTEXT_ALIASES = {
+    app: 'application',
+    scope: 'application',
+    update_set: 'updateset',
+    'update-set': 'updateset',
+};
 // Human labels + the environment variable each gate is *actually* read from in
 // config.ts. Deriving the variable name from the camelCase gate key produces
 // SNU_ALLOW_RESTREQUEST, which nothing reads, so an agent told to set it hits
@@ -166,11 +189,11 @@ function resolveTableCodeFields(tableName, cwd) {
     }
     return ['script'];
 }
-function resolveFieldExtension(tableName, fieldName, cwd) {
+function resolveFieldExtension(tableName, fieldName, cwd, liveType) {
     const meta = getMetaDataRelations(cwd);
     let fieldType = 'script';
     try {
-        fieldType = meta?.tableFields?.[tableName]?.codeFields?.[fieldName]?.type || fieldName;
+        fieldType = liveType || meta?.tableFields?.[tableName]?.codeFields?.[fieldName]?.type || fieldName;
     }
     catch { }
     let ext = FIELDTYPES[fieldType]?.extension;
@@ -251,6 +274,8 @@ class StandaloneDispatcher {
     pending;
     config;
     pendingReviewRequests = new Map(); // correlationId/requestId -> reviewId
+    /** Pause before the single retry after E_SCREENSHOT_PERMISSION; tests shorten it. */
+    screenshotRetryDelayMs = 10_000;
     requestIdToCorrelationId = new Map(); // requestId -> correlationId
     constructor(opts) {
         this.cwd = opts.cwd || process.cwd();
@@ -475,7 +500,7 @@ class StandaloneDispatcher {
             sysparm_offset: String(offset),
             sysparm_display_value: 'false',
             sysparm_exclude_reference_link: 'true',
-            sysparm_no_count: 'true',
+            sysparm_no_count: 'false',
         };
         if (combinedQuery) {
             queryParams.sysparm_query = combinedQuery;
@@ -499,6 +524,7 @@ class StandaloneDispatcher {
         const isFolderRecordTable = FOLDERRECORDTABLES.includes(table);
         let filesWritten = 0;
         let skippedEmpty = 0;
+        let skippedUnreadable = 0;
         const warnings = [];
         const pulledRecordsList = [];
         for (const rec of matchedRecords) {
@@ -553,7 +579,12 @@ class StandaloneDispatcher {
             }
             const recordFiles = [];
             for (const field of codeFields) {
-                const ext = resolveFieldExtension(table, field, this.cwd);
+                if (!Object.prototype.hasOwnProperty.call(rec, field)) {
+                    skippedUnreadable++;
+                    warnings.push(`${table}/${sysId}.${field}: field not returned; local file preserved.`);
+                    continue;
+                }
+                const ext = resolveFieldExtension(table, field, this.cwd, opts.fieldDefinitions?.[field]?.type);
                 let targetPath;
                 try {
                     targetPath = isFolderRecordTable
@@ -603,27 +634,18 @@ class StandaloneDispatcher {
             });
         }
         return {
+            pagination: res.pagination,
             table,
             matchedRecords: matchedRecords.length,
             pulledRecords: pulledRecordsList.length,
             filesWritten,
             skippedEmpty,
+            skippedUnreadable,
             warnings,
             records: pulledRecordsList,
         };
     }
-    // Which artifact tables snu knows how to write to disk: the ones in
-    // resources/metaDataRelations.json that declare code fields.
-    allCodeTables() {
-        const meta = getMetaDataRelations(this.cwd);
-        const out = new Set();
-        for (const [table, def] of Object.entries(meta?.tableFields || {})) {
-            if (def?.codeFields && typeof def.codeFields === 'object')
-                out.add(table);
-        }
-        return out;
-    }
-    async restGet(inst, reqCommand, endpoint, queryParams) {
+    async restGet(inst, reqCommand, endpoint, queryParams, withPagination = false) {
         const correlationId = crypto.randomUUID();
         const pendingPromise = this.pending.register({ id: correlationId, command: reqCommand, timeoutMs: 70_000 });
         this.ws.sendToBrowser({
@@ -637,9 +659,10 @@ class StandaloneDispatcher {
         });
         const res = await pendingPromise;
         if (res?.success === false) {
-            throw Object.assign(new Error(res.error || `REST request failed: ${endpoint}`), { code: res.code || 'E_COMMAND_FAILED' });
+            const hint = res?.status ? '' : (0, authProbe_js_1.helperFailureHint)(typeof res?.error === 'string' ? res.error : '', inst.settings?.url);
+            throw Object.assign(new Error([res.error || `REST request failed: ${endpoint}`, hint].filter(Boolean).join(' ')), { code: res.code || 'E_COMMAND_FAILED' });
         }
-        return res?.data;
+        return withPagination ? { rows: res?.data?.result, pagination: res?.pagination } : res?.data;
     }
     resolveInstance(requestInstance) {
         const folders = this.listInstanceFolders();
@@ -680,8 +703,16 @@ class StandaloneDispatcher {
             if (live) {
                 return { name: live.name, folder: this.cwd, settings: live };
             }
-            throw Object.assign(new Error(`No authenticated instance named "${requestInstance}" is connected. Run /token on that ServiceNow instance and retry.`), {
+            const known = [
+                ...liveInstances.map((candidate) => `${candidate.name} (${candidate.url})`),
+                ...folders.map((folder) => path.basename(folder)),
+            ];
+            const knownText = known.length
+                ? ` Known here: ${[...new Set(known)].join(', ')}. Pass one of these as the instance, by name, hostname or origin.`
+                : ' This bridge has not received any session since it started.';
+            throw Object.assign(new Error(`No authenticated instance named "${requestInstance}" is connected.${knownText} Otherwise open that exact hostname in the browser, run /token and retry.`), {
                 code: 'E_INSTANCE_NOT_FOUND',
+                details: { requested: requestInstance, liveInstances: liveInstances.map((candidate) => ({ name: candidate.name, url: candidate.url })) },
             });
         }
         if (folders.length === 1) {
@@ -731,6 +762,88 @@ class StandaloneDispatcher {
         this.pending.cancel(requestId, reason);
         this.requestIdToCorrelationId.delete(requestId);
     }
+    // Screenshot round trip, mirroring the VS Code host: the helper answers a
+    // takeScreenshot with base64 PNG data and this side writes the file under
+    // <workspace>/screenshots. allowDebugger carries the user's browserDebugger
+    // gate so a tab without an activeTab grant can be captured through the
+    // Chrome debugger (Debug edition + Pro; the helper re-checks both). Without
+    // it, or when the debugger path is not available, the helper asks for the
+    // extension-icon click and this side retries once after a pause.
+    async captureScreenshot(req, correlationId) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        let fileName = typeof req.params?.fileName === 'string' && req.params.fileName.trim()
+            ? req.params.fileName.trim()
+            : `screenshot_${timestamp}.png`;
+        if (!/\.png$/i.test(fileName))
+            fileName += '.png';
+        const savePath = safeJoinUnderRoot(this.cwd, 'screenshots', fileName);
+        const request = async (id, tabId) => {
+            const pendingPromise = this.pending.register({ id, command: req.command, timeoutMs: 70_000 });
+            this.ws.sendToBrowser({
+                action: exports.BROWSER_ACTIONS.take_screenshot,
+                agentRequestId: id,
+                url: req.params?.url,
+                tabId,
+                exactUrl: req.params?.exactUrl === true,
+                focus: req.params?.focus === true,
+                fileName,
+                savePath,
+                allowDebugger: this.config.gates.browserDebugger === true,
+                appName: 'SN Utils CLI',
+            });
+            try {
+                return await pendingPromise;
+            }
+            catch (err) {
+                // The bridge rejects a failed helper reply; a permission refusal is
+                // handled here (retry), so hand it back as a plain result.
+                if (err?.code === 'E_SCREENSHOT_PERMISSION') {
+                    return {
+                        success: false,
+                        code: err.code,
+                        error: err.message,
+                        tabId: err.details?.tabId,
+                        tabUrl: err.details?.tabUrl,
+                        cdpFallbackAvailable: err.details?.cdpFallbackAvailable,
+                    };
+                }
+                throw err;
+            }
+        };
+        let res = await request(correlationId, req.params?.tabId);
+        if (res?.code === 'E_SCREENSHOT_PERMISSION') {
+            // Give the user time to click the extension icon on the tab, then retry
+            // once on the tab the helper named.
+            await new Promise((resolve) => setTimeout(resolve, this.screenshotRetryDelayMs));
+            if (!this.ws.hasBrowserClient()) {
+                throw Object.assign(new Error('Browser helper disconnected while waiting for screenshot permission.'), { code: 'E_BROWSER_DISCONNECTED' });
+            }
+            res = await request(`${correlationId}_retry`, res.tabId ?? req.params?.tabId);
+        }
+        if (res?.code === 'E_SCREENSHOT_PERMISSION') {
+            throw Object.assign(new Error(res.error || 'Browser denied the screenshot (tab not capturable / permission).'), {
+                code: 'E_SCREENSHOT_PERMISSION',
+                details: { tabId: res.tabId, tabUrl: res.tabUrl, cdpFallbackAvailable: res.cdpFallbackAvailable === true },
+            });
+        }
+        if (res?.success === false) {
+            throw Object.assign(new Error(res.error || 'Screenshot failed'), { code: res.code || 'E_COMMAND_FAILED' });
+        }
+        if (typeof res?.imageData !== 'string' || !res.imageData) {
+            throw Object.assign(new Error('No image data received from browser'), { code: 'E_INTERNAL' });
+        }
+        fs.mkdirSync(path.dirname(savePath), { recursive: true });
+        fs.writeFileSync(savePath, Buffer.from(res.imageData, 'base64'));
+        return {
+            saved: true,
+            filePath: savePath,
+            fileName,
+            url: res.url || res.tabUrl || req.params?.url,
+            tabId: res.tabId ?? req.params?.tabId,
+            tabTitle: res.tabTitle,
+            capturedVia: res.capturedVia || 'activeTab',
+        };
+    }
     async dispatch(req) {
         const correlationId = `snu_req_${req.id}_${Date.now()}`;
         this.requestIdToCorrelationId.set(req.id, correlationId);
@@ -792,6 +905,18 @@ class StandaloneDispatcher {
                         message: 'The SN Utils helper tab is not connected, so the session cannot be checked.',
                     });
                 }
+                const hasLiveSession = !!origin && this.ws.getLiveInstances().some((live) => {
+                    try {
+                        return new URL(live.url).origin.toLowerCase() === origin;
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                if (!inst.settings?.g_ck) {
+                    const verdict = (0, authProbe_js_1.classifyProbe)({ error: 'Missing instance URL or authentication token', origin, hasLiveSession });
+                    return reply({ ok: false, state: verdict.state, message: verdict.message });
+                }
                 const correlationId = crypto.randomUUID();
                 const pendingPromise = this.pending.register({ id: correlationId, command: req.command, timeoutMs: 15_000 });
                 this.ws.sendToBrowser({
@@ -805,32 +930,25 @@ class StandaloneDispatcher {
                 });
                 try {
                     const res = await pendingPromise;
-                    const status = res?.status;
                     // 401 and 403 mean opposite things: the session is gone, versus the
-                    // session authenticated and an ACL refused the row.
-                    const state = res?.success === false
-                        ? status === 401
-                            ? 'AUTH_EXPIRED'
-                            : status === 403
-                                ? 'AUTH_OK'
-                                : 'AUTH_UNKNOWN'
-                        : 'AUTH_OK';
+                    // session authenticated and an ACL refused the row. Failures without
+                    // a status are classified from the helper tab's own error text.
+                    const verdict = res?.success === false
+                        ? (0, authProbe_js_1.classifyProbe)({ status: res?.status, error: typeof res?.error === 'string' ? res.error : res?.error?.message, origin, hasLiveSession })
+                        : (0, authProbe_js_1.classifyProbe)({ status: 200, origin, hasLiveSession });
                     return reply({
-                        ok: state === 'AUTH_OK',
-                        state,
-                        message: state === 'AUTH_OK'
-                            ? 'ServiceNow accepted the session.'
-                            : state === 'AUTH_EXPIRED'
-                                ? 'ServiceNow rejected the session (401). Open the instance in the browser and run /token to refresh it.'
-                                : 'The session check could not complete. This is not a verdict — retry before acting on it.',
+                        ok: verdict.state === 'AUTH_OK',
+                        state: verdict.state,
+                        message: verdict.message,
                         detail: res?.error,
                     });
                 }
                 catch (err) {
+                    const verdict = (0, authProbe_js_1.classifyProbe)({ status: err?.details?.status, error: err?.message || String(err), origin, hasLiveSession });
                     return reply({
                         ok: false,
-                        state: 'AUTH_UNKNOWN',
-                        message: 'The session check could not complete. This is not a verdict — retry before acting on it.',
+                        state: verdict.state,
+                        message: verdict.message,
                         detail: err?.message || String(err),
                     });
                 }
@@ -1427,64 +1545,66 @@ class StandaloneDispatcher {
                     }
                     catch { }
                 }
-                // Which artifact tables does this application actually use?
+                const fetchPage = (table, query) => this.restGet(inst, req.command, `/api/now/table/${table}`, query, true);
+                const discovery = await (0, scopeDiscovery_js_1.readAllPages)(fetchPage, 'sys_metadata', `sys_scope=${scopeSysId}^sys_class_name!=sys_metadata_delete^sys_update_name!=NULL^ORDERBYsys_id`, 'sys_class_name');
                 const classCounts = new Map();
-                const metaPage = 1000;
-                for (let offset = 0;; offset += metaPage) {
-                    const data = await this.restGet(inst, req.command, '/api/now/table/sys_metadata', {
-                        sysparm_query: `sys_scope=${scopeSysId}^sys_class_name!=sys_metadata_delete^sys_update_name!=NULL^ORDERBYsys_id`,
-                        sysparm_fields: 'sys_class_name',
-                        sysparm_limit: String(metaPage),
-                        sysparm_offset: String(offset),
-                        sysparm_exclude_reference_link: 'true',
-                        sysparm_no_count: 'true',
-                    });
-                    const rows = Array.isArray(data?.result) ? data.result : [];
-                    for (const r of rows) {
-                        const cls = String(typeof r.sys_class_name === 'object' ? r.sys_class_name.value : r.sys_class_name || '');
-                        if (cls)
-                            classCounts.set(cls, (classCounts.get(cls) || 0) + 1);
-                    }
-                    if (rows.length < metaPage)
-                        break;
+                for (const row of discovery.rows) {
+                    const cls = String(typeof row.sys_class_name === 'object' ? row.sys_class_name.value : row.sys_class_name || '');
+                    if (/^[a-zA-Z0-9_]+$/.test(cls))
+                        classCounts.set(cls, (classCounts.get(cls) || 0) + 1);
                 }
-                const codeTables = this.allCodeTables();
-                const tables = [...classCounts.keys()].filter((t) => codeTables.has(t) && (!tableFilter || tableFilter.has(t))).sort();
-                const skippedTables = [...classCounts.keys()].filter((t) => !codeTables.has(t)).sort()
-                    .map((t) => ({ table: t, records: classCounts.get(t) || 0 }));
+                const schema = await (0, scopeDiscovery_js_1.discoverScopeFields)([...classCounts.keys()], getMetaDataRelations(this.cwd)?.tableFields || {}, fetchPage);
+                const tables = [...classCounts.keys()].filter(t => Object.keys(schema.definitions[t]?.codeFields || {}).length && (!tableFilter || tableFilter.has(t))).sort();
+                const skippedTables = [...classCounts.keys()].filter(t => !Object.keys(schema.definitions[t]?.codeFields || {}).length).sort()
+                    .map(table => ({ table, records: classCounts.get(table) || 0, reason: schema.warnings.some(w => w.startsWith(`${table}:`)) ? 'dictionary_unavailable' : 'no_scriptable_fields' }));
                 const missingTables = tableFilter ? [...tableFilter].filter((t) => !classCounts.has(t)).sort() : [];
                 const perTable = [];
-                const warnings = [];
-                let totalRecords = 0, totalFiles = 0, totalSkippedEmpty = 0;
+                const warnings = [...discovery.warnings, ...schema.warnings];
+                let complete = discovery.complete && schema.warnings.length === 0;
+                let totalRecords = 0, totalFiles = 0, totalSkippedEmpty = 0, totalSkippedUnreadable = 0;
                 for (const table of tables) {
-                    const codeFields = resolveTableCodeFields(table, this.cwd);
+                    const fieldDefinitions = schema.definitions[table].codeFields;
+                    const codeFields = Object.keys(fieldDefinitions);
                     const query = `sys_scope=${scopeSysId}^sys_class_name=${table}^ORDERBYsys_id`;
-                    const entry = { table, matchedRecords: 0, pulledRecords: 0, filesWritten: 0, skippedEmpty: 0, truncated: false };
+                    const entry = { table, matchedRecords: 0, pulledRecords: 0, filesWritten: 0, skippedEmpty: 0, skippedUnreadable: 0, truncated: false };
                     if (includeRecords)
                         entry.records = [];
-                    for (let offset = 0;; offset += PAGE) {
+                    let reportedTotal;
+                    for (let offset = 0;;) {
                         const pageLimit = Math.min(PAGE, limit - entry.matchedRecords);
                         if (pageLimit <= 0) {
                             entry.truncated = true;
                             break;
                         }
-                        const page = await this.pullTablePage(inst, req.command, { table, query, codeFields, limit: pageLimit, offset });
+                        const page = await this.pullTablePage(inst, req.command, { table, query, codeFields, fieldDefinitions, limit: pageLimit, offset });
+                        if (page.pagination?.totalCount && /^\d+$/.test(page.pagination.totalCount))
+                            reportedTotal = Number(page.pagination.totalCount);
                         entry.matchedRecords += page.matchedRecords;
                         entry.pulledRecords += page.pulledRecords;
                         entry.filesWritten += page.filesWritten;
                         entry.skippedEmpty += page.skippedEmpty;
+                        entry.skippedUnreadable += page.skippedUnreadable;
                         if (includeRecords)
                             entry.records.push(...page.records);
                         for (const w of page.warnings)
                             warnings.push(`${table}: ${w}`);
-                        if (page.matchedRecords < pageLimit)
+                        const paging = (0, scopeDiscovery_js_1.pageState)(page.pagination, offset, pageLimit, page.matchedRecords);
+                        if (paging.nextOffset === undefined) {
+                            complete = complete && paging.complete;
+                            if (paging.warning)
+                                warnings.push(`${table}: ${paging.warning}`);
                             break;
+                        }
+                        offset = paging.nextOffset;
                     }
+                    if (!entry.truncated && reportedTotal !== undefined && reportedTotal > entry.matchedRecords)
+                        warnings.push(`${table}: ${reportedTotal - entry.matchedRecords} matching records were not returned; access controls or changing records may account for the difference.`);
                     if (entry.truncated)
                         warnings.push(`${table}: stopped at the per-table limit of ${limit} records; raise "limit" or pull the rest with pull_records.`);
                     totalRecords += entry.pulledRecords;
                     totalFiles += entry.filesWritten;
                     totalSkippedEmpty += entry.skippedEmpty;
+                    totalSkippedUnreadable += entry.skippedUnreadable;
                     perTable.push(entry);
                 }
                 for (const t of missingTables)
@@ -1495,10 +1615,12 @@ class StandaloneDispatcher {
                     status: 'success',
                     timestamp: Date.now(),
                     result: {
+                        complete: complete && !perTable.some(t => t.truncated) && warnings.length === 0,
+                        metadataRecords: discovery.rows.length,
                         scope: { name: scopeName, sys_id: scopeSysId },
                         folder: path.join(inst.name, scopeName).replace(/\\/g, '/'),
                         tables: perTable,
-                        totals: { tables: perTable.length, records: totalRecords, filesWritten: totalFiles, skippedEmpty: totalSkippedEmpty },
+                        totals: { tables: perTable.length, records: totalRecords, filesWritten: totalFiles, skippedEmpty: totalSkippedEmpty, skippedUnreadable: totalSkippedUnreadable },
                         skippedTables,
                         warnings,
                     },
@@ -1603,16 +1725,55 @@ class StandaloneDispatcher {
                     result: { status: res.status, data: res.data },
                 };
             }
-            // Browser Form & UI Actions
-            if (['get_form_state', 'set_field', 'run_ui_action', 'navigate', 'take_screenshot'].includes(req.command)) {
-                const actionMap = {
-                    get_form_state: 'agentGetFormState',
-                    set_field: 'agentSetField',
-                    run_ui_action: 'agentRunUiAction',
-                    navigate: 'agentNavigate',
-                    take_screenshot: 'agentTakeScreenshot',
+            if (req.command === 'take_screenshot') {
+                const result = await this.captureScreenshot(req, correlationId);
+                return { id: req.id, command: req.command, status: 'success', timestamp: Date.now(), result };
+            }
+            // Session context switch: the helper PUTs to the same concourse picker
+            // endpoint the header pickers use, so no form is driven. Needs the
+            // instance session (url + g_ck), which is why it is not in the generic
+            // browser relay below.
+            if (req.command === 'switch_context') {
+                const rawType = String(req.params?.switchType || '').trim().toLowerCase();
+                const switchType = SWITCH_CONTEXT_ALIASES[rawType] || rawType;
+                if (!SWITCH_CONTEXT_TYPES.includes(switchType)) {
+                    throw Object.assign(new Error(`Missing or invalid switchType. Must be one of: ${SWITCH_CONTEXT_TYPES.join(', ')}`), { code: 'E_INVALID_PARAMS' });
+                }
+                const value = String(req.params?.value ?? req.params?.sysId ?? req.params?.sys_id ?? '').trim();
+                if (!value || /[\s\0]/.test(value)) {
+                    throw Object.assign(new Error('Missing required param: value (sys_id of the update set, application or domain)'), { code: 'E_INVALID_PARAMS' });
+                }
+                const pendingPromise = this.pending.register({ id: correlationId, command: req.command, timeoutMs: 70_000 });
+                this.ws.sendToBrowser({
+                    action: exports.BROWSER_ACTIONS.switch_context,
+                    agentRequestId: correlationId,
+                    switchType,
+                    value,
+                    reloadTab: req.params?.reloadTab !== false,
+                    tabUrl: typeof req.params?.tabUrl === 'string' && req.params.tabUrl ? req.params.tabUrl : 'https://*.service-now.com/*',
+                    instance: inst.settings,
+                    appName: 'SN Utils CLI',
+                });
+                const res = await pendingPromise;
+                if (res?.success === false) {
+                    throw Object.assign(new Error(res.error || `Could not switch ${switchType}`), { code: res.code || 'E_COMMAND_FAILED' });
+                }
+                return {
+                    id: req.id,
+                    command: req.command,
+                    status: 'success',
+                    timestamp: Date.now(),
+                    result: {
+                        switched: true,
+                        switchType: res?.switchType || switchType,
+                        value: res?.value || value,
+                        reloaded: res?.reloaded === true,
+                    },
                 };
-                const action = actionMap[req.command];
+            }
+            // Browser Form & UI Actions
+            if (['get_form_state', 'set_field', 'run_ui_action', 'navigate'].includes(req.command)) {
+                const action = exports.BROWSER_ACTIONS[req.command];
                 const pendingPromise = this.pending.register({ id: correlationId, command: req.command, timeoutMs: 70_000 });
                 this.ws.sendToBrowser({
                     action,