@adhdev/daemon-core 0.5.3

package/providers/_builtin/ide/antigravity/scripts/1.107/new_session.js

@@ -0,0 +1,75 @@
+/**
+ * Antigravity v1 — new_session
+ *
+ * Antigravity Agent 패널 상단의 + 아이콘 클릭으로 새 대화 시작.
+ *
+ * DOM 구조:
+ *   .antigravity-agent-side-panel 상단 아이콘 바
+ *     [0] <a> + (Plus) → 새 대화    ← 이것을 클릭
+ *     [1] <a> 히스토리 (data-past-conversations-toggle)
+ *     [2] <div> 더보기 (⋯)
+ *     [3] <a> 닫기 (✕)
+ *
+ * 전략:
+ *   1. 히스토리 토글의 이전 형제 <a> 클릭 (Plus 아이콘)
+ *   2. SVG path "M12 4.5v15m7.5-7.5h-15" (+ 모양) 찾기
+ *   3. 패널 상단 첫 번째 <a> 클릭 폴백
+ *
+ * 최종 확인: 2026-03-11
+ */
+(() => {
+    try {
+        // ─── 1. 히스토리 토글의 이전 형제 요소 (Plus 아이콘) ───
+        const toggle = document.querySelector('[data-past-conversations-toggle="true"]');
+        if (toggle) {
+            const parent = toggle.parentElement;
+            if (parent) {
+                const children = Array.from(parent.children).filter(c => c.offsetWidth > 0);
+                const toggleIdx = children.indexOf(toggle);
+                // Plus 아이콘은 히스토리 바로 앞
+                if (toggleIdx > 0) {
+                    const plusBtn = children[toggleIdx - 1];
+                    plusBtn.click();
+                    return 'clicked (sibling of toggle)';
+                }
+            }
+        }
+
+        // ─── 2. SVG path 기반: Plus(+) 모양 SVG ───
+        const panel = document.querySelector('.antigravity-agent-side-panel') || document.querySelector('#conversation');
+        if (panel) {
+            const svgs = panel.querySelectorAll('svg');
+            for (const svg of svgs) {
+                const path = svg.querySelector('path');
+                if (path) {
+                    const d = path.getAttribute('d') || '';
+                    // Plus 아이콘 SVG: 세로선 + 가로선
+                    if (d.includes('v15') && d.includes('h-15')) {
+                        const clickable = svg.closest('a') || svg.closest('button') || svg.parentElement;
+                        if (clickable) {
+                            clickable.click();
+                            return 'clicked (svg plus)';
+                        }
+                    }
+                }
+            }
+        }
+
+        // ─── 3. 폴백: 패널 상단 영역의 첫 번째 <a> ───
+        if (panel) {
+            const topLinks = Array.from(panel.querySelectorAll('a')).filter(a => {
+                const r = a.getBoundingClientRect();
+                const pr = panel.getBoundingClientRect();
+                return r.y < pr.y + 30 && a.offsetWidth > 0 && a.offsetWidth < 30;
+            });
+            if (topLinks.length > 0) {
+                topLinks[0].click();
+                return 'clicked (first top link)';
+            }
+        }
+
+        return 'no new session button found';
+    } catch (e) {
+        return 'error: ' + e.message;
+    }
+})()

package/providers/_builtin/ide/antigravity/scripts/1.107/read_chat.js

