remoat 0.2.0

package/dist/services/assistantDomExtractor.js

@@ -0,0 +1,340 @@
+"use strict";
+/**
+ * Structured DOM extraction for Antigravity assistant responses.
+ *
+ * Provides two functions:
+ * - extractAssistantSegmentsPayloadScript() — Returns a CDP-evaluatable IIFE string
+ *   that walks the DOM and returns a typed segment array.
+ * - classifyAssistantSegments(payload) — Node.js-side classifier that converts
+ *   the raw payload into finalOutputText, activityLines, feedback, and diagnostics.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyAssistantSegments = classifyAssistantSegments;
+exports.extractAssistantSegmentsPayloadScript = extractAssistantSegmentsPayloadScript;
+const htmlToTelegramMarkdown_1 = require("../utils/htmlToTelegramMarkdown");
+// ---------------------------------------------------------------------------
+// classifyAssistantSegments — Node.js side
+// ---------------------------------------------------------------------------
+/**
+ * Classify an AssistantDomSegmentPayload into output text, activity lines,
+ * feedback, and diagnostics.
+ *
+ * If the payload is invalid, returns a legacy-fallback result with empty fields.
+ */
+function classifyAssistantSegments(payload) {
+    if (!isValidPayload(payload)) {
+        return {
+            finalOutputText: '',
+            activityLines: [],
+            feedback: [],
+            diagnostics: {
+                source: 'legacy-fallback',
+                segmentCounts: {},
+                fallbackReason: 'invalid-payload',
+            },
+        };
+    }
+    const typed = payload;
+    const segments = typed.segments;
+    const bodyTexts = [];
+    const activityLines = [];
+    const feedbackTexts = [];
+    const segmentCounts = {};
+    for (const seg of segments) {
+        segmentCounts[seg.kind] = (segmentCounts[seg.kind] ?? 0) + 1;
+        switch (seg.kind) {
+            case 'assistant-body':
+                if (seg.text && seg.text.trim()) {
+                    bodyTexts.push(seg.text);
+                }
+                break;
+            case 'thinking':
+            case 'tool-call':
+            case 'tool-result':
+                if (seg.text && seg.text.trim()) {
+                    activityLines.push(seg.text.trim());
+                }
+                break;
+            case 'feedback':
+                if (seg.text && seg.text.trim()) {
+                    feedbackTexts.push(seg.text.trim());
+                }
+                break;
+        }
+    }
+    // Join body segments and apply HTML-to-Markdown conversion
+    const rawBody = bodyTexts.join('\n\n');
+    const finalOutputText = (0, htmlToTelegramMarkdown_1.htmlToTelegramHtml)(rawBody);
+    return {
+        finalOutputText,
+        activityLines,
+        feedback: feedbackTexts,
+        diagnostics: {
+            source: 'dom-structured',
+            segmentCounts,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// extractAssistantSegmentsPayloadScript — CDP IIFE
+// ---------------------------------------------------------------------------
+/**
+ * Return a CDP-evaluatable IIFE string that walks the Antigravity DOM
+ * and returns an AssistantDomSegmentPayload object.
+ *
+ * The IIFE extracts:
+ * - assistant-body segments (innerHTML for Markdown conversion)
+ * - thinking segments (from <details> summary text)
+ * - tool-call / tool-result segments (from <details> content)
+ * - feedback segments (Good/Bad buttons)
+ */
+function extractAssistantSegmentsPayloadScript() {
+    // The IIFE is a plain string evaluated in the browser context via CDP.
+    // It MUST NOT reference any Node.js module or import.
+    //
+    // Uses the same multi-selector strategy as RESPONSE_TEXT to find
+    // assistant content nodes in Antigravity's DOM.
+    return `(() => {
+    var panel = document.querySelector('.antigravity-agent-side-panel');
+    var scope = panel || document;
+
+    // Same selectors as RESPONSE_TEXT — ordered by specificity
+    var selectors = [
+        '.rendered-markdown',
+        '.leading-relaxed.select-text',
+        '.flex.flex-col.gap-y-3',
+        '[data-message-author-role="assistant"]',
+        '[data-message-role="assistant"]',
+        '[class*="assistant-message"]',
+        '[class*="message-content"]',
+        '[class*="markdown-body"]',
+        '.prose',
+    ];
+
+    var looksLikeActivityLog = function(text) {
+        var normalized = (text || '').trim().toLowerCase();
+        if (!normalized) return false;
+        if (/^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|fetching|connecting|creating|updating|deleting|installing|building|compiling|deploying|checking|scanning|parsing|resolving|downloading|uploading|analyzed|read|wrote|ran|created|updated|deleted|fetched|built|compiled|installed|resolved|downloaded|connected)\\b/i.test(normalized) && normalized.length <= 220) return true;
+        if (/^initiating\\s/i.test(normalized) && normalized.length <= 500) return true;
+        if (/^thought for\\s/i.test(normalized) && normalized.length <= 500) return true;
+        return false;
+    };
+
+    var looksLikeFeedbackFooter = function(text) {
+        var normalized = (text || '').trim().toLowerCase().replace(/\\s+/g, ' ');
+        return normalized === 'good bad' || normalized === 'good' || normalized === 'bad';
+    };
+
+    var looksLikeToolOutput = function(text) {
+        var first = (text || '').trim().split('\\n')[0] || '';
+        if (/^[a-z0-9._-]+\\s*\\/\\s*[a-z0-9._-]+$/i.test(first)) return true;
+        if (/^full output written to\\b/i.test(first)) return true;
+        if (/^output\\.[a-z0-9._-]+(?:#l\\d+(?:-\\d+)?)?$/i.test(first)) return true;
+        return false;
+    };
+
+    var isInsideExcludedContainer = function(node) {
+        if (node.closest('details')) return true;
+        if (node.closest('[class*="feedback"], footer')) return true;
+        if (node.closest('.notify-user-container')) return true;
+        if (node.closest('[role="dialog"]')) return true;
+        return false;
+    };
+
+    var segments = [];
+    var seen = new Set();
+    var bodyFound = false;
+
+    // Pass 1: Find assistant body — last non-excluded content node (recency first)
+    var combinedSelector = selectors.join(', ');
+    var nodes = scope.querySelectorAll(combinedSelector);
+
+    for (var i = nodes.length - 1; i >= 0; i--) {
+        var node = nodes[i];
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (isInsideExcludedContainer(node)) continue;
+
+        var text = (node.innerText || node.textContent || '').replace(/\\r/g, '').trim();
+        if (!text || text.length < 2) continue;
+        if (looksLikeActivityLog(text)) continue;
+        if (looksLikeFeedbackFooter(text)) continue;
+        if (looksLikeToolOutput(text)) continue;
+
+        // This is the assistant body — normalize code blocks then extract innerHTML
+        // AG wraps code in <pre><div class="..."> with a header div for language label,
+        // embedded <style> tags, and code-line divs — NOT standard <pre><code>.
+        // We normalize to <pre><code> for htmlToTelegramHtml.
+        var clone = node.cloneNode(true);
+        var pres = clone.querySelectorAll('pre');
+        for (var pi = 0; pi < pres.length; pi++) {
+            var pre = pres[pi];
+            // Extract language from header div (font-sans text-sm class)
+            var langDiv = pre.querySelector('.font-sans.text-sm, [class*="text-sm"][class*="opacity"]');
+            var lang = langDiv ? (langDiv.textContent || '').trim() : '';
+
+            // Remove <style> tags before extracting text (AG injects code-block CSS)
+            var styles = pre.querySelectorAll('style');
+            for (var si = 0; si < styles.length; si++) {
+                styles[si].parentNode.removeChild(styles[si]);
+            }
+
+            // Remove the header bar (language label + copy button)
+            var headerBar = pre.querySelector('[class*="rounded-t"][class*="border-b"]');
+            if (headerBar) headerBar.parentNode.removeChild(headerBar);
+
+            // Extract code text: prefer code-line elements for reliable newlines
+            var codeLines = pre.querySelectorAll('.code-line, [class*="code-line"]');
+            var codeText;
+            if (codeLines.length > 0) {
+                var lineTexts = [];
+                for (var cli = 0; cli < codeLines.length; cli++) {
+                    lineTexts.push(codeLines[cli].textContent || '');
+                }
+                codeText = lineTexts.join('\\n');
+            } else {
+                // Fallback: use innerText of cleaned pre
+                codeText = (pre.innerText || '').trim();
+                if (lang && codeText.startsWith(lang)) {
+                    codeText = codeText.slice(lang.length).trim();
+                }
+            }
+            // Remove trailing "Copy" or clipboard button text
+            codeText = codeText.replace(/\\nCopy$/i, '').replace(/\\ncopy code$/i, '').trim();
+            // Replace with simple <pre><code>
+            var newPre = document.createElement('pre');
+            var newCode = document.createElement('code');
+            if (lang) newCode.setAttribute('class', 'language-' + lang);
+            newCode.textContent = codeText;
+            newPre.appendChild(newCode);
+            pre.parentNode.replaceChild(newPre, pre);
+        }
+        // Also remove any top-level <style> tags from the clone
+        var topStyles = clone.querySelectorAll('style');
+        for (var tsi = 0; tsi < topStyles.length; tsi++) {
+            topStyles[tsi].parentNode.removeChild(topStyles[tsi]);
+        }
+        var bodyHtml = clone.innerHTML;
+        if (bodyHtml && bodyHtml.trim()) {
+            segments.push({
+                kind: 'assistant-body',
+                text: bodyHtml,
+                role: 'assistant',
+                messageIndex: 0,
+                domPath: 'multi-selector'
+            });
+            bodyFound = true;
+            break; // Only take the last (most recent) output node
+        }
+    }
+
+    // Pass 2: Extract thinking + tool segments from <details>
+    var details = scope.querySelectorAll('details');
+    for (var di = 0; di < details.length; di++) {
+        var detail = details[di];
+        var summary = detail.querySelector('summary');
+        if (summary) {
+            var summaryText = (summary.textContent || '').trim();
+            if (summaryText) {
+                segments.push({
+                    kind: 'thinking',
+                    text: summaryText,
+                    role: 'assistant',
+                    messageIndex: 0,
+                    domPath: 'details:nth(' + di + ') summary'
+                });
+            }
+        }
+        // Extract child content (tool-call / tool-result) inside <details>
+        var children = detail.children;
+        for (var ci = 0; ci < children.length; ci++) {
+            var child = children[ci];
+            if (child.tagName === 'SUMMARY' || child.tagName === 'STYLE') continue;
+            var childText = (child.innerText || child.textContent || '').trim();
+            if (!childText || childText.length < 2) continue;
+            var childKind = looksLikeToolOutput(childText) ? 'tool-result' : 'tool-call';
+            segments.push({
+                kind: childKind,
+                text: childText.slice(0, 300),
+                role: 'assistant',
+                messageIndex: 0,
+                domPath: 'details:nth(' + di + ') child:nth(' + ci + ')'
+            });
+        }
+    }
+
+    // Pass 2.5: Broad activity scan - leaf-ish elements with activity-like text
+    // Uses querySelectorAll('*') to find activity nodes that don't match content
+    // selectors (e.g. "Analyzed package.json#L1-75" inside <div class="flex flex-row">).
+    // Excludes nodes inside response body containers to avoid false positives.
+    // Uses ancestor dedup to prevent capturing both parent and child activity nodes.
+    var actSeen = new Set();
+    var allEls = scope.querySelectorAll('*');
+    for (var ai = 0; ai < allEls.length; ai++) {
+        var el = allEls[ai];
+        if (el.children.length > 3) continue;       // leaf-ish only
+        if (seen.has(el)) continue;                  // already captured in Pass 1/2
+        if (isInsideExcludedContainer(el)) continue;
+        // Skip nodes inside response body containers (prevents capturing inline words)
+        if (el.closest('.leading-relaxed, .rendered-markdown, .prose, .animate-markdown, [data-message-role], [data-message-author-role]')) continue;
+        var aText = (el.innerText || el.textContent || '').replace(/\\r/g, '').trim();
+        if (!aText || aText.length < 4 || aText.length > 300) continue;
+        if (looksLikeActivityLog(aText) || looksLikeToolOutput(aText)) {
+            // Ancestor dedup: skip if a parent was already captured as activity
+            var dup = false;
+            var p = el.parentElement;
+            while (p && p !== scope) {
+                if (actSeen.has(p)) { dup = true; break; }
+                p = p.parentElement;
+            }
+            if (dup) continue;
+            actSeen.add(el);
+            var aKind = looksLikeToolOutput(aText) ? 'tool-result' : 'tool-call';
+            segments.push({
+                kind: aKind,
+                text: aText.slice(0, 300),
+                role: 'assistant',
+                messageIndex: 0,
+                domPath: 'activity-scan:nth(' + ai + ')'
+            });
+        }
+    }
+
+    // Pass 3: Extract feedback buttons
+    var feedbackBtns = scope.querySelectorAll('[class*="feedback"] button, footer button');
+    for (var fi = 0; fi < feedbackBtns.length; fi++) {
+        var btnText = (feedbackBtns[fi].textContent || '').trim();
+        if (btnText === 'Good' || btnText === 'Bad') {
+            segments.push({
+                kind: 'feedback',
+                text: btnText,
+                role: 'assistant',
+                messageIndex: 0,
+                domPath: 'feedback button.' + btnText.toLowerCase()
+            });
+        }
+    }
+
+    if (!bodyFound && segments.length === 0) return null;
+
+    return {
+        source: 'dom-structured',
+        extractedAt: Date.now(),
+        segments: segments
+    };
+})()`;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isValidPayload(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const obj = value;
+    if (obj.source !== 'dom-structured')
+        return false;
+    if (!Array.isArray(obj.segments))
+        return false;
+    return true;
+}
+//# sourceMappingURL=assistantDomExtractor.js.map

package/dist/services/assistantDomExtractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistantDomExtractor.js","sourceRoot":"","sources":["../../src/services/assistantDomExtractor.ts"],"names":[],"mappings":"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"}

package/dist/services/autoAcceptService.d.ts

@@ -0,0 +1,14 @@
+export type AutoAcceptAction = 'on' | 'off' | 'status';
+export interface AutoAcceptCommandResult {
+    success: boolean;
+    enabled: boolean;
+    changed: boolean;
+    message: string;
+}
+export declare class AutoAcceptService {
+    private enabled;
+    constructor(initialEnabled?: boolean);
+    isEnabled(): boolean;
+    handle(rawAction?: string): AutoAcceptCommandResult;
+    private normalizeAction;
+}

package/dist/services/autoAcceptService.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoAcceptService = void 0;
+const i18n_1 = require("../utils/i18n");
+class AutoAcceptService {
+    enabled;
+    constructor(initialEnabled = false) {
+        this.enabled = initialEnabled;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    handle(rawAction) {
+        const action = this.normalizeAction(rawAction);
+        if (!action) {
+            return {
+                success: false,
+                enabled: this.enabled,
+                changed: false,
+                message: (0, i18n_1.t)('⚠️ Invalid argument. Usage: `/autoaccept [on/off/status]`'),
+            };
+        }
+        if (action === 'status') {
+            return {
+                success: true,
+                enabled: this.enabled,
+                changed: false,
+                message: (0, i18n_1.t)(`⚙️ Auto-accept mode: **${this.enabled ? 'ON' : 'OFF'}**`),
+            };
+        }
+        if (action === 'on') {
+            if (this.enabled) {
+                return {
+                    success: true,
+                    enabled: true,
+                    changed: false,
+                    message: (0, i18n_1.t)('ℹ️ Auto-accept mode is already **ON**.'),
+                };
+            }
+            this.enabled = true;
+            return {
+                success: true,
+                enabled: true,
+                changed: true,
+                message: (0, i18n_1.t)('✅ Auto-accept mode turned **ON**. Future dialogs will be auto-allowed.'),
+            };
+        }
+        if (!this.enabled) {
+            return {
+                success: true,
+                enabled: false,
+                changed: false,
+                message: (0, i18n_1.t)('ℹ️ Auto-accept mode is already **OFF**.'),
+            };
+        }
+        this.enabled = false;
+        return {
+            success: true,
+            enabled: false,
+            changed: true,
+            message: (0, i18n_1.t)('✅ Auto-accept mode turned **OFF**. Returned to manual approval.'),
+        };
+    }
+    normalizeAction(rawAction) {
+        if (!rawAction || rawAction.trim().length === 0)
+            return 'status';
+        const normalized = rawAction.trim().toLowerCase();
+        if (['on', 'enable', 'enabled', 'true', '1'].includes(normalized)) {
+            return 'on';
+        }
+        if (['off', 'disable', 'disabled', 'false', '0'].includes(normalized)) {
+            return 'off';
+        }
+        if (['status', 'state', 'show'].includes(normalized)) {
+            return 'status';
+        }
+        return null;
+    }
+}
+exports.AutoAcceptService = AutoAcceptService;
+//# sourceMappingURL=autoAcceptService.js.map

package/dist/services/autoAcceptService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoAcceptService.js","sourceRoot":"","sources":["../../src/services/autoAcceptService.ts"],"names":[],"mappings":";;;AAAA,wCAAkC;AAWlC,MAAa,iBAAiB;IAClB,OAAO,CAAU;IAEzB,YAAY,iBAA0B,KAAK;QACvC,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC;IAClC,CAAC;IAED,SAAS;QACL,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,MAAM,CAAC,SAAkB;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC/C,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,OAAO;gBACH,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,IAAA,QAAC,EAAC,2DAA2D,CAAC;aAC1E,CAAC;QACN,CAAC;QAED,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;YACtB,OAAO;gBACH,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,IAAA,QAAC,EAAC,0BAA0B,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;aACxE,CAAC;QACN,CAAC;QAED,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YAClB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,OAAO;oBACH,OAAO,EAAE,IAAI;oBACb,OAAO,EAAE,IAAI;oBACb,OAAO,EAAE,KAAK;oBACd,OAAO,EAAE,IAAA,QAAC,EAAC,wCAAwC,CAAC;iBACvD,CAAC;YACN,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,OAAO;gBACH,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,IAAA,QAAC,EAAC,wEAAwE,CAAC;aACvF,CAAC;QACN,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAChB,OAAO;gBACH,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,IAAA,QAAC,EAAC,yCAAyC,CAAC;aACxD,CAAC;QACN,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,OAAO;YACH,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,KAAK;YACd,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,IAAA,QAAC,EAAC,iEAAiE,CAAC;SAChF,CAAC;IACN,CAAC;IAEO,eAAe,CAAC,SAAkB;QACtC,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,QAAQ,CAAC;QAEjE,MAAM,UAAU,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAClD,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YAChE,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YACpE,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YACnD,OAAO,QAAQ,CAAC;QACpB,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ;AAlFD,8CAkFC"}

package/dist/services/cdpBridgeManager.d.ts

@@ -0,0 +1,50 @@
+import { Api } from 'grammy';
+import { AutoAcceptService } from './autoAcceptService';
+import { CdpConnectionPool } from './cdpConnectionPool';
+import { CdpService } from './cdpService';
+import { QuotaService } from './quotaService';
+import { UserMessageInfo } from './userMessageDetector';
+/** Represents a Telegram chat target: either a chat_id or chat_id + message_thread_id */
+export interface TelegramChannel {
+    chatId: number | string;
+    threadId?: number;
+}
+export interface CdpBridge {
+    pool: CdpConnectionPool;
+    quota: QuotaService;
+    autoAccept: AutoAcceptService;
+    lastActiveWorkspace: string | null;
+    lastActiveChannel: TelegramChannel | null;
+    approvalChannelByWorkspace: Map<string, TelegramChannel>;
+    approvalChannelBySession: Map<string, TelegramChannel>;
+    botApi: Api | null;
+    botToken: string;
+}
+export declare function getCurrentChatTitle(cdp: CdpService): Promise<string | null>;
+export declare function registerApprovalWorkspaceChannel(bridge: CdpBridge, projectName: string, channel: TelegramChannel): void;
+export declare function registerApprovalSessionChannel(bridge: CdpBridge, projectName: string, sessionTitle: string, channel: TelegramChannel): void;
+export declare function resolveApprovalChannelForCurrentChat(bridge: CdpBridge, projectName: string, currentChatTitle: string | null): TelegramChannel | null;
+export declare function buildApprovalCustomId(action: 'approve' | 'always_allow' | 'deny', projectName: string, channelId?: string): string;
+export declare function parseApprovalCustomId(customId: string): {
+    action: 'approve' | 'always_allow' | 'deny';
+    projectName: string | null;
+    channelId: string | null;
+} | null;
+export declare function buildPlanningCustomId(action: 'open' | 'proceed', projectName: string, channelId?: string): string;
+export declare function parsePlanningCustomId(customId: string): {
+    action: 'open' | 'proceed';
+    projectName: string | null;
+    channelId: string | null;
+} | null;
+export declare function buildErrorPopupCustomId(action: 'dismiss' | 'copy_debug' | 'retry', projectName: string, channelId?: string): string;
+export declare function parseErrorPopupCustomId(customId: string): {
+    action: 'dismiss' | 'copy_debug' | 'retry';
+    projectName: string | null;
+    channelId: string | null;
+} | null;
+export declare function initCdpBridge(autoApproveDefault: boolean): CdpBridge;
+export declare function getCurrentCdp(bridge: CdpBridge): CdpService | null;
+export declare function ensureApprovalDetector(bridge: CdpBridge, cdp: CdpService, projectName: string): void;
+export declare function ensurePlanningDetector(bridge: CdpBridge, cdp: CdpService, projectName: string): void;
+export declare function ensureErrorPopupDetector(bridge: CdpBridge, cdp: CdpService, projectName: string): void;
+export declare function ensureUserMessageDetector(bridge: CdpBridge, cdp: CdpService, projectName: string, onUserMessage: (info: UserMessageInfo) => void): void;