antigravity-chat-proxy 0.1.0

package/lib/actions/send-message.ts

@@ -0,0 +1,31 @@
+/**
+ * Send a chat message by typing into the Antigravity input and pressing Enter.
+ */
+
+import { SELECTORS } from '../cdp/selectors';
+import { sleep } from '../utils';
+import { logger } from '@/lib/logger';
+import type { ProxyContext } from '../types';
+
+export async function sendMessage(ctx: ProxyContext, text: string) {
+  if (!ctx.workbenchPage) throw new Error('Not connected to Antigravity');
+
+  logger.info(`[Chat] Sending message (${text.length} chars)...`);
+
+  await ctx.workbenchPage.click(SELECTORS.chatInput);
+  await sleep(200);
+
+  await ctx.workbenchPage.evaluate((sel: string) => {
+    const el = document.querySelector(sel);
+    if (el) {
+      el.textContent = '';
+      (el as HTMLElement).focus();
+    }
+  }, SELECTORS.chatInput);
+
+  await ctx.workbenchPage.keyboard.type(text);
+  await sleep(300);
+
+  await ctx.workbenchPage.keyboard.press('Enter');
+  logger.info(`[Chat] Sent.`);
+}

package/lib/actions/switch-conversation.ts

@@ -0,0 +1,92 @@
+/**
+ * Switch the active conversation in the IDE using CDP.
+ */
+
+import { sleep } from '../utils';
+import { logger } from '@/lib/logger';
+import type { ProxyContext } from '../types';
+
+export async function switchIdeConversation(
+  ctx: ProxyContext,
+  conversationTitle: string
+): Promise<boolean> {
+  if (!ctx.workbenchPage || !conversationTitle) return false;
+
+  try {
+    const success = await ctx.workbenchPage.evaluate(
+      async (targetTitle: string) => {
+        const historyBtn = document.querySelector('a[data-past-conversations-toggle="true"]');
+        if (!historyBtn) return false;
+
+        let isAlreadyOpen = !!document.querySelector('.text-quickinput-foreground.opacity-50');
+        
+        if (!isAlreadyOpen) {
+          historyBtn.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, view: window }));
+          historyBtn.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window }));
+          historyBtn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+          
+          for (let i = 0; i < 20; i++) {
+            await new Promise(r => setTimeout(r, 100));
+            if (document.querySelector('.text-quickinput-foreground.opacity-50')) {
+              isAlreadyOpen = true;
+              break;
+            }
+          }
+        }
+
+        if (!isAlreadyOpen) return false;
+
+        const rowSelector = '.cursor-pointer.flex.items-center.justify-between.rounded-md.text-quickinput-foreground';
+        const rowElements = Array.from(document.querySelectorAll(rowSelector));
+        
+        let matchedRow: Element | null = null;
+        for (const row of rowElements) {
+          const titleEl = row.querySelector('.truncate span');
+          const title = titleEl ? titleEl.textContent?.trim() : row.textContent?.trim();
+          
+          if (title === targetTitle) {
+            matchedRow = row;
+            break;
+          }
+        }
+
+        if (matchedRow) {
+          matchedRow.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true, view: window }));
+          matchedRow.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, view: window }));
+          matchedRow.dispatchEvent(new PointerEvent('pointerup', { bubbles: true, view: window }));
+          matchedRow.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window }));
+          matchedRow.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+          
+          // The modal usually auto-closes on click.
+          // If it doesn't, we can simulate an escape or click body.
+          setTimeout(() => {
+             const stillOpen = !!document.querySelector('.text-quickinput-foreground.opacity-50');
+             if (stillOpen && historyBtn) {
+               historyBtn.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, view: window }));
+               historyBtn.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window }));
+               historyBtn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+             }
+          }, 300);
+          
+          return true;
+        }
+
+        // If not found, close modal
+        historyBtn.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, view: window }));
+        historyBtn.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window }));
+        historyBtn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+
+        return false;
+      },
+      conversationTitle
+    );
+
+    if (success) {
+      await sleep(1000); // Give it a second to load the new conversation
+    }
+    return success;
+  } catch (e: any) {
+    logger.error('[Action] Error switching IDE conversation:', e);
+    return false;
+  }
+}

