kiro-mobile-bridge 1.0.7 → 1.0.10

package/src/services/message.js

@@ -0,0 +1,214 @@
+/**
+ * Message injection service - sends messages to Kiro chat via CDP
+ */
+import { escapeForJavaScript, validateMessage } from '../utils/security.js';
+
+/**
+ * Create script to inject message into chat input
+ * @param {string} messageText - Message to inject
+ * @returns {string} - JavaScript expression
+ */
+function createInjectScript(messageText) {
+  // Use proper escaping to prevent XSS and injection attacks
+  const escaped = escapeForJavaScript(messageText);
+  
+  return `(async () => {
+    const text = '${escaped}';
+    let targetDoc = document;
+    const activeFrame = document.getElementById('active-frame');
+    if (activeFrame && activeFrame.contentDocument) targetDoc = activeFrame.contentDocument;
+    
+    // Find the CHAT INPUT editor specifically (not any contenteditable in the page)
+    // Look for the input area at the bottom of the chat, not message bubbles
+    let editor = null;
+    
+    // Strategy 1: Find by common chat input container patterns
+    const inputContainerSelectors = [
+      '[class*="chat-input"]',
+      '[class*="message-input"]', 
+      '[class*="composer"]',
+      '[class*="input-area"]',
+      '[class*="InputArea"]',
+      'form[class*="chat"]',
+      '[data-testid*="input"]'
+    ];
+    
+    for (const containerSel of inputContainerSelectors) {
+      const container = targetDoc.querySelector(containerSel);
+      if (container) {
+        const editorInContainer = container.querySelector('.tiptap.ProseMirror[contenteditable="true"], [data-lexical-editor="true"][contenteditable="true"], [contenteditable="true"], textarea');
+        if (editorInContainer && editorInContainer.offsetParent !== null) {
+          editor = editorInContainer;
+          break;
+        }
+      }
+    }
+    
+    // Strategy 2: Find TipTap/ProseMirror editors that are visible and near a submit button
+    if (!editor) {
+      const allEditors = [...targetDoc.querySelectorAll('.tiptap.ProseMirror[contenteditable="true"]')].filter(el => el.offsetParent !== null);
+      for (const ed of allEditors) {
+        // Check if there's a submit button nearby (sibling or in same parent form)
+        const parent = ed.closest('form') || ed.parentElement?.parentElement?.parentElement;
+        if (parent) {
+          const hasSubmit = parent.querySelector('button[data-variant="submit"], button[type="submit"], svg.lucide-arrow-right');
+          if (hasSubmit) { editor = ed; break; }
+        }
+      }
+      // Fallback to last visible TipTap editor
+      if (!editor && allEditors.length > 0) editor = allEditors.at(-1);
+    }
+    
+    // Strategy 3: Find Lexical editors
+    if (!editor) {
+      const lexicalEditors = [...targetDoc.querySelectorAll('[data-lexical-editor="true"][contenteditable="true"]')].filter(el => el.offsetParent !== null);
+      for (const ed of lexicalEditors) {
+        const parent = ed.closest('form') || ed.parentElement?.parentElement?.parentElement;
+        if (parent) {
+          const hasSubmit = parent.querySelector('button[data-variant="submit"], button[type="submit"]');
+          if (hasSubmit) { editor = ed; break; }
+        }
+      }
+      if (!editor && lexicalEditors.length > 0) editor = lexicalEditors.at(-1);
+    }
+    
+    // Strategy 4: Generic contenteditable (last resort)
+    if (!editor) {
+      const editables = [...targetDoc.querySelectorAll('[contenteditable="true"]')].filter(el => el.offsetParent !== null);
+      editor = editables.at(-1);
+    }
+    
+    // Strategy 5: Textarea fallback
+    if (!editor) {
+      const textareas = [...targetDoc.querySelectorAll('textarea')].filter(el => el.offsetParent !== null);
+      editor = textareas.at(-1);
+    }
+    
+    if (!editor) return { ok: false, error: 'editor_not_found' };
+    
+    const isTextarea = editor.tagName.toLowerCase() === 'textarea';
+    const isProseMirror = editor.classList.contains('ProseMirror') || editor.classList.contains('tiptap');
+    const isLexical = editor.hasAttribute('data-lexical-editor');
+    
+    // Focus the editor first
+    editor.focus();
+    await new Promise(r => setTimeout(r, 50));
+    
+    if (isTextarea) {
+      // Textarea: simple value assignment
+      editor.value = text;
+      editor.dispatchEvent(new Event('input', { bubbles: true }));
+    } else if (isProseMirror) {
+      // ProseMirror/TipTap: Clear and insert via DOM manipulation
+      // This works because TipTap syncs DOM changes to its state
+      editor.innerHTML = '';
+      const p = targetDoc.createElement('p');
+      p.textContent = text;
+      editor.appendChild(p);
+      editor.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: text }));
+    } else if (isLexical) {
+      // Lexical: Must use execCommand to properly update internal state
+      // Lexical listens to beforeinput/input events from execCommand
+      
+      // First, select all content
+      const selection = targetDoc.getSelection();
+      const range = targetDoc.createRange();
+      range.selectNodeContents(editor);
+      selection.removeAllRanges();
+      selection.addRange(range);
+      
+      // Delete existing content
+      targetDoc.execCommand('delete', false, null);
+      
+      // Wait for Lexical to process the deletion
+      await new Promise(r => setTimeout(r, 30));
+      
+      // Insert new text using execCommand (Lexical intercepts this)
+      const inserted = targetDoc.execCommand('insertText', false, text);
+      
+      if (!inserted) {
+        // Fallback: Try setting textContent and dispatching events
+        editor.textContent = text;
+        editor.dispatchEvent(new InputEvent('beforeinput', { bubbles: true, cancelable: true, inputType: 'insertText', data: text }));
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: text }));
+      }
+    } else {
+      // Generic contenteditable
+      const selection = targetDoc.getSelection();
+      const range = targetDoc.createRange();
+      range.selectNodeContents(editor);
+      selection.removeAllRanges();
+      selection.addRange(range);
+      
+      targetDoc.execCommand('delete', false, null);
+      
+      let inserted = false;
+      try { inserted = !!targetDoc.execCommand('insertText', false, text); } catch (e) {}
+      
+      if (!inserted) {
+        editor.textContent = text;
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: text }));
+      }
+    }
+    
+    // Wait for editor state to sync
+    await new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)));
+    await new Promise(r => setTimeout(r, 100));
+    
+    // Find and click submit button
+    const submitButton = targetDoc.querySelector('button[data-variant="submit"]:not([disabled])') ||
+                         targetDoc.querySelector('svg.lucide-arrow-right')?.closest('button:not([disabled])') ||
+                         targetDoc.querySelector('button[type="submit"]:not([disabled])') ||
+                         targetDoc.querySelector('button[aria-label*="send" i]:not([disabled])');
+    
+    if (submitButton) {
+      submitButton.click();
+      return { ok: true, method: 'click_submit' };
+    }
+    
+    // Fallback: Enter key
+    editor.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, cancelable: true, key: 'Enter', code: 'Enter', keyCode: 13 }));
+    return { ok: true, method: 'enter_key' };
+  })()`;
+}
+
+/**
+ * Inject a message into the chat via CDP
+ * @param {CDPConnection} cdp - CDP connection
+ * @param {string} message - Message text
+ * @returns {Promise<{success: boolean, method?: string, error?: string}>}
+ */
+export async function injectMessage(cdp, message) {
+  // Validate message before processing
+  const validation = validateMessage(message);
+  if (!validation.valid) {
+    return { success: false, error: validation.error };
+  }
+  
+  if (!cdp.rootContextId) {
+    return { success: false, error: 'No execution context available' };
+  }
+  
+  try {
+    const result = await cdp.call('Runtime.evaluate', {
+      expression: createInjectScript(message),
+      contextId: cdp.rootContextId,
+      returnByValue: true,
+      awaitPromise: true
+    });
+    
+    if (result.exceptionDetails) {
+      return { success: false, error: result.exceptionDetails.exception?.description || 'Unknown error' };
+    }
+    
+    const value = result.result?.value;
+    if (value?.ok) {
+      console.log(`[Inject] Message sent via ${value.method}`);
+      return { success: true, method: value.method };
+    }
+    return { success: false, error: value?.error || 'Injection failed' };
+  } catch (err) {
+    console.error('[Inject] CDP call failed:', err.message);
+    return { success: false, error: err.message };
+  }
+}