@@ -0,0 +1,262 @@
+/**
+ * Antigravity v1 — read_chat (v4 — 스크롤 아래만, 가시 영역만 수집)
+ * 
+ * 원칙:
+ * - 스크롤은 아래로만 (위로 절대 안 감)
+ * - 가상화로 사라진 과거 사용자 메시지는 무시
+ * - 현재 보이는 메시지만 수집 (최신 턴 중심)
+ * 
+ * DOM 구조:
+ *   사용자: bg-gray-500/15 + select-text + p-2, 내부 whitespace-pre-wrap
+ *   어시스턴트: .leading-relaxed.select-text
+ */
+(() => {
+    try {
+        const conv = document.querySelector('#conversation') || document.querySelector('.antigravity-agent-side-panel') || document.body;
+        const scroll = conv.querySelector('.overflow-y-auto') || conv;
+
+        // 1. 상태 감지 — 사이드바 하단 Send/Stop 버튼 기반 (오탐 방지)
+        let status = 'idle';
+
+        // 시그널 A (1순위): 사이드바 하단 빨간 Stop 사각형 (.bg-red-500) — generating 중일 때 표시됨
+        const stopSquare = conv.querySelector('[class*="bg-red-500"]') || conv.querySelector('button[class*="rounded"] [class*="bg-red"]');
+        if (stopSquare && stopSquare.offsetWidth > 0) {
+            status = 'generating';
+        }
+
+        // 시그널 B: conv 내부의 animate-markdown (생성 중 마크다운 렌더링)
+        if (status === 'idle') {
+            const animMarkdown = scroll.querySelector('.leading-relaxed [class*="animate-markdown"]');
+            if (animMarkdown && animMarkdown.offsetWidth > 0) status = 'generating';
+        }
+
+        const title = document.title.split(' \u2014 ')[0].trim() || 'Active Session';
+
+        // ─── HTML → Markdown 변환기 (대시보드가 ReactMarkdown+remarkGfm 사용) ───
+        function htmlToMd(node) {
+            if (node.nodeType === 3) return node.textContent || '';
+            if (node.nodeType !== 1) return '';
+            const tag = node.tagName;
+
+            // 스타일/스크립트 제거
+            if (tag === 'STYLE' || tag === 'SCRIPT' || tag === 'SVG') return '';
+
+            // 테이블 → GFM
+            if (tag === 'TABLE') {
+                const rows = Array.from(node.querySelectorAll('tr'));
+                if (rows.length === 0) return '';
+                const table = rows.map(tr =>
+                    Array.from(tr.querySelectorAll('th, td')).map(cell => (cell.textContent || '').trim().replace(/\|/g, '\\|'))
+                );
+                if (table.length === 0) return '';
+                const colCount = Math.max(...table.map(r => r.length));
+                const header = table[0];
+                const sep = Array(colCount).fill('---');
+                const body = table.slice(1);
+                let md = '| ' + header.join(' | ') + ' |\n';
+                md += '| ' + sep.join(' | ') + ' |\n';
+                for (const row of body) {
+                    while (row.length < colCount) row.push('');
+                    md += '| ' + row.join(' | ') + ' |\n';
+                }
+                return '\n' + md + '\n';
+            }
+
+            if (tag === 'UL') return '\n' + Array.from(node.children).map(li => '- ' + childrenToMd(li).trim()).join('\n') + '\n';
+            if (tag === 'OL') return '\n' + Array.from(node.children).map((li, i) => (i + 1) + '. ' + childrenToMd(li).trim()).join('\n') + '\n';
+            if (tag === 'LI') return childrenToMd(node);
+
+            if (tag === 'H1') return '\n# ' + childrenToMd(node).trim() + '\n';
+            if (tag === 'H2') return '\n## ' + childrenToMd(node).trim() + '\n';
+            if (tag === 'H3') return '\n### ' + childrenToMd(node).trim() + '\n';
+            if (tag === 'H4') return '\n#### ' + childrenToMd(node).trim() + '\n';
+
+            if (tag === 'STRONG' || tag === 'B') return '**' + childrenToMd(node).trim() + '**';
+            if (tag === 'EM' || tag === 'I') return '*' + childrenToMd(node).trim() + '*';
+
+            if (tag === 'PRE') {
+                const codeEl = node.querySelector('code');
+                const lang = codeEl ? (codeEl.className.match(/language-(\w+)/)?.[1] || '') : '';
+                const code = (codeEl || node).textContent || '';
+                return '\n```' + lang + '\n' + code.trim() + '\n```\n';
+            }
+            if (tag === 'CODE') {
+                if (node.parentElement && node.parentElement.tagName === 'PRE') return node.textContent || '';
+                return '`' + (node.textContent || '').trim() + '`';
+            }
+
+            if (tag === 'BLOCKQUOTE') return '\n> ' + childrenToMd(node).trim().replace(/\n/g, '\n> ') + '\n';
+            if (tag === 'A') return '[' + childrenToMd(node).trim() + '](' + (node.getAttribute('href') || '') + ')';
+            if (tag === 'BR') return '\n';
+            if (tag === 'P') return '\n' + childrenToMd(node).trim() + '\n';
+
+            return childrenToMd(node);
+        }
+        function childrenToMd(node) {
+            return Array.from(node.childNodes).map(htmlToMd).join('');
+        }
+
+        function getCleanMd(el) {
+            const clone = el.cloneNode(true);
+            // 노이즈 제거
+            clone.querySelectorAll('button, [role="button"], style, script, svg, .codicon, [class*="feedback"], [aria-label*="Good"], [aria-label*="Bad"]').forEach(n => n.remove());
+            // 상태 텍스트 제거 (leaf만, 60자 이하만)
+            clone.querySelectorAll('*').forEach(child => {
+                if (!child.parentNode) return;
+                const t = (child.textContent || '').trim();
+                if (t.length > 60) return;
+                const low = t.toLowerCase();
+                if (/^(analyzed\s+\d|edited\s+\d|ran\s+\S|terminal\s|reading|searching)/i.test(low)) child.remove();
+                if (/^(mcp|customizationmcp|serversexport)/i.test(low)) child.remove();
+            });
+            let md = htmlToMd(clone);
+            // "Thought for X seconds" 제거
+            md = md.replace(/^Thought for\s+[\d.]+\s*(seconds?|s)\s*/i, '');
+            md = md.replace(/\n{3,}/g, '\n\n').trim();
+            return md;
+        }
+
+        // 2. 메시지 수집 (스크롤 조작 없음 — 현재 DOM에 있는 것만)
+        const collected = [];
+        const seenHashes = new Set();
+
+        // 사용자 메시지 (bg-gray-500/15 + select-text + p-2)
+        const allDivs = scroll.querySelectorAll('div');
+        for (const el of allDivs) {
+            const cls = (el.className || '');
+            if (typeof cls !== 'string') continue;
+            if (cls.includes('bg-gray-500/15') && cls.includes('select-text') && cls.includes('p-2')) {
+                const textEl = el.querySelector('[class*="whitespace-pre-wrap"]') || el;
+                const text = (textEl.innerText || '').trim();
+                if (!text || text.length < 1) continue;
+                const hash = 'user:' + text.slice(0, 200);
+                if (seenHashes.has(hash)) continue;
+                seenHashes.add(hash);
+                collected.push({ role: 'user', text, el });
+            }
+        }
+
+        // 어시스턴트 메시지 (leading-relaxed.select-text) — HTML→Markdown 변환
+        const assistantBlocks = scroll.querySelectorAll('.leading-relaxed.select-text');
+        for (const ab of assistantBlocks) {
+            if (ab.offsetHeight < 10) continue;
+            if (ab.closest('[class*="max-h-"][class*="overflow-y-auto"]')) continue;
+
+            let text = getCleanMd(ab);
+            if (!text || text.length < 2) continue;
+            if (/^(Running command|Checked command|collectStatus)/i.test(text)) continue;
+
+            const hash = 'assistant:' + text.slice(0, 200);
+            if (seenHashes.has(hash)) continue;
+            seenHashes.add(hash);
+            collected.push({ role: 'assistant', text, el: ab });
+        }
+
+        // 3. DOM 순서 정렬
+        collected.sort((a, b) => {
+            const pos = a.el.compareDocumentPosition(b.el);
+            if (pos & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+            if (pos & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+            return 0;
+        });
+
+        // 최신 30개만 유지 (대화 첫 로드 시 수백 개 수집 방지)
+        const trimmed = collected.length > 30 ? collected.slice(-30) : collected;
+
+        const final = trimmed.map((m, i) => ({
+            id: 'msg_' + i,
+            role: m.role,
+            content: m.text.length > 6000 ? m.text.slice(0, 6000) + '\n[... truncated]' : m.text,
+            index: i,
+            kind: 'standard',
+            vsc_history: true
+        }));
+
+        // 4. 입력창
+        const editor = conv.querySelector('[contenteditable="true"][role="textbox"]') ||
+            conv.querySelector('[data-lexical-editor="true"]') ||
+            conv.querySelector('textarea');
+        const inputContent = editor ? (editor.innerText || editor.value || '').trim() : '';
+
+        // 5. 모달/승인 감지 — Run⌥⏎/Reject 인라인 + Deny/Allow 브라우저 승인
+        let activeModal = null;
+        try {
+            const isApprovalLike = (el) => {
+                const t = (el.textContent || '').trim().toLowerCase();
+                // 드롭다운 옵션 제외
+                if (t === 'ask every time') return false;
+                return /^(run|reject|skip|approve|allow|deny|cancel|accept|yes|no)\b/i.test(t)
+                    || t === 'always allow' || t === 'always deny'
+                    || t.includes('run ') || t.includes('approve') || t.includes('reject')
+                    || t.includes('skip');
+            };
+            // A: 전통적 모달 다이얼로그
+            const dialog = document.querySelector('.monaco-dialog-box, [role="dialog"], .monaco-modal-block');
+            if (dialog && dialog.offsetWidth > 80 && dialog.offsetHeight > 40) {
+                const msg = (dialog.querySelector('.dialog-message, .dialog-message-text') || dialog).innerText?.trim() || '';
+                const buttons = Array.from(dialog.querySelectorAll('.monaco-button, button'))
+                    .map(b => (b.innerText || '').trim())
+                    .filter(t => t.length > 0 && t.length < 30);
+                if (msg || buttons.length > 0) {
+                    activeModal = { message: msg.slice(0, 300), buttons, width: dialog.offsetWidth, height: dialog.offsetHeight };
+                }
+            }
+            // B: 인라인 approval 버튼 (Run⌥⏎, Reject, Deny, Allow 등)
+            // ⚠ 사이드바(conv) 내부의 버튼만 검사 — 에디터의 Accept/Reject Changes 제외
+            if (!activeModal) {
+                const panelBtns = Array.from(conv.querySelectorAll('button')).filter(b => b.offsetWidth > 0 && b.offsetHeight > 0);
+                const approvalBtns = panelBtns.filter(isApprovalLike);
+                if (approvalBtns.length > 0) {
+                    const hasActionBtn = approvalBtns.some(b => {
+                        const t = (b.textContent || '').trim().toLowerCase();
+                        return t.indexOf('run') === 0 || t === 'reject' || t.indexOf('reject') === 0
+                            || t === 'skip' || t.indexOf('skip') === 0
+                            || t === 'deny' || t === 'allow' || t === 'always allow' || t === 'always deny'
+                            || t === 'accept' || t === 'approve';
+                    });
+                    if (hasActionBtn) {
+                        const btnTexts = [...new Set(
+                            approvalBtns.map(b => (b.textContent || '').trim())
+                                .filter(t => t.length > 0 && t.length < 40)
+                        )];
+                        const firstApproval = approvalBtns[0];
+                        let wrapper = firstApproval.parentElement;
+                        for (let up = 0; up < 5 && wrapper; up++, wrapper = wrapper.parentElement) {
+                            if (wrapper.offsetHeight > 40) break;
+                        }
+                        const msg = wrapper ? (wrapper.textContent || '').trim().slice(0, 300) : '';
+                        activeModal = { message: msg, buttons: btnTexts, width: 400, height: 100 };
+                    }
+                }
+            }
+            // C: footer 기반 사용량/quota 다이얼로그 (Dismiss / See Plans / Enable Overages 등)
+            // <footer> 요소가 conv 안에 존재하고 2개 이상 버튼이 있으면 사용자 액션이 필요한 카드로 판단
+            if (!activeModal) {
+                const footers = Array.from(conv.querySelectorAll('footer')).filter(f => f.offsetWidth > 0 && f.offsetHeight > 0);
+                for (const footer of footers) {
+                    const footerBtns = Array.from(footer.querySelectorAll('button, a')).filter(b => b.offsetWidth > 0);
+                    if (footerBtns.length >= 2) {
+                        // 카드 컨테이너: footer 상위에서 충분한 높이를 가진 첫 번째 요소
+                        let card = footer.parentElement;
+                        for (let up = 0; up < 4 && card; up++) {
+                            if (card.offsetHeight > 60) break;
+                            card = card.parentElement;
+                        }
+                        const msg = card ? (card.innerText || '').trim().slice(0, 300) : '';
+                        const btnTexts = footerBtns.map(b => (b.innerText || '').trim()).filter(t => t.length > 0 && t.length < 40);
+                        if (btnTexts.length >= 2) {
+                            activeModal = { message: msg, buttons: btnTexts, width: card ? card.offsetWidth : 300, height: card ? card.offsetHeight : 100 };
+                            break;
+                        }
+                    }
+                }
+            }
+            // 모달이 감지되면 status를 waiting_approval로 변경
+            if (activeModal) status = 'waiting_approval';
+        } catch (e) { activeModal = null; }
+
+        return { id: 'active_session', status, title, messages: final, inputContent, activeModal };
+    } catch (e) {
+        return { id: 'error', status: 'error', error: e.message, messages: [] };
+    }
+})()

package/providers/_builtin/ide/antigravity/scripts/1.107/resolve_action.js

@@ -0,0 +1,68 @@
+/**
+ * Antigravity v1 — resolve_action
+ * 
+ * 버튼 찾기 + 좌표 반환 (CDP Input.dispatchMouseEvent로 클릭)
+ * 파라미터: ${BUTTON_TEXT}
+ * 
+ * 핵심: viewport 안에 보이는 버튼 중 마지막(최신) 매칭 우선
+ */
+(() => {
+    const want = ${ BUTTON_TEXT };
+    const wantNorm = (want || '').replace(/\s+/g, ' ').trim().toLowerCase();
+    
+    function norm(t) { return (t || '').replace(/\s+/g, ' ').trim().toLowerCase(); }
+    
+    function matches(el) {
+        const raw = (el.textContent || '').trim();
+        const t = norm(raw);
+        if (!t || t.length > 80) return false;
+        if (t === wantNorm) return true;
+        if (t.indexOf(wantNorm) === 0) return true;
+        if (wantNorm.indexOf(t) >= 0 && t.length > 2) return true;
+        if (t.indexOf(wantNorm) >= 0) return true;
+        if (/^(run|approve|allow|accept|always|yes)\b/.test(wantNorm)) {
+            if (/^run\b/.test(t)) return true;
+            if (/^allow\b/.test(t)) return true;
+            if (/^accept\b/.test(t) && !t.includes('changes')) return true;
+            if (/^always\b/.test(t)) return true;
+        }
+        if (/^(reject|deny|no|abort)\b/.test(wantNorm)) {
+            if (/^reject\b/.test(t) && !t.includes('changes')) return true;
+            if (/^deny\b/.test(t)) return true;
+        }
+        if (/^(skip|cancel)\b/.test(wantNorm)) {
+            if (/^skip\b/.test(t) || /^cancel\b/.test(t)) return true;
+        }
+        return false;
+    }
+    
+    const sel = 'button, [role="button"]';
+    const allBtns = [...document.querySelectorAll(sel)].filter(b => {
+        if (!b.offsetWidth || !b.getBoundingClientRect().height) return false;
+        const rect = b.getBoundingClientRect();
+        // viewport 안에 보이는 것만 (y > 0, y < window.innerHeight)
+        return rect.y > 0 && rect.y < window.innerHeight;
+    });
+    
+    // 마지막(최신) 매칭 우선 — 역순 검색
+    let found = null;
+    for (let i = allBtns.length - 1; i >= 0; i--) {
+        if (matches(allBtns[i])) {
+            found = allBtns[i];
+            break;
+        }
+    }
+    
+    if (found) {
+        const rect = found.getBoundingClientRect();
+        return JSON.stringify({
+            found: true,
+            text: found.textContent?.trim()?.substring(0, 40),
+            x: Math.round(rect.x + rect.width / 2),
+            y: Math.round(rect.y + rect.height / 2),
+            w: Math.round(rect.width),
+            h: Math.round(rect.height)
+        });
+    }
+    return JSON.stringify({ found: false, want: wantNorm });
+})()

package/providers/_builtin/ide/antigravity/scripts/1.107/scripts.js

@@ -0,0 +1,67 @@
+/**
+ * Antigravity CDP Scripts
+ *
+ * Version routing is handled by ProviderLoader:
+ *   - provider.json "versions" field declares script directory overrides
+ *   - VersionArchive detects installed Antigravity version at daemon startup
+ *   - resolve() picks scripts/legacy/ for < 1.107.0, scripts/ for >= 1.107.0
+ *
+ * To add support for a new breaking version:
+ *   1. Create scripts/v<next>/ with updated scripts
+ *   2. Add entry to provider.json "versions" field:
+ *      "< X.Y.Z": { "__dir": "scripts/v<next>" }
+ *   3. Update "testedVersions" in provider.json
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const DIR  = __dirname;  // scripts/1.107/
+
+function load(name) {
+    try { return fs.readFileSync(path.join(DIR, name), 'utf-8'); }
+    catch { return null; }
+}
+
+module.exports.readChat    = () => load('read_chat.js');
+module.exports.focusEditor = () => load('focus_editor.js');
+module.exports.listSessions = () => load('list_chats.js');
+module.exports.newSession  = () => load('new_session.js');
+module.exports.listModels  = () => load('list_models.js');
+module.exports.listModes   = () => load('list_modes.js');
+
+module.exports.sendMessage = (text) => {
+    const script = load('send_message.js');
+    if (!script) return null;
+    return script.replace(/\$\{\s*MESSAGE\s*\}/g, JSON.stringify(text));
+};
+
+module.exports.switchSession = (sessionId) => {
+    const script = load('switch_session.js');
+    if (!script) return null;
+    return script.replace(/\$\{\s*SESSION_ID\s*\}/g, JSON.stringify(sessionId));
+};
+
+module.exports.resolveAction = (params) => {
+    const action     = typeof params === 'string' ? params : params?.action || 'approve';
+    const buttonText = params?.button || params?.buttonText
+        || (action === 'approve' ? 'Accept' : action === 'reject' ? 'Reject' : action);
+    const script = load('resolve_action.js');
+    if (!script) return null;
+    return script.replace(/\$\{\s*BUTTON_TEXT\s*\}/g, JSON.stringify(buttonText));
+};
+
+module.exports.setModel = (params) => {
+    const model = typeof params === 'string' ? params : params?.model;
+    const script = load('set_model.js');
+    if (!script) return null;
+    return script.replace(/\$\{\s*MODEL\s*\}/g, JSON.stringify(model));
+};
+
+module.exports.setMode = (params) => {
+    const mode = typeof params === 'string' ? params : params?.mode;
+    const script = load('set_mode.js');
+    if (!script) return null;
+    return script.replace(/\$\{\s*MODE\s*\}/g, JSON.stringify(mode));
+};

package/providers/_builtin/ide/antigravity/scripts/1.107/send_message.js

@@ -0,0 +1,56 @@
+/**
+ * Antigravity v1 — send_message
+ *
+ * Antigravity는 contenteditable div[role="textbox"]를 사용.
+ * 여러 개의 contenteditable이 있을 수 있으므로 y좌표가 가장 큰 (메인 채팅) 것을 선택.
+ *
+ * ⚠️ Enter 이벤트에 composed: true + which 필수 (Shadow DOM 경계 통과 + React 호환)
+ * ⚠️ keydown + keypress + keyup 전체 시퀀스 필요
+ *
+ * 파라미터: ${ MESSAGE }
+ * 최종 확인: 2026-03-10
+ */
+(async () => {
+    try {
+        const msg = ${ MESSAGE };
+
+        // ─── 1. 메인 채팅 입력 필드 찾기 ───
+        const editors = document.querySelectorAll('[contenteditable="true"][role="textbox"]');
+        if (!editors.length) return 'error: no contenteditable textbox found';
+
+        // y좌표가 가장 큰 (화면 아래쪽 = 메인 채팅) 에디터 선택
+        const editor = [...editors].reduce((a, b) =>
+            b.getBoundingClientRect().y > a.getBoundingClientRect().y ? b : a
+        );
+
+        // ─── 2. 텍스트 삽입 ───
+        editor.focus();
+
+        // 기존 내용 삭제
+        document.execCommand('selectAll', false, null);
+        document.execCommand('delete', false, null);
+
+        // 텍스트 삽입
+        document.execCommand('insertText', false, msg);
+
+        // React에 변경 알림
+        editor.dispatchEvent(new Event('input', { bubbles: true }));
+
+        await new Promise(r => setTimeout(r, 300));
+
+        // ─── 3. Enter 키 전송 (full sequence) ───
+        const enterOpts = {
+            key: 'Enter', code: 'Enter',
+            keyCode: 13, which: 13,
+            bubbles: true, cancelable: true, composed: true,
+        };
+
+        editor.dispatchEvent(new KeyboardEvent('keydown', enterOpts));
+        editor.dispatchEvent(new KeyboardEvent('keypress', enterOpts));
+        editor.dispatchEvent(new KeyboardEvent('keyup', enterOpts));
+
+        return 'sent';
+    } catch (e) {
+        return 'error: ' + e.message;
+    }
+})()

package/providers/_builtin/ide/antigravity/scripts/1.107/set_mode.js

@@ -0,0 +1,67 @@
+/**
+ * Antigravity — set_mode  [>= 1.107.0]
+ * mode trigger: BUTTON with py-1 pl-1 pr-2 opacity-70
+ * ${MODE} → JSON.stringify(modeName)
+ * → { success: boolean, mode?: string }
+ */
+(async () => {
+    try {
+        const target = ${MODE};
+
+        // ── Helper: find mode button ──────────────────────────────────────────
+        function findModeBtn() {
+            return [...document.querySelectorAll('button')].find(b => {
+                const cls = b.className || '';
+                return cls.includes('py-1') &&
+                       cls.includes('pl-1') &&
+                       cls.includes('pr-2') &&
+                       cls.includes('opacity-70') &&
+                       b.offsetWidth > 0;
+            }) || null;
+        }
+
+        // ── Helper: click item in open "Conversation mode" panel ─────────────
+        function clickModeItem(targetName) {
+            const headers = document.querySelectorAll('.text-xs.px-2.pb-1.opacity-80');
+            for (const header of headers) {
+                if (header.textContent?.trim() === 'Conversation mode') {
+                    const parent = header.parentElement;
+                    if (!parent) continue;
+                    for (const item of parent.querySelectorAll('.font-medium')) {
+                        const text = item.textContent?.trim();
+                        if (text && text.toLowerCase() === targetName.toLowerCase()) {
+                            item.click();
+                            return text;
+                        }
+                    }
+                    break;
+                }
+            }
+            return null;
+        }
+
+        // ── Step 1: Panel already open — direct click ─────────────────────────
+        const direct = clickModeItem(target);
+        if (direct) {
+            await new Promise(r => setTimeout(r, 300));
+            return JSON.stringify({ success: true, mode: direct });
+        }
+
+        // ── Step 2: Open panel via mode button, then click ───────────────────
+        const modeBtn = findModeBtn();
+        if (modeBtn) {
+            modeBtn.click();
+            await new Promise(r => setTimeout(r, 400));
+
+            const hit = clickModeItem(target);
+            if (hit) {
+                return JSON.stringify({ success: true, mode: hit });
+            }
+            modeBtn.click(); // Close if not found
+        }
+
+        return JSON.stringify({ success: false, error: 'mode not found: ' + target });
+    } catch (e) {
+        return JSON.stringify({ success: false, error: e.message });
+    }
+})()

package/providers/_builtin/ide/antigravity/scripts/1.107/set_model.js

@@ -0,0 +1,72 @@
+/**
+ * Antigravity — set_model
+ * 모델 드롭다운에서 모델 선택
+ *
+ * Version compatibility:
+ *   v0 (old): .flex.min-w-0.max-w-full.cursor-pointer.items-center trigger
+ *   v1 (new): Tailwind arbitrary values → partial matching required
+ *   Both: dropdown items .px-2.py-1.flex.items-center.justify-between.cursor-pointer
+ *
+ * ${MODEL} → JSON.stringify(modelName)
+ * → { success: boolean, model?: string }
+ */
+(async () => {
+    try {
+        const target = ${MODEL};
+
+        // ── Helper: find model trigger button (v0 + v1 compat) ───────────────
+        function findModelTrigger() {
+            // v0: exact selector
+            const v0 = document.querySelector('.flex.min-w-0.max-w-full.cursor-pointer.items-center');
+            if (v0 && v0.offsetWidth > 0) return v0;
+            // v1: partial matching
+            return [...document.querySelectorAll('div, button')].find(e => {
+                const cls = e.className || '';
+                return cls.includes('min-w-0') &&
+                       cls.includes('max-w-full') &&
+                       cls.includes('cursor-pointer') &&
+                       cls.includes('items-center') &&
+                       e.offsetWidth > 0;
+            }) || null;
+        }
+
+        // ── Helper: find and click a model from open dropdown ────────────────
+        function clickModelItem(targetName) {
+            const items = document.querySelectorAll('.px-2.py-1.flex.items-center.justify-between.cursor-pointer');
+            for (const item of items) {
+                const label = item.querySelector('.text-xs.font-medium');
+                const text = (label || item).textContent?.trim();
+                if (text && (text === targetName || text.toLowerCase().includes(targetName.toLowerCase()))) {
+                    item.click();
+                    return text;
+                }
+            }
+            return null;
+        }
+
+        // ── Step 1: Dropdown already open — try direct click ─────────────────
+        const directHit = clickModelItem(target);
+        if (directHit) {
+            await new Promise(r => setTimeout(r, 200));
+            return JSON.stringify({ success: true, model: directHit });
+        }
+
+        // ── Step 2: Dropdown closed — open trigger, then select ──────────────
+        const trigger = findModelTrigger();
+        if (trigger) {
+            trigger.click();
+            await new Promise(r => setTimeout(r, 400));
+
+            const hit = clickModelItem(target);
+            if (hit) {
+                return JSON.stringify({ success: true, model: hit });
+            }
+            // Close dropdown if target not found
+            trigger.click();
+        }
+
+        return JSON.stringify({ success: false, error: 'model not found: ' + target });
+    } catch (e) {
+        return JSON.stringify({ success: false, error: e.message });
+    }
+})()