package/lib/cdp/connection.ts

@@ -0,0 +1,95 @@
+/**
+ * CDP (Chrome DevTools Protocol) connection management.
+ * Handles connecting to Antigravity's Electron app via Puppeteer.
+ */
+
+import puppeteer, { Browser } from 'puppeteer-core';
+import { logger } from '../logger';
+import type { ProxyContext } from '../types';
+
+const CDP_PORT_RAW = process.env.CDP_PORT || '9223';
+const CDP_PORT = parseInt(CDP_PORT_RAW, 10);
+
+/**
+ * Discover all workbench pages in the Electron app.
+ */
+export async function discoverWorkbenches(ctx: ProxyContext) {
+  if (isNaN(CDP_PORT) || CDP_PORT <= 0 || CDP_PORT > 65535) {
+    throw new Error(`[CDP] Invalid CDP_PORT configured: "${CDP_PORT_RAW}". Please check your .env.local file.`);
+  }
+
+  if (!ctx.browser || !ctx.browser.isConnected()) {
+    logger.info(`[CDP] Initializing connection on port ${CDP_PORT}...`);
+    try {
+      ctx.browser = await puppeteer.connect({
+        browserURL: `http://localhost:${CDP_PORT}`,
+        defaultViewport: null,
+      });
+      ctx.browser.on('disconnected', () => {
+        logger.info('[CDP] Browser disconnected. Resetting context...');
+        ctx.browser = null;
+        ctx.workbenchPage = null;
+        ctx.allWorkbenches = [];
+      });
+    } catch (err) {
+      logger.error(`[CDP] Failed to connect on port ${CDP_PORT}. Ensure IDE is running with --remote-debugging-port=${CDP_PORT}`);
+      throw err;
+    }
+  }
+  const pages = await ctx.browser.pages();
+
+  ctx.allWorkbenches = [];
+  for (const p of pages) {
+    const url = p.url();
+    if (url.includes('workbench.html') && !url.includes('jetski')) {
+      const title = await p.title();
+      ctx.allWorkbenches.push({ page: p, title, url });
+    }
+  }
+  return ctx.allWorkbenches;
+}
+
+/**
+ * Connect to the default (or env-specified) workbench window.
+ */
+export async function connectToWorkbench(ctx: ProxyContext) {
+  await discoverWorkbenches(ctx);
+
+  if (ctx.allWorkbenches.length === 0) {
+    throw new Error(
+      'No workbench pages found. Is Antigravity running with --remote-debugging-port=9223?'
+    );
+  }
+
+  logger.info(`[CDP] Found ${ctx.allWorkbenches.length} Antigravity window(s).`);
+  for (let i = 0; i < ctx.allWorkbenches.length; i++) {
+    logger.info(`  [${i}] ${ctx.allWorkbenches[i].title}`);
+  }
+
+  const targetIdx = parseInt(process.env.PROXY_PAGE || '0', 10);
+  ctx.activeWindowIdx = targetIdx;
+  ctx.workbenchPage =
+    ctx.allWorkbenches[targetIdx]?.page || ctx.allWorkbenches[0].page;
+  
+  ctx.workbenchPage.on('close', () => {
+    logger.info('[CDP] Workbench page closed. Resetting context...');
+    ctx.workbenchPage = null;
+  });
+
+  logger.info(`[CDP] Active window index set to ${ctx.activeWindowIdx}. Connected to: "${ctx.allWorkbenches[ctx.activeWindowIdx]?.title || 'unknown'}"`);
+}
+
+/**
+ * Switch to a different workbench window by index.
+ */
+export function selectWindow(ctx: ProxyContext, idx: number) {
+  if (idx < 0 || idx >= ctx.allWorkbenches.length) {
+    throw new Error(
+      `Invalid window index ${idx}. Available: 0-${ctx.allWorkbenches.length - 1}`
+    );
+  }
+  ctx.activeWindowIdx = idx;
+  ctx.workbenchPage = ctx.allWorkbenches[idx].page;
+  logger.info(`[CDP] Switched to window [${idx}] ${ctx.allWorkbenches[idx].title}`);
+  return ctx.allWorkbenches[idx];
+}

