antigravity-chat-proxy 0.1.0

package/lib/context.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared server-side context singleton.
+ *
+ * Module-level state persists across API route invocations in the same
+ * Node.js process (Next.js dev server keeps the process alive).
+ * This replaces the mutable `ctx` object passed through the old codebase.
+ */
+
+import type { ProxyContext } from './types';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __PROXY_CTX: ProxyContext | undefined;
+}
+
+const ctx: ProxyContext = globalThis.__PROXY_CTX || {
+  workbenchPage: null,
+  browser: null,
+  allWorkbenches: [],
+  activeWindowIdx: 0,
+  activeConversationId: null,
+  activeTitle: null,
+  lastActionTimestamp: 0,
+};
+
+// In development, HMR clears module state but keeps globalThis.
+// In production, Next.js server retains module state per Node process,
+// but using globalThis ensures a single source of truth across all 
+// dynamic route executions.
+if (process.env.NODE_ENV !== 'production') {
+  globalThis.__PROXY_CTX = ctx;
+}
+
+export function getContext(): ProxyContext {
+  return ctx;
+}
+
+export default ctx;

package/lib/init.ts

@@ -0,0 +1,48 @@
+/**
+ * CDP initialization.
+ * Ensures the CDP connection is established before any API route runs.
+ * Called lazily on first API request.
+ */
+
+import { connectToWorkbench } from './cdp/connection';
+import { logger } from './logger';
+import ctx from './context';
+
+let initialized = false;
+let initPromise: Promise<void> | null = null;
+
+export async function ensureCdpConnection(): Promise<void> {
+  if (initialized && ctx.workbenchPage) return;
+
+  if (!initPromise) {
+    initPromise = (async () => {
+      try {
+        await connectToWorkbench(ctx);
+        initialized = true;
+
+        // Auto-reconnect on IDE close/crash
+        ctx.browser?.on('disconnected', () => {
+          logger.error('[CDP] Browser disconnected. Will reconnect on next request.');
+          initialized = false;
+          initPromise = null;
+          ctx.workbenchPage = null;
+          ctx.browser = null;
+          ctx.allWorkbenches = [];
+        });
+
+        ctx.workbenchPage?.on('close', () => {
+          logger.warn('[CDP] Workbench page closed. Will reconnect on next request.');
+          initialized = false;
+          initPromise = null;
+          ctx.workbenchPage = null;
+        });
+
+      } catch (e: any) {
+        logger.error('[CDP Init] Failed to connect:', e.message);
+        initPromise = null; // Allow retry
+      }
+    })();
+  }
+
+  await initPromise;
+}

package/lib/logger.ts

@@ -0,0 +1,32 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+class Logger {
+  private level: LogLevel = 'info';
+
+  constructor() {
+    this.level = (process.env.LOG_LEVEL as LogLevel) || 'info';
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const levels: LogLevel[] = ['debug', 'info', 'warn', 'error'];
+    return levels.indexOf(level) >= levels.indexOf(this.level);
+  }
+
+  debug(message: string, meta?: any) {
+    if (this.shouldLog('debug')) console.debug(`[DEBUG] ${message}`, meta || '');
+  }
+
+  info(message: string, meta?: any) {
+    if (this.shouldLog('info')) console.info(`[INFO] ${message}`, meta || '');
+  }
+
+  warn(message: string, meta?: any) {
+    if (this.shouldLog('warn')) console.warn(`[WARN] ${message}`, meta || '');
+  }
+
+  error(message: string, meta?: any) {
+    if (this.shouldLog('error')) console.error(`[ERROR] ${message}`, meta || '');
+  }
+}
+
+export const logger = new Logger();

package/lib/scraper/agent-mode.ts

