antigravity-chat-proxy 0.1.0

package/app/api/v1/chat/action/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { clickActionButton } from '@/lib/actions/hitl';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST(request: NextRequest) {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json({ error: 'Not connected' }, { status: 503 });
+  }
+
+  const body = await request.json();
+  const { toolId, buttonText } = body;
+  if (!buttonText) {
+    return NextResponse.json(
+      { error: 'buttonText is required' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const result = await clickActionButton(ctx, toolId || null, buttonText);
+    ctx.lastActionTimestamp = Date.now();
+    return NextResponse.json(result, { status: result.success ? 200 : 404 });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/chat/approve/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { clickApproveButton } from '@/lib/actions/hitl';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json({ error: 'Not connected' }, { status: 503 });
+  }
+
+  try {
+    const result = await clickApproveButton(ctx);
+    ctx.lastActionTimestamp = Date.now();
+    return NextResponse.json(result, { status: result.success ? 200 : 404 });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/chat/history/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { getChatHistory } from '@/lib/scraper/chat-history';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  try {
+    const history = await getChatHistory(ctx);
+    return NextResponse.json(history);
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/chat/mode/route.ts

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { getAgentMode, setAgentMode } from '@/lib/scraper/agent-mode';
+import type { AgentMode } from '@/lib/scraper/agent-mode';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/v1/chat/mode — Read the current conversation mode.
+ */
+export async function GET() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  try {
+    const mode = await getAgentMode(ctx);
+    return NextResponse.json({ mode });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+/**
+ * POST /api/v1/chat/mode — Switch the conversation mode.
+ * Body: { mode: 'planning' | 'fast' }
+ */
+export async function POST(req: NextRequest) {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  try {
+    const body = await req.json();
+    const targetMode = body.mode as AgentMode;
+
+    if (targetMode !== 'planning' && targetMode !== 'fast') {
+      return NextResponse.json(
+        { error: 'Invalid mode. Must be "planning" or "fast".' },
+        { status: 400 }
+      );
+    }
+
+    await setAgentMode(ctx, targetMode);
+    const currentMode = await getAgentMode(ctx);
+    return NextResponse.json({ success: true, mode: currentMode });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/chat/new/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { startNewChat } from '@/lib/actions/new-chat';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json({ error: 'Not connected' }, { status: 503 });
+  }
+
+  try {
+    const result = await startNewChat(ctx);
+    ctx.lastActionTimestamp = Date.now();
+    return NextResponse.json(result, { status: result.success ? 200 : 404 });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/chat/reject/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { clickRejectButton } from '@/lib/actions/hitl';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json({ error: 'Not connected' }, { status: 503 });
+  }
+
+  try {
+    const result = await clickRejectButton(ctx);
+    ctx.lastActionTimestamp = Date.now();
+    return NextResponse.json(result, { status: result.success ? 200 : 404 });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,105 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { sendMessage } from '@/lib/actions/send-message';
+import { getFullAgentState } from '@/lib/scraper/agent-state';
+import { sleep } from '@/lib/utils';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/v1/chat — Blocking chat endpoint.
+ * Sends a message and polls until the agent completes, then returns the response.
+ */
+export async function POST(request: NextRequest) {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  const body = await request.json();
+  const { message } = body;
+  if (!message) {
+    return NextResponse.json(
+      { error: 'message is required' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    await sendMessage(ctx, message);
+
+    const startTime = Date.now();
+    const timeoutMs = 180000;
+    let doneCount = 0;
+    let started = false;
+    const initialState = await getFullAgentState(ctx);
+    const initialBlockCount = initialState.responses.length + initialState.notifications.length;
+
+    // Phase 1: Wait for agent to start
+    for (let i = 0; i < 40; i++) {
+      await sleep(300);
+      const state = await getFullAgentState(ctx);
+      if (state.isRunning) {
+        started = true;
+        break;
+      }
+      const blocks = state.responses.length + state.notifications.length;
+      if (blocks > initialBlockCount) {
+        started = true;
+        await sleep(500);
+        const check = await getFullAgentState(ctx);
+        if (!check.isRunning) {
+          const response = check.notifications.length > 0
+            ? check.notifications[check.notifications.length - 1]
+            : check.responses.length > 0
+              ? check.responses[check.responses.length - 1]
+              : '';
+          return NextResponse.json({ response });
+        }
+        break;
+      }
+    }
+
+    if (!started) {
+      const state = await getFullAgentState(ctx);
+      const response = state.responses.length > 0
+        ? state.responses[state.responses.length - 1]
+        : '[Agent did not respond]';
+      return NextResponse.json({ response });
+    }
+
+    // Phase 2: Wait for completion
+    while (Date.now() - startTime < timeoutMs) {
+      const state = await getFullAgentState(ctx);
+      if (state.error) {
+        return NextResponse.json({ response: state.error });
+      }
+      if (!state.isRunning) {
+        doneCount++;
+        if (doneCount >= 3) {
+          const response = state.notifications.length > 0
+            ? state.notifications[state.notifications.length - 1]
+            : state.responses.length > 0
+              ? state.responses[state.responses.length - 1]
+              : '[Agent did not produce a response]';
+          return NextResponse.json({ response });
+        }
+      } else {
+        doneCount = 0;
+      }
+      await sleep(500);
+    }
+
+    const finalState = await getFullAgentState(ctx);
+    const response = finalState.responses.length > 0
+      ? finalState.responses[finalState.responses.length - 1]
+      : '[Timeout: No response received]';
+    return NextResponse.json({ response });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/chat/state/route.ts

@@ -0,0 +1,23 @@
+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';
+
+export async function GET() {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return NextResponse.json(
+      { error: 'Not connected to Antigravity' },
+      { status: 503 }
+    );
+  }
+
+  try {
+    const state = await getFullAgentState(ctx);
+    return NextResponse.json(state);
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/v1/chat/stream/route.ts

@@ -0,0 +1,258 @@
+import { NextRequest } from 'next/server';
+import { ensureCdpConnection } from '@/lib/init';
+import ctx from '@/lib/context';
+import { sendMessage } from '@/lib/actions/send-message';
+import { getFullAgentState } from '@/lib/scraper/agent-state';
+import { diffStates } from '@/lib/sse/diff-states';
+import type { AgentState, ToolCall } from '@/lib/types';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/v1/chat/stream — SSE streaming endpoint.
+ * Sends a message and streams agent state diffs as Server-Sent Events.
+ */
+export async function POST(request: NextRequest) {
+  await ensureCdpConnection();
+  if (!ctx.workbenchPage) {
+    return new Response(
+      JSON.stringify({ error: 'Not connected to Antigravity' }),
+      { status: 503, headers: { 'Content-Type': 'application/json' } }
+    );
+  }
+
+  const body = await request.json();
+  const { message } = body;
+  if (!message) {
+    return new Response(
+      JSON.stringify({ error: 'message is required' }),
+      { status: 400, headers: { 'Content-Type': 'application/json' } }
+    );
+  }
+
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const writeEvent = (type: string, data: Record<string, unknown>) => {
+        try {
+          const payload = JSON.stringify({ ...data, type });
+          controller.enqueue(encoder.encode(`data: ${payload}\n\n`));
+        } catch {
+          // Controller may already be closed
+        }
+      };
+
+      let closed = false;
+      const closeStream = () => {
+        if (closed) return;
+        closed = true;
+        try { controller.close(); } catch { /* already closed */ }
+      };
+
+      try {
+        writeEvent('status', { isRunning: true, phase: 'sending' });
+
+        // Capture initial state before sending
+        let prevState = await getFullAgentState(ctx);
+        const sessionToolCalls = new Map<string, ToolCall>();
+        let sessionResponses: string[] = [];
+
+        await sendMessage(ctx, message);
+
+        writeEvent('status', { isRunning: true, phase: 'waiting' });
+
+        const startTime = Date.now();
+        let doneCount = 0;
+        let started = false;
+        let lastStableHTML = '';
+        const initialTurnCount = prevState.turnCount;
+        let pollErrorCount = 0;
+
+        const interval = setInterval(async () => {
+          if (closed) { clearInterval(interval); return; }
+
+          try {
+            const currState = await getFullAgentState(ctx);
+            pollErrorCount = 0; // Reset on success
+
+            // Track tools by ID to survive virtualization
+            if (currState.turnCount > prevState.turnCount) {
+              sessionToolCalls.clear();
+              prevState = {
+                ...prevState,
+                toolCalls: [],
+                responses: [],
+                thinking: [],
+                notifications: [],
+                fileChanges: [],
+              };
+            }
+            for (const t of currState.toolCalls) {
+              sessionToolCalls.set(t.id, t);
+            }
+            currState.toolCalls = Array.from(sessionToolCalls.values());
+
+            // Accumulate responses to survive DOM virtualization
+            if (currState.responses.length > sessionResponses.length) {
+              sessionResponses = [...currState.responses];
+            } else if (
+              currState.responses.length < sessionResponses.length &&
+              currState.responses.length > 0
+            ) {
+              const lastIdx = currState.responses.length - 1;
+              sessionResponses[sessionResponses.length - 1] =
+                currState.responses[lastIdx];
+            } else if (
+              currState.responses.length === sessionResponses.length &&
+              currState.responses.length > 0
+            ) {
+              sessionResponses[sessionResponses.length - 1] =
+                currState.responses[currState.responses.length - 1];
+            }
+            currState.responses = [...sessionResponses];
+
+            // Detect start
+            if (!started) {
+              if (
+                currState.isRunning ||
+                currState.turnCount > initialTurnCount ||
+                currState.toolCalls.length > prevState.toolCalls.length ||
+                currState.responses.length > prevState.responses.length ||
+                currState.thinking.length > prevState.thinking.length
+              ) {
+                started = true;
+                writeEvent('status', { isRunning: true, phase: 'processing' });
+              }
+            }
+
+            // Check for unresolved tools
+            const hasUnresolvedTools = Array.from(
+              sessionToolCalls.values()
+            ).some((t) => t.hasCancelBtn && !t.exitCode);
+
+            // Compute and emit diffs
+            const events = diffStates(prevState, currState);
+            for (const evt of events) {
+              writeEvent(evt.type, evt.data);
+            }
+
+            // Check for completion
+            if (started && !currState.isRunning && !currState.error && !hasUnresolvedTools) {
+              const contentChanged =
+                currState.toolCalls.length !== prevState.toolCalls.length ||
+                currState.responses.length !== prevState.responses.length ||
+                currState.thinking.length !== prevState.thinking.length ||
+                currState.notifications.length !== prevState.notifications.length ||
+                currState.fileChanges.length !== prevState.fileChanges.length ||
+                currState.stepGroupCount !== prevState.stepGroupCount ||
+                (currState.responses.length > 0 &&
+                  prevState.responses.length > 0 &&
+                  currState.responses[currState.responses.length - 1] !==
+                    prevState.responses[prevState.responses.length - 1]) ||
+                currState.lastTurnResponseHTML !== prevState.lastTurnResponseHTML;
+
+              if (contentChanged) {
+                doneCount = 0;
+                lastStableHTML = '';
+              } else if (Date.now() - ctx.lastActionTimestamp < 15000) {
+                doneCount = 0;
+                lastStableHTML = '';
+              } else {
+                doneCount++;
+              }
+
+              const currentHTML = currState.lastTurnResponseHTML || '';
+              if (doneCount >= 2 && currentHTML && currentHTML !== lastStableHTML) {
+                doneCount = 1;
+              }
+              lastStableHTML = currentHTML;
+
+              const hasSubagentTools = currState.toolCalls.some(
+                (t) =>
+                  t.type === 'browser' ||
+                  (t.status || '').toLowerCase().includes('subagent') ||
+                  (t.status || '').toLowerCase().includes('navigat')
+              );
+              const requiredDoneCount = hasSubagentTools ? 20 : 10;
+              if (doneCount >= requiredDoneCount) {
+                const finalResponse =
+                  currState.notifications.length > 0
+                    ? currState.notifications[currState.notifications.length - 1]
+                    : currState.responses.length > 0
+                      ? currState.responses[currState.responses.length - 1]
+                      : '';
+
+                writeEvent('done', {
+                  finalResponse,
+                  isHTML: true,
+                  thinking: currState.thinking,
+                  toolCalls: currState.toolCalls,
+                });
+                clearInterval(interval);
+                closeStream();
+                return;
+              }
+            } else {
+              doneCount = 0;
+              lastStableHTML = '';
+            }
+
+            // Error
+            if (currState.error) {
+              writeEvent('error', { message: currState.error });
+              writeEvent('done', { error: currState.error });
+              clearInterval(interval);
+              closeStream();
+              return;
+            }
+
+            // Timeout (10 min)
+            if (Date.now() - startTime > 600000) {
+              const finalResponse =
+                currState.responses.length > 0
+                  ? currState.responses[currState.responses.length - 1]
+                  : '[Timeout]';
+              writeEvent('done', { finalResponse, timeout: true });
+              clearInterval(interval);
+              closeStream();
+              return;
+            }
+
+            prevState = currState;
+          } catch (e: any) {
+            // Transient errors: don't kill the stream, just log and retry
+            pollErrorCount++;
+            console.error(`[Stream] Poll error (${pollErrorCount}):`, e.message);
+
+            // Only kill after many consecutive failures
+            if (pollErrorCount >= 20) {
+              writeEvent('error', { message: `Too many poll errors: ${e.message}` });
+              writeEvent('done', { error: e.message });
+              clearInterval(interval);
+              closeStream();
+            }
+          }
+        }, 500);
+
+        // Handle client disconnect
+        request.signal.addEventListener('abort', () => {
+          clearInterval(interval);
+          closeStream();
+        });
+      } catch (e: any) {
+        writeEvent('error', { message: e.message });
+        closeStream();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+    },
+  });
+}
+

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

@@ -0,0 +1,117 @@
+import { NextResponse } from 'next/server';
+import ctx from '@/lib/context';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+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');
+  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('# ')) {
+          return trimmed.slice(2).trim();
+        }
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+  return null;
+}
+
+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 [];
+  }
+}
+
+/**
+ * Auto-detect the most recently modified conversation directory.
+ * This ensures the currently opened conversation is pre-selected on first load.
+ */
+function autoDetectActiveConversation(): string | null {
+  try {
+    if (!fs.existsSync(BRAIN_DIR)) return null;
+    const entries = fs.readdirSync(BRAIN_DIR, { withFileTypes: true });
+    let latest: { id: string; mtime: number } | null = null;
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+      const dirPath = path.join(BRAIN_DIR, entry.name);
+      const stat = fs.statSync(dirPath);
+      // Use the most recently modified directory
+      if (!latest || stat.mtimeMs > latest.mtime) {
+        latest = { id: entry.name, mtime: stat.mtimeMs };
+      }
+    }
+    return latest?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export async function GET() {
+  // Auto-detect on first load if no conversation has been selected yet
+  if (!ctx.activeConversationId && !ctx.activeTitle) {
+    ctx.activeConversationId = autoDetectActiveConversation();
+  }
+
+  if (!ctx.activeConversationId && ctx.activeTitle) {
+    return NextResponse.json({
+      active: true,
+      id: null,
+      title: ctx.activeTitle,
+      files: [],
+      mtime: new Date().toISOString(),
+    });
+  }
+
+  if (!ctx.activeConversationId) {
+    return NextResponse.json({ active: false });
+  }
+
+  const convDir = path.join(BRAIN_DIR, ctx.activeConversationId);
+  if (!fs.existsSync(convDir)) {
+    ctx.activeConversationId = null;
+    return NextResponse.json({ active: false });
+  }
+
+  const files = getConversationFiles(convDir);
+  const title = extractTitle(convDir);
+  const stat = fs.statSync(convDir);
+
+  return NextResponse.json({
+    active: true,
+    id: ctx.activeConversationId,
+    title,
+    files,
+    mtime: stat.mtime.toISOString(),
+  });
+}
+