package/lib/cdp/process-manager.ts

@@ -0,0 +1,327 @@
+/**
+ * Antigravity Process Manager (Cross-Platform)
+ * 
+ * Manages the Antigravity IDE process lifecycle:
+ * - Check if CDP server is active
+ * - Start the Antigravity binary with remote debugging
+ * - Open new windows in a specific directory
+ * - Close individual windows
+ * 
+ * Supports: Linux, macOS, and Windows
+ */
+
+import { exec, spawn, ChildProcess } from 'child_process';
+import { promisify } from 'util';
+import { existsSync, statSync } from 'fs';
+import { resolve } from 'path';
+import { logger } from '../logger';
+
+const execAsync = promisify(exec);
+
+const CDP_PORT_RAW = process.env.CDP_PORT || '9223';
+const CDP_PORT = parseInt(CDP_PORT_RAW, 10);
+const IS_WIN = process.platform === 'win32';
+const IS_MAC = process.platform === 'darwin';
+
+/**
+ * Resolve the Antigravity binary path based on the OS.
+ * Can be overridden with ANTIGRAVITY_BINARY env var.
+ */
+function getAntigravityBinary(): string {
+  // Allow explicit override via env
+  if (process.env.ANTIGRAVITY_BINARY) {
+    return process.env.ANTIGRAVITY_BINARY;
+  }
+
+  if (IS_WIN) {
+    // Windows: check common install locations
+    const candidates = [
+      resolve(process.env.LOCALAPPDATA || '', 'Programs', 'Antigravity', 'Antigravity.exe'),
+      resolve(process.env.PROGRAMFILES || 'C:\\Program Files', 'Google', 'Antigravity', 'Antigravity.exe'),
+      resolve(process.env.PROGRAMFILES || 'C:\\Program Files', 'Antigravity', 'Antigravity.exe'),
+    ];
+    for (const candidate of candidates) {
+      if (candidate && existsSync(candidate)) return candidate;
+    }
+    // Fallback — assume it's in PATH
+    return 'Antigravity.exe';
+  }
+
+  if (IS_MAC) {
+    // macOS: standard .app bundle location
+    const macBinary = '/Applications/Antigravity.app/Contents/MacOS/Antigravity';
+    if (existsSync(macBinary)) return macBinary;
+    // Also check user Applications folder
+    const userMacBinary = resolve(process.env.HOME || '', 'Applications', 'Antigravity.app', 'Contents', 'MacOS', 'Antigravity');
+    if (existsSync(userMacBinary)) return userMacBinary;
+    return macBinary; // fallback to standard path
+  }
+
+  // Linux
+  return '/usr/share/antigravity/antigravity';
+}
+
+/**
+ * Kill all existing Antigravity processes (cross-platform).
+ */
+async function killAllAntigravity(): Promise<void> {
+  try {
+    if (IS_WIN) {
+      await execAsync('taskkill /F /IM Antigravity.exe 2>nul || exit 0');
+    } else {
+      await execAsync('killall antigravity 2>/dev/null || true');
+    }
+    logger.info('[ProcessManager] Killed existing Antigravity processes.');
+    // Wait for process cleanup
+    await new Promise(resolve => setTimeout(resolve, 1500));
+  } catch {
+    // Ignore errors - process might not exist
+  }
+}
+
+/** Track spawned processes so we can clean up if needed */
+let spawnedProcess: ChildProcess | null = null;
+
+/**
+ * Check if the CDP server is accessible by pinging /json endpoint.
+ */
+export async function isCdpServerActive(): Promise<{
+  active: boolean;
+  windowCount: number;
+  error?: string;
+}> {
+  try {
+    const response = await fetch(`http://localhost:${CDP_PORT}/json`);
+    if (!response.ok) {
+      return { active: false, windowCount: 0, error: `HTTP ${response.status}` };
+    }
+    const pages = await response.json() as any[];
+    const workbenches = pages.filter(
+      (p: any) => p.url?.includes('workbench.html') && !p.url?.includes('jetski')
+    );
+    return { active: true, windowCount: workbenches.length };
+  } catch (e: any) {
+    return { active: false, windowCount: 0, error: e.message };
+  }
+}
+
+/**
+ * Start the Antigravity binary with CDP enabled.
+ * 
+ * IMPORTANT: From the KI, we know that if ANY Antigravity window exists,
+ * new windows will merge into the existing Electron process and immediately
+ * shut down the CDP server. So we must ensure a clean slate.
+ * 
+ * @param projectDir - The directory to open in Antigravity
+ * @param killExisting - If true, kill all existing Antigravity processes first
+ */
+export async function startCdpServer(
+  projectDir: string = '.',
+  killExisting: boolean = false,
+): Promise<{
+  success: boolean;
+  message: string;
+  pid?: number;
+}> {
+  // Check if CDP is already active
+  const status = await isCdpServerActive();
+  if (status.active) {
+    return {
+      success: true,
+      message: `CDP server already active on port ${CDP_PORT} with ${status.windowCount} window(s).`,
+    };
+  }
+
+  // Kill existing Antigravity instances if requested (required for clean CDP start)
+  if (killExisting) {
+    await killAllAntigravity();
+  }
+
+  const binaryPath = getAntigravityBinary();
+  // resolve() handles both absolute ('/home/user/proj') and relative ('my-proj') paths correctly
+  const absoluteDir = resolve(projectDir || '.');
+
+  // Validate the directory exists
+  try {
+    const stat = statSync(absoluteDir);
+    if (!stat.isDirectory()) {
+      return { success: false, message: `"${absoluteDir}" is not a directory.` };
+    }
+  } catch {
+    return { success: false, message: `Directory not found: "${absoluteDir}"` };
+  }
+
+  // Spawn the Antigravity binary
+  try {
+    logger.info(`[ProcessManager] Starting Antigravity: ${binaryPath} --remote-debugging-port=${CDP_PORT} --new-window ${absoluteDir}`);
+    logger.info(`[ProcessManager] Platform: ${process.platform}, Binary: ${binaryPath}`);
+
+    spawnedProcess = spawn(
+      binaryPath,
+      [`--remote-debugging-port=${CDP_PORT}`, '--new-window', absoluteDir],
+      {
+        detached: !IS_WIN, // detached not needed on Windows
+        stdio: 'ignore',
+        env: { ...process.env },
+        // On Windows, use shell to resolve .exe correctly
+        shell: IS_WIN,
+      }
+    );
+
+    // Unref so the process doesn't keep Node alive
+    spawnedProcess.unref();
+
+    const pid = spawnedProcess.pid;
+
+    spawnedProcess.on('error', (err) => {
+      logger.error(`[ProcessManager] Antigravity process error: ${err.message}`);
+      spawnedProcess = null;
+    });
+
+    spawnedProcess.on('exit', (code) => {
+      logger.info(`[ProcessManager] Antigravity process exited with code ${code}`);
+      spawnedProcess = null;
+    });
+
+    // Wait for CDP to become available (poll up to 15 seconds)
+    const started = await waitForCdp(15000);
+    if (started) {
+      return {
+        success: true,
+        message: `Antigravity started with CDP on port ${CDP_PORT}.`,
+        pid: pid || undefined,
+      };
+    } else {
+      return {
+        success: false,
+        message: `Antigravity process started but CDP server did not become available on port ${CDP_PORT} within 15s.`,
+        pid: pid || undefined,
+      };
+    }
+  } catch (e: any) {
+    logger.error(`[ProcessManager] Failed to start Antigravity: ${e.message}`);
+    return {
+      success: false,
+      message: `Failed to start Antigravity: ${e.message}`,
+    };
+  }
+}
+
+/**
+ * Open a new Antigravity window with a specified directory.
+ * 
+ * If CDP is already active (Antigravity is running), this will open
+ * a new window in the existing Electron process.
+ * If CDP is NOT active, it will start Antigravity fresh.
+ */
+export async function openNewWindow(projectDir: string): Promise<{
+  success: boolean;
+  message: string;
+}> {
+  // resolve() handles both absolute ('/home/user/proj') and relative ('my-proj') paths correctly
+  const absoluteDir = resolve(projectDir);
+
+  // Validate the directory exists before trying to open
+  try {
+    const stat = statSync(absoluteDir);
+    if (!stat.isDirectory()) {
+      return { success: false, message: `"${absoluteDir}" is not a directory. Please provide a folder path.` };
+    }
+  } catch {
+    return { success: false, message: `Directory not found: "${absoluteDir}". Make sure the path exists.` };
+  }
+
+  const status = await isCdpServerActive();
+  const binaryPath = getAntigravityBinary();
+
+  if (status.active) {
+    // Antigravity is already running — open a new window via CLI
+    // This will open a new window in the same Electron process
+    try {
+      logger.info(`[ProcessManager] Opening new window for: ${absoluteDir}`);
+      const child = spawn(
+        binaryPath,
+        ['--new-window', absoluteDir],
+        {
+          detached: !IS_WIN,
+          stdio: 'ignore',
+          env: { ...process.env },
+          shell: IS_WIN,
+        }
+      );
+      child.unref();
+
+      // Wait for the new window to appear
+      await new Promise(resolve => setTimeout(resolve, 3000));
+      return {
+        success: true,
+        message: `Opened new window for "${absoluteDir}".`,
+      };
+    } catch (e: any) {
+      return { success: false, message: `Failed to open window: ${e.message}` };
+    }
+  } else {
+    // No CDP server — start fresh with this directory
+    const result = await startCdpServer(projectDir, false);
+    return { success: result.success, message: result.message };
+  }
+}
+
+/**
+ * Close a specific workbench window by its CDP page index.
+ * Uses the CDP protocol to close the page's target.
+ */
+export async function closeWindow(targetId: string): Promise<{
+  success: boolean;
+  message: string;
+}> {
+  try {
+    const response = await fetch(`http://localhost:${CDP_PORT}/json/close/${targetId}`);
+    if (response.ok) {
+      return { success: true, message: 'Window closed successfully.' };
+    } else {
+      return { success: false, message: `Failed to close window: HTTP ${response.status}` };
+    }
+  } catch (e: any) {
+    return { success: false, message: `Failed to close window: ${e.message}` };
+  }
+}
+
+/**
+ * Get detailed info about all CDP targets (workbench windows).
+ */
+export async function getWindowTargets(): Promise<{
+  targets: Array<{ id: string; title: string; url: string }>;
+  error?: string;
+}> {
+  try {
+    const response = await fetch(`http://localhost:${CDP_PORT}/json`);
+    if (!response.ok) {
+      return { targets: [], error: `HTTP ${response.status}` };
+    }
+    const pages = await response.json() as any[];
+    const workbenches = pages
+      .filter((p: any) => p.url?.includes('workbench.html') && !p.url?.includes('jetski'))
+      .map((p: any) => ({
+        id: p.id,
+        title: p.title || 'Untitled',
+        url: p.url,
+      }));
+    return { targets: workbenches };
+  } catch (e: any) {
+    return { targets: [], error: e.message };
+  }
+}
+
+/**
+ * Poll until CDP server is accessible.
+ */
+async function waitForCdp(timeoutMs: number): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const status = await isCdpServerActive();
+    if (status.active) return true;
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+  return false;
+}