@@ -0,0 +1,122 @@
+/**
+ * Agent conversation mode scraper and switcher.
+ * Reads and sets the Plan/Fast mode in the Antigravity IDE via CDP.
+ */
+
+import { logger } from '@/lib/logger';
+import { sleep } from '@/lib/utils';
+import type { ProxyContext } from '../types';
+
+export type AgentMode = 'planning' | 'fast';
+
+/**
+ * Read the current conversation mode from the IDE's agent panel DOM.
+ * Looks for the mode button's span text near the chat input.
+ */
+export async function getAgentMode(ctx: ProxyContext): Promise<AgentMode> {
+  if (!ctx.workbenchPage) throw new Error('Not connected to Antigravity');
+
+  const mode = await ctx.workbenchPage.evaluate(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    if (!panel) return null;
+
+    // The mode button contains a <span class="text-xs select-none"> with text "Planning" or "Fast"
+    const spans = panel.querySelectorAll('span.text-xs.select-none');
+    for (const span of spans) {
+      const text = (span.textContent || '').trim().toLowerCase();
+      if (text === 'planning' || text === 'fast') {
+        return text;
+      }
+    }
+    return null;
+  });
+
+  if (!mode) {
+    logger.warn('[Mode] Could not detect current mode, defaulting to "planning"');
+    return 'planning';
+  }
+
+  return mode as AgentMode;
+}
+
+/**
+ * Switch the conversation mode in the IDE.
+ * Clicks the mode button to open the dropdown, then selects the target mode.
+ */
+export async function setAgentMode(ctx: ProxyContext, targetMode: AgentMode): Promise<void> {
+  if (!ctx.workbenchPage) throw new Error('Not connected to Antigravity');
+
+  const currentMode = await getAgentMode(ctx);
+  if (currentMode === targetMode) {
+    logger.info(`[Mode] Already in "${targetMode}" mode, skipping.`);
+    return;
+  }
+
+  logger.info(`[Mode] Switching from "${currentMode}" to "${targetMode}"...`);
+
+  // Step 1: Click the mode button to open the dialog
+  const clicked = await ctx.workbenchPage.evaluate(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    if (!panel) return false;
+
+    const spans = panel.querySelectorAll('span.text-xs.select-none');
+    for (const span of spans) {
+      const text = (span.textContent || '').trim().toLowerCase();
+      if (text === 'planning' || text === 'fast') {
+        const btn = span.closest('button');
+        if (btn) {
+          btn.click();
+          return true;
+        }
+      }
+    }
+    return false;
+  });
+
+  if (!clicked) {
+    throw new Error('Could not find mode button to click');
+  }
+
+  await sleep(400);
+
+  // Step 2: Find the dialog and click the target option
+  const targetLabel = targetMode === 'planning' ? 'Planning' : 'Fast';
+
+  const selected = await ctx.workbenchPage.evaluate((label: string) => {
+    // Find the "Conversation mode" dialog
+    const dialogs = document.querySelectorAll('[role="dialog"]');
+    for (const dialog of dialogs) {
+      const text = (dialog.textContent || '').trim();
+      if (!text.includes('Conversation mode')) continue;
+
+      // Find the option with matching text
+      const options = dialog.querySelectorAll('.font-medium');
+      for (const opt of options) {
+        if ((opt.textContent || '').trim() === label) {
+          // Click the option's parent (the clickable row)
+          const clickTarget = opt.closest('[class*="cursor-pointer"]');
+          if (clickTarget) {
+            (clickTarget as HTMLElement).click();
+            return true;
+          }
+          // Fallback: click the option itself
+          (opt as HTMLElement).click();
+          return true;
+        }
+      }
+    }
+    return false;
+  }, targetLabel);
+
+  if (!selected) {
+    // Close dialog by pressing Escape
+    await ctx.workbenchPage.keyboard.press('Escape');
+    throw new Error(`Could not find "${targetLabel}" option in mode dialog`);
+  }
+
+  await sleep(300);
+
+  // Verify the switch
+  const newMode = await getAgentMode(ctx);
+  logger.info(`[Mode] Mode is now "${newMode}".`);
+}