package/src/services/snapshot.js

@@ -0,0 +1,370 @@
+/**
+ * Snapshot capture service - captures DOM snapshots from Kiro via CDP
+ */
+import { getLanguageFromExtension } from '../utils/constants.js';
+
+/**
+ * Capture chat metadata (title, active state)
+ * @param {CDPConnection} cdp - CDP connection
+ * @returns {Promise<{chatTitle: string, isActive: boolean}>}
+ */
+export async function captureMetadata(cdp) {
+  if (!cdp.rootContextId) return { chatTitle: '', isActive: false };
+  
+  const script = `(function() {
+    let chatTitle = '';
+    let isActive = false;
+    
+    const titleSelectors = ['.chat-title', '.conversation-title', '[data-testid="chat-title"]', '.chat-header h1', '.chat-header h2'];
+    for (const selector of titleSelectors) {
+      const el = document.querySelector(selector);
+      if (el && el.textContent) { chatTitle = el.textContent.trim(); break; }
+    }
+    
+    const activeIndicators = ['.typing-indicator', '.loading-indicator', '[data-loading="true"]'];
+    for (const selector of activeIndicators) {
+      if (document.querySelector(selector)) { isActive = true; break; }
+    }
+    isActive = isActive || document.hasFocus();
+    
+    return { chatTitle, isActive };
+  })()`;
+  
+  try {
+    const result = await cdp.call('Runtime.evaluate', {
+      expression: script,
+      contextId: cdp.rootContextId,
+      returnByValue: true
+    });
+    return result.result?.value || { chatTitle: '', isActive: false };
+  } catch (err) {
+    console.error('[Snapshot] Failed to capture metadata:', err.message);
+    return { chatTitle: '', isActive: false };
+  }
+}
+
+/**
+ * Capture CSS styles from the page (run once per connection)
+ * @param {CDPConnection} cdp - CDP connection
+ * @returns {Promise<string>} - Combined CSS string
+ */
+export async function captureCSS(cdp) {
+  if (!cdp.rootContextId) return '';
+  
+  const script = `(function() {
+    let css = '';
+    let targetDoc = document;
+    const activeFrame = document.getElementById('active-frame');
+    if (activeFrame && activeFrame.contentDocument) targetDoc = activeFrame.contentDocument;
+    
+    const rootStyles = window.getComputedStyle(targetDoc.documentElement);
+    const allProps = [];
+    for (let i = 0; i < rootStyles.length; i++) allProps.push(rootStyles[i]);
+    
+    // Safely iterate stylesheets with null check
+    const styleSheets = targetDoc.styleSheets || [];
+    for (const sheet of styleSheets) {
+      try {
+        if (sheet.cssRules) {
+          for (const rule of sheet.cssRules) {
+            if (rule.style) {
+              for (let i = 0; i < rule.style.length; i++) {
+                const prop = rule.style[i];
+                if (prop.startsWith('--') && !allProps.includes(prop)) allProps.push(prop);
+              }
+            }
+          }
+        }
+      } catch (e) {
+        // CORS restriction on external stylesheets, skip
+      }
+    }
+    
+    let cssVars = ':root {\\n';
+    for (const prop of allProps) {
+      if (prop.startsWith('--')) {
+        const value = rootStyles.getPropertyValue(prop).trim();
+        if (value) cssVars += '  ' + prop + ': ' + value + ';\\n';
+      }
+    }
+    cssVars += '}\\n\\n';
+    css += cssVars;
+    
+    for (const sheet of styleSheets) {
+      try {
+        if (sheet.cssRules) {
+          for (const rule of sheet.cssRules) css += rule.cssText + '\\n';
+        }
+      } catch (e) {
+        // CORS restriction, skip
+      }
+    }
+    
+    const styleTags = targetDoc.querySelectorAll('style');
+    for (const tag of styleTags) css += tag.textContent + '\\n';
+    
+    return css;
+  })()`;
+  
+  try {
+    const result = await cdp.call('Runtime.evaluate', {
+      expression: script,
+      contextId: cdp.rootContextId,
+      returnByValue: true
+    });
+    return result.result?.value || '';
+  } catch (err) {
+    console.error('[Snapshot] Failed to capture CSS:', err.message);
+    return '';
+  }
+}
+
+
+/**
+ * Capture HTML snapshot of the chat interface
+ * @param {CDPConnection} cdp - CDP connection
+ * @returns {Promise<{html: string, bodyBg: string, bodyColor: string} | null>}
+ */
+export async function captureSnapshot(cdp) {
+  if (!cdp.rootContextId) {
+    console.log('[Snapshot] No rootContextId available');
+    return null;
+  }
+  
+  const script = `(function() {
+    let targetDoc = document;
+    let targetBody = document.body;
+    
+    const activeFrame = document.getElementById('active-frame');
+    if (activeFrame && activeFrame.contentDocument) {
+      targetDoc = activeFrame.contentDocument;
+      targetBody = targetDoc.body;
+    }
+    
+    if (!targetBody) return { html: '<div style="padding:20px;color:#888;">No content found</div>', bodyBg: '', bodyColor: '' };
+    
+    const bodyStyles = window.getComputedStyle(targetBody);
+    const bodyBg = bodyStyles.backgroundColor || '';
+    const bodyColor = bodyStyles.color || '';
+    
+    const scrollContainers = targetDoc.querySelectorAll('[class*="scroll"], [style*="overflow"]');
+    
+    for (const container of scrollContainers) {
+      if (container.scrollHeight > container.clientHeight) {
+        const isHistoryPanel = container.matches('[class*="history"], [class*="History"], [class*="session-list"], [class*="SessionList"]') ||
+          container.closest('[class*="history"], [class*="History"], [class*="session-list"], [class*="SessionList"]');
+        
+        if (isHistoryPanel) {
+          container.scrollTop = 0;
+        } else {
+          container.scrollTop = container.scrollHeight;
+        }
+      }
+    }
+    
+    const clone = targetBody.cloneNode(true);
+    
+    // Capture any portal/overlay content that might be outside the body
+    // Radix UI and similar libraries render dropdowns in portals at document root
+    const portals = targetDoc.querySelectorAll('[data-radix-portal], [data-radix-popper-content-wrapper], [class*="portal"], [class*="Portal"]');
+    portals.forEach(portal => {
+      try {
+        const portalClone = portal.cloneNode(true);
+        clone.appendChild(portalClone);
+      } catch(e) {
+        // Clone failed, skip
+      }
+    });
+    
+    // Also check for any floating/overlay elements at document level
+    const floatingSelectors = [
+      'body > [role="listbox"]', 
+      'body > [role="menu"]', 
+      'body > [data-state="open"]', 
+      'body > [class*="dropdown"]',
+      'body > div[style*="position: absolute"]',
+      'body > div[style*="position: fixed"]'
+    ];
+    
+    floatingSelectors.forEach(sel => {
+      try {
+        targetDoc.querySelectorAll(sel).forEach(el => {
+          const elClone = el.cloneNode(true);
+          clone.appendChild(elClone);
+        });
+      } catch(e) {
+        // Selector failed, skip
+      }
+    });
+    
+    // Remove ONLY tooltips from clone - preserve everything else
+    try {
+      clone.querySelectorAll('[role="tooltip"]').forEach(el => el.remove());
+    } catch(e) {
+      // Removal failed, continue
+    }
+    
+    // Fix SVG currentColor
+    clone.querySelectorAll('svg').forEach(svg => {
+      try {
+        const computedColor = '#cccccc';
+        svg.querySelectorAll('[fill="currentColor"]').forEach(el => el.setAttribute('fill', computedColor));
+        svg.querySelectorAll('[stroke="currentColor"]').forEach(el => el.setAttribute('stroke', computedColor));
+      } catch(e) {
+        // SVG fix failed, continue
+      }
+    });
+    
+    // Remove placeholder text
+    try {
+      clone.querySelectorAll('[contenteditable="true"], [data-lexical-editor="true"]').forEach(editable => {
+        const parent = editable.parentElement;
+        if (parent) {
+          Array.from(parent.children).forEach(sibling => {
+            if (sibling === editable) return;
+            const text = (sibling.textContent || '').toLowerCase();
+            if (text.includes('ask') || text.includes('question') || text.includes('task') || text.includes('describe')) {
+              sibling.remove();
+            }
+          });
+        }
+      });
+      
+      clone.querySelectorAll('[class*="placeholder"], [class*="Placeholder"], [data-placeholder]').forEach(el => {
+        if (!el.matches('[contenteditable], [data-lexical-editor], textarea, input')) {
+          if (!el.querySelector('[contenteditable], [data-lexical-editor], textarea, input')) el.remove();
+        }
+      });
+    } catch(e) {
+      // Placeholder removal failed, continue
+    }
+    
+    return { html: clone.outerHTML, bodyBg, bodyColor };
+  })()`;
+  
+  try {
+    const result = await cdp.call('Runtime.evaluate', {
+      expression: script,
+      contextId: cdp.rootContextId,
+      returnByValue: true
+    });
+    
+    return result.result?.value || null;
+  } catch (err) {
+    console.error('[Snapshot] Failed to capture HTML:', err.message);
+    return null;
+  }
+}
+
+/**
+ * Capture Editor panel snapshot (currently open file)
+ * @param {CDPConnection} cdp - CDP connection
+ * @returns {Promise<{fileName: string, language: string, content: string, lineCount: number, hasContent: boolean} | null>}
+ */
+export async function captureEditor(cdp) {
+  if (!cdp.rootContextId) return null;
+  
+  const script = `(function() {
+    let targetDoc = document;
+    const activeFrame = document.getElementById('active-frame');
+    if (activeFrame && activeFrame.contentDocument) targetDoc = activeFrame.contentDocument;
+    
+    const result = { html: '', fileName: '', language: '', content: '', lineCount: 0, hasContent: false };
+    
+    // Get active tab / file name
+    const tabSelectors = ['.tab.active .label-name', '.tab.active', '[role="tab"][aria-selected="true"]'];
+    for (const selector of tabSelectors) {
+      try {
+        const tab = targetDoc.querySelector(selector);
+        if (tab && tab.textContent) {
+          result.fileName = tab.textContent.trim().split('\\n')[0].trim();
+          if (result.fileName) break;
+        }
+      } catch(e) {
+        // Selector failed, continue
+      }
+    }
+    
+    // Try Monaco API
+    try {
+      const monacoEditors = targetDoc.querySelectorAll('.monaco-editor');
+      for (const editorEl of monacoEditors) {
+        const editorInstance = editorEl.__vscode_editor__ || editorEl._editor ||
+          (window.monaco && window.monaco.editor && window.monaco.editor.getEditors && window.monaco.editor.getEditors()[0]);
+        if (editorInstance && editorInstance.getModel) {
+          const model = editorInstance.getModel();
+          if (model) {
+            result.content = model.getValue();
+            result.lineCount = model.getLineCount();
+            result.language = model.getLanguageId ? model.getLanguageId() : '';
+            result.hasContent = true;
+            break;
+          }
+        }
+      }
+    } catch(e) {
+      // Monaco API not available, continue
+    }
+    
+    // Fallback: Extract from view-lines
+    if (!result.content) {
+      const viewLines = targetDoc.querySelector('.monaco-editor .view-lines');
+      if (viewLines) {
+        const lines = viewLines.querySelectorAll('.view-line');
+        if (lines.length > 0) {
+          let codeContent = '';
+          let minLineNum = Infinity, maxLineNum = 0;
+          const lineMap = new Map();
+          
+          lines.forEach(line => {
+            const top = parseFloat(line.style.top) || 0;
+            const lineNum = Math.round(top / 19) + 1;
+            lineMap.set(lineNum, line.textContent || '');
+            minLineNum = Math.min(minLineNum, lineNum);
+            maxLineNum = Math.max(maxLineNum, lineNum);
+          });
+          
+          for (let i = minLineNum; i <= Math.min(maxLineNum, minLineNum + 500); i++) {
+            codeContent += (lineMap.get(i) || '') + '\\n';
+          }
+          
+          result.content = codeContent;
+          result.lineCount = maxLineNum;
+          result.startLine = minLineNum;
+          result.hasContent = codeContent.trim().length > 0;
+          if (minLineNum > 1) {
+            result.isPartial = true;
+            result.note = 'Showing lines ' + minLineNum + '-' + maxLineNum + '. Scroll in Kiro to see other parts.';
+          }
+        }
+      }
+    }
+    
+    // Detect language from filename
+    if (!result.language && result.fileName) {
+      const ext = result.fileName.split('.').pop()?.toLowerCase();
+      const extMap = {
+        'ts': 'typescript', 'tsx': 'typescript', 'js': 'javascript', 'jsx': 'javascript',
+        'py': 'python', 'java': 'java', 'html': 'html', 'css': 'css', 'json': 'json',
+        'md': 'markdown', 'yaml': 'yaml', 'yml': 'yaml', 'go': 'go', 'rs': 'rust',
+        'c': 'c', 'cpp': 'cpp', 'h': 'c', 'cs': 'csharp', 'rb': 'ruby', 'php': 'php',
+        'sql': 'sql', 'sh': 'bash', 'vue': 'vue', 'svelte': 'svelte'
+      };
+      result.language = extMap[ext] || ext || '';
+    }
+    
+    return result;
+  })()`;
+  
+  try {
+    const result = await cdp.call('Runtime.evaluate', {
+      expression: script,
+      contextId: cdp.rootContextId,
+      returnByValue: true
+    });
+    return result.result?.value || null;
+  } catch (err) {
+    console.error('[Editor] Failed to capture:', err.message);
+    return null;
+  }
+}

