@anweat/dsh-browser 0.1.7 → 0.1.9

package/lib/browser-service.js

@@ -21,60 +21,75 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { loadPlaywright, runOpencli, runNode, playwrightCliPath } from "./deps.js";
+import { browserRuntimeCliPath, loadBrowserRuntime, opencliEntryPath, runOpencli, runNode } from "./deps.js";
 import { AuthProfileStore } from "./auth-profiles.js";
 import { applyRuleSteps, resolveRulePack } from "./rule-packs.js";
 import { runRecipe } from "./automation.js";
 import { BUILTIN_SCRIPTS, builtinScript, executeUserscript, validateUserscript } from "./scripts.js";
-import { browserToolsForMode } from "./freedom.js";
+import { configuredBrowserTools } from "./freedom.js";
+import { filterOpencliCatalog, parseOpencliCatalog } from "./opencli-catalog.js";
+import { UsageGovernor } from "./usage-policy.js";
 /** Rules-aware content extractor (runs in the page). */
-const EXTRACTOR_FN = `(ruleList) => {
-  const doc = document
-  const title = doc.title ? doc.title.trim() : ''
-  let host = ''
-  try { host = location.hostname } catch (e) {}
-  const norm = (h) => { const x = h.toLowerCase(); return x.startsWith('www.') ? x.slice(4) : x }
-  let rule = null
-  for (const r of ruleList) {
-    const rh = norm(r.hostname)
-    if (host === rh || host.endsWith('.' + rh)) rule = r
-  }
-  const pick = (selectors) => {
-    for (const sel of selectors) {
-      try {
-        const el = doc.querySelector(sel)
-        if (el && (el.textContent || '').trim().length > 40) return el
-      } catch (e) {}
-    }
-    return null
-  }
-  const content = rule ? pick(rule.contentSelectors) : (pick(['article', 'main', '[role="main"]']) || doc.body)
-  if (content && rule && rule.removeSelectors) {
-    for (const sel of rule.removeSelectors) {
-      try { content.querySelectorAll(sel).forEach((el) => el.remove()) } catch (e) {}
-    }
-  }
-  const text = content ? (content.innerText || content.textContent || '') : ''
-  return { title, text, html: doc.documentElement.outerHTML.slice(0, 2000000), usedRule: rule ? rule.hostname : null }
+const EXTRACTOR_FN = `(ruleList) => {
+  const doc = document
+  const title = doc.title ? doc.title.trim() : ''
+  let host = ''
+  try { host = location.hostname } catch (e) {}
+  const norm = (h) => { const x = h.toLowerCase(); return x.startsWith('www.') ? x.slice(4) : x }
+  let rule = null
+  for (const r of ruleList) {
+    const rh = norm(r.hostname)
+    if (host === rh || host.endsWith('.' + rh)) rule = r
+  }
+  const pick = (selectors) => {
+    for (const sel of selectors) {
+      try {
+        const el = doc.querySelector(sel)
+        if (el && (el.textContent || '').trim().length > 40) return el
+      } catch (e) {}
+    }
+    return null
+  }
+  const content = rule ? pick(rule.contentSelectors) : (pick(['article', 'main', '[role="main"]']) || doc.body)
+  if (content && rule && rule.removeSelectors) {
+    for (const sel of rule.removeSelectors) {
+      try { content.querySelectorAll(sel).forEach((el) => el.remove()) } catch (e) {}
+    }
+  }
+  const text = content ? (content.innerText || content.textContent || '') : ''
+  return { title, text, html: doc.documentElement.outerHTML.slice(0, 2000000), usedRule: rule ? rule.hostname : null }
 }`;
 /** Platform search-page list extractor (runs in the page). */
-const LIST_EXTRACTOR = `(spec) => {
-  const items = []
-  const nodes = document.querySelectorAll(spec.item)
-  for (let i = 0; i < nodes.length && items.length < 20; i++) {
-    const el = nodes[i]
-    const titleEl = spec.title ? el.querySelector(spec.title) : null
-    const linkEl = spec.link ? el.querySelector(spec.link) : null
-    const textEl = spec.text ? el.querySelector(spec.text) : null
-    const title = (titleEl ? titleEl.textContent : el.textContent || '').trim().replace(/\\s+/g, ' ')
-    let url = linkEl ? (linkEl.href || linkEl.getAttribute('href') || '') : ''
-    if (url && url.startsWith('/')) url = location.origin + url
-    if (!url && linkEl === null && titleEl) { const a = titleEl.closest ? titleEl.closest('a') : null; if (a) url = a.href }
-    const snippet = textEl ? (textEl.textContent || '').trim().replace(/\\s+/g, ' ').slice(0, 300) : ''
-    if (!url || !title || title.length < 2) continue
-    items.push({ url, title, snippet })
-  }
-  return items
+const LIST_EXTRACTOR = `(spec) => {
+  const items = []
+  const nodes = document.querySelectorAll(spec.item)
+  for (let i = 0; i < nodes.length && items.length < 20; i++) {
+    const el = nodes[i]
+    const titleEl = spec.title ? el.querySelector(spec.title) : null
+    const linkEl = spec.link ? el.querySelector(spec.link) : null
+    const textEl = spec.text ? el.querySelector(spec.text) : null
+    const title = (titleEl ? titleEl.textContent : el.textContent || '').trim().replace(/\\s+/g, ' ')
+    let url = linkEl ? (linkEl.href || linkEl.getAttribute('href') || '') : ''
+    if (url && url.startsWith('/')) url = location.origin + url
+    if (!url && linkEl === null && titleEl) { const a = titleEl.closest ? titleEl.closest('a') : null; if (a) url = a.href }
+    const snippet = textEl ? (textEl.textContent || '').trim().replace(/\\s+/g, ' ').slice(0, 300) : ''
+    if (!url || !title || title.length < 2) continue
+    items.push({ url, title, snippet })
+  }
+  return items
+}`;
+const CRAWL_EXTRACTOR = `(maxChars) => {
+  const root = document.querySelector('article, main, [role="main"]') || document.body
+  const text = ((root && (root.innerText || root.textContent)) || '').replace(/\\n{3,}/g, '\\n\\n').trim().slice(0, maxChars)
+  const links = []
+  for (const anchor of document.querySelectorAll('a[href]')) {
+    try {
+      const url = new URL(anchor.href, location.href)
+      if ((url.protocol === 'http:' || url.protocol === 'https:') && !links.includes(url.href)) links.push(url.href)
+      if (links.length >= 500) break
+    } catch (e) {}
+  }
+  return { title: document.title || '', text, links }
 }`;
 function uid() {
     return crypto.randomUUID();
@@ -90,6 +105,18 @@ function specArg(spec) {
 function evaluateExtractor(page, rules) {
     return page.evaluate('(' + EXTRACTOR_FN + ')(' + JSON.stringify(rules) + ')');
 }
+function storageStateOptions(statePath, label, allowMissing = false) {
+    if (!statePath)
+        return {};
+    if (!fs.existsSync(statePath)) {
+        if (allowMissing)
+            return {};
+        throw new Error(`dsh-browser: ${label} storageState file does not exist: ${statePath}`);
+    }
+    if (!fs.statSync(statePath).isFile())
+        throw new Error(`dsh-browser: ${label} storageState path is not a file: ${statePath}`);
+    return { storageState: statePath };
+}
 export class BrowserService {
     config;
     browser;
@@ -99,19 +126,27 @@ export class BrowserService {
     activeProfile;
     activeRulePack;
     authProfiles;
+    usageGovernor;
+    opencliCatalogCache;
     constructor(config) {
         this.config = config;
         this.authProfiles = new AuthProfileStore(config.authProfiles);
+        this.usageGovernor = new UsageGovernor(config.usagePolicy);
     }
     available() {
         return this.config.enabled;
     }
+    assertEnabled() {
+        if (!this.config.enabled)
+            throw new Error('dsh-browser: browser service is disabled');
+    }
     async ensure() {
+        this.assertEnabled();
         if (this.browser)
             return this.browser;
         if (!this.launching) {
             this.launching = (async () => {
-                const pw = loadPlaywright();
+                const pw = loadBrowserRuntime(this.config.browserRuntime);
                 const launchOptions = { headless: this.config.headless };
                 if (this.config.channel)
                     launchOptions.channel = this.config.channel;
@@ -128,7 +163,7 @@ export class BrowserService {
                             this.browser = await pw.chromium.launch(launchOptions);
                         }
                         else {
-                            throw new Error('dsh-browser: chromium is not installed. Run the browser_install tool, or: node "' + playwrightCliPath() + '" install chromium');
+                            throw new Error('dsh-browser: chromium is not installed for ' + this.config.browserRuntime + '. Run the browser_install tool, or: node "' + browserRuntimeCliPath(this.config.browserRuntime) + '" install chromium');
                         }
                     }
                     else {
@@ -145,16 +180,37 @@ export class BrowserService {
     }
     /** Run `playwright install chromium` from the bundled playwright CLI. */
     installChromium() {
-        return runNode(playwrightCliPath(), ['install', 'chromium'], { timeoutMs: 600_000, signal: undefined, maxOutput: 256 * 1024 });
+        this.assertEnabled();
+        return runNode(browserRuntimeCliPath(this.config.browserRuntime), ['install', 'chromium'], { timeoutMs: 600_000, signal: undefined, maxOutput: 256 * 1024 });
+    }
+    async navigate(page, url, options, signal) {
+        let response;
+        for (let attempt = 0; attempt <= this.config.usagePolicy.retryLimit; attempt++) {
+            response = await this.usageGovernor.run(url, () => page.goto(url, options), signal);
+            const status = Number(response?.status?.() ?? 0);
+            if (status >= 200 && status < 400)
+                this.usageGovernor.noteResponse(url, status);
+            if (![429, 502, 503, 504].includes(status))
+                return response;
+            const rawRetryAfter = String(response?.headers?.()?.['retry-after'] ?? '');
+            const retryAfterMs = /^\d+(?:\.\d+)?$/.test(rawRetryAfter)
+                ? Number(rawRetryAfter) * 1000
+                : (Number.isFinite(Date.parse(rawRetryAfter)) ? Math.max(Date.parse(rawRetryAfter) - Date.now(), 0) : undefined);
+            this.usageGovernor.noteResponse(url, status, retryAfterMs);
+            if (attempt === this.config.usagePolicy.retryLimit)
+                return response;
+        }
+        return response;
     }
     async transientContext(url, opts = {}) {
         const browser = await this.ensure();
-        const profileId = opts.authProfile ?? this.config.defaultAuthProfile;
+        const profileId = opts.anonymous ? undefined : (opts.authProfile ?? this.config.defaultAuthProfile);
         const profile = profileId ? this.authProfiles.resolve(profileId, url) : undefined;
         const rulePack = resolveRulePack(this.config.rulePacks, opts.rulePack, url);
-        const context = await browser.newContext(profile?.storageStatePath
-            ? { storageState: profile.storageStatePath }
-            : (this.config.storageStatePath ? { storageState: this.config.storageStatePath } : {}));
+        const stateOptions = profile
+            ? storageStateOptions(profile.storageStatePath, `auth profile ${profile.id}`, profile.persistState)
+            : (!opts.anonymous ? storageStateOptions(this.config.storageStatePath, 'global') : {});
+        const context = await browser.newContext(stateOptions);
         try {
             if (rulePack?.initScriptPath)
                 await context.addInitScript({ path: rulePack.initScriptPath });
@@ -192,7 +248,7 @@ export class BrowserService {
             signal?.addEventListener('abort', onAbort);
         try {
             page.setDefaultTimeout(20_000);
-            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 25_000 });
+            await this.navigate(page, url, { waitUntil: 'domcontentloaded', timeout: 25_000 }, signal);
             await page.waitForLoadState('networkidle', { timeout: 8_000 }).catch(() => { });
             await applyRuleSteps(page, session.rulePack);
             if (opts.waitMs)
@@ -225,21 +281,22 @@ export class BrowserService {
             signal?.addEventListener('abort', onAbort);
         fs.mkdirSync(opts.outDir, { recursive: true });
         const stamp = Date.now() + '-' + uid().slice(0, 8);
-        const screenshotPath = path.join(opts.outDir, stamp + '.png');
+        const screenshotPath = opts.screenshot === false ? undefined : path.join(opts.outDir, stamp + '.png');
         const htmlPath = path.join(opts.outDir, stamp + '.html');
         try {
             page.setDefaultTimeout(25_000);
-            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+            await this.navigate(page, url, { waitUntil: 'domcontentloaded', timeout: 30_000 }, signal);
             await page.waitForLoadState('networkidle', { timeout: 10_000 }).catch(() => { });
             await applyRuleSteps(page, session.rulePack);
-            await page.screenshot({ path: screenshotPath, fullPage: true });
+            if (screenshotPath)
+                await page.screenshot({ path: screenshotPath, fullPage: true });
             const html = await page.content();
             fs.writeFileSync(htmlPath, html, 'utf8');
             const data = await evaluateExtractor(page, rules);
             return {
                 title: String(data.title ?? ''),
                 text: capText(String(data.text ?? '').replace(/\n{3,}/g, '\n\n').trim(), opts.maxChars ?? 200_000),
-                screenshotPath,
+                ...screenshotPath ? { screenshotPath } : {},
                 htmlPath,
                 ...data.usedRule ? { usedRule: String(data.usedRule) } : {},
             };
@@ -266,7 +323,7 @@ export class BrowserService {
             signal?.addEventListener('abort', onAbort);
         try {
             page.setDefaultTimeout(25_000);
-            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+            await this.navigate(page, url, { waitUntil: 'domcontentloaded', timeout: 30_000 }, signal);
             await page.waitForLoadState('networkidle', { timeout: 8_000 }).catch(() => { });
             await applyRuleSteps(page, session.rulePack);
             if (opts.waitMs)
@@ -291,19 +348,140 @@ export class BrowserService {
     }
     // ── bundled opencli ───────────────────────────────────────────────────────
     opencliAvailable() {
-        return this.config.opencliEnabled;
+        if (!this.config.enabled || !this.config.opencliEnabled)
+            return false;
+        try {
+            return fs.existsSync(opencliEntryPath());
+        }
+        catch {
+            return false;
+        }
     }
     opencli(args, opts = {}) {
+        if (!this.config.enabled)
+            return Promise.resolve({ code: -1, stdout: '', stderr: 'dsh-browser: browser service is disabled', timedOut: false });
         if (!this.config.opencliEnabled)
             return Promise.resolve({ code: -1, stdout: '', stderr: 'dsh-browser: OpenCLI is disabled', timedOut: false });
+        if (!this.opencliAvailable())
+            return Promise.resolve({ code: -1, stdout: '', stderr: 'dsh-browser: OpenCLI entry is not installed', timedOut: false });
         if (args.length < 1 || args.length > 40 || args.some(arg => typeof arg !== 'string' || arg.length > 2_000)) {
             return Promise.resolve({ code: -1, stdout: '', stderr: 'dsh-browser: OpenCLI requires 1 to 40 arguments, each at most 2000 characters', timedOut: false });
         }
-        return runOpencli(args, { ...opts, signal: opts.signal });
+        // OpenCLI adapters can issue real site traffic outside Playwright, so they
+        // share the same approval-independent concurrency and burst buffer.
+        return this.usageGovernor.run('https://opencli.local/', () => runOpencli(args, { ...opts, signal: opts.signal }), opts.signal);
     }
     opencliDoctor(signal) {
         return this.opencli(['doctor'], { timeoutMs: 30_000, signal });
     }
+    async opencliCatalog(filter = {}, signal) {
+        if (!this.config.opencliEnabled)
+            throw new Error('dsh-browser: OpenCLI is disabled');
+        if (!this.opencliCatalogCache) {
+            const result = await this.opencli(['list', '-f', 'json'], { timeoutMs: 60_000, signal });
+            if (result.code !== 0 || result.timedOut)
+                throw new Error('OpenCLI catalog failed: ' + (result.stderr || result.stdout).slice(0, 500));
+            this.opencliCatalogCache = parseOpencliCatalog(result.stdout);
+        }
+        return filterOpencliCatalog(this.opencliCatalogCache, filter);
+    }
+    async crawl(startUrls, opts = {}) {
+        if (startUrls.length < 1 || startUrls.length > 5)
+            throw new Error('browser crawl requires 1 to 5 start URLs');
+        const normalized = startUrls.map(value => {
+            const url = new URL(value);
+            if (!['http:', 'https:'].includes(url.protocol))
+                throw new Error('browser crawl only supports HTTP(S) URLs');
+            url.hash = '';
+            return url.href;
+        });
+        const maxPages = opts.maxPages ?? this.config.usagePolicy.maxPagesPerRun;
+        const maxDepth = opts.maxDepth ?? this.config.usagePolicy.maxDepth;
+        if (!Number.isInteger(maxPages) || maxPages < 1 || maxPages > this.config.usagePolicy.maxPagesPerRun) {
+            throw new Error('browser crawl maxPages must be from 1 to configured usagePolicy.maxPagesPerRun (' + this.config.usagePolicy.maxPagesPerRun + ')');
+        }
+        if (!Number.isInteger(maxDepth) || maxDepth < 0 || maxDepth > this.config.usagePolicy.maxDepth) {
+            throw new Error('browser crawl maxDepth must be from 0 to configured usagePolicy.maxDepth (' + this.config.usagePolicy.maxDepth + ')');
+        }
+        const maxCharsPerPage = Math.min(Math.max(opts.maxCharsPerPage ?? 20_000, 1_000), 50_000);
+        const sameOrigin = opts.sameOrigin ?? true;
+        const allowedOrigins = new Set(normalized.map(value => new URL(value).origin));
+        const queue = normalized.map(url => ({ url, depth: 0 }));
+        const seen = new Set(normalized);
+        const pages = [];
+        const errors = [];
+        const before = this.usageGovernor.snapshot();
+        const started = Date.now();
+        const session = await this.transientContext(normalized[0], { anonymous: true });
+        try {
+            while (queue.length && pages.length + errors.length < maxPages) {
+                if (opts.signal?.aborted)
+                    throw new Error('browser crawl aborted');
+                const item = queue.shift();
+                const page = await session.context.newPage();
+                try {
+                    page.setDefaultTimeout(30_000);
+                    const response = await this.navigate(page, item.url, { waitUntil: 'domcontentloaded', timeout: 30_000 }, opts.signal);
+                    const status = Number(response?.status?.() ?? 0);
+                    if (sameOrigin && !allowedOrigins.has(new URL(page.url()).origin)) {
+                        errors.push({ url: item.url, depth: item.depth, status, error: 'cross-origin redirect blocked: ' + page.url() });
+                        continue;
+                    }
+                    if (status >= 400) {
+                        errors.push({ url: item.url, depth: item.depth, status, error: 'HTTP ' + status });
+                        continue;
+                    }
+                    await page.waitForLoadState('networkidle', { timeout: 5_000 }).catch(() => { });
+                    const data = await page.evaluate('(' + CRAWL_EXTRACTOR + ')(' + maxCharsPerPage + ')');
+                    pages.push({ url: page.url(), title: String(data.title ?? ''), text: String(data.text ?? ''), depth: item.depth, status });
+                    if (item.depth >= maxDepth)
+                        continue;
+                    for (const rawLink of Array.isArray(data.links) ? data.links : []) {
+                        let link;
+                        try {
+                            link = new URL(rawLink);
+                            link.hash = '';
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (sameOrigin && !allowedOrigins.has(link.origin))
+                            continue;
+                        const href = link.href;
+                        if (seen.has(href) || seen.size >= maxPages * 25)
+                            continue;
+                        seen.add(href);
+                        queue.push({ url: href, depth: item.depth + 1 });
+                    }
+                }
+                catch (error) {
+                    errors.push({ url: item.url, depth: item.depth, error: String(error).slice(0, 500) });
+                }
+                finally {
+                    await page.close().catch(() => { });
+                }
+            }
+        }
+        finally {
+            await this.persistAndClose(session);
+        }
+        const after = this.usageGovernor.snapshot();
+        return {
+            pages,
+            errors,
+            stats: {
+                pagesVisited: pages.length + errors.length,
+                queued: queue.length,
+                elapsedMs: Date.now() - started,
+                waitMs: after.totalWaitMs - before.totalWaitMs,
+                backoffEvents: after.backoffEvents - before.backoffEvents,
+            },
+            warnings: [
+                'Bounded crawl: respect each site\'s terms, robots directives, copyright, privacy, and applicable law.',
+                'No-approval mode skips human confirmation only; concurrency, burst, page/depth budgets, and server-pressure backoff remain active.',
+            ],
+        };
+    }
     scriptCatalog() {
         return BUILTIN_SCRIPTS.map(script => ({
             id: script.id,
@@ -330,7 +508,7 @@ export class BrowserService {
         let timer;
         try {
             page.setDefaultTimeout(30_000);
-            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+            await this.navigate(page, url, { waitUntil: 'domcontentloaded', timeout: 30_000 }, signal);
             await page.waitForLoadState('networkidle', { timeout: 8_000 }).catch(() => { });
             await applyRuleSteps(page, session.rulePack);
             const timeoutMs = Math.min(Math.max(opts.timeoutMs ?? 15_000, 1_000), 30_000);
@@ -340,7 +518,7 @@ export class BrowserService {
                     reject(new Error('userscript timed out after ' + timeoutMs + 'ms'));
                 }, timeoutMs);
             });
-            const executed = await Promise.race([executeUserscript(page, source), timeout]);
+            const executed = await Promise.race([executeUserscript(page, source, 100_000, opts.inputs), timeout]);
             return {
                 url: page.url(),
                 name: validation.metadata.name,
@@ -385,7 +563,7 @@ export class BrowserService {
         }
         else {
             const browser = await this.ensure();
-            this.activeContext = await browser.newContext(this.config.storageStatePath ? { storageState: this.config.storageStatePath } : {});
+            this.activeContext = await browser.newContext(storageStateOptions(this.config.storageStatePath, 'global'));
         }
         this.activePage = await this.activeContext.newPage();
         return this.activePage;
@@ -410,7 +588,7 @@ export class BrowserService {
     async open(url, opts = {}) {
         const page = await this.ensureActivePage(url, opts);
         page.setDefaultTimeout(30_000);
-        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+        await this.navigate(page, url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
         await page.waitForLoadState('networkidle', { timeout: 8_000 }).catch(() => { });
         await applyRuleSteps(page, this.activeRulePack);
         if (opts.waitMs)
@@ -453,7 +631,7 @@ export class BrowserService {
         const page = await this.ensureActivePage(opts.url, opts);
         if (opts.url) {
             page.setDefaultTimeout(30_000);
-            await page.goto(opts.url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+            await this.navigate(page, opts.url, { waitUntil: 'domcontentloaded', timeout: 30_000 }, opts.signal);
             await page.waitForLoadState('networkidle', { timeout: 8_000 }).catch(() => { });
             await applyRuleSteps(page, this.activeRulePack);
             if (opts.waitMs)
@@ -485,25 +663,59 @@ export class BrowserService {
     }
     async status() {
         let chromiumInstalled = false;
+        let chromiumExecutablePath;
         try {
-            const pw = loadPlaywright();
-            chromiumInstalled = !!pw.chromium.executablePath();
+            const pw = loadBrowserRuntime(this.config.browserRuntime);
+            const expectedPath = this.config.executablePath || pw.chromium.executablePath();
+            if (typeof expectedPath === 'string' && expectedPath.trim()) {
+                chromiumExecutablePath = path.resolve(expectedPath);
+                chromiumInstalled = fs.existsSync(chromiumExecutablePath);
+            }
         }
         catch {
             chromiumInstalled = false;
         }
+        let opencliInstalled = false;
+        let resolvedOpencliEntryPath;
+        try {
+            resolvedOpencliEntryPath = path.resolve(opencliEntryPath());
+            opencliInstalled = fs.existsSync(resolvedOpencliEntryPath);
+        }
+        catch {
+            opencliInstalled = false;
+        }
+        const runtimeWarnings = this.config.browserRuntime === 'patchright'
+            ? [
+                'Patchright is Chromium-only and disables Playwright console APIs to avoid Runtime.enable detection.',
+                ...(this.config.channel !== 'chrome' || this.config.headless
+                    ? ['Patchright stealth is strongest with channel=chrome and headless=false; current settings favor automation/test compatibility.']
+                    : []),
+            ]
+            : [];
+        if (!chromiumInstalled && chromiumExecutablePath && (this.config.channel === 'chromium' || !!this.config.executablePath)) {
+            runtimeWarnings.push(`Expected Chromium executable is missing: ${chromiumExecutablePath}. Run browser_install for ${this.config.browserRuntime}.`);
+        }
+        if (this.config.opencliEnabled && !opencliInstalled)
+            runtimeWarnings.push('OpenCLI is enabled but its package entry is not installed.');
         return {
             enabled: this.config.enabled,
             channel: this.config.channel,
+            browserRuntime: this.config.browserRuntime,
+            runtimeWarnings,
             headless: this.config.headless,
             opencliEnabled: this.config.opencliEnabled,
+            opencliInstalled,
+            ...resolvedOpencliEntryPath ? { opencliEntryPath: resolvedOpencliEntryPath } : {},
             automationMode: this.config.automationMode,
-            exposedTools: browserToolsForMode(this.config.automationMode),
-            directInteractionPolicy: this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'standard' ? 'ask' : 'allow',
-            mutatingRecipePolicy: this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'standard' ? 'ask' : 'allow',
-            externalUserscriptPolicy: this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'unrestricted' ? 'allow' : 'ask',
-            opencliRunPolicy: this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'unrestricted' ? 'allow' : 'ask',
+            exposedTools: configuredBrowserTools(this.config.automationMode, this.config.automationAssets, this.config.enabled),
+            directInteractionPolicy: !this.config.enabled || this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'standard' ? 'ask' : 'allow',
+            mutatingRecipePolicy: !this.config.enabled || this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'standard' ? 'ask' : 'allow',
+            externalUserscriptPolicy: !this.config.enabled || this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'unrestricted' ? 'allow' : 'ask',
+            opencliRunPolicy: !this.config.enabled || this.config.automationMode === 'read-only' ? 'deny' : this.config.automationMode === 'unrestricted' ? 'allow' : 'ask',
             chromiumInstalled,
+            ...chromiumExecutablePath ? { chromiumExecutablePath } : {},
+            usagePolicy: this.config.usagePolicy,
+            usageGovernor: this.usageGovernor.snapshot(),
             authProfiles: this.authProfiles.list(),
             rulePacks: Object.keys(this.config.rulePacks).sort(),
             builtinScripts: BUILTIN_SCRIPTS.map(script => script.id),