antigravity-chat-proxy 0.1.0

package/app/api/v1/conversations/route.ts

@@ -0,0 +1,189 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import { getIdeConversations } from '@/lib/scraper/ide-conversations';
+
+export const dynamic = 'force-dynamic';
+
+const BRAIN_DIR = path.join(os.homedir(), '.gemini', 'antigravity', 'brain');
+
+function extractTitle(convDir: string): string | null {
+  const taskFile = path.join(convDir, 'task.md');
+  let title = null;
+  try {
+    if (fs.existsSync(taskFile)) {
+      const content = fs.readFileSync(taskFile, 'utf-8');
+      const lines = content.split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('# ')) {
+          title = trimmed.slice(2).trim();
+          break;
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return title;
+}
+
+function getConversationFiles(convDir: string) {
+  try {
+    const results: any[] = [];
+    const entries = fs.readdirSync(convDir, { recursive: true, withFileTypes: true });
+    for (const d of entries) {
+      if (!d.isFile() || !d.name.endsWith('.md')) continue;
+      
+      // Node 20+ uses parentPath, older Node might use path. Fallback to convDir just in case
+      // @ts-ignore
+      const parentDir = d.parentPath || d.path || convDir;
+      const fullPath = path.join(parentDir, d.name);
+      const relPath = path.relative(convDir, fullPath).replace(/\\/g, '/');
+      
+      if (relPath.split('/').some(p => p.startsWith('.'))) continue;
+      
+      const stat = fs.statSync(fullPath);
+      results.push({ name: relPath, size: stat.size, mtime: stat.mtime.toISOString() });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+// Compute a simple word overlap score for fuzzy string matching
+function getMatchScore(s1: string, s2: string): number {
+  if (!s1 || !s2) return 0;
+  const words1 = s1.toLowerCase().replace(/[^a-z0-9]/g, ' ').split(/\s+/).filter(w => w.length > 2);
+  const words2 = s2.toLowerCase().replace(/[^a-z0-9]/g, ' ').split(/\s+/).filter(w => w.length > 2);
+  
+  if (words1.length === 0 || words2.length === 0) return 0;
+  
+  let matches = 0;
+  for (const w of words1) {
+    if (words2.includes(w)) matches++;
+  }
+  return matches / Math.min(words1.length, words2.length);
+}
+
+/**
+ * GET /api/v1/conversations — list conversations from the IDE's history panel.
+ * These are per-window (only shows conversations for the active window).
+ */
+export async function GET() {
+  await ensureCdpConnection();
+
+  if (!ctx.workbenchPage) {
+    return NextResponse.json({ conversations: [] });
+  }
+
+  try {
+    const ideConversations = await getIdeConversations(ctx);
+
+    // Get the globally active backend title
+    let globalActiveTitle: string | null = ctx.activeTitle || null;
+    if (ctx.activeConversationId) {
+        const dirPath = path.join(BRAIN_DIR, ctx.activeConversationId);
+        const title = extractTitle(dirPath);
+        if (title) globalActiveTitle = title;
+    }
+
+    // Pre-calculate BRAIN metadata so we can map it to IDE conversations
+    const brainData: any[] = [];
+    if (fs.existsSync(BRAIN_DIR)) {
+      const entries = fs.readdirSync(BRAIN_DIR, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+          const dirPath = path.join(BRAIN_DIR, entry.name);
+          const files = getConversationFiles(dirPath);
+          const title = extractTitle(dirPath);
+          const latestMtime = files.reduce((max, f) => {
+              const t = new Date(f.mtime).getTime();
+              return t > max ? t : max;
+          }, 0);
+          brainData.push({ id: entry.name, title, files, mtime: new Date(latestMtime).toISOString() });
+        }
+      }
+    }
+
+    let foundActive = false;
+    let conversations = ideConversations.map((c) => {
+      const isActive = globalActiveTitle 
+         ? (c.title === globalActiveTitle || c.title.includes(globalActiveTitle) || globalActiveTitle.includes(c.title)) 
+         : c.active;
+      if (isActive) foundActive = true;
+      
+      // Map IDE title back to Brain
+      let mappedId = c.index.toString();
+      let files: any[] = [];
+      let mtime: string | undefined = undefined;
+
+      let bestMatch: any = null;
+      for (const bd of brainData) {
+          if (!bd.title) continue;
+          if (bd.title === c.title || bd.title.includes(c.title) || c.title.includes(bd.title)) {
+              mappedId = bd.id;
+              files = bd.files;
+              mtime = bd.mtime;
+              break;
+          }
+          const score = getMatchScore(bd.title, c.title);
+          const bdtime = new Date(bd.mtime).getTime();
+          if (score > 0 && (!bestMatch || score > bestMatch.score || (score === bestMatch.score && bdtime > bestMatch.time))) {
+              bestMatch = { ...bd, score, time: bdtime };
+          }
+      }
+
+      if (mappedId === c.index.toString() && bestMatch && bestMatch.score >= 0.2) {
+          mappedId = bestMatch.id;
+          files = bestMatch.files;
+          mtime = bestMatch.mtime;
+      }
+
+      return {
+        id: mappedId,
+        title: c.title,
+        active: isActive,
+        index: c.index,
+        files,
+        mtime
+      };
+    });
+
+    // If the globally active conversation isn't in the IDE dropdown yet, but we know it's active
+    if (!foundActive && globalActiveTitle) {
+        let files: any[] = [];
+        let mtime: string | undefined = undefined;
+        let mappedId = '-1';
+        
+        if (ctx.activeConversationId) {
+            const bd = brainData.find(b => b.id === ctx.activeConversationId);
+            if (bd) {
+                mappedId = bd.id;
+                files = bd.files;
+                mtime = bd.mtime;
+            }
+        }
+
+        conversations.unshift({
+            id: mappedId,
+            title: globalActiveTitle,
+            active: true,
+            index: -1,
+            files,
+            mtime
+        });
+    }
+
+    // Fallback: if nothing is active, default back to the first one like the IDE does
+    if (!foundActive && conversations.length > 0 && !globalActiveTitle) {
+        conversations[0].active = true;
+    }
+
+    return NextResponse.json({ conversations });
+  } catch (err: any) {
+    return NextResponse.json({ error: err.message }, { status: 500 });
+  }
+}

package/app/api/v1/conversations/select/route.ts

@@ -0,0 +1,114 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { switchIdeConversation } from '@/lib/actions/switch-conversation';
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export const dynamic = 'force-dynamic';
+
+const BRAIN_DIR = path.join(os.homedir(), '.gemini', 'antigravity', 'brain');
+
+function extractTitle(convDir: string): string | null {
+  const taskFile = path.join(convDir, 'task.md');
+  let title = null;
+  try {
+    if (fs.existsSync(taskFile)) {
+      const content = fs.readFileSync(taskFile, 'utf-8');
+      const lines = content.split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('# ')) {
+          title = trimmed.slice(2).trim();
+          break;
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return title;
+}
+
+// Compute a simple word overlap score for fuzzy string matching
+function getMatchScore(s1: string, s2: string): number {
+  if (!s1 || !s2) return 0;
+  const words1 = s1.toLowerCase().replace(/[^a-z0-9]/g, ' ').split(/\s+/).filter(w => w.length > 2);
+  const words2 = s2.toLowerCase().replace(/[^a-z0-9]/g, ' ').split(/\s+/).filter(w => w.length > 2);
+  
+  if (words1.length === 0 || words2.length === 0) return 0;
+  
+  let matches = 0;
+  for (const w of words1) {
+    if (words2.includes(w)) matches++;
+  }
+  return matches / Math.min(words1.length, words2.length); // 0.0 to 1.0 (overlap ratio)
+}
+
+/**
+ * POST /api/v1/conversations/select — switch conversation in the IDE.
+ * Accepts { title: string }
+ */
+export async function POST(request: NextRequest) {
+  await ensureCdpConnection();
+
+  const body = await request.json();
+  const { title } = body;
+  if (!title) {
+    return NextResponse.json({ error: 'title is required' }, { status: 400 });
+  }
+
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  try {
+    // 1. Switch the IDE UI
+    const success = await switchIdeConversation(ctx, title);
+
+    // 2. Add memory cache of the selected title, in case we can't find the UUID
+    ctx.activeTitle = title;
+    ctx.activeConversationId = null; // Reset it
+
+    // 3. Map the title back to a brain directory so the artifact panel works
+    if (fs.existsSync(BRAIN_DIR)) {
+        const entries = fs.readdirSync(BRAIN_DIR, { withFileTypes: true });
+        
+        let bestMatch: { id: string; score: number; mtime: number } | null = null;
+
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                const dirPath = path.join(BRAIN_DIR, entry.name);
+                const convTitle = extractTitle(dirPath);
+                
+                if (convTitle) {
+                    // Exact or substring match
+                    if (convTitle === title || convTitle.includes(title) || title.includes(convTitle)) {
+                        ctx.activeConversationId = entry.name;
+                        break;
+                    }
+
+                    // Fuzzy match scoring
+                    const score = getMatchScore(convTitle, title);
+                    const mtime = fs.statSync(dirPath).mtimeMs;
+                    if (score > 0 && (!bestMatch || score > bestMatch.score || (score === bestMatch.score && mtime > bestMatch.mtime))) {
+                        bestMatch = { id: entry.name, score, mtime };
+                    }
+                }
+            }
+        }
+
+        // 4. Fallback to best fuzzy match if no exact match found
+        if (!ctx.activeConversationId && bestMatch && bestMatch.score >= 0.2) {
+            ctx.activeConversationId = bestMatch.id;
+        }
+    }
+
+    return NextResponse.json({ success, title, activeConversationId: ctx.activeConversationId });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/debug/dom/route.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/v1/debug/dom — dump raw HTML of the agent panel for debugging.
+ */
+export async function GET() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  try {
+    const html = await ctx.workbenchPage.evaluate(() => {
+      const panel = document.querySelector('.antigravity-agent-side-panel');
+      return panel ? (panel as HTMLElement).innerHTML : 'Panel not found';
+    });
+    return new Response(html, {
+      headers: { 'Content-Type': 'text/html; charset=utf-8' },
+    });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/debug/scrape/route.ts

@@ -0,0 +1,56 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { getFullAgentState } from '@/lib/scraper/agent-state';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/v1/debug/scrape — Returns both the raw last-turn HTML
+ * and the full parsed agent state for debugging.
+ */
+export async function GET() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  try {
+    // 1. Get parsed state via the scraper
+    const parsedState = await getFullAgentState(ctx);
+
+    // 2. Get raw HTML of the last turn from the panel
+    const rawHTML = await ctx.workbenchPage.evaluate(() => {
+      const panel = document.querySelector('.antigravity-agent-side-panel');
+      if (!panel) return '<p>Panel not found</p>';
+
+      const conversation =
+        panel.querySelector('#conversation') ||
+        document.querySelector('#conversation');
+      const scrollArea = conversation?.querySelector('.overflow-y-auto');
+      const msgList = scrollArea?.querySelector('.mx-auto');
+      const allTurns = msgList ? Array.from(msgList.children) : [];
+      const lastTurn = allTurns.length > 0 ? allTurns[allTurns.length - 1] : null;
+
+      if (!lastTurn) return '<p>No turns found</p>';
+      return (lastTurn as HTMLElement).innerHTML;
+    });
+
+    return NextResponse.json({
+      raw: rawHTML,
+      parsed: parsedState,
+      meta: {
+        timestamp: new Date().toISOString(),
+        activeWindowIdx: ctx.activeWindowIdx,
+        turnCount: parsedState.turnCount,
+        toolCallCount: parsedState.toolCalls.length,
+        responseCount: parsedState.responses.length,
+      },
+    });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/health/route.ts

@@ -0,0 +1,13 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  await ensureCdpConnection();
+  return NextResponse.json({
+    status: 'ok',
+    connected: !!ctx.workbenchPage,
+  });
+}

package/app/api/v1/windows/cdp-start/route.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { startCdpServer } from '@/lib/cdp/process-manager';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/v1/windows/cdp-start — Start the Antigravity CDP server.
+ * 
+ * Body (optional):
+ *   { "projectDir": "/path/to/project", "killExisting": false }
+ * 
+ * If projectDir is not provided, defaults to ".".
+ * If killExisting is true, all existing Antigravity instances are killed first.
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const projectDir = body.projectDir || '.';
+    const killExisting = body.killExisting === true;
+
+    const result = await startCdpServer(projectDir, killExisting);
+
+    return NextResponse.json(result, {
+      status: result.success ? 200 : 500,
+    });
+  } catch (e: any) {
+    return NextResponse.json(
+      { success: false, message: e.message },
+      { status: 500 },
+    );
+  }
+}

package/app/api/v1/windows/cdp-status/route.ts

@@ -0,0 +1,32 @@
+import { NextResponse } from 'next/server';
+import { isCdpServerActive, getWindowTargets } from '@/lib/cdp/process-manager';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/v1/windows/cdp-status — Check if the CDP server is active.
+ * Returns the status and a list of open workbench windows.
+ */
+export async function GET() {
+  try {
+    const status = await isCdpServerActive();
+    let targets: { id: string; title: string; url: string }[] = [];
+
+    if (status.active) {
+      const result = await getWindowTargets();
+      targets = result.targets;
+    }
+
+    return NextResponse.json({
+      active: status.active,
+      windowCount: status.windowCount,
+      targets,
+      error: status.error || null,
+    });
+  } catch (e: any) {
+    return NextResponse.json(
+      { active: false, windowCount: 0, targets: [], error: e.message },
+      { status: 500 },
+    );
+  }
+}

package/app/api/v1/windows/close/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { closeWindow, getWindowTargets } from '@/lib/cdp/process-manager';
+import ctx from '@/lib/context';
+import { discoverWorkbenches } from '@/lib/cdp/connection';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/v1/windows/close — Close a specific Antigravity window.
+ * 
+ * Body:
+ *   { "targetId": "CDP-target-id" }
+ *   OR
+ *   { "index": 0 }  — closes by window index
+ */
+export async function POST(request: NextRequest) {
+  const body = await request.json().catch(() => ({}));
+  let { targetId, index } = body;
+
+  // If index is provided instead of targetId, resolve it
+  if (!targetId && index !== undefined && index !== null) {
+    const { targets } = await getWindowTargets();
+    if (index < 0 || index >= targets.length) {
+      return NextResponse.json(
+        { success: false, message: `Invalid window index ${index}. Available: 0-${targets.length - 1}` },
+        { status: 400 },
+      );
+    }
+    targetId = targets[index].id;
+  }
+
+  if (!targetId) {
+    return NextResponse.json(
+      { success: false, message: 'Either targetId or index is required.' },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const result = await closeWindow(targetId);
+
+    // After closing, re-discover workbenches
+    if (result.success) {
+      // Wait a moment for the window to fully close
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      try {
+        await discoverWorkbenches(ctx);
+        // If the active window was closed, reset to first available
+        if (ctx.allWorkbenches.length > 0 && ctx.activeWindowIdx >= ctx.allWorkbenches.length) {
+          ctx.activeWindowIdx = 0;
+          ctx.workbenchPage = ctx.allWorkbenches[0].page;
+        }
+      } catch {
+        // Non-fatal
+      }
+    }
+
+    return NextResponse.json(result, {
+      status: result.success ? 200 : 500,
+    });
+  } catch (e: any) {
+    return NextResponse.json(
+      { success: false, message: e.message },
+      { status: 500 },
+    );
+  }
+}

package/app/api/v1/windows/open/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { openNewWindow } from '@/lib/cdp/process-manager';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { discoverWorkbenches } from '@/lib/cdp/connection';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/v1/windows/open — Open a new Antigravity window.
+ * 
+ * Body:
+ *   { "projectDir": "/path/to/project" }
+ */
+export async function POST(request: NextRequest) {
+  const body = await request.json().catch(() => ({}));
+  const { projectDir } = body;
+
+  if (!projectDir || typeof projectDir !== 'string' || projectDir.trim() === '') {
+    return NextResponse.json(
+      { success: false, message: 'projectDir is required and must be a non-empty string.' },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const result = await openNewWindow(projectDir.trim());
+
+    // After opening, re-discover workbenches so the proxy knows about the new window
+    if (result.success) {
+      try {
+        // Try to reconnect/rediscover
+        await ensureCdpConnection();
+        await discoverWorkbenches(ctx);
+      } catch {
+        // Non-fatal — the window list will refresh on next poll
+      }
+    }
+
+    return NextResponse.json(result, {
+      status: result.success ? 200 : 500,
+    });
+  } catch (e: any) {
+    return NextResponse.json(
+      { success: false, message: e.message },
+      { status: 500 },
+    );
+  }
+}

package/app/api/v1/windows/recent/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getRecentProjects } from '@/lib/cdp/recent-projects';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/v1/windows/recent — List recently opened Antigravity projects.
+ * 
+ * Query params:
+ *   ?limit=10  (default: 15)
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const url = new URL(request.url);
+    const limit = parseInt(url.searchParams.get('limit') || '15', 10);
+    const recentProjects = getRecentProjects(limit);
+
+    return NextResponse.json({ recentProjects });
+  } catch (e: any) {
+    return NextResponse.json(
+      { recentProjects: [], error: e.message },
+      { status: 500 },
+    );
+  }
+}

package/app/api/v1/windows/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { discoverWorkbenches, selectWindow } from '@/lib/cdp/connection';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/v1/windows — list all available Antigravity workbench windows.
+ */
+export async function GET() {
+  await ensureCdpConnection();
+
+  try {
+    const workbenches = await discoverWorkbenches(ctx);
+    return NextResponse.json({
+      windows: workbenches.map((w, idx) => ({
+        index: idx,
+        title: w.title,
+        url: w.url,
+        active: idx === ctx.activeWindowIdx,
+      })),
+    });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/windows/select/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { selectWindow } from '@/lib/cdp/connection';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/v1/windows/select — switch to a different workbench window.
+ */
+export async function POST(request: NextRequest) {
+  await ensureCdpConnection();
+
+  const body = await request.json();
+  const { index } = body;
+  if (index === undefined || index === null) {
+    return NextResponse.json(
+      { error: 'index is required' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const info = selectWindow(ctx, index);
+    return NextResponse.json({
+      success: true,
+      window: { index, title: info.title, url: info.url },
+    });
+  } catch (e: any) {
+    return NextResponse.json(
+      { error: e.message },
+      { status: 400 }
+    );
+  }
+}