explorbot 0.2.3 → 0.2.5

package/dist/src/remote.js

@@ -0,0 +1,235 @@
+import stripAnsi from 'strip-ansi';
+import { addActivityListener } from "./activity.js";
+import { executionController } from "./execution-controller.js";
+import { addDestination } from "./utils/logger.js";
+const QUEUE_CAP = 1000;
+const CONTENT_CAP = 8000;
+const RECONNECT_BASE_MS = 500;
+const RECONNECT_MAX_MS = 10_000;
+const ASK_TIMEOUT_MS = 15 * 60_000;
+const FLUSH_TIMEOUT_MS = 3000;
+/**
+ * Streams a run to a remote UI over one WebSocket, dialling out so a child
+ * process and a CI bot are the same case.
+ *
+ * It **is** a LogDestination — that is the whole integration on the logger's
+ * side, messages and `data` alike — and it answers asks by installing itself
+ * as the execution controller's input callback. Nothing else in explorbot
+ * knows it exists.
+ */
+export class Remote {
+    url = null;
+    socket = null;
+    queue = [];
+    reconnectDelay = RECONNECT_BASE_MS;
+    reconnectTimer = null;
+    asks = new Map();
+    askCounter = 0;
+    lastActivity = null;
+    registerOption(program) {
+        program.option('--ws <url>', 'Stream this run to a remote UI over WebSocket');
+        program.hook('preAction', (_thisCommand, actionCommand) => {
+            const url = actionCommand.optsWithGlobals().ws || process.env.EXPLORBOT_WS_URL;
+            if (!url)
+                return;
+            this.attach(String(url), this.commandPath(actionCommand));
+        });
+    }
+    attach(url, command) {
+        if (this.url)
+            return;
+        this.url = url;
+        this.connect();
+        this.send('hello', { command, cwd: process.cwd(), pid: process.pid });
+        addDestination(this);
+        executionController.setInputCallback((prompt) => this.ask(prompt));
+        addActivityListener((activity) => this.reportActivity(activity));
+    }
+    isAttached() {
+        return !!this.url;
+    }
+    send(type, data = {}) {
+        if (!this.url)
+            return;
+        const frame = { type, ts: Date.now(), ...data };
+        if (this.socket?.readyState === WebSocket.OPEN) {
+            this.push(frame);
+            return;
+        }
+        this.queue.push(frame);
+        if (this.queue.length > QUEUE_CAP)
+            this.queue.splice(0, this.queue.length - QUEUE_CAP);
+    }
+    ask(prompt) {
+        if (!this.url)
+            return Promise.resolve(null);
+        this.askCounter++;
+        const askId = `ask-${this.askCounter}`;
+        this.send('ask', { askId, prompt });
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.asks.delete(askId);
+                resolve(null);
+            }, ASK_TIMEOUT_MS);
+            this.asks.set(askId, (value) => {
+                clearTimeout(timer);
+                resolve(value);
+            });
+        });
+    }
+    async close(exitCode) {
+        if (!this.url)
+            return;
+        this.send('result', { ok: exitCode === 0, exitCode });
+        await this.flush();
+        this.url = null;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        // Whoever asks next has nobody to ask — leaving the callback installed would
+        // route them into a closed socket and park them until the ask times out.
+        executionController.clearInputCallback();
+        for (const resolve of this.asks.values())
+            resolve(null);
+        this.asks.clear();
+        this.queue = [];
+        this.socket?.close();
+        this.socket = null;
+    }
+    isEnabled() {
+        return this.isAttached();
+    }
+    /**
+     * The entry as the logger already built it, so the `LogType` reaches the UI
+     * as the frame's level and each kind is styled there instead of being scraped
+     * back out of flattened text.
+     */
+    write(entry) {
+        if (entry.type === 'html')
+            return;
+        if (entry.type === 'data') {
+            const [kind, payload] = entry.originalArgs || [];
+            this.send(String(kind), payload);
+            return;
+        }
+        let content = stripAnsi(entry.content ?? '');
+        if (content.length > CONTENT_CAP)
+            content = `${content.slice(0, CONTENT_CAP)}… (${content.length} chars)`;
+        this.send('log', {
+            level: entry.type,
+            content,
+            namespace: entry.namespace,
+            error: this.errorOf(entry.originalArgs),
+        });
+    }
+    connect() {
+        if (!this.url)
+            return;
+        let opening;
+        try {
+            opening = new WebSocket(this.url);
+        }
+        catch {
+            this.reconnect();
+            return;
+        }
+        this.socket = opening;
+        opening.addEventListener('open', () => {
+            this.reconnectDelay = RECONNECT_BASE_MS;
+            this.drain();
+        });
+        opening.addEventListener('message', (event) => this.receive(String(event.data)));
+        opening.addEventListener('close', () => {
+            if (this.socket !== opening)
+                return;
+            this.socket = null;
+            this.reconnect();
+        });
+        // A failed connection always closes too, which is where the retry is scheduled.
+        opening.addEventListener('error', () => { });
+    }
+    reconnect() {
+        if (!this.url || this.reconnectTimer)
+            return;
+        const delay = this.reconnectDelay;
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, RECONNECT_MAX_MS);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+        this.reconnectTimer.unref?.();
+    }
+    async flush() {
+        const deadline = Date.now() + FLUSH_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (this.socket?.readyState === WebSocket.OPEN) {
+                this.drain();
+                if (!this.queue.length && !this.socket.bufferedAmount)
+                    return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+    drain() {
+        if (this.socket?.readyState !== WebSocket.OPEN)
+            return;
+        const pending = this.queue;
+        this.queue = [];
+        for (const frame of pending)
+            this.push(frame);
+    }
+    push(frame) {
+        try {
+            this.socket?.send(JSON.stringify(frame));
+        }
+        catch {
+            this.queue.push(frame);
+        }
+    }
+    receive(raw) {
+        let frame;
+        try {
+            frame = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (frame.type === 'interrupt') {
+            executionController.interrupt();
+            return;
+        }
+        const resolve = this.asks.get(String(frame.askId));
+        if (!resolve)
+            return;
+        this.asks.delete(String(frame.askId));
+        resolve(frame.value ?? null);
+    }
+    /** A new listener is primed with the current activity, which at attach time is
+     *  nothing — so skip repeats, the priming null included. */
+    reportActivity(activity) {
+        const message = activity?.message ?? null;
+        if (message === this.lastActivity)
+            return;
+        this.lastActivity = message;
+        this.send('activity', { message, kind: activity?.type });
+    }
+    errorOf(args) {
+        const failure = args?.[1] ?? args?.[0]?.error;
+        if (!failure)
+            return undefined;
+        if (typeof failure === 'string')
+            return failure;
+        if (typeof failure.message === 'string')
+            return failure.message;
+        return undefined;
+    }
+    commandPath(command) {
+        const parts = [];
+        let node = command;
+        while (node) {
+            parts.unshift(node.name());
+            node = node.parent;
+        }
+        return parts.slice(1).join(' ') || parts.join(' ');
+    }
+}
+export const remote = new Remote();

package/dist/src/reporter.d.ts

@@ -26,6 +26,7 @@ export declare class Reporter {
     combineStepsAndNotes(test: Test, lastScreenshotFile?: string): Step[];
     buildVerificationStep(test: Test, lastScreenshotFile?: string): Step | undefined;
     reportTest(test: Test, meta?: ReporterMeta): Promise<void>;
+    reportTestData(status: string | null, testData: Record<string, unknown>): Promise<void>;
     finishRun(): Promise<void>;
     isEnabled(): boolean;
     setRunDescription(text: string): Promise<void>;

package/dist/src/reporter.js

@@ -242,13 +242,19 @@ export class Reporter {
                 time: durationMs != null ? Math.round(durationMs) : 0,
             };
             debugLog(testData);
-            await this.client.addTestRun(status, testData);
+            await this.reportTestData(status, testData);
             debugLog(`Test reported: ${test.scenario} - ${status}`);
         }
         catch (error) {
             debugLog('Failed to report test:', error);
         }
     }
+    async reportTestData(status, testData) {
+        await this.startRun();
+        if (!this.isRunStarted)
+            return;
+        await this.client.addTestRun(status, testData);
+    }
     async finishRun() {
         if (!this.isRunStarted) {
             return;

package/dist/src/state-manager.d.ts

@@ -1,4 +1,4 @@
-import { ActionResult } from './action-result.js';
+import { ActionResult, type FocusedElement } from './action-result.js';
 import type { ExperienceTracker } from './experience-tracker.js';
 import type { Knowledge, KnowledgeTracker } from './knowledge-tracker.js';
 export interface Link {
@@ -37,6 +37,7 @@ export interface WebPageState {
     h4?: string;
     ariaSnapshot?: string | null;
     ariaSnapshotFile?: string;
+    focusedElement?: FocusedElement | null;
     links?: Link[];
     verifications?: Record<string, boolean>;
 }

package/dist/src/state-manager.js

@@ -1,6 +1,6 @@
 import { ActionResult } from './action-result.js';
 import { detectFocusArea } from './utils/aria.js';
-import { createDebug } from './utils/logger.js';
+import { createDebug, tag } from './utils/logger.js';
 import { slugify } from './utils/strings.js';
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:state');
@@ -40,6 +40,8 @@ export class StateManager {
      * Emit state change event to all listeners
      */
     emitStateChange(event) {
+        const state = event.toState;
+        tag('data').log('state', { url: state.fullUrl || state.url, path: state.url, title: state.title, h1: state.h1 });
         this.stateChangeListeners.forEach((listener) => {
             try {
                 listener(event);

package/dist/src/stats.d.ts

@@ -13,6 +13,7 @@ export declare class Stats {
     static plans: number;
     static mode?: ExplorbotMode;
     static focus?: string;
+    static visionDisabled: boolean;
     static models: Record<string, TokenUsage>;
     static recordTokens(_agent: string, model: string, usage: TokenUsage): void;
     static getElapsedTime(): string;

package/dist/src/stats.js

@@ -7,6 +7,7 @@ export class Stats {
     static plans = 0;
     static mode;
     static focus;
+    static visionDisabled = false;
     static models = {};
     static recordTokens(_agent, model, usage) {
         if (!Stats.models[model]) {

package/dist/src/test-plan.d.ts

@@ -18,6 +18,7 @@ export interface Note {
     endTime: number;
     screenshot?: string;
     log?: string;
+    observation?: boolean;
 }
 export declare class ActiveNote {
     task: Task;
@@ -56,6 +57,7 @@ export declare class Task {
     getPrintableNotes(): string[];
     notesToString(): string;
     addNote(message: string, status?: TestResultType, screenshot?: string, log?: string): void;
+    addObservation(message: string): void;
     addUrlNote(state: UrlNoteState, prevState?: {
         title?: string;
         h1?: string;
@@ -111,6 +113,7 @@ export declare class Test extends Task {
     finish(result?: TestResultType): void;
     getDurationMs(): number | null;
     getRemainingExpectations(): string[];
+    reportStatus(): void;
     getLog(): Array<{
         type: 'step' | 'note' | 'artifact';
         content: string;

package/dist/src/test-plan.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { tag } from "./utils/logger.js";
 import { parsePlanFromMarkdown, planToAiContext, savePlanToMarkdown, savePlansToMarkdown } from "./utils/test-plan-markdown.js";
 import { uniqSessionName } from "./utils/unique-names.js";
 export const TestResult = {
@@ -91,6 +92,13 @@ export class Task {
         const timestamp = `${now}_${this.timestampCounter++}`;
         this.notes[timestamp] = { message, status, startTime: now, endTime: now, screenshot, log };
     }
+    addObservation(message) {
+        const isDuplicate = Object.values(this.notes).some((note) => note.message === message);
+        if (isDuplicate)
+            return;
+        const now = performance.now();
+        this.notes[`${now}_${this.timestampCounter++}`] = { message, status: TestResult.FAILED, startTime: now, endTime: now, observation: true };
+    }
     addUrlNote(state, prevState) {
         const fullUrl = state.fullUrl || state.url;
         if (!fullUrl)
@@ -253,12 +261,14 @@ export class Test extends Task {
         this.startTime = performance.now();
         this.addNote(`Test started. Session name: ${this.sessionName}`);
         this.plan?.notifyChange();
+        this.reportStatus();
     }
     finish(result = TestResult.FAILED) {
         this.status = TestStatus.DONE;
         this.result = result;
         this.endTime = performance.now();
         this.plan?.notifyChange();
+        this.reportStatus();
     }
     getDurationMs() {
         if (this.startTime != null && this.endTime != null)
@@ -269,6 +279,17 @@ export class Test extends Task {
         const achieved = this.getCheckedExpectations();
         return this.expected.filter((e) => !achieved.includes(e));
     }
+    reportStatus() {
+        tag('data').log('test', {
+            scenario: this.scenario,
+            status: this.status,
+            result: this.result,
+            priority: this.priority,
+            sessionName: this.sessionName,
+            url: this.startUrl,
+            plan: this.plan?.title,
+        });
+    }
     getLog() {
         const merged = {};
         for (const [key, stepData] of Object.entries(this.steps)) {
@@ -331,6 +352,11 @@ export class Plan {
         for (const listener of this.changeListeners) {
             listener(this.tests);
         }
+        tag('data').log('plan', {
+            title: this.title,
+            url: this.url,
+            tests: this.tests.map((test) => ({ scenario: test.scenario, status: test.status, result: test.result, priority: test.priority })),
+        });
     }
     getAllTests() {
         if (!this.parentPlan)

package/dist/src/utils/aria.d.ts

@@ -3,17 +3,11 @@ export interface FocusAreaResult {
     type: 'dialog' | 'modal' | null;
     name: string | null;
 }
-export declare const compactAriaSnapshot: (snapshot: string | null, keepNamed?: boolean) => string;
+export type ValueOffload = (value: string) => string | undefined;
+export declare const compactAriaSnapshot: (snapshot: string | null, keepNamed?: boolean, offload?: ValueOffload) => string;
 export declare const diffAriaSnapshots: (previous: string | null, current: string | null) => AriaDiff;
 export declare const detectFocusArea: (snapshot: string | null) => FocusAreaResult;
 export declare const collectInteractiveNodes: (snapshot: string | null) => Array<Record<string, unknown>>;
-export interface FocusedElementInfo {
-    role: string;
-    name: string;
-    value?: string;
-    attributes?: string[];
-}
-export declare function extractFocusedElement(ariaSnapshot: string | null): FocusedElementInfo | null;
 export declare function parseAriaLocator(ariaStr: string): {
     role: string;
     text: string;

package/dist/src/utils/aria.js

@@ -78,8 +78,7 @@ const parseLabel = (label) => {
         rest = rest.slice(nameMatch[0].length);
     }
     const attributes = {};
-    const attrMatch = rest.match(/\[([^\]]*)\]/);
-    if (attrMatch) {
+    for (const attrMatch of rest.matchAll(/\[([^\]]*)\]/g)) {
         for (const tok of attrMatch[1].split(/[\s,]+/).filter(Boolean)) {
             const eq = tok.indexOf('=');
             if (eq === -1) {
@@ -189,7 +188,8 @@ const dropEmpty = (nodes, opts = {}) => nodes.flatMap((node) => {
 // STEP 3 · Render: AriaNode[] → text or flat entries
 // ─────────────────────────────────────────────────────────────────
 // One-line representation of a node. Stable attr order so diff comparisons are deterministic.
-const formatNode = (node) => {
+const MAX_INLINE_VALUE = 400;
+const formatNode = (node, offload) => {
     let line = node.role;
     if (node.name?.trim())
         line += ` "${node.name.trim()}"`;
@@ -209,11 +209,20 @@ const formatNode = (node) => {
         line += ` [${attrStr}]`;
     if (node.value !== undefined && node.value !== null) {
         const text = String(node.value).trim();
-        if (text)
+        if (text && text.length <= MAX_INLINE_VALUE)
             line += `: ${text}`;
+        if (text && text.length > MAX_INLINE_VALUE)
+            line += `: ${offloadValue(text, offload)}`;
     }
     return line;
 };
+const offloadValue = (text, offload) => {
+    const head = `${text.slice(0, MAX_INLINE_VALUE)}…`;
+    const reference = offload?.(text);
+    if (!reference)
+        return `${head} (${text.length} chars, truncated)`;
+    return `${head} (${text.length} chars) [Full Text: ${reference}]`;
+};
 // Group consecutive same-role siblings.  [a,a,b,a,a,a] → [[a,a],[b],[a,a,a]]
 const groupByConsecutiveRole = (nodes) => nodes.reduce((groups, node) => {
     const last = groups[groups.length - 1];
@@ -236,16 +245,16 @@ const collapseGroup = (group, depth) => {
 };
 const collapseSiblingGroups = (nodes, depth) => groupByConsecutiveRole(nodes).flatMap((group) => collapseGroup(group, depth));
 // Tree → indented YAML text.
-const renderTree = (nodes, depth = 0) => collapseSiblingGroups(nodes, depth)
+const renderTree = (nodes, depth = 0, offload) => collapseSiblingGroups(nodes, depth)
     .map((entry) => {
     if ('placeholder' in entry)
         return entry.placeholder;
     const { node } = entry;
     const indent = '  '.repeat(depth);
-    const head = `${indent}- ${formatNode(node)}`;
+    const head = `${indent}- ${formatNode(node, offload)}`;
     if (node.children.length === 0)
         return head;
-    return `${head}:\n${renderTree(node.children, depth + 1)}`;
+    return `${head}:\n${renderTree(node.children, depth + 1, offload)}`;
 })
     .join('\n');
 // Build the structured "entry" object for an interactive node, or null if not worth keeping.
@@ -384,6 +393,42 @@ const detectToggles = (prev, curr) => {
     }
     return { toggled, togglePaths };
 };
+const detectValueChanges = (prev, curr) => {
+    const typed = [];
+    const typedPaths = new Set();
+    const currByPath = new Map(curr.map((e) => [e.path, e]));
+    for (const before of prev) {
+        const after = currByPath.get(before.path);
+        if (!after)
+            continue;
+        if (before.entry.role !== after.entry.role)
+            continue;
+        if (before.entry.name !== after.entry.name)
+            continue;
+        const was = valueWord(before.entry.value);
+        const now = valueWord(after.entry.value);
+        if (was === now)
+            continue;
+        typedPaths.add(before.path);
+        let label = String(after.entry.role);
+        const name = after.entry.name;
+        if (typeof name === 'string' && name.trim())
+            label += ` "${name.trim()}"`;
+        typed.push(`${label}: ${was} -> ${now}`);
+    }
+    return { typed, typedPaths };
+};
+const VALUE_EXCERPT = 60;
+const valueWord = (value) => {
+    if (value === undefined || value === null)
+        return 'empty';
+    const text = String(value).trim();
+    if (!text)
+        return 'empty';
+    if (text.length <= VALUE_EXCERPT)
+        return JSON.stringify(text);
+    return `${JSON.stringify(text.slice(0, VALUE_EXCERPT))}… (${text.length} chars)`;
+};
 const TOP_DIFF_ITEMS = 10;
 const formatDiffSection = (label, items) => {
     const summary = countBy(items);
@@ -407,10 +452,15 @@ const formatDiffSection = (label, items) => {
     }
     return lines;
 };
-const formatDiff = (added, removed, toggled) => {
-    if (added.length === 0 && removed.length === 0 && toggled.length === 0)
+const formatDiff = (added, removed, toggled, typed = []) => {
+    if (added.length === 0 && removed.length === 0 && toggled.length === 0 && typed.length === 0)
         return null;
     const sections = ['ariaDiff:'];
+    if (typed.length > 0) {
+        sections.push('  typed:');
+        for (const line of typed)
+            sections.push(`    - ${line}`);
+    }
     if (toggled.length > 0) {
         sections.push('  toggled:');
         for (const line of toggled)
@@ -461,17 +511,14 @@ const findDialogOrModal = (nodes) => {
     }
     return null;
 };
-// ─────────────────────────────────────────────────────────────────
-// Public API — pipelines composed visibly, top-to-bottom
-// ─────────────────────────────────────────────────────────────────
-export const compactAriaSnapshot = (snapshot, keepNamed = false) => {
+export const compactAriaSnapshot = (snapshot, keepNamed = false, offload) => {
     if (!snapshot)
         return '';
     let tree = parseSnapshot(snapshot);
     tree = unwrapIgnored(tree);
     tree = nameIconButtons(tree);
     tree = dropEmpty(tree, { keepNamed });
-    return renderTree(tree);
+    return renderTree(tree, 0, offload);
 };
 export const diffAriaSnapshots = (previous, current) => {
     const flat = (snap) => {
@@ -484,15 +531,17 @@ export const diffAriaSnapshots = (previous, current) => {
     const prevAll = flat(previous);
     const currAll = flat(current);
     const { toggled, togglePaths } = detectToggles(prevAll, currAll);
-    const prev = prevAll.filter((e) => !togglePaths.has(e.path));
-    const curr = currAll.filter((e) => !togglePaths.has(e.path));
+    const { typed, typedPaths } = detectValueChanges(prevAll, currAll);
+    const skip = (entry) => togglePaths.has(entry.path) || typedPaths.has(entry.path);
+    const prev = prevAll.filter((e) => !skip(e));
+    const curr = currAll.filter((e) => !skip(e));
     const prevTotals = countBy(prev.map((e) => e.summary));
     const currTotals = countBy(curr.map((e) => e.summary));
     const byCount = diffByCount(prevTotals, currTotals);
     const renames = detectRenames(prev, curr, prevTotals, currTotals);
     const added = [...byCount.added, ...renames.added];
     const removed = [...byCount.removed, ...renames.removed];
-    return { text: formatDiff(added, removed, toggled), count: added.length + removed.length + toggled.length };
+    return { text: formatDiff(added, removed, toggled, typed), count: added.length + removed.length + toggled.length + typed.length };
 };
 export const detectFocusArea = (snapshot) => {
     let tree = parseSnapshot(snapshot);
@@ -513,29 +562,9 @@ export const collectInteractiveNodes = (snapshot) => {
     tree = dropEmpty(tree);
     return flatten(tree).map((e) => e.entry);
 };
-export function extractFocusedElement(ariaSnapshot) {
-    if (!ariaSnapshot)
-        return null;
-    const focusedMatch = ariaSnapshot.match(/-\s*(\w+)\s+"([^"]*)"([^:\n]*)\[focused\](?::\s*(.*))?/);
-    if (!focusedMatch)
-        return null;
-    const [, role, name, attributesStr, value] = focusedMatch;
-    const attributes = [];
-    if (attributesStr) {
-        const attrMatches = attributesStr.matchAll(/\[([^\]]+)\]/g);
-        for (const match of attrMatches) {
-            if (match[1] !== 'focused') {
-                attributes.push(match[1]);
-            }
-        }
-    }
-    const result = { role, name };
-    if (value)
-        result.value = value.trim();
-    if (attributes.length > 0)
-        result.attributes = attributes;
-    return result;
-}
+// ─────────────────────────────────────────────────────────────────
+// Standalone helpers (regex on raw strings — not part of the pipeline)
+// ─────────────────────────────────────────────────────────────────
 export function parseAriaLocator(ariaStr) {
     const trimmed = ariaStr.trim();
     if (trimmed === '-' || trimmed === '' || trimmed === '"-"')

package/dist/src/utils/html.js

@@ -1376,6 +1376,7 @@ function cleanElement(element) {
             attr.value = attr.value
                 .split(/\s+/)
                 .filter((className) => !/\d/.test(className))
+                .filter((className) => !className.includes(':'))
                 .filter((className) => !TAILWIND_CLASS_PATTERNS.some((pattern) => pattern.test(className)))
                 .join(' ');
             if (!attr.value) {

package/dist/src/utils/logger.d.ts

@@ -1,5 +1,5 @@
 import { type Span } from '@opentelemetry/api';
-export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'operation' | 'step' | 'multiline' | 'details' | 'html' | 'input';
+export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'operation' | 'step' | 'multiline' | 'details' | 'html' | 'input' | 'data';
 export interface TaggedLogEntry {
     type: LogType;
     content: string;
@@ -9,6 +9,10 @@ export interface TaggedLogEntry {
     maxLines?: number;
 }
 type LogEntry = TaggedLogEntry;
+export interface LogDestination {
+    isEnabled(): boolean;
+    write(entry: TaggedLogEntry): void;
+}
 export declare const tag: (type: LogType) => {
     log: (...args: any[]) => void;
 };
@@ -23,9 +27,11 @@ export declare const startLogCapture: () => void;
 export declare const stopLogCapture: () => string[];
 export declare const setVerboseMode: (enabled: boolean) => void;
 export declare const setPreserveConsoleLogs: (enabled: boolean) => void;
+export declare const setQuietMode: (enabled: boolean) => void;
 export declare const isVerboseMode: () => boolean;
 export declare const setDebugMode: (enabled: boolean) => void;
 export declare const isDebugMode: () => boolean;
+export declare const addDestination: (destination: LogDestination) => void;
 export declare const registerLogPane: (addLog: (entry: LogEntry) => void) => void;
 export declare const unregisterLogPane: (addLog: (entry: LogEntry) => void) => void;
 export declare const addTruncateTag: (tagName: string) => void;