package/src/utils/constants.js

@@ -0,0 +1,116 @@
+/**
+ * Shared constants used across the application
+ * Centralizes configuration to eliminate duplication and improve maintainability
+ */
+
+/**
+ * CDP ports to scan for Kiro instances
+ * @type {number[]}
+ */
+export const CDP_PORTS = [9000, 9001, 9002, 9003, 9222, 9229];
+
+/**
+ * Model names for AI model detection and matching
+ * Order matters: check specific names (opus, sonnet, haiku) BEFORE generic (claude)
+ * @type {string[]}
+ */
+export const MODEL_NAMES = ['auto', 'opus', 'sonnet', 'haiku', 'gpt', 'claude', 'gemini', 'llama'];
+
+/**
+ * Code file extensions for workspace file filtering
+ * @type {Set<string>}
+ */
+export const CODE_EXTENSIONS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.py', '.java', '.go', '.rs',
+  '.html', '.css', '.scss', '.json', '.yaml', '.yml', '.md',
+  '.sql', '.sh', '.c', '.cpp', '.h', '.cs', '.vue', '.svelte', '.rb', '.php'
+]);
+
+/**
+ * File extension to language mapping for syntax highlighting
+ * @type {Object<string, string>}
+ */
+export const EXTENSION_TO_LANGUAGE = {
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.py': 'python',
+  '.html': 'html',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.json': 'json',
+  '.md': 'markdown',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.java': 'java',
+  '.c': 'c',
+  '.cpp': 'cpp',
+  '.h': 'c',
+  '.cs': 'csharp',
+  '.rb': 'ruby',
+  '.php': 'php',
+  '.sql': 'sql',
+  '.sh': 'bash',
+  '.vue': 'vue',
+  '.svelte': 'svelte'
+};
+
+/**
+ * Get language from file extension
+ * @param {string} filename - File name or path
+ * @returns {string} - Language identifier or extension without dot
+ */
+export function getLanguageFromExtension(filename) {
+  const ext = filename.includes('.') ? '.' + filename.split('.').pop().toLowerCase() : '';
+  return EXTENSION_TO_LANGUAGE[ext] || ext.slice(1) || 'text';
+}
+
+/**
+ * Check if a file has a code extension
+ * @param {string} filename - File name or path
+ * @returns {boolean}
+ */
+export function isCodeFile(filename) {
+  const ext = filename.includes('.') ? '.' + filename.split('.').pop().toLowerCase() : '';
+  return CODE_EXTENSIONS.has(ext);
+}
+
+/**
+ * CDP call timeout in milliseconds
+ * @type {number}
+ */
+export const CDP_CALL_TIMEOUT = 10000;
+
+/**
+ * HTTP request timeout in milliseconds
+ * @type {number}
+ */
+export const HTTP_TIMEOUT = 2000;
+
+/**
+ * Discovery polling intervals
+ */
+export const DISCOVERY_INTERVAL_ACTIVE = 10000;  // 10 seconds when changes detected
+export const DISCOVERY_INTERVAL_STABLE = 30000;  // 30 seconds when stable
+
+/**
+ * Snapshot polling intervals
+ */
+export const SNAPSHOT_INTERVAL_ACTIVE = 1000;    // 1 second when active
+export const SNAPSHOT_INTERVAL_IDLE = 3000;      // 3 seconds when idle
+export const SNAPSHOT_IDLE_THRESHOLD = 10000;    // 10 seconds before considered idle
+
+/**
+ * Maximum depth for recursive file search
+ * @type {number}
+ */
+export const MAX_FILE_SEARCH_DEPTH = 4;
+
+/**
+ * Maximum depth for workspace file collection
+ * @type {number}
+ */
+export const MAX_WORKSPACE_DEPTH = 5;