package/lib/cdp/recent-projects.ts

@@ -0,0 +1,137 @@
+/**
+ * Recent Projects Reader (Cross-Platform)
+ * 
+ * Reads Antigravity's workspaceStorage to discover recently opened projects.
+ * Each workspace entry is stored as a subdirectory containing a workspace.json
+ * with the folder URI.
+ * 
+ * Config paths by OS:
+ *   Linux:   ~/.config/Antigravity/User/workspaceStorage/
+ *   macOS:   ~/Library/Application Support/Antigravity/User/workspaceStorage/
+ *   Windows: %APPDATA%/Antigravity/User/workspaceStorage/
+ */
+
+import { readdirSync, readFileSync, statSync, existsSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+import { logger } from '../logger';
+
+export interface RecentProject {
+  /** Absolute filesystem path to the project directory */
+  path: string;
+  /** Short display name (last segment of the path) */
+  name: string;
+  /** ISO timestamp of last time this workspace was active */
+  lastOpened: string;
+}
+
+/**
+ * Resolve the Antigravity workspaceStorage directory based on the OS.
+ */
+function getWorkspaceStoragePath(): string {
+  const home = homedir();
+  const platform = process.platform;
+
+  if (platform === 'win32') {
+    return join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'Antigravity', 'User', 'workspaceStorage');
+  }
+  if (platform === 'darwin') {
+    return join(home, 'Library', 'Application Support', 'Antigravity', 'User', 'workspaceStorage');
+  }
+  // Linux
+  return join(process.env.XDG_CONFIG_HOME || join(home, '.config'), 'Antigravity', 'User', 'workspaceStorage');
+}
+
+/**
+ * Read all workspace entries and return recent projects sorted by last-opened (desc).
+ * 
+ * Filters out:
+ *  - Remote workspaces (vscode-remote://)
+ *  - Playground directories (/.gemini/antigravity/playground/)
+ *  - Directories that no longer exist on disk
+ */
+export function getRecentProjects(limit: number = 15): RecentProject[] {
+  const storagePath = getWorkspaceStoragePath();
+
+  if (!existsSync(storagePath)) {
+    logger.warn(`[RecentProjects] Workspace storage not found at: ${storagePath}`);
+    return [];
+  }
+
+  const entries: RecentProject[] = [];
+
+  try {
+    const dirs = readdirSync(storagePath, { withFileTypes: true });
+
+    for (const dir of dirs) {
+      if (!dir.isDirectory()) continue;
+
+      const wsJsonPath = join(storagePath, dir.name, 'workspace.json');
+      if (!existsSync(wsJsonPath)) continue;
+
+      try {
+        const raw = readFileSync(wsJsonPath, 'utf-8');
+        const data = JSON.parse(raw);
+        const folderUri: string | undefined = data.folder;
+
+        if (!folderUri) continue;
+
+        // Skip remote workspaces
+        if (folderUri.startsWith('vscode-remote://')) continue;
+
+        // Extract the filesystem path from file:// URI
+        let fsPath: string;
+        if (folderUri.startsWith('file://')) {
+          fsPath = decodeURIComponent(new URL(folderUri).pathname);
+          // On Windows, strip leading / from /C:/Users/...
+          if (process.platform === 'win32' && fsPath.startsWith('/') && fsPath[2] === ':') {
+            fsPath = fsPath.substring(1);
+          }
+        } else {
+          fsPath = folderUri;
+        }
+
+        // Skip playground directories
+        if (fsPath.includes('/playground/') || fsPath.includes('\\playground\\')) continue;
+
+        // Skip directories that no longer exist
+        try {
+          const s = statSync(fsPath);
+          if (!s.isDirectory()) continue;
+        } catch {
+          continue; // Directory doesn't exist anymore
+        }
+
+        // Use the workspace storage directory's mtime as lastOpened
+        const dirPath = join(storagePath, dir.name);
+        const dirStat = statSync(dirPath);
+
+        entries.push({
+          path: fsPath,
+          name: basename(fsPath),
+          lastOpened: dirStat.mtime.toISOString(),
+        });
+      } catch {
+        // Skip malformed workspace.json files
+      }
+    }
+  } catch (e: any) {
+    logger.error(`[RecentProjects] Failed to read workspace storage: ${e.message}`);
+    return [];
+  }
+
+  // Sort by lastOpened descending (most recent first)
+  entries.sort((a, b) => new Date(b.lastOpened).getTime() - new Date(a.lastOpened).getTime());
+
+  // Deduplicate by path (keep the most recent entry)
+  const seen = new Set<string>();
+  const deduped: RecentProject[] = [];
+  for (const entry of entries) {
+    if (!seen.has(entry.path)) {
+      seen.add(entry.path);
+      deduped.push(entry);
+    }
+  }
+
+  return deduped.slice(0, limit);
+}

package/lib/cdp/selectors.ts

@@ -0,0 +1,11 @@
+/**
+ * DOM selectors for the Antigravity agent side panel.
+ */
+
+export const SELECTORS = {
+  chatInput:
+    '#antigravity\\.agentSidePanelInputBox [contenteditable="true"][role="textbox"]',
+  messageList: '#conversation > div:first-child .mx-auto.w-full',
+  conversation: '#conversation',
+  spinner: '.antigravity-agent-side-panel .animate-spin',
